qet.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 "qet.h"
#include "qeticons.h"

#include <limits>
#include <QGraphicsSceneContextMenuEvent>
#include <QAction>
#include <QFileInfo>
#include <QSaveFile>

Qet::Orientation Qet::orientationFromString(const QString &s) {
    QChar c = s[0];
    if (c == 'e') return(Qet::East);
    else if (c == 's') return(Qet::South);
    else if (c == 'w') return (Qet::West);
    else return(Qet::North);
}

QString Qet::orientationToString(Qet::Orientation o) {
    QString ret;
    switch(o) {
        case Qet::North: ret = "n"; break;
        case Qet::East : ret = "e"; break;
        case Qet::South: ret = "s"; break;
        case Qet::West : ret = "w"; break;
    }
    return(ret);
}

bool Qet::surLeMemeAxe(Qet::Orientation a, Qet::Orientation b) {
    if ((a == Qet::North || a == Qet::South) && (b == Qet::North || b == Qet::South)) return(true);
    else if ((a == Qet::East || a == Qet::West) && (b == Qet::East || b == Qet::West)) return(true);
    else return(false);
}

bool Qet::isOpposed(Qet::Orientation a, Qet::Orientation b)
{
    bool result = false;

    switch (a)
    {
        case Qet::North:
            if (b == Qet::South) result = true;
            break;
        case Qet::East:
            if (b == Qet::West) result = true;
            break;
        case Qet::South:
            if (b == Qet::North) result = true;
            break;
        case Qet::West:
            if (b == Qet::East) result = true;
            break;
        default:
            break;
    }

    return result;
}

bool Qet::isHorizontal(Qet::Orientation a) {
    return(a == Qet::East || a == Qet::West);
}

bool Qet::isVertical(Qet::Orientation a) {
    return(a == Qet::North || a == Qet::South);
}

Qet::Orientation Qet::nextOrientation(Qet::Orientation o) {
    if (o < 0 || o > 2) return(Qet::North);
    return((Qet::Orientation)(o + 1));
}

Qet::Orientation Qet::previousOrientation(Qet::Orientation o) {
    if (o < 0 || o > 3) return(Qet::North);
    if (o == Qet::North) return(Qet::West);
    return((Qet::Orientation)(o - 1));
}

bool QET::lineContainsPoint(const QLineF &line, const QPointF &point) {
    if (point == line.p1()) return(true);
    QLineF point_line(line.p1(), point);
    if (point_line.unitVector() != line.unitVector()) return(false);
    return(point_line.length() <= line.length());
}

bool QET::orthogonalProjection(const QPointF &point, const QLineF &line, QPointF *intersection) {
    // recupere le vecteur normal de `line'
    QLineF line_normal_vector(line.normalVector());
    QPointF normal_vector(line_normal_vector.dx(), line_normal_vector.dy());
    
    // cree une droite perpendiculaire a `line' passant par `point'
    QLineF perpendicular_line(point, point + normal_vector);
    
    // determine le point d'intersection des deux droites = le projete orthogonal
    QPointF intersection_point;
    QLineF::IntersectType it = line.intersect(perpendicular_line, &intersection_point);
    
    // ne devrait pas arriver (mais bon...)
    if (it == QLineF::NoIntersection) return(false);
    
    // fournit le point d'intersection a l'appelant si necessaire
    if (intersection) {
        *intersection = intersection_point;
    }
    
    // determine si le point d'intersection appartient au segment de droite
    if (QET::lineContainsPoint(line, intersection_point)) {
        return(true);
    }
    return(false);
}

bool QET::attributeIsAnInteger(const QDomElement &e, const QString& nom_attribut, int *entier) {
    // verifie la presence de l'attribut
    if (!e.hasAttribute(nom_attribut)) return(false);
    // verifie la validite de l'attribut
    bool ok;
    int tmp = e.attribute(nom_attribut).toInt(&ok);
    if (!ok) return(false);
    if (entier != nullptr) *entier = tmp;
    return(true);
}

