nameslist.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 "nameslist.h"
#include "qetapp.h"

// make this class usable with QVariant
int NamesList::MetaTypeId = qRegisterMetaType<NamesList>("NamesList");

NamesList::NamesList() {
}

NamesList::NamesList(const NamesList &other) : hash_names(other.hash_names) {   
}

NamesList::~NamesList() {
}

void NamesList::addName(const QString &lang, const QString &name) {
    if (lang.length() != 2) return;
    hash_names.insert(lang, name);
}

void NamesList::removeName(const QString &lang) {
    hash_names.remove(lang);
}

void NamesList::clearNames() {
    hash_names.clear();
}

QList<QString> NamesList::langs() const {
    return(hash_names.keys());
}

bool NamesList::isEmpty() const {
    return(hash_names.isEmpty());
}

int NamesList::count() const {
    return(hash_names.count());
}

QString &NamesList::operator[](const QString &lang) {
    return(hash_names[lang]);
}

const QString NamesList::operator[](const QString &lang) const {
    return(hash_names.value(lang));
}



void NamesList::fromXml(const QDomElement &xml_element, const QHash<QString, QString> &xml_options) {
    QHash<QString, QString> xml_opt = getXmlOptions(xml_options);
    // parcourt les enfants "names" de l'element XML
    for (QDomNode node = xml_element.firstChild() ; !node.isNull() ; node = node.nextSibling()) {
        QDomElement names = node.toElement();
        if (names.isNull() || names.tagName() != xml_opt["ParentTagName"]) continue;
        // parcourt les petits-enfants "name"
        for (QDomNode n = names.firstChild() ; !n.isNull() ; n = n.nextSibling()) {
            QDomElement name = n.toElement();
            if (name.isNull() || name.tagName() != xml_opt["TagName"]) continue;
            addName(name.attribute(xml_opt["LanguageAttribute"]), name.text());
        }
    }
}

QDomElement NamesList::toXml(QDomDocument &xml_document, const QHash<QString, QString> &xml_options) const {
    QHash<QString, QString> xml_opt = getXmlOptions(xml_options);
    QDomElement names_elmt = xml_document.createElement(xml_opt["ParentTagName"]);
    QHashIterator<QString, QString> names_iterator(hash_names);
    while (names_iterator.hasNext()) {
        names_iterator.next();
        QDomElement name_elmt = xml_document.createElement(xml_opt["TagName"]);
        name_elmt.setAttribute(xml_opt["LanguageAttribute"], names_iterator.key());
        name_elmt.appendChild(xml_document.createTextNode(names_iterator.value()));
        names_elmt.appendChild(name_elmt);
    }
    return(names_elmt);
}

QHash<QString, QString> NamesList::getXmlOptions(const QHash<QString, QString> &xml_options) const {
    QHash<QString, QString> new_xml_options = xml_options;
    if (!xml_options.contains("ParentTagName")) {
        new_xml_options.insert("ParentTagName", "names");
    }
    if (!xml_options.contains("TagName")) {
        new_xml_options.insert("TagName", "name");
    }
    if (!xml_options.contains("LanguageAttribute")) {
        new_xml_options.insert("LanguageAttribute", "lang");
    }
    return new_xml_options;
}

bool NamesList::operator!=(const NamesList &nl) const {
    return(hash_names != nl.hash_names);
}

bool NamesList::operator==(const NamesList &nl) const {
    return(hash_names == nl.hash_names);
}

QString NamesList::name(const QString &fallback_name) const {
    QString system_language = QETApp::langFromSetting();
    QString returned_name;
    if (!hash_names[system_language].isEmpty()) {
        returned_name = hash_names[system_language];
    } else if (!hash_names["en"].isEmpty()) {
        returned_name = hash_names["en"];
    } else if (!fallback_name.isEmpty()) {
        returned_name = fallback_name;
    } else if (hash_names.count()) {
        returned_name = hash_names.value(hash_names.keys().first());
    }
    return(returned_name);
}