fileelementcollectionitem.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 "fileelementcollectionitem.h"
#include "elementslocation.h"
#include "qetapp.h"
#include "qeticons.h"

#include <QDir>

FileElementCollectionItem::FileElementCollectionItem()
{}

bool FileElementCollectionItem::setRootPath(const QString& path, bool set_data, bool hide_element)
{
    QDir dir(path);
    if (dir.exists()) {
        m_path = path;
        populate(set_data, hide_element);
        return true;
    }

    return false;
}

QString FileElementCollectionItem::fileSystemPath() const
{
    if (isCollectionRoot())
        return m_path;

    FileElementCollectionItem *feci = static_cast<FileElementCollectionItem *> (parent());
    if (feci)
        return feci->fileSystemPath() + "/" + m_path;
    else
        return QString();
}

QString FileElementCollectionItem::dirPath() const
{
    if (isDir())
        return fileSystemPath();
    else if (parent() && parent()->type() == FileElementCollectionItem::Type)
        return static_cast<FileElementCollectionItem*>(parent())->fileSystemPath();
    else
        return QString();
}

bool FileElementCollectionItem::isDir() const
{
    if (m_path.endsWith(".elmt"))
        return false;
    else
        return true;

}

bool FileElementCollectionItem::isElement() const
{
    return (!isDir());
}

QString FileElementCollectionItem::localName()
{
    if (!text().isNull())
        return text();

    else if (isDir()) {
        if (isCollectionRoot()) {
            if (m_path == QETApp::commonElementsDirN())
                setText(QObject::tr("Collection QET"));
            else if (m_path == QETApp::customElementsDirN())
                setText(QObject::tr("Collection utilisateur"));
            else
                setText(QObject::tr("Collection inconnue"));
        }
        else {
                //Open the qet_directory file, to get the traductions name of this dir
            QFile dir_conf(fileSystemPath() + "/qet_directory");

            if (dir_conf.exists() && dir_conf.open(QIODevice::ReadOnly | QIODevice::Text)) {

                    //Get the content of the file
                QDomDocument document;
                if (document.setContent(&dir_conf)) {
                    QDomElement root = document.documentElement();
                    if (root.tagName() == "qet-directory") {
                        NamesList nl;
                        nl.fromXml(root);
                        setText(nl.name());
                    }
                }
            }
        }
    }
    else if (isElement()) {
        ElementsLocation loc(collectionPath());
        setText(loc.name());
    }

    return text();
}

QString FileElementCollectionItem::name() const
{
    if (isCollectionRoot())
        return QString();
    else
        return m_path;
}

QString FileElementCollectionItem::collectionPath() const
{
    if (isCollectionRoot()) {
        if (m_path == QETApp::commonElementsDirN())
            return "common://";
        else
            return "custom://";
    }
    else if (parent() && parent()->type() == FileElementCollectionItem::Type) {
        ElementCollectionItem *eci = static_cast<ElementCollectionItem*>(parent());
        if (eci->isCollectionRoot())
            return eci->collectionPath() + m_path;
        else
            return eci->collectionPath() + "/" + m_path;
    }
    else
        return QString();
}

bool FileElementCollectionItem::isCollectionRoot() const
{
    if (m_path == QETApp::commonElementsDirN() || m_path == QETApp::customElementsDirN())
        return true;
    else
        return false;
}

bool FileElementCollectionItem::isCommonCollection() const
{
    return fileSystemPath().startsWith(QETApp::commonElementsDirN());
}

bool FileElementCollectionItem::isCustomCollection() const
{
    return fileSystemPath().startsWith(QETApp::customElementsDirN());
}

void FileElementCollectionItem::addChildAtPath(const QString &collection_name)
{
    if (collection_name.isEmpty())
        return;

    FileElementCollectionItem *feci = new FileElementCollectionItem();
    insertRow(rowForInsertItem(collection_name), feci);
    feci->setPathName(collection_name);
    feci->setUpData();
}

void FileElementCollectionItem::setUpData()
{
        //Setup the displayed name
    localName();

    if (isDir())
        setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsEnabled);
    else
    {
        setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled);
        
            //Set the local name and all informations of the element
            //in the data Qt::UserRole+1, these data will be use for search.
        ElementsLocation location(collectionPath());
        DiagramContext context = location.elementInformations();
        QStringList search_list;
        for (QString key : context.keys()) {
            search_list.append(context.value(key).toString());
        }
        search_list.append(localName());
        setData(search_list.join(" "));
    }

    setToolTip(collectionPath());
}

void FileElementCollectionItem::setUpIcon()
{
    if (!icon().isNull())
        return;

    if (isCollectionRoot()) {
        if (m_path == QETApp::commonElementsDirN())
            setIcon(QIcon(":/ico/16x16/qet.png"));
        else
            setIcon(QIcon(":/ico/16x16/go-home.png"));
    }
    else {
        if (isDir())
            setIcon(QET::Icons::Folder);
        else {
            ElementsLocation loc(collectionPath());
            setIcon(loc.icon());
        }
    }
}

void FileElementCollectionItem::setPathName(const QString& path_name, bool set_data, bool hide_element)
{
    m_path = path_name;

        //This isn't an element, we create the childs
    if (!path_name.endsWith(".elmt"))
        populate(set_data, hide_element);
}

void FileElementCollectionItem::populate(bool set_data, bool hide_element)
{
    QDir dir (fileSystemPath());

        //Get all directory in this directory.
    foreach(QString str, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name))
    {
        FileElementCollectionItem *feci = new FileElementCollectionItem();
        appendRow(feci);
        feci->setPathName(str, set_data, hide_element);
        if (set_data)
            feci->setUpData();
    }

    if (hide_element)
        return;

        //Get all elmt file in this directory
    dir.setNameFilters(QStringList() << "*.elmt");
    foreach(QString str, dir.entryList(QDir::Files | QDir::NoDotAndDotDot, QDir::Name))
    {
        FileElementCollectionItem *feci = new FileElementCollectionItem();
        appendRow(feci);
        feci->setPathName(str, set_data);
        if (set_data)
            feci->setUpData();
    }
}