xmlelementcollection.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 "xmlelementcollection.h"
#include "nameslist.h"
#include "qetxml.h"
#include "elementslocation.h"
#include "qetproject.h"

XmlElementCollection::XmlElementCollection(QETProject *project) :
    QObject(project),
    m_project(project)
{
    QDomElement collection = m_dom_document.createElement("collection");
    m_dom_document.appendChild(collection);
    QDomElement import = m_dom_document.createElement("category");
    import.setAttribute("name", "import");
    collection.appendChild(import);

    NamesList names;

    const QChar russian_data[24] = { 0x0418, 0x043C, 0x043F, 0x043E, 0x0440, 0x0442, 0x0438, 0x0440, 0x043E, 0x0432, 0x0430, 0x043D, 0x043D, 0x044B, 0x0435, 0x0020, 0x044D, 0x043B, 0x0435, 0x043C, 0x0435, 0x043D, 0x0442, 0x044B };
    const QChar greek_data[18] = { 0x0395, 0x03b9, 0x03c3, 0x03b7, 0x03b3, 0x03bc, 0x03ad, 0x03bd, 0x03b1, 0x0020, 0x03c3, 0x03c4, 0x03bf, 0x03b9, 0x03c7, 0x03b5, 0x03af, 0x03b1 };
    const QChar turkish_data[12] ={ 0x0130, 0x0074, 0x0068, 0x0061, 0x006C, 0x0020, 0x00F6, 0x011F, 0x0065, 0x006C, 0x0065, 0x0072 };
    names.addName("fr", "Éléments importés");
    names.addName("en", "Imported elements");
    names.addName("de", "Importierte elemente");
    names.addName("es", "Elementos importados");
    names.addName("ru", QString(russian_data, 24));
    names.addName("cs", "Zavedené prvky");
    names.addName("pl", "Elementy importowane");
    names.addName("pt", "elementos importados");
    names.addName("it", "Elementi importati");
    names.addName("el", QString(greek_data, 18));
    names.addName("nl", "Elementen geïmporteerd");
    names.addName("hr", "Uvezeni elementi");
    names.addName("ca", "Elements importats");
    names.addName("ro", "Elemente importate");
    names.addName("tr", QString(turkish_data, 12));
    names.addName("da", "Importerede elementer");
    names.addName("hr", "Uvezeni elementi");
    names.addName("sl", "Uvoženi elementi");
    

    import.appendChild(names.toXml(m_dom_document));
}

XmlElementCollection::XmlElementCollection(const QDomElement &dom_element, QETProject *project) :
    QObject(project),
    m_project(project)
{
    if (dom_element.tagName() == "collection")
        m_dom_document.appendChild(m_dom_document.importNode(dom_element, true));
    else
        qDebug() << "XmlElementCollection : tagName of dom_element is not collection";
}

QDomElement XmlElementCollection::root() const {
    return m_dom_document.documentElement();
}

QDomElement XmlElementCollection::importCategory() const {
    return root().firstChildElement("category");
}

QDomNodeList XmlElementCollection::childs(const QDomElement &parent_element) const
{
    if (parent_element.ownerDocument() != m_dom_document) return QDomNodeList();
    return parent_element.childNodes();
}

QDomElement XmlElementCollection::child(const QDomElement &parent_element, const QString &child_name) const
{
    if (parent_element.ownerDocument() != m_dom_document) return QDomElement();

        //Get all childs element of parent_element
    QDomNodeList child_list = parent_element.childNodes();
    QString tag_name(child_name.endsWith(".elmt")? "element" : "category");
    QList <QDomElement> found_dom_element;
    for (int i=0 ; i<child_list.length() ; i++)
    {
        QDomElement child_element = child_list.item(i).toElement();
        if (child_element.tagName() == tag_name) found_dom_element << child_element;
    }

    if (found_dom_element.isEmpty()) return QDomElement();

    foreach (QDomElement elmt, found_dom_element)
        if (elmt.attribute("name") == child_name)
            return elmt;

    return QDomElement();
}

QDomElement XmlElementCollection::child(const QString &path) const
{
    QStringList path_list = path.split("/");
    if (path_list.isEmpty()) return QDomElement();

    QDomElement parent_element = root();
    foreach (QString str, path_list)
    {
        QDomElement child_element = child(parent_element, str);

        if (child_element.isNull())
            return QDomElement();
        else
            parent_element = child_element;
    }

    return parent_element;
}

QList<QDomElement> XmlElementCollection::directories(const QDomElement &parent_element) const
{
    QList <QDomElement> directory_list;
    QDomNodeList node_list = childs(parent_element);
    if (node_list.isEmpty()) return directory_list;

    for (int i=0 ; i < node_list.count() ; i++)
    {
        QDomNode node = node_list.at(i);
        if (node.isElement() &&  node.toElement().tagName() == "category")
            directory_list << node.toElement();
    }

    return directory_list;
}