bool QET::attributeIsAReal(const QDomElement &e, const QString& nom_attribut, qreal *reel) {
    // verifie la presence de l'attribut
    if (!e.hasAttribute(nom_attribut)) return(false);
    // verifie la validite de l'attribut
    bool ok;
    qreal tmp = e.attribute(nom_attribut).toDouble(&ok);
    if (!ok) return(false);
    if (reel != nullptr) *reel = tmp;
    return(true);
}

QString QET::ElementsAndConductorsSentence(int elements_count, int conductors_count, int texts_count, int images_count, int shapes_count, int element_text_count) {
    QString text;
    if (elements_count) {
        text += QObject::tr(
            "%n élément(s)",
            "part of a sentence listing the content of a diagram",
            elements_count
        );
    }
    
    if (conductors_count) {
        if (!text.isEmpty()) text += ", ";
        text += QObject::tr(
            "%n conducteur(s)",
            "part of a sentence listing the content of a diagram",
            conductors_count
        );
    }
    
    if (texts_count) {
        if (!text.isEmpty()) text += ", ";
        text += QObject::tr(
            "%n champ(s) de texte",
            "part of a sentence listing the content of a diagram",
            texts_count
        );
    }

    if (images_count) {
        if (!text.isEmpty()) text += ", ";
        text += QObject::tr(
            "%n image(s)",
            "part of a sentence listing the content of a diagram",
            images_count
        );
    }

    if (shapes_count) {
        if (!text.isEmpty()) text += ", ";
        text += QObject::tr(
            "%n forme(s)",
            "part of a sentence listing the content of a diagram",
            shapes_count
        );
    }
    
    if (element_text_count) {
        if (!text.isEmpty()) text += ", ";
        text += QObject::tr(
                    "%n texte(s) d'élément",
                    "part of a sentence listing the content of a diagram",
                    element_text_count);
    }
    
    return(text);
}

QList<QDomElement> QET::findInDomElement(const QDomElement &e, const QString &tag_name) {
    QList<QDomElement> return_list;
    for (QDomNode node = e.firstChild() ; !node.isNull() ; node = node.nextSibling()) {
        if (!node.isElement()) continue;
        QDomElement element = node.toElement();
        if (element.isNull() || element.tagName() != tag_name) continue;
        return_list << element;
    }
    return(return_list);
}

QList<QDomElement> QET::findInDomElement(const QDomElement &e, const QString &parent, const QString &children) {
    QList<QDomElement> return_list;
    
    // parcours des elements parents
    for (QDomNode enfant = e.firstChild() ; !enfant.isNull() ; enfant = enfant.nextSibling()) {
        // on s'interesse a l'element XML "parent"
        QDomElement parents = enfant.toElement();
        if (parents.isNull() || parents.tagName() != parent) continue;
        // parcours des enfants de l'element XML "parent"
        for (QDomNode node_children = parents.firstChild() ; !node_children.isNull() ; node_children = node_children.nextSibling()) {
            // on s'interesse a l'element XML "children"
            QDomElement n_children = node_children.toElement();
            if (!n_children.isNull() && n_children.tagName() == children) return_list.append(n_children);
        }
    }
    return(return_list);
}

QString QET::license() {
    // Recuperation du texte de la GNU/GPL dans un fichier integre a l'application
    QFile *file_license = new QFile(":/LICENSE");
    QString txt_license;
    // verifie que le fichier existe
    if (!file_license -> exists()) {
        txt_license = QString(QObject::tr("Le fichier texte contenant la licence GNU/GPL est introuvable - bon bah de toute façon, vous la connaissez par coeur non ?"));
    } else {
        // ouvre le fichier en mode texte et en lecture seule
        if (!file_license -> open(QIODevice::ReadOnly | QIODevice::Text)) {
            txt_license = QString(QObject::tr("Le fichier texte contenant la licence GNU/GPL existe mais n'a pas pu être ouvert - bon bah de toute façon, vous la connaissez par coeur non ?"));
        } else {
            // charge le contenu du fichier dans une QString
            QTextStream in(file_license);
            txt_license = QString("");
            while (!in.atEnd()) txt_license += in.readLine()+"\n";
            // ferme le fichier
            file_license -> close();
        }
    }
    return(txt_license);
};


QList<QChar> QET::forbiddenCharacters() {
    return(QList<QChar>() << '\\' << '/' << ':' << '*' << '?' << '"' << '<' << '>' << '|');
}

QString QET::stringToFileName(const QString &name) {
    QString file_name(name.toLower());
    
    // remplace les caracteres interdits par des tirets
    foreach(QChar c, QET::forbiddenCharacters()) {
        file_name.replace(c, '-');
    }
    
    // remplace les espaces par des underscores
    file_name.replace(' ', '_');
    
    return(file_name);
}

QString QET::escapeSpaces(const QString &string) {
    return(QString(string).replace('\\', "\\\\").replace(' ', "\\ "));
}

QString QET::unescapeSpaces(const QString &string) {
    return(QString(string).replace("\\\\", "\\").replace("\\ ", " "));
}

QString QET::joinWithSpaces(const QStringList &string_list) {
    QString returned_string;
    
    for (int i = 0 ; i < string_list.count() ; ++ i) {
        returned_string += QET::escapeSpaces(string_list.at(i));
        if (i != string_list.count() - 1) returned_string += " ";
    }
    
    return(returned_string);
}

QStringList QET::splitWithSpaces(const QString &string) {
    // les chaines sont separees par des espaces non echappes = avec un nombre nul ou pair de backslashes devant
    QStringList escaped_strings = string.split(QRegExp("[^\\]?(?:\\\\)* "), QString::SkipEmptyParts);
    
    QStringList returned_list;
    foreach(QString escaped_string, escaped_strings) {
        returned_list << QET::unescapeSpaces(escaped_string);
    }
    return(returned_list);
}

QString Qet::endTypeToString(const Qet::EndType &end_type) {
    switch(end_type) {
        case Qet::Simple:   return("simple");
        case Qet::Triangle: return("triangle");
        case Qet::Circle:   return("circle");
        case Qet::Diamond:  return("diamond");
        case Qet::None:
        default:
            return("none");
    }
}

Qet::EndType Qet::endTypeFromString(const QString &string) {
    if (string == "simple")        return(Qet::Simple);
    else if (string == "triangle") return(Qet::Triangle);
    else if (string == "circle")   return(Qet::Circle);
    else if (string == "diamond")  return(Qet::Diamond);
    else return(Qet::None);
}

QString QET::diagramAreaToString(const QET::DiagramArea &diagram_area) {
    if (diagram_area == ElementsArea) return("elements");
    else return("border");
}

QET::DiagramArea QET::diagramAreaFromString(const QString &string) {
    if (!string.compare("border", Qt::CaseInsensitive)) return(QET::BorderArea);
    else return(QET::ElementsArea);
}

qreal QET::round(qreal x, qreal epsilon) {
    return(int(x * epsilon) / epsilon);
}

qreal QET::correctAngle(const qreal &angle) {
    // ramene l'angle demande entre -360.0 et +360.0 degres
    qreal corrected_angle = angle;
    while (corrected_angle <= -360.0) corrected_angle += 360.0;
    while (corrected_angle >=  360.0) corrected_angle -= 360.0;
    return(corrected_angle);
}

bool QET::compareCanonicalFilePaths(const QString &first, const QString &second) {
    QString first_canonical_path = QFileInfo(first).canonicalFilePath();
    if (first_canonical_path.isEmpty()) return(false);

    QString second_canonical_path = QFileInfo(second).canonicalFilePath();
    if (second_canonical_path.isEmpty()) return(false);
    
#ifdef Q_OS_WIN
    // sous Windows, on ramene les chemins en minuscules
    first_canonical_path  = first_canonical_path.toLower();
    second_canonical_path = second_canonical_path.toLower();
#endif
    
    return(first_canonical_path == second_canonical_path);
}

bool QET::writeXmlFile(QDomDocument &xml_doc, const QString &filepath, QString *error_message)
{
    QSaveFile file(filepath);

        // Note: we do not set QIODevice::Text to avoid generating CRLF end of lines
    bool file_opening = file.open(QIODevice::WriteOnly);
    if (!file_opening)
    {
        if (error_message)
        {
            *error_message = QString(QObject::tr("Impossible d'ouvrir le fichier %1 en écriture, erreur %2 rencontrée.",
                                                 "error message when attempting to write an XML file")).arg(filepath).arg(file.error());
        }
        return(false);
    }

    QTextStream out(&file);
    out.setCodec("UTF-8");
    out.setGenerateByteOrderMark(false);
    out << xml_doc.toString(4);
    if  (!file.commit())
    {
        if (error_message) {
            *error_message = QString(QObject::tr("Une erreur est survenue lors de l'écriture du fichier %1, erreur %2 rencontrée.",
                                                 "error message when attempting to write an XML file")).arg(filepath).arg(file.error());
        }

        return false;
    }

    return(true);
}

bool QET::eachStrIsEqual(const QStringList &qsl) {
    if (qsl.size() == 1) return true;
    foreach (const QString t, qsl) {
        if (qsl.at(0) != t) return false;
    }
    return true;
}

QString QET::qetCollectionToString(const QET::QetCollection &c)
{
    switch (c)
    {
        case Common :
            return "common";
        case Custom :
            return "custom";
        case Embedded :
            return "embedded";
        default:
            return "common";
    }
}

QET::QetCollection QET::qetCollectionFromString(const QString &str)
{
    if (str == "common")
        return QetCollection::Common;
    else if (str == "custom")
        return QetCollection::Custom;
    else if (str == "embedded")
        return QetCollection::Embedded;
    else
        return QetCollection::Common;
}

QActionGroup *QET::depthActionGroup(QObject *parent)
{
    QActionGroup *action_group = new QActionGroup(parent);

    QAction *edit_forward  = new QAction(QET::Icons::BringForward, QObject::tr("Amener au premier plan"), action_group);    
    QAction *edit_raise    = new QAction(QET::Icons::Raise,        QObject::tr("Rapprocher"),             action_group);
    QAction *edit_lower    = new QAction(QET::Icons::Lower,        QObject::tr("Éloigner"),               action_group);
    QAction *edit_backward = new QAction(QET::Icons::SendBackward, QObject::tr("Envoyer au fond"),        action_group);

    edit_forward ->setStatusTip(QObject::tr("Ramène la ou les sélections au premier plan"));
    edit_raise   ->setStatusTip(QObject::tr("Rapproche la ou les sélections"));
    edit_lower   ->setStatusTip(QObject::tr("Éloigne la ou les sélections"));
    edit_backward->setStatusTip(QObject::tr("Envoie en arrière plan la ou les sélections"));
    
    edit_raise   ->setShortcut(QKeySequence(QObject::tr("Ctrl+Shift+Up")));
    edit_lower   ->setShortcut(QKeySequence(QObject::tr("Ctrl+Shift+Down")));
    edit_backward->setShortcut(QKeySequence(QObject::tr("Ctrl+Shift+End")));
    edit_forward ->setShortcut(QKeySequence(QObject::tr("Ctrl+Shift+Home")));
    
    edit_forward ->setData(QET::BringForward);
    edit_raise   ->setData(QET::Raise);
    edit_lower   ->setData(QET::Lower);
    edit_backward->setData(QET::SendBackward);
    
    return action_group;
}

bool QET::writeToFile(QDomDocument &xml_doc, QFile *file, QString *error_message)
{
    bool opened_here = file->isOpen() ? false : true;

    if (!file->isOpen())
    {
        bool open_ = file->open(QIODevice::WriteOnly);
        if (!open_)
        {
            if (error_message)
            {
                QFileInfo info_(*file);
                *error_message = QString(
                            QObject::tr("Impossible d'ouvrir le fichier %1 en écriture, erreur %2 rencontrée.",
                                        "error message when attempting to write an XML file")
                ).arg(info_.absoluteFilePath()).arg(file->error());
            }
            return false;
        }
    }

    QTextStream out(file);
    out.seek(0);
    out.setCodec("UTF-8");
    out.setGenerateByteOrderMark(false);
    out << xml_doc.toString(4);
    if (opened_here) {
        file->close();
    }

    return(true);
}