templatescollection.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 "templatescollection.h"
#include "titleblocktemplate.h"
#include "qetapp.h"
#include "qetproject.h"

TitleBlockTemplatesCollection::TitleBlockTemplatesCollection(QObject *parent) :
    QObject(parent),
    protocol_("unknown")
{
}

TitleBlockTemplatesCollection::~TitleBlockTemplatesCollection() {
}

QString TitleBlockTemplatesCollection::title() const {
    return(title_);
}

void TitleBlockTemplatesCollection::setTitle(const QString &title) {
    title_ = title;
}

QString TitleBlockTemplatesCollection::protocol() const {
    return(protocol_);
}

void TitleBlockTemplatesCollection::setProtocol(const QString &protocol) {
    if (!protocol.isEmpty()) protocol_ = protocol;
}

QET::QetCollection TitleBlockTemplatesCollection::collection() const {
    return m_collection;
}

void TitleBlockTemplatesCollection::setCollection(QET::QetCollection c) {
    m_collection = c;
}

QETProject *TitleBlockTemplatesCollection::parentProject() {
    return(nullptr);
}

QList<TitleBlockTemplateLocation> TitleBlockTemplatesCollection::templatesLocations() {
    QList<TitleBlockTemplateLocation> locations;
    foreach (QString template_name, templates()) {
        locations << location(template_name);
    }
    return(locations);
}

TitleBlockTemplatesProjectCollection::TitleBlockTemplatesProjectCollection(QETProject *project, QObject *parent) :
    TitleBlockTemplatesCollection(parent),
    project_(project)
{
    m_collection = QET::QetCollection::Embedded;
}

TitleBlockTemplatesProjectCollection::~TitleBlockTemplatesProjectCollection() {
}

QString TitleBlockTemplatesProjectCollection::title() const {
    if (!title_.isEmpty()) return(title_);
    
    // if the title attribute is empty, we generate a suitable one using the
    // parent project
    QString final_title;
    if (project_) {
        QString project_title = project_ -> title();
        if (project_title.isEmpty()) {
            final_title = QString(
                tr(
                    "Cartouches du projet sans titre (id %1)",
                    "collection title when the parent project has an empty title -- %1 is the project internal id"
                )
            );
            final_title = final_title.arg(QETApp::projectId(project_));
        } else {
            final_title = QString(
                tr(
                    "Cartouches du projet \"%1\"",
                    "collection title when the project has a suitable title -- %1 is the project title"
                )
            );
            final_title = final_title.arg(project_title);
        }
    }
    return(final_title);
}

QString TitleBlockTemplatesProjectCollection::protocol() const {
    if (project_) {
        int project_id = QETApp::projectId(project_);
        if (project_id != -1) {
            return(QString("project%1+embedtbt").arg(project_id));
        }
    }
    // fall back on the parent method
    return(TitleBlockTemplatesCollection::protocol());
}

QETProject *TitleBlockTemplatesProjectCollection::parentProject() {
    return(project_);
}

QStringList TitleBlockTemplatesProjectCollection::templates() {
    return(titleblock_templates_xml_.keys());
}

TitleBlockTemplate *TitleBlockTemplatesProjectCollection::getTemplate(const QString &template_name){
    // Do we have already loaded this template?
    if (titleblock_templates_.contains(template_name)) {
        return(titleblock_templates_[template_name]);
    }
    
    // No? Do we even know of it?
    if (!titleblock_templates_xml_.contains(template_name)) {
        return(nullptr);
    }
    
    // Ok, we have its XML description, we have to generate a TitleBlockTemplate object
    TitleBlockTemplate *titleblock_template = new TitleBlockTemplate(this);
    if (titleblock_template -> loadFromXmlElement(titleblock_templates_xml_[template_name])) {
        titleblock_templates_.insert(template_name, titleblock_template);
        return(titleblock_template);
    } else {
        return(nullptr);
    }
}

QDomElement TitleBlockTemplatesProjectCollection::getTemplateXmlDescription(const QString &template_name)  {
    if (titleblock_templates_xml_.contains(template_name)) {
        return(titleblock_templates_xml_[template_name]);
    }
    return(QDomElement());
}