QStringList XmlElementCollection::directoriesNames(const QDomElement &parent_element) const
{
    QList <QDomElement> childs = directories(parent_element);
    QStringList names;

    foreach (QDomElement child, childs)
    {
        QString name = child.attribute("name");
        if (!name.isEmpty())
            names.append(name);
    }

    return names;
}

QList<QDomElement> XmlElementCollection::elements(const QDomElement &parent_element) const
{
    QList <QDomElement> element_list;
    QDomNodeList node_list = childs(parent_element);
    if (node_list.isEmpty()) return element_list;

    for (int i=0 ; i < node_list.count() ; i++)
    {
        QDomNode node = node_list.at(i);
        if (node.isElement() &&  node.toElement().tagName() == "element")
            element_list << node.toElement();
    }

    return element_list;
}

QStringList XmlElementCollection::elementsNames(const QDomElement &parent_element) const
{
    QList <QDomElement> childs = elements(parent_element);
    QStringList names;

    foreach (QDomElement child, childs)
    {
        QString name = child.attribute("name");
        if (!name.isEmpty())
            names.append(name);
    }

    return names;
}

QDomElement XmlElementCollection::element(const QString &path) const
{
    if (!path.endsWith(".elmt")) return QDomElement();

    QDomElement element = child(path);

    if (element.tagName() == "element")
        return element;
    else
        return QDomElement();
}

QDomElement XmlElementCollection::directory(const QString &path) const
{
    QDomElement directory = child(path);

    if (directory.tagName() == "category")
        return directory;
    else
        return QDomElement();
}

QString XmlElementCollection::addElement(ElementsLocation &location)
{
        //location must be an element and exist
    if (!(location.exist() && location.isElement()))
        return QString();

        //Add an element from this collection to this collection have no sense
    if (location.isProject() && location.projectCollection() == this)
        return QString();

        //First we check if this location exist in this collection if so, we do nothing
    if ( exist("import/" + location.collectionPath(false)) )
        return QString();

        //Get the import dir of this collection
    QDomElement parent_element = importCategory();
    if (parent_element.isNull())
        return QString();

    QString integrated_path = parent_element.attribute("name");

        //Split the path
    QStringList splitted_path = location.collectionPath(false).split("/");
    if (splitted_path.isEmpty())
        return QString();

    if (location.isFileSystem()) {
            //Get the root dir of the filesystem collection
        QDir dir(location.fileSystemPath().remove(location.collectionPath(false)));
        if (!dir.exists())
            return QString();

        foreach(QString str, splitted_path) {
            QDomElement child_element = child(parent_element, str);

                //Child doesn't exist, we create it
            if (child_element.isNull()) {
                QDomElement created_child;

                    //str is the path of an element, we integrate an element
                if (str.endsWith(".elmt")) {
                    QFile element_file(dir.filePath(str));
                    if (!element_file.exists())
                        return QString();

                    created_child = QETXML::fileSystemElementToXmlCollectionElement(m_dom_document, element_file);
                }

                    //str is the path of a directory, we integrate a directory.
                else {
                        //Dir doesn't exist.
                    if (!dir.cd(str))
                        return QString();

                    created_child = QETXML::fileSystemDirToXmlCollectionDir(m_dom_document, dir);
                }

                if(created_child.isNull())
                    return QString();

                parent_element.appendChild(created_child);
                parent_element = created_child;
            }
                //Child exist
            else {
                if (!dir.cd(str))
                    return QString();

                parent_element = child_element;
            }

            integrated_path.append("/"+str);
        }
    }
    else if (location.isProject()) {
        QString path;
        foreach(QString str, splitted_path) {
            if (path.isEmpty())
                path = str;
            else
                path = path + "/" + str;

            QDomElement child_element = child(parent_element, str);

                //Child doesn't exist, we create it
            if (child_element.isNull()) {
                QDomElement created_child;

                    //str is the path of an element, we integrate an element
                if (str.endsWith(".elmt")) {
                    created_child = m_dom_document.createElement("element");
                    created_child.setAttribute("name", str);

                    created_child.appendChild(location.xml().cloneNode(true));
                }

                    //str is the path of a directory, we integrate a directory.
                else {
                    created_child = m_dom_document.createElement("category");
                    created_child.setAttribute("name", str);

                    ElementsLocation sub_dir_location(path, location.project());
                    QDomElement names_element = sub_dir_location.nameList().toXml(m_dom_document);
                    created_child.appendChild(names_element);
                }

                if(created_child.isNull())
                    return QString();

                parent_element.appendChild(created_child);
                parent_element = created_child;
            }
                //Child exist
            else
                parent_element = child_element;

            integrated_path.append("/"+str);
        }
    }

    emit elementAdded(integrated_path);
    return integrated_path;
}

bool XmlElementCollection::addElementDefinition(const QString &dir_path, const QString &elmt_name, const QDomElement &xml_definition)
{
    QDomElement dom_dir = directory(dir_path);
    if (dom_dir.isNull()) {
        qDebug() << "XmlElementCollection::addElementDefinition : No directory at path : " << dir_path;
        return false;
    }

    if (xml_definition.tagName() != "definition") {
        qDebug() << "XmlElementCollection::addElementDefinition : xml_defintion tag name is not \"definition\"";
        return false;
    }

    QString name = elmt_name;
    if (!name.endsWith(".elmt")) {
        name += ".elmt";
    }

    QDomElement dom_elmt = m_dom_document.createElement("element");
    dom_elmt.setAttribute("name", name);
    dom_elmt.appendChild(xml_definition.cloneNode(true));
    dom_dir.appendChild(dom_elmt);

    emit elementAdded(dir_path + "/" + name);

    return true;
}

bool XmlElementCollection::removeElement(const QString& path)
{
    QDomElement elmt = element(path);

    if (!elmt.isNull()) {
        elmt.parentNode().removeChild(elmt);
        emit elementRemoved(path);
        return true;
    }

    return false;
}

ElementsLocation XmlElementCollection::copy(ElementsLocation &source, ElementsLocation &destination, const QString& rename, bool deep_copy)
{
    if (!(source.exist() && destination.isDirectory() && destination.isProject() && destination.projectCollection() == this))
        return ElementsLocation();

    if (source.isElement())
        return copyElement(source, destination, rename);
    else
        return copyDirectory(source, destination, rename, deep_copy);
}

bool XmlElementCollection::exist(const QString &path) const
{
    if (child(path).isNull())
        return false;
    else
        return true;
}

bool XmlElementCollection::createDir(const QString& path, const QString& name, const NamesList &name_list)
{
    QString new_dir_path = path + "/" + name;

    if (!directory(new_dir_path).isNull()) {
        return true;
    }

    QDomElement parent_dir = directory(path);
    if (parent_dir.isNull()) {
        qDebug() << "XmlElementCollection::createDir : directorie at path doesn't exist";
        return false;
    }

    QDomElement new_dir = m_dom_document.createElement("category");
    new_dir.setAttribute("name", name);
    new_dir.appendChild(name_list.toXml(m_dom_document));

    parent_dir.appendChild(new_dir);

    emit directorieAdded(new_dir_path);

    return true;
}

bool XmlElementCollection::removeDir(const QString& path)
{
    QDomElement dir = directory(path);
    if (!dir.isNull()) {
        dir.parentNode().removeChild(dir);
        emit directoryRemoved(path);
        return true;
    }
    return false;
}

QList<ElementsLocation> XmlElementCollection::elementsLocation(QDomElement dom_element, bool childs) const
{
    QList <ElementsLocation> location_list;

    if (dom_element.isNull())
        dom_element = m_dom_document.documentElement();

    if (dom_element.ownerDocument() != m_dom_document)
        return location_list;

        //get element childs
    QList <QDomElement> element_list = elements(dom_element);

    foreach (QDomElement elmt, element_list) {
        ElementsLocation location = domToLocation(elmt);
        if (location.exist())
            location_list << location;
    }

        //get directory childs
    QList <QDomElement> directory_list = directories(dom_element);

    foreach (QDomElement dir, directory_list) {
        ElementsLocation location = domToLocation(dir);
        if (location.exist())
            location_list << location;

        if (childs)
            location_list.append(elementsLocation(dir, childs));
    }

    return location_list;
}

ElementsLocation XmlElementCollection::domToLocation(QDomElement dom_element) const
{
    if (dom_element.ownerDocument() == m_dom_document) {
        QString path = dom_element.attribute("name");

        while (!dom_element.parentNode().isNull() && dom_element.parentNode().isElement()) {
            dom_element = dom_element.parentNode().toElement();

            if (dom_element.tagName() == "category")
                path.prepend(dom_element.attribute("name") + "/");
        }

        return ElementsLocation(path, m_project);
    }
    else
        return ElementsLocation();
}

void XmlElementCollection::cleanUnusedElement()
{
    foreach (ElementsLocation loc, m_project->unusedElements())
        removeElement(loc.collectionPath(false));
}

void XmlElementCollection::cleanUnusedDirectory()
{
    QDomNodeList lst = importCategory().elementsByTagName("category");

    for(int i=0 ; i<lst.size() ; i++) {
        QDomElement dir = lst.item(i).toElement();
            //elmt haven't got child node "element" or "category", so he is emty, we can remove it
        if (dir.elementsByTagName("element").isEmpty() && dir.elementsByTagName("category").isEmpty()) {
            if (removeDir(domToLocation(dir).collectionPath(false)))
                i=-1;
        }
    }
}

ElementsLocation XmlElementCollection::copyDirectory(ElementsLocation &source, ElementsLocation &destination, const QString& rename, bool deep_copy)
{
    QString new_dir_name = rename.isEmpty() ? source.fileName() : rename;

            //Get the xml directory where the new directory must be added
    QDomElement parent_dir_dom = directory(destination.collectionPath(false));
    if (parent_dir_dom.isNull()) return ElementsLocation();

        //Remove the previous directory with the same path
    QDomElement element = child(destination.collectionPath(false) + "/" + new_dir_name);
    if (!element.isNull()) {
        element.parentNode().removeChild(element);
        emit directoryRemoved(destination.collectionPath(false) + "/" + new_dir_name);
    }

    ElementsLocation created_location;

        //Copy with a file system collection source
    if (source.isFileSystem())
    {
        QDir source_dir(source.fileSystemPath());
        if (!source_dir.exists()) return ElementsLocation();


        QDir dir(source.fileSystemPath());
        QDomElement elmt_dom = QETXML::fileSystemDirToXmlCollectionDir(m_dom_document, dir, new_dir_name);
        if (elmt_dom.isNull()) return ElementsLocation();

        parent_dir_dom.appendChild(elmt_dom);

        created_location.setPath(destination.projectCollectionPath() + "/" + new_dir_name);

        if (deep_copy)
        {
                //Append all directories of source to the new created directory
            foreach(QString str, source_dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name))
            {
                ElementsLocation sub_source(source.fileSystemPath() + "/" + str);
                copyDirectory(sub_source, created_location);
            }

                //Append all elements of source to the new created directory
            source_dir.setNameFilters(QStringList() << "*.elmt");
            foreach(QString str, source_dir.entryList(QDir::Files | QDir::NoDotAndDotDot, QDir::Name))
            {
                ElementsLocation sub_source(source.fileSystemPath() + "/" + str);
                copyElement(sub_source, created_location);
            }
        }
    }

        //Copy with a xml collection source
    else
    {
        if (!source.projectCollection()) return ElementsLocation();

        QDomNode other_collection_node = source.projectCollection()->child(source.collectionPath(false)).cloneNode(deep_copy);

            //We don't make a deep copy, but we must to get the local names of the copied directory
        if (!deep_copy) {
            QDomNode names = source.projectCollection()->child(source.collectionPath(false)).namedItem("names");
            if (!names.isNull() && names.isElement())
                other_collection_node.appendChild(names.cloneNode(true));
        }

        if (other_collection_node.isNull()) return ElementsLocation();

        QDomElement other_collection_dom_dir = other_collection_node.toElement();
        other_collection_dom_dir.setAttribute("name", new_dir_name);
        parent_dir_dom.appendChild(other_collection_dom_dir);

        created_location.setPath(destination.projectCollectionPath() + "/" + new_dir_name);
    }

    emit directorieAdded(created_location.collectionPath(false));
    return created_location;
}

ElementsLocation XmlElementCollection::copyElement(ElementsLocation &source, ElementsLocation &destination, const QString& rename)
{
    QString new_elmt_name = rename.isEmpty() ? source.fileName() : rename;

    QDomElement elmt_dom;

        //Copy with a file system collection source
    if (source.isFileSystem())
    {
        QFile file(source.fileSystemPath());
        elmt_dom = QETXML::fileSystemElementToXmlCollectionElement(m_dom_document, file, new_elmt_name);
        if (elmt_dom.isNull()) return ElementsLocation();
    }
        //Copy with a xml collection source
    else
    {
        QDomElement other_collection = source.xml();
        elmt_dom = m_dom_document.createElement("element");
        elmt_dom.setAttribute("name", new_elmt_name);
        elmt_dom.appendChild(other_collection.cloneNode());
    }


        //Remove the previous element with the same path
    QDomElement element = child(destination.collectionPath(false) + "/" + new_elmt_name);
    bool removed = false;
    if (!element.isNull()) {
        element.parentNode().removeChild(element);
        removed = true;
    }

        //Get the xml directory where the new element must be added
    QDomElement dir_dom = directory(destination.collectionPath(false));
    if (dir_dom.isNull()) return ElementsLocation();
    dir_dom.appendChild(elmt_dom);

    ElementsLocation copy_loc(destination.projectCollectionPath() + "/" + new_elmt_name);

    if (removed) {
        emit elementChanged(copy_loc.collectionPath(false));
    }
    else {
        emit elementAdded(copy_loc.collectionPath(false));
    }

    return copy_loc;
}