diagramcontext.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 "diagramcontext.h"
#include <QRegExp>
#include "qet.h"
#include <algorithm>

void DiagramContext::add(DiagramContext other)
{
    for (QString key : other.keys()) {
        addValue(key, other.value(key));
    }
}

QList<QString> DiagramContext::keys(DiagramContext::KeyOrder order) const
{
    if (order == None) {
        return m_content.keys();
    }
    else
    {
        QList<QString> keys_list = m_content.keys();
        if (order == Alphabetical) {
            std::sort(keys_list.begin(), keys_list.end());
        } else {
            std::sort(keys_list.begin(), keys_list.end(), DiagramContext::stringLongerThan);
        }
        return(keys_list);
    }
}

bool DiagramContext::contains(const QString &key) const {
    return(m_content.contains(key));
}

const QVariant DiagramContext::operator[](const QString &key) const {
    return(m_content[key]);
}

bool DiagramContext::addValue(const QString &key, const QVariant &value, bool show) {
    if (keyIsAcceptable(key)) {
        m_content.insert(key, value);
        m_content_show.insert(key, show);
        return(true);
        }
    return(false);
}

QVariant DiagramContext::value(const QString &key) const {
    return m_content.value(key);
}

void DiagramContext::clear() {
    m_content.clear();
    m_content_show.clear();
}

int DiagramContext::count() {
    return(m_content.count());
}

bool DiagramContext::keyMustShow(const QString &key) const {
    if (m_content_show.contains(key))
        return m_content_show[key];
    return false;
}

bool DiagramContext::operator==(const DiagramContext &dc) const {
    return(m_content     == dc.m_content &&
           m_content_show == dc.m_content_show);
}

bool DiagramContext::operator!=(const DiagramContext &dc) const {
    return(!(*this == dc));
}

void DiagramContext::toXml(QDomElement &e, const QString &tag_name) const {
    foreach (QString key, keys()) {
        QDomElement property = e.ownerDocument().createElement(tag_name);
        property.setAttribute("name", key);
        property.setAttribute("show",m_content_show[key]);
        QDomText value = e.ownerDocument().createTextNode(m_content[key].toString());
        property.appendChild(value);
        e.appendChild(property);
    }
}

void DiagramContext::fromXml(const QDomElement &e, const QString &tag_name) {
    foreach (QDomElement property, QET::findInDomElement(e, tag_name)) {
        if (!property.hasAttribute("name")) continue;
        addValue(property.attribute("name"), QVariant(property.text()));
        m_content_show.insert(property.attribute("name"), property.attribute("show", "1").toInt());
    }
}

void DiagramContext::toSettings(QSettings &settings, const QString &array_name) const {
    settings.beginWriteArray(array_name);
    int i = 0;
    foreach (QString key, m_content.keys()) {
        settings.setArrayIndex(i);
        settings.setValue("name", key);
        settings.setValue("value", m_content[key].toString());
        ++ i;
    }
    settings.endArray();
}

void DiagramContext::fromSettings(QSettings &settings, const QString &array_name) {
    int size = settings.beginReadArray(array_name);
    for (int i = 0 ; i < size; ++ i) {
        settings.setArrayIndex(i);
        QString key = settings.value("name").toString();
        if (key.isEmpty()) continue;
        addValue(key, settings.value("value").toString());
    }
    settings.endArray();
}

QString DiagramContext::validKeyRegExp() {
    return("^[a-z0-9-]+$");
}

bool DiagramContext::stringLongerThan(const QString &a, const QString &b) {
    return (a.length() > b.length());
}

bool DiagramContext::keyIsAcceptable(const QString &key) const {
    QRegExp re(DiagramContext::validKeyRegExp());
    return(re.exactMatch(key));
}