bool TitleBlockTemplatesProjectCollection::setTemplateXmlDescription(const QString &template_name, const QDomElement &xml_elmt) {
    // check basic stuff
    if (xml_elmt.tagName() != "titleblocktemplate") {
        return(false);
    }
    
    // we *require* a project (at least for the moment...)
    if (!project_) return(false);
    
    // we import the provided XML element in the project document
    QDomElement import = xml_document_.importNode(xml_elmt, true).toElement();
    
    // ensure the name stored in the XML description remains consistent with the provided template name
    import.setAttribute("name", template_name);
    
    // we either replace the previous description
    if (titleblock_templates_xml_.contains(template_name)) {
        QDomElement old_description = titleblock_templates_xml_[template_name];
        if (!old_description.parentNode().isNull()) {
            old_description.parentNode().replaceChild(import, old_description);
        }
    }
    titleblock_templates_xml_.insert(template_name, import);
    
    if (titleblock_templates_.contains(template_name)) {
        titleblock_templates_[template_name] -> loadFromXmlElement(titleblock_templates_xml_[template_name]);
    }
    emit(changed(this, template_name));
    
    return(true);
}

void TitleBlockTemplatesProjectCollection::removeTemplate(const QString &template_name) {
    emit(aboutToRemove(this, template_name));
    
    // remove the template itself
    titleblock_templates_xml_.remove(template_name);
    titleblock_templates_.remove(template_name);
    
    // warn the rest of the world that the list of templates embedded within this project has changed
    emit(changed(this, template_name));
}

TitleBlockTemplateLocation TitleBlockTemplatesProjectCollection::location(const QString &template_name) {
    return(TitleBlockTemplateLocation(template_name, this));
}

bool TitleBlockTemplatesProjectCollection::hasFilePath() {
    return(false);
}

QString TitleBlockTemplatesProjectCollection::filePath() {
    return(QString());
}

bool TitleBlockTemplatesProjectCollection::isReadOnly(const QString &template_name) const {
    Q_UNUSED(template_name)
    if (project_) {
        return(project_ -> isReadOnly());
    }
    return(false);
}

void TitleBlockTemplatesProjectCollection::fromXml(const QDomElement &xml_element) {
    foreach (QDomElement e, QET::findInDomElement(xml_element, "titleblocktemplates", "titleblocktemplate")) {
        // each titleblock template must have a name
        if (!e.hasAttribute("name")) continue;
        QString titleblock_template_name = e.attribute("name");
        
        // if several templates have the same name, we keep the first one encountered
        if (titleblock_templates_xml_.contains(titleblock_template_name)) continue;
        
        // we simply store the XML element describing the titleblock template,
        // without any further analysis for the moment
        titleblock_templates_xml_.insert(titleblock_template_name, e);
    }
}

void TitleBlockTemplatesProjectCollection::deleteUnusedTitleBlocKTemplates() {
    if (!project_) return;
    
    foreach (QString template_name, templates()) {
        if (!project_ -> usesTitleBlockTemplate(location(template_name))) {
            removeTemplate(template_name);
        }
    }
}

TitleBlockTemplatesFilesCollection::TitleBlockTemplatesFilesCollection(const QString &path, QObject *parent) :
    TitleBlockTemplatesCollection(parent),
    dir_(
        path,
        QString("*%1").arg(TITLEBLOCKS_FILE_EXTENSION),
        QDir::SortFlags(QDir::Name | QDir::IgnoreCase),
        QDir::Readable | QDir::Files
    )
{
    if (dir_.exists()) {
        watcher_.addPath(dir_.canonicalPath());
    }
    connect(&watcher_, SIGNAL(directoryChanged(const QString &)), this, SLOT(fileSystemChanged(const QString &)));
}

TitleBlockTemplatesFilesCollection::~TitleBlockTemplatesFilesCollection() {
}

QString TitleBlockTemplatesFilesCollection::path(const QString &template_name) const {
    if (template_name.isEmpty()) {
        return(dir_.canonicalPath());
    } else {
        return(dir_.absoluteFilePath(toFileName(template_name)));
    }
}

QStringList TitleBlockTemplatesFilesCollection::templates() {
    QStringList templates_names;
    QRegExp replace_regexp(QString("%1$").arg(TITLEBLOCKS_FILE_EXTENSION));
    foreach(QString name, dir_.entryList()) {
        templates_names << name.replace(replace_regexp, "");
    }
    return(templates_names);
}

TitleBlockTemplate *TitleBlockTemplatesFilesCollection::getTemplate(const QString &template_name) {
    if (!templates().contains(template_name)) return(nullptr);
    
    TitleBlockTemplate *tbtemplate = new TitleBlockTemplate();
    QString tbt_file_path = path(template_name);
    
    bool loading = tbtemplate -> loadFromXmlFile(tbt_file_path);
    if (!loading) {
        delete tbtemplate;
        return(nullptr);
    }
    return(tbtemplate);
}

QDomElement TitleBlockTemplatesFilesCollection::getTemplateXmlDescription(const QString &template_name) {
    QString xml_file_path = path(template_name);
    
    QFileInfo xml_file_info(xml_file_path);
    if (!xml_file_info.exists() || !xml_file_info.isReadable()) {
        return(QDomElement());
    }
    
    QFile xml_file(xml_file_path);
    if (!xml_file.open(QIODevice::ReadOnly)) {
        return(QDomElement());
    }
    
    QDomDocument *xml_document = new QDomDocument();
    bool xml_parsing = xml_document -> setContent(&xml_file);
    if (!xml_parsing) {
        delete xml_document;
        return(QDomElement());
    }
    return(xml_document -> documentElement());
}

bool TitleBlockTemplatesFilesCollection::setTemplateXmlDescription(const QString &template_name, const QDomElement &xml_element) {
    if (template_name.isEmpty()) return(false);
    
    // prevent the watcher from emitting signals while we open and write to file
    blockSignals(true);
    
    QDomDocument doc;
    doc.appendChild(doc.importNode(xml_element, true));
    
    bool writing = QET::writeXmlFile(doc, path(template_name));
    if (!writing) return(false);
    
    // emit a single signal for the change
    blockSignals(false);
    emit(changed(this, template_name));
    return(true);
}

void TitleBlockTemplatesFilesCollection::removeTemplate(const QString &template_name) {
    emit(aboutToRemove(this, template_name));
    // prevent the watcher from emitting signals while we open and write to file
    blockSignals(true);
    
    dir_.remove(toFileName(template_name));
    
    // emit a single signal for the removal
    blockSignals(false);
    emit(changed(this, template_name));
}

TitleBlockTemplateLocation TitleBlockTemplatesFilesCollection::location(const QString &template_name) {
    return(TitleBlockTemplateLocation(template_name, this));
}

bool TitleBlockTemplatesFilesCollection::hasFilePath() {
    return(true);
}

QString TitleBlockTemplatesFilesCollection::filePath() {
    return(dir_.canonicalPath());
}

bool TitleBlockTemplatesFilesCollection::isReadOnly(const QString &template_name) const {
    if (template_name.isEmpty()) {
        QFileInfo info(dir_.canonicalPath());
        return(!info.isWritable());
    } else {
        QFileInfo info(dir_.absoluteFilePath(toFileName(template_name)));
        return(!info.isWritable());
    }
}

QString TitleBlockTemplatesFilesCollection::toTemplateName(const QString &file_name) {
    static QRegExp replace_regexp(QString("%1$").arg(TITLEBLOCKS_FILE_EXTENSION));
    QString template_name(file_name);
    return(template_name.replace(replace_regexp, ""));
}

QString TitleBlockTemplatesFilesCollection::toFileName(const QString &template_name) {
    return(QString("%1%2").arg(template_name).arg(TITLEBLOCKS_FILE_EXTENSION));
}

void TitleBlockTemplatesFilesCollection::fileSystemChanged(const QString &str) {
    Q_UNUSED(str);
    dir_.refresh();
    emit(changed(this));
}