qetproject.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 "qetproject.h"
#include "diagram.h"
#include "diagramfoliolist.h"
#include "qetapp.h"
#include "qetresult.h"
#include "movetemplateshandler.h"
#include "qetmessagebox.h"
#include "titleblocktemplate.h"
#include "ui/dialogwaiting.h"
#include "numerotationcontext.h"
#include "reportproperties.h"
#include "integrationmovetemplateshandler.h"
#include "xmlelementcollection.h"
#include "importelementdialog.h"
#include "numerotationcontextcommands.h"
#include "assignvariables.h"

#include <QTimer>
#include <QStandardPaths>
#include <utility>
#include <KAutoSaveFile>

static int BACKUP_INTERVAL = 120000; //interval in ms of backup = 2min

QETProject::QETProject(QObject *parent) :
    QObject              (parent),
    m_titleblocks_collection(this)
{
    m_elements_collection = new XmlElementCollection(this);
    init();
}

QETProject::QETProject(const QString &path, QObject *parent) :
    QObject              (parent),
    m_titleblocks_collection(this)
{
    QFile file(path);
    m_state = openFile(&file);
    if (m_state != ProjectState::Ok) {
        return;
    }

    init();
}

QETProject::QETProject(KAutoSaveFile *backup, QObject *parent) :
    QObject              (parent),
    m_titleblocks_collection(this)
{
    m_state = openFile(backup);
        //Failed to open from the backup, try to open the crashed
    if (m_state != ProjectState::Ok)
    {
        QFile file(backup->managedFile().path());
        m_state = openFile(&file);
        if(m_state != ProjectState::Ok)
        {
            backup->open(QIODevice::ReadWrite);
            delete backup;
            return;
        }
    }
        //Set the real path, instead of the path of the backup.
    setFilePath(backup->managedFile().path());
    delete  backup;

        //Set the project to read only mode if the file it.
    QFileInfo fi(m_file_path);
    setReadOnly(!fi.isWritable());

    init();
}

QETProject::~QETProject() {
    qDeleteAll(m_diagrams_list);
}

void QETProject::init()
{
    connect(&m_titleblocks_collection, &TitleBlockTemplatesCollection::changed, this, &QETProject::updateDiagramsTitleBlockTemplate);
    connect(&m_titleblocks_collection, &TitleBlockTemplatesCollection::aboutToRemove, this, &QETProject::removeDiagramsTitleBlockTemplate);

    m_undo_stack = new QUndoStack(this);
    connect(m_undo_stack, SIGNAL(cleanChanged(bool)), this, SLOT(undoStackChanged(bool)));

    m_save_backup_timer.setInterval(BACKUP_INTERVAL);
    connect(&m_save_backup_timer, &QTimer::timeout, this, &QETProject::writeBackup);
    m_save_backup_timer.start();
    writeBackup();

    QSettings settings;
    int autosave_interval = settings.value("diagrameditor/autosave-interval", 0).toInt();
    if(autosave_interval > 0)
    {
        int ms = autosave_interval*60*1000;
        m_autosave_timer.setInterval(ms);
        connect(&m_autosave_timer, &QTimer::timeout, [this]()
        {
            if(!this->m_file_path.isEmpty())
                this->write();
        });
        m_autosave_timer.start();
    }
}

QETProject::ProjectState QETProject::openFile(QFile *file)
{
    bool opened_here = file->isOpen() ? false : true;
    if (!file->isOpen() && !file->open(QIODevice::ReadOnly | QIODevice::Text)) {
        return FileOpenFailed;
    }
    QFileInfo fi(*file);
    setFilePath(fi.absoluteFilePath());

        //Extract the content of the xml
    QDomDocument xml_project;
    if (!xml_project.setContent(file))
    {
        if(opened_here) {
            file->close();
        }
        return XmlParsingFailed;
    }

        //Build the project from the xml
    readProjectXml(xml_project);

    if (!fi.isWritable()) {
        setReadOnly(true);
    }
    if(opened_here) {
        file->close();
    }
    return ProjectState::Ok;
}

QETProject::ProjectState QETProject::state() const {
    return(m_state);
}

int QETProject::getFolioSheetsQuantity() const {
    return(m_folio_sheets_quantity);
}

void QETProject::setFolioSheetsQuantity(int quantity) {
    m_folio_sheets_quantity = quantity;
}

QList<Diagram *> QETProject::diagrams() const {
    return(m_diagrams_list);
}

int QETProject::folioIndex(const Diagram *diagram) const {
    // QList::indexOf returns -1 if no item matched.
    return(m_diagrams_list.indexOf(const_cast<Diagram *>(diagram)));
}

XmlElementCollection *QETProject::embeddedElementCollection() const {
    return m_elements_collection;
}

TitleBlockTemplatesProjectCollection *QETProject::embeddedTitleBlockTemplatesCollection() {
    return(&m_titleblocks_collection);
}

QString QETProject::filePath() {
    return(m_file_path);
}

void QETProject::setFilePath(const QString &filepath)
{
    if (filepath == m_file_path) {
        return;
    }

    if (m_backup_file)
    {
        delete m_backup_file;
        m_backup_file = nullptr;
    }

    m_backup_file = new KAutoSaveFile(QUrl::fromLocalFile(filepath), this);
    if (!m_backup_file->open(QIODevice::WriteOnly)) {
        delete m_backup_file;
        m_backup_file = nullptr;
    }
    m_file_path = filepath;
    
    QFileInfo fi(m_file_path);
    if (fi.isWritable()) {
        setReadOnly(false);
    }

        //title block variables should be updated after file save as dialog is confirmed, before file is saved.
    m_project_properties.addValue("saveddate", QDate::currentDate().toString("yyyy-MM-dd"));
    m_project_properties.addValue("savedtime", QDateTime::currentDateTime().toString("HH:mm"));
    m_project_properties.addValue("savedfilename", QFileInfo(filePath()).baseName());
    m_project_properties.addValue("savedfilepath", filePath());
    
    
    
    emit(projectFilePathChanged(this, m_file_path));
    emit(projectInformationsChanged(this));
    updateDiagramsFolioData();
}

QString QETProject::currentDir() const {
    QString current_directory;
    if (m_file_path.isEmpty()) {
        current_directory = QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);
    } else {
        current_directory = QFileInfo(m_file_path).absoluteDir().absolutePath();
    }
    return(current_directory);
}

QString QETProject::pathNameTitle() const {
    QString final_title;
    
    if (!project_title_.isEmpty()) {
        final_title = QString(
            tr(
                "Projet « %1 : %2»",
                "displayed title for a ProjectView - %1 is the project title, -%2 is the project path"
            )
        ).arg(project_title_).arg (m_file_path);
    } else if (!m_file_path.isEmpty()) {
        final_title = QString(
            tr(
                "Projet %1",
                "displayed title for a title-less project - %1 is the file name"
            )
        ).arg(QFileInfo(m_file_path).completeBaseName());
    } else {
        final_title = QString(
            tr(
                "Projet sans titre",
                "displayed title for a project-less, file-less project"
            )
        );
    }
    
    if (isReadOnly()) {
        final_title = QString(
            tr(
                "%1 [lecture seule]",
                "displayed title for a read-only project - %1 is a displayable title"
            )
        ).arg(final_title);
    }
    if (m_modified) {
        final_title = QString(
            tr(
                "%1 [modifié]",
                "displayed title for a modified project - %1 is a displayable title"
            )
        ).arg(final_title);
    }
    
    return(final_title);
}

QString QETProject::title() const {
    return(project_title_);
}

qreal QETProject::declaredQElectroTechVersion() {
    return(m_project_qet_version);
}

void QETProject::setTitle(const QString &title) {
    // ne fait rien si le projet est en lecture seule
    if (isReadOnly()) return;
    
    // ne fait rien si le titre du projet n'est pas change par l'appel de cette methode
    if (project_title_ == title) return;
    
    project_title_ = title;
    emit(projectTitleChanged(this, project_title_));
    emit(projectInformationsChanged(this));
    updateDiagramsFolioData();
}

BorderProperties QETProject::defaultBorderProperties() const {
    return(default_border_properties_);
}

void QETProject::setDefaultBorderProperties(const BorderProperties &border) {
    default_border_properties_ = border;
}

TitleBlockProperties QETProject::defaultTitleBlockProperties() const {
    return(default_titleblock_properties_);
}

void QETProject::setDefaultTitleBlockProperties(const TitleBlockProperties &titleblock) {
    default_titleblock_properties_ = titleblock;
        //Integrate the title block in this project
    if (!titleblock.template_name.isEmpty())
    {
        TitleBlockTemplatesFilesCollection *collection = nullptr;
        switch (titleblock.collection)
        {
            case QET::Common :
                collection = QETApp::commonTitleBlockTemplatesCollection();
                break;
            case QET::Custom :
                collection = QETApp::customTitleBlockTemplatesCollection();
                break;
            case QET::Embedded :
                //Titleblock is already embedded to project
                return;
            default:
                return;
        }

        QScopedPointer<IntegrationMoveTitleBlockTemplatesHandler> m(new IntegrationMoveTitleBlockTemplatesHandler);
        integrateTitleBlockTemplate(collection -> location(titleblock.template_name), m.data());
    }
    emit defaultTitleBlockPropertiesChanged();
}

ConductorProperties QETProject::defaultConductorProperties() const {
    return(default_conductor_properties_);
}

void QETProject::setDefaultConductorProperties(const ConductorProperties &conductor) {
    default_conductor_properties_ = conductor;
}

QString QETProject::defaultReportProperties() const {
    return m_default_report_properties;
}

void QETProject::setDefaultReportProperties(const QString &properties)
{
    QString old = m_default_report_properties;
    m_default_report_properties = properties;
    
    emit reportPropertiesChanged(old, properties);
}

void QETProject::setDefaultXRefProperties(const QString& type, const XRefProperties &properties) {
    m_default_xref_properties.insert(type, properties);
    emit XRefPropertiesChanged();
}

void QETProject::setDefaultXRefProperties(QHash<QString, XRefProperties> hash)
{
    m_default_xref_properties.swap(hash);
    emit XRefPropertiesChanged();
}

QHash <QString, NumerotationContext> QETProject::conductorAutoNum() const {
    return m_conductor_autonum;
}

QHash <QString, NumerotationContext> QETProject::elementAutoNum() const {
    return m_element_autonum;
}

QString QETProject::elementAutoNumFormula (const QString& key) const
{
    if (m_element_autonum.contains(key)) {
        return autonum::numerotationContextToFormula(m_element_autonum[key]);
    }

    return QString();
}

QString QETProject::elementAutoNumCurrentFormula() const {
    return elementAutoNumFormula(m_current_element_autonum);
}

QString QETProject::elementCurrentAutoNum () const {
    return m_current_element_autonum;
}

void QETProject::setCurrrentElementAutonum(QString autoNum) {
    m_current_element_autonum = std::move(autoNum);
}

QString QETProject::conductorAutoNumFormula (const QString& key) const
{
    if (m_conductor_autonum.contains(key))
        return autonum::numerotationContextToFormula(m_conductor_autonum.value(key));
    else
        return QString();
}

QString QETProject::conductorCurrentAutoNum () const {
    return m_current_conductor_autonum;
}

void QETProject::setCurrentConductorAutoNum(QString autoNum) {
    m_current_conductor_autonum = std::move(autoNum);
}

QHash <QString, NumerotationContext> QETProject::folioAutoNum() const {
    return  m_folio_autonum;
}

void QETProject::addConductorAutoNum(const QString& key, const NumerotationContext& context) {
    m_conductor_autonum.insert(key, context);
}

void QETProject::addElementAutoNum(const QString& key, const NumerotationContext& context)
{
    m_element_autonum.insert(key, context);
    emit elementAutoNumAdded(key);
}

void QETProject::addFolioAutoNum(const QString& key, const NumerotationContext& context) {
    m_folio_autonum.insert(key, context);
}

void QETProject::removeConductorAutoNum(const QString& key) {
    m_conductor_autonum.remove(key);
}

void QETProject::removeElementAutoNum(const QString& key)
{
    m_element_autonum.remove(key);
    emit elementAutoNumRemoved(key);
}

void QETProject::removeFolioAutoNum(const QString& key) {
    m_folio_autonum.remove(key);
}

NumerotationContext QETProject::conductorAutoNum (const QString &key) const {
    if (m_conductor_autonum.contains(key)) return m_conductor_autonum[key];
    else return NumerotationContext();
}

NumerotationContext QETProject::elementAutoNum (const QString &key) {
    if (m_element_autonum.contains(key)) return m_element_autonum[key];
    else return NumerotationContext();
}

NumerotationContext QETProject::folioAutoNum (const QString &key) const {
    if (m_folio_autonum.contains(key)) return m_folio_autonum[key];
    else return NumerotationContext();
}

void QETProject::freezeExistentConductorLabel(bool freeze, int from, int to) {
    for (int i = from; i <= to; i++) {
        m_diagrams_list.at(i)->freezeConductors(freeze);
    }
}

void QETProject::freezeNewConductorLabel(bool freeze, int from, int to) {
    for (int i = from; i <= to; i++) {
        m_diagrams_list.at(i)->setFreezeNewConductors(freeze);
    }
}

bool QETProject::isFreezeNewConductors() {
    return m_freeze_new_conductors;
}

void QETProject::setFreezeNewConductors(bool set) {
    m_freeze_new_conductors = set;
}

void QETProject::freezeExistentElementLabel(bool freeze, int from, int to) {
    for (int i = from; i <= to; i++) {
        m_diagrams_list.at(i)->freezeElements(freeze);
    }
}

void QETProject::freezeNewElementLabel(bool freeze, int from, int to) {
    for (int i = from; i <= to; i++) {
        m_diagrams_list.at(i)->setFreezeNewElements(freeze);
    }
}

bool QETProject::isFreezeNewElements() {
    return m_freeze_new_elements;
}

void QETProject::setFreezeNewElements(bool set) {
    m_freeze_new_elements = set;
}

bool QETProject::autoConductor() const
{
    return m_auto_conductor;
}

void QETProject::setAutoConductor(bool ac)
{
    if (ac != m_auto_conductor)
        m_auto_conductor = ac;
}

void QETProject::autoFolioNumberingNewFolios(){
    emit addAutoNumDiagram();
}

void QETProject::autoFolioNumberingSelectedFolios(int from, int to, const QString& autonum){
    int total_folio = m_diagrams_list.count();
    DiagramContext project_wide_properties = m_project_properties;
    for (int i=from; i<=to; i++) {
        QString title = m_diagrams_list[i] -> title();
        NumerotationContext nC = folioAutoNum(autonum);
        NumerotationContextCommands nCC = NumerotationContextCommands(nC);
        m_diagrams_list[i] -> border_and_titleblock.setFolio("%autonum");
        m_diagrams_list[i] -> border_and_titleblock.setFolioData(i + 1, total_folio, nCC.toRepresentedString(), project_wide_properties);
        m_diagrams_list[i] -> project() -> addFolioAutoNum(autonum,nCC.next());
        m_diagrams_list[i] -> update();
    }
}

QDomDocument QETProject::toXml() {
    // racine du projet
    QDomDocument xml_doc;
    QDomElement project_root = xml_doc.createElement("project");
    project_root.setAttribute("version", QET::version);
    project_root.setAttribute("title", project_title_);

    // write the present value of folioSheetsQuantity to XML.
    project_root.setAttribute("folioSheetQuantity", QString::number(m_folio_sheets_quantity));
    xml_doc.appendChild(project_root);
    
    // titleblock templates, if any
    if (m_titleblocks_collection.templates().count()) {
        QDomElement titleblocktemplates_elmt = xml_doc.createElement("titleblocktemplates");
        foreach (QString template_name, m_titleblocks_collection.templates()) {
            QDomElement e = m_titleblocks_collection.getTemplateXmlDescription(template_name);
            titleblocktemplates_elmt.appendChild(xml_doc.importNode(e, true));
        }
        project_root.appendChild(titleblocktemplates_elmt);
    }
    
    // project-wide properties
    QDomElement project_properties = xml_doc.createElement("properties");
    writeProjectPropertiesXml(project_properties);
    project_root.appendChild(project_properties);
    
    // Properties for news diagrams
    QDomElement new_diagrams_properties = xml_doc.createElement("newdiagrams");
    writeDefaultPropertiesXml(new_diagrams_properties);
    project_root.appendChild(new_diagrams_properties);
    
    // schemas
    
    // qDebug() << "Export XML de" << diagrams_.count() << "schemas";
    int order_num = 1;
    const QList<Diagram *> diagrams_list = m_diagrams_list;
    for(Diagram *diagram : diagrams_list)
    {
        // Write the diagram to XML only if it is not of type DiagramFolioList.
        DiagramFolioList *ptr = dynamic_cast<DiagramFolioList *>(diagram);
        if ( !ptr )
        {
            qDebug() << qPrintable(QString("QETProject::toXml() : exporting diagram \"%1\"").arg(diagram -> title())) << "[" << diagram << "]";
            QDomElement xml_diagram = diagram->toXml().documentElement();
            QDomNode xml_node = xml_doc.importNode(xml_diagram, true);
            
            QDomNode appended_diagram = project_root.appendChild(xml_node);
            appended_diagram.toElement().setAttribute("order", order_num ++);
        }
    }
    
        //Write the elements collection.
    project_root.appendChild(m_elements_collection->root().cloneNode(true));
    
    return(xml_doc);
}

bool QETProject::close() {
    return(true);
}

QETResult QETProject::write()
{
        // this operation requires a filepath
    if (m_file_path.isEmpty())
        return(QString("unable to save project to file: no filepath was specified"));

        // if the project was opened read-only and the file is still non-writable, do not save the project
    if (isReadOnly() && !QFileInfo(m_file_path).isWritable())
        return(QString("the file %1 was opened read-only and thus will not be written").arg(m_file_path));

        //Get the project in xml
    QDomDocument xml_project;
    xml_project.appendChild(xml_project.importNode(toXml().documentElement(), true));

    QString error_message;
    if (!QET::writeXmlFile(xml_project, m_file_path, &error_message)) return(error_message);
    
    //title block variables should be updated after file save dialog is confirmed, before file is saved.
    m_project_properties.addValue("saveddate", QDate::currentDate().toString(Qt::SystemLocaleShortDate));
    m_project_properties.addValue("savedtime", QDateTime::currentDateTime().toString("HH:mm"));
    m_project_properties.addValue("savedfilename", QFileInfo(filePath()).baseName());
    m_project_properties.addValue("savedfilepath", filePath());
    
    emit(projectInformationsChanged(this));
    updateDiagramsFolioData();
    
    setModified(false);
    return(QETResult());
}

bool QETProject::isReadOnly() const {
    return(m_read_only && read_only_file_path_ == m_file_path);
}

void QETProject::setReadOnly(bool read_only)
{
    if (m_read_only != read_only)
    {
            //keep the file to which this project is read-only
        read_only_file_path_ = m_file_path;
        m_read_only = read_only;
        emit(readOnlyChanged(this, read_only));
    }
}

bool QETProject::isEmpty() const {
    // si le projet a un titre, on considere qu'il n'est pas vide
    if (!project_title_.isEmpty()) return(false);
    
    //@TODO check if the embedded element collection is empty
    
    // compte le nombre de schemas non vides
    int pertinent_diagrams = 0;
    foreach(Diagram *diagram, m_diagrams_list) {
        if (!diagram -> isEmpty()) ++ pertinent_diagrams;
    }
    
    return(pertinent_diagrams > 0);
}

ElementsLocation QETProject::importElement(ElementsLocation &location)
{
        //Location isn't an element or doesn't exist
    if (! (location.isElement() && location.exist()) ) {
        return ElementsLocation();
    }

        //Get the path where the element must be imported
    QString import_path;
    if (location.isFileSystem()) {
        import_path = "import/" + location.collectionPath(false);
    }
    else if (location.isProject()) {
        if (location.project() == this) {
            return location;
        }

        import_path = location.collectionPath(false);
    }

        //Element already exist in the embedded collection, we ask what to do to user
    if (m_elements_collection->exist(import_path)) {
        ElementsLocation existing_location(import_path, this);

            //@existing_location and @location have the same uuid, so it is the same element
        if (existing_location.uuid() == location.uuid()) {
            return existing_location;
        }

        ImportElementDialog ied;
        if (ied.exec() == QDialog::Accepted) {
            QET::Action action = ied.action();

                //Use the exisitng element
            if (action == QET::Ignore) {
                return existing_location;
            }
                //Erase the existing element, and use the newer instead
            else if (action == QET::Erase) {
                ElementsLocation parent_loc = existing_location.parent();
                return m_elements_collection->copy(location, parent_loc);
            }
                //Add the new element with an other name.
            else if (action == QET::Rename) {
                int a = 0;
                QString parent_path = existing_location.parent().projectCollectionPath();
                QString name_ = existing_location.fileName();
                name_.remove(".elmt");

                ElementsLocation loc;
                do
                {
                    a++;
                    QString new_path = parent_path + "/" + name_ + QString::number(a) + ".elmt";
                    loc = ElementsLocation (new_path);
                } while (loc.exist());

                ElementsLocation parent_loc = existing_location.parent();
                return m_elements_collection->copy(location, parent_loc, loc.fileName());
            }
            else {
                return ElementsLocation();
            }
        }
        else {
            return ElementsLocation();
        }
    }
        //Element doesn't exist in the collection, we just import it
    else {
        ElementsLocation loc(m_elements_collection->addElement(location), this);

        if (!loc.exist()) {
            qDebug() << "QETProject::importElement : failed to import location. " << location;
            return ElementsLocation();
        }
        else {
            return loc;
        }
    }

    return ElementsLocation();
}

QString QETProject::integrateTitleBlockTemplate(const TitleBlockTemplateLocation &src_tbt, MoveTitleBlockTemplatesHandler *handler) {
    TitleBlockTemplateLocation dst_tbt(src_tbt.name(), &m_titleblocks_collection);
    
    // check whether a TBT having the same name already exists within this project
    QString target_name = dst_tbt.name();
    while (m_titleblocks_collection.templates().contains(target_name))
    {
        QET::Action action = handler -> templateAlreadyExists(src_tbt, dst_tbt);
        if (action == QET::Retry) {
            continue;
        } else if (action == QET::Erase) {
            break;
        } else if (action == QET::Abort || action == QET::Ignore) {
            return(QString());
        } else if (action == QET::Rename) {
            target_name = handler -> nameForRenamingOperation();
        } else if (action == QET::Managed) {
            return(target_name);
        }
    }
    
    if (!m_titleblocks_collection.setTemplateXmlDescription(target_name, src_tbt.getTemplateXmlDescription()))
    {
        handler -> errorWithATemplate(src_tbt, tr("Une erreur s'est produite durant l'intégration du modèle.", "error message"));
        target_name = QString();
    }
    return(target_name);
}

bool QETProject::usesElement(const ElementsLocation &location) const
{
    foreach(Diagram *diagram, diagrams()) {
        if (diagram -> usesElement(location)) {
            return(true);
        }
    }
    return(false);
}

QList<ElementsLocation> QETProject::unusedElements() const
{
    QList <ElementsLocation> unused_list;

    foreach(ElementsLocation location, m_elements_collection->elementsLocation())
        if (location.isElement() && !usesElement(location))
            unused_list << location;

    return unused_list;
}

bool QETProject::usesTitleBlockTemplate(const TitleBlockTemplateLocation &location) {
    // a diagram can only use a title block template embedded wihtin its parent project
    if (location.parentProject() != this) return(false);
    
    foreach (Diagram *diagram, diagrams()) {
        if (diagram -> usesTitleBlockTemplate(location.name())) {
            return(true);
        }
    }
    return(false);
}

Diagram *QETProject::addNewDiagram() {
    // ne fait rien si le projet est en lecture seule
    if (isReadOnly()) return(nullptr);
    
    // cree un nouveau schema
    Diagram *diagram = new Diagram(this);
    
    // lui transmet les parametres par defaut
    diagram -> border_and_titleblock.importBorder(defaultBorderProperties());
    diagram -> border_and_titleblock.importTitleBlock(defaultTitleBlockProperties());
    diagram -> defaultConductorProperties = defaultConductorProperties();
    
    addDiagram(diagram);
    emit(diagramAdded(this, diagram));
    return(diagram);
}

QList <Diagram *> QETProject::addNewDiagramFolioList() {
    // do nothing if project is read only or folio sheet is alredy created
    QList <Diagram *> diagram_list;

    if (!isReadOnly() && getFolioSheetsQuantity() == 0) {

        //reset the number of folio sheet
        setFolioSheetsQuantity(0);

        int diagCount = diagrams().size();
        for (int i = 0; i <= diagCount/29; i++) {

            //create new diagram
            Diagram *diagram_folio_list = new DiagramFolioList(this);

            // setup default properties
            diagram_folio_list -> border_and_titleblock.importBorder(defaultBorderProperties());
            diagram_folio_list -> border_and_titleblock.importTitleBlock(defaultTitleBlockProperties());
            diagram_folio_list -> defaultConductorProperties = defaultConductorProperties();

            diagram_folio_list -> border_and_titleblock.setTitle(tr("Liste des Folios"));
            // no need to display rows and columns
            diagram_folio_list -> border_and_titleblock.displayRows(false);
            diagram_folio_list -> border_and_titleblock.displayColumns(false);

            addDiagram(diagram_folio_list);
            setFolioSheetsQuantity( getFolioSheetsQuantity()+1 );
            emit(diagramAdded(this, diagram_folio_list));
            diagram_list << diagram_folio_list;
            diagCount++;
        }
    }

    return(diagram_list);
}

void QETProject::removeDiagram(Diagram *diagram) {
    // ne fait rien si le projet est en lecture seule
    if (isReadOnly()) return;   
    if (!diagram || !m_diagrams_list.contains(diagram)) return;

    if (m_diagrams_list.removeAll(diagram)) {
        emit(diagramRemoved(this, diagram));
        delete diagram;
    }
    
    updateDiagramsFolioData();
}

void QETProject::diagramOrderChanged(int old_index, int new_index) {
    if (old_index < 0 || new_index < 0) return;
    
    int diagram_max_index = m_diagrams_list.size() - 1;
    if (old_index > diagram_max_index || new_index > diagram_max_index) return;
    
    m_diagrams_list.move(old_index, new_index);
    updateDiagramsFolioData();
    setModified(true);
    emit(projectDiagramsOrderChanged(this, old_index, new_index));
}

void QETProject::setModified(bool modified) {
    if (m_modified != modified) {
        m_modified = modified;
        emit(projectModified(this, m_modified));
        emit(projectInformationsChanged(this));
    }
}

void QETProject::readProjectXml(QDomDocument &xml_project)
{
    QDomElement root_elmt = xml_project.documentElement();
    m_state = ProjectParsingRunning;
    
        //The roots of the xml document must be a "project" element
    if (root_elmt.tagName() == "project")
    {
            //Normal opening mode
        if (root_elmt.hasAttribute("version"))
        {
            bool conv_ok;
            m_project_qet_version = root_elmt.attribute("version").toDouble(&conv_ok);

            if (conv_ok && QET::version.toDouble() < m_project_qet_version)
            {
                int ret = QET::QetMessageBox::warning(
                              nullptr,
                              tr("Avertissement", "message box title"),
                              tr(
                                  "Ce document semble avoir été enregistré avec "
                                  "une version ultérieure de QElectroTech. Il est "
                                  "possible que l'ouverture de tout ou partie de ce "
                                  "document échoue.\n"
                                  "Que désirez vous faire ?",
                                  "message box content"
                                  ),
                              QMessageBox::Open | QMessageBox::Cancel
                              );
                
                if (ret == QMessageBox::Cancel)
                {
                    m_state = FileOpenDiscard;
                    return;
                }
            }
        }
        setTitle(root_elmt.attribute("title"));
    }
    else
    {
        m_state = ProjectParsingFailed;
    }
    
        //Load the project-wide properties
    readProjectPropertiesXml(xml_project);
        //Load the default properties for the new diagrams
    readDefaultPropertiesXml(xml_project);
        //load the embedded titleblock templates
    m_titleblocks_collection.fromXml(xml_project.documentElement());
        //Load the embedded elements collection
    readElementsCollectionXml(xml_project);
        //Load the diagrams
    readDiagramsXml(xml_project);

        // if there is an attribute for folioSheetQuantity, then set it accordingly.
        // If not, then the value remains at the initial value of zero.
    if (root_elmt.attribute("folioSheetQuantity","0").toInt())
        addNewDiagramFolioList();
    
    m_state = Ok;
}

void QETProject::readDiagramsXml(QDomDocument &xml_project)
{
    QMultiMap<int, Diagram *> loaded_diagrams;
    
    //@TODO try to solve a weird bug (dialog is black) since port to Qt5 with the DialogWaiting
    //show DialogWaiting
    DialogWaiting *dlgWaiting = nullptr;
    if(DialogWaiting::hasInstance())
    {
        dlgWaiting = DialogWaiting::instance();
        dlgWaiting -> setModal(true);
        dlgWaiting -> show();
        dlgWaiting -> setTitle( tr("<p align=\"center\">"
                                   "<b>Ouverture du projet en cours...</b><br/>"
                                   "Création des folios"
                                   "</p>"));
    }
    
        //Search the diagrams in the project
    QDomNodeList diagram_nodes = xml_project.elementsByTagName("diagram");
    
    if(dlgWaiting)
        dlgWaiting->setProgressBarRange(0, diagram_nodes.length()*3);
    
    for (int i = 0 ; i < diagram_nodes.length() ; ++ i)
    {
        if(dlgWaiting)
            dlgWaiting->setProgressBar(i+1);
        
        if (diagram_nodes.at(i).isElement())
        {
            QDomElement diagram_xml_element = diagram_nodes.at(i).toElement();
            Diagram *diagram = new Diagram(this);
            bool diagram_loading = diagram -> initFromXml(diagram_xml_element);
            if (diagram_loading)
            {
                if(dlgWaiting)
                    dlgWaiting->setDetail( diagram->title() );
                
                    //Get the attribute "order" of the diagram
                int diagram_order = -1;
                if (!QET::attributeIsAnInteger(diagram_xml_element, "order", &diagram_order)) diagram_order = 500000;
                loaded_diagrams.insert(diagram_order, diagram);
            }
            else
            {
                delete diagram;
            }
        }
    }
    
        //Add the diagrams according to there "order" attribute
    foreach(Diagram *diagram, loaded_diagrams.values())
        addDiagram(diagram);

        //Initialise links between elements in this project
        //and refresh the text of conductor
    if(dlgWaiting)
    {
        dlgWaiting->setTitle( tr("<p align=\"center\">"
                                 "<b>Ouverture du projet en cours...</b><br/>"
                                 "Mise en place des références croisées"
                                 "</p>"));
    }
    for(Diagram *d : diagrams())
    {
        if(dlgWaiting)
        {
            dlgWaiting->setProgressBar(dlgWaiting->progressBarValue()+1);
            dlgWaiting->setDetail(d->title());
        }
        d->refreshContents();
    }
}

void QETProject::readElementsCollectionXml(QDomDocument &xml_project)
{
        //Get the embedded elements collection of the project
    QDomNodeList collection_roots = xml_project.elementsByTagName("collection");
    QDomElement collection_root;

    if (!collection_roots.isEmpty())
    {
            //Only the first found collection is take
        collection_root = collection_roots.at(0).toElement();
    }
        //Make an empty collection
    if (collection_root.isNull())  {
        m_elements_collection = new XmlElementCollection(this);
    }
        //Read the collection
    else {
        m_elements_collection = new XmlElementCollection(collection_root, this);
    }
}

void QETProject::readProjectPropertiesXml(QDomDocument &xml_project)
{
    foreach (QDomElement e, QET::findInDomElement(xml_project.documentElement(), "properties"))
        m_project_properties.fromXml(e);
}

void QETProject::readDefaultPropertiesXml(QDomDocument &xml_project)
{
        // Find xml element where is stored properties for new diagram
    QDomNodeList newdiagrams_nodes = xml_project.elementsByTagName("newdiagrams");
    if (newdiagrams_nodes.isEmpty()) return;

    QDomElement newdiagrams_elmt = newdiagrams_nodes.at(0).toElement();

        // By default, use value find in the global conf of QElectroTech
    default_border_properties_     = BorderProperties::    defaultProperties();
    default_titleblock_properties_ = TitleBlockProperties::defaultProperties();
    default_conductor_properties_  = ConductorProperties:: defaultProperties();
    m_default_report_properties    = ReportProperties::    defaultProperties();
    m_default_xref_properties      = XRefProperties::      defaultProperties();

        //Read values indicate in project
    QDomElement border_elmt, titleblock_elmt, conductors_elmt, report_elmt, xref_elmt, conds_autonums, folio_autonums, element_autonums;

    for (QDomNode child = newdiagrams_elmt.firstChild() ; !child.isNull() ; child = child.nextSibling())
    {
        QDomElement child_elmt = child.toElement();
        if (child_elmt.isNull()) continue;

        if (child_elmt.tagName() == "border")
            border_elmt = child_elmt;
        else if (child_elmt.tagName() == "inset")
            titleblock_elmt = child_elmt;
        else if (child_elmt.tagName() == "conductors")
            conductors_elmt = child_elmt;
        else if (child_elmt.tagName() == "report")
            report_elmt = child_elmt;
        else if (child_elmt.tagName() == "xrefs")
            xref_elmt = child_elmt;
        else if (child_elmt.tagName() == "conductors_autonums")
            conds_autonums = child_elmt;
        else if (child_elmt.tagName()== "folio_autonums")
            folio_autonums = child_elmt;
        else if (child_elmt.tagName()== "element_autonums")
            element_autonums = child_elmt;
    }

        // size, titleblock, conductor, report, conductor autonum, folio autonum, element autonum
    if (!border_elmt.isNull())     default_border_properties_.fromXml(border_elmt);
    if (!titleblock_elmt.isNull()) default_titleblock_properties_.fromXml(titleblock_elmt);
    if (!conductors_elmt.isNull()) default_conductor_properties_.fromXml(conductors_elmt);
    if (!report_elmt.isNull())     setDefaultReportProperties(report_elmt.attribute("label"));
    if (!xref_elmt.isNull())
    {
        foreach(QDomElement elmt, QET::findInDomElement(xref_elmt, "xref"))
        {
            XRefProperties xrp;
            xrp.fromXml(elmt);
            m_default_xref_properties.insert(elmt.attribute("type"), xrp);
        }
    }
    if (!conds_autonums.isNull())
    {
        m_current_conductor_autonum = conds_autonums.attribute("current_autonum");
        m_freeze_new_conductors = conds_autonums.attribute("freeze_new_conductors") == "true";
        foreach (QDomElement elmt, QET::findInDomElement(conds_autonums, "conductor_autonum"))
        {
            NumerotationContext nc;
            nc.fromXml(elmt);
            m_conductor_autonum.insert(elmt.attribute("title"), nc);
        }
    }
    if (!folio_autonums.isNull())
    {
        foreach (QDomElement elmt, QET::findInDomElement(folio_autonums, "folio_autonum"))
        {
            NumerotationContext nc;
            nc.fromXml(elmt);
            m_folio_autonum.insert(elmt.attribute("title"), nc);
        }
    }
    if (!element_autonums.isNull())
    {
        m_current_element_autonum = element_autonums.attribute("current_autonum");
        m_freeze_new_elements = element_autonums.attribute("freeze_new_elements") == "true";
        foreach (QDomElement elmt, QET::findInDomElement(element_autonums, "element_autonum"))
        {
            NumerotationContext nc;
            nc.fromXml(elmt);
            m_element_autonum.insert(elmt.attribute("title"), nc);
        }
    }
}

void QETProject::writeProjectPropertiesXml(QDomElement &xml_element) {
    m_project_properties.toXml(xml_element);
}

void QETProject::writeDefaultPropertiesXml(QDomElement &xml_element) {
    QDomDocument xml_document = xml_element.ownerDocument();
    
    // export size of border
    QDomElement border_elmt = xml_document.createElement("border");
    default_border_properties_.toXml(border_elmt);
    xml_element.appendChild(border_elmt);
    
    // export content of titleblock
    QDomElement titleblock_elmt = xml_document.createElement("inset");
    default_titleblock_properties_.toXml(titleblock_elmt);
    xml_element.appendChild(titleblock_elmt);
    
    // exporte default conductor
    QDomElement conductor_elmt = xml_document.createElement("conductors");
    default_conductor_properties_.toXml(conductor_elmt);
    xml_element.appendChild(conductor_elmt);

    // export default report properties
    QDomElement report_elmt = xml_document.createElement("report");
    report_elmt.setAttribute("label", defaultReportProperties());
    xml_element.appendChild(report_elmt);

    // export default XRef properties
    QDomElement xrefs_elmt = xml_document.createElement("xrefs");
    foreach (QString key, defaultXRefProperties().keys()) {
        QDomElement xref_elmt = xml_document.createElement("xref");
        xref_elmt.setAttribute("type", key);
        defaultXRefProperties()[key].toXml(xref_elmt);
        xrefs_elmt.appendChild(xref_elmt);
    }
    xml_element.appendChild(xrefs_elmt);

    //Export Conductor Autonums
    QDomElement conductor_autonums = xml_document.createElement("conductors_autonums");
    conductor_autonums.setAttribute("current_autonum", m_current_conductor_autonum);
    conductor_autonums.setAttribute("freeze_new_conductors", m_freeze_new_conductors ? "true" : "false");
    foreach (QString key, conductorAutoNum().keys()) {
    QDomElement conductor_autonum = conductorAutoNum(key).toXml(xml_document, "conductor_autonum");
        if (key != "" && conductorAutoNumFormula(key) != "") {
            conductor_autonum.setAttribute("title", key);
            conductor_autonum.setAttribute("formula", conductorAutoNumFormula(key));
            conductor_autonums.appendChild(conductor_autonum);
        }
    }
    xml_element.appendChild(conductor_autonums);

    //Export Folio Autonums
    QDomElement folio_autonums = xml_document.createElement("folio_autonums");
    foreach (QString key, folioAutoNum().keys()) {
    QDomElement folio_autonum = folioAutoNum(key).toXml(xml_document, "folio_autonum");
        folio_autonum.setAttribute("title", key);
        folio_autonums.appendChild(folio_autonum);
    }
    xml_element.appendChild(folio_autonums);

    //Export Element Autonums
    QDomElement element_autonums = xml_document.createElement("element_autonums");
    element_autonums.setAttribute("current_autonum", m_current_element_autonum);
    element_autonums.setAttribute("freeze_new_elements", m_freeze_new_elements ? "true" : "false");
    foreach (QString key, elementAutoNum().keys()) {
    QDomElement element_autonum = elementAutoNum(key).toXml(xml_document, "element_autonum");
        if (key != "" && elementAutoNumFormula(key) != "") {
            element_autonum.setAttribute("title", key);
            element_autonum.setAttribute("formula", elementAutoNumFormula(key));
            element_autonums.appendChild(element_autonum);
        }
    }
    xml_element.appendChild(element_autonums);
}

void QETProject::addDiagram(Diagram *diagram) {
    if (!diagram) return;
    
    // Ensure diagram know is parent project
    diagram -> setProject(this);
    
    connect(
        &(diagram -> border_and_titleblock),
        SIGNAL(needFolioData()),
        this,
        SLOT(updateDiagramsFolioData())
    );
    connect(
        diagram, SIGNAL(usedTitleBlockTemplateChanged(const QString &)),
        this, SLOT(usedTitleBlockTemplateChanged(const QString &))
    );
    
    // add diagram to project
        m_diagrams_list << diagram;
    
    updateDiagramsFolioData();
}

NamesList QETProject::namesListForIntegrationCategory() {
    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 };

    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");

    return(names);
}

void QETProject::writeBackup()
{
    if (!m_backup_file ||
        (!m_backup_file->isOpen() && !m_backup_file->open(QIODevice::ReadWrite))) {
        return;
    }

    QDomDocument xml_project;
    xml_project.appendChild(xml_project.importNode(toXml().documentElement(), true));
    QET::writeToFile(xml_project, m_backup_file);
}

bool QETProject::projectOptionsWereModified() {
    // unlike similar methods, this method does not compare the content against
    // expected values; instead, we just check whether we have been set as modified.
    return(m_modified);
}

DiagramContext QETProject::projectProperties() {
    return(m_project_properties);
}

void QETProject::setProjectProperties(const DiagramContext &context) {
    m_project_properties = context;
    updateDiagramsFolioData();
}

bool QETProject::projectWasModified() {

    if ( projectOptionsWereModified()    ||
         !m_undo_stack -> isClean()       ||
         m_titleblocks_collection.templates().count() )
        return(true);
    
    else
        return(false);
}

void QETProject::updateDiagramsFolioData()
{
    int total_folio = m_diagrams_list.count();
    
    DiagramContext project_wide_properties = m_project_properties;
    project_wide_properties.addValue("projecttitle", title());
    project_wide_properties.addValue("projectpath", filePath());
    project_wide_properties.addValue("projectfilename", QFileInfo(filePath()).baseName());
    
    for (int i = 0 ; i < total_folio ; ++ i)
    {
        QString autopagenum = m_diagrams_list[i]->border_and_titleblock.autoPageNum();
        NumerotationContext nC = folioAutoNum(autopagenum);
        NumerotationContextCommands nCC = NumerotationContextCommands(nC);
        
        if ((m_diagrams_list[i]->border_and_titleblock.folio().contains("%autonum")) && 
            (!autopagenum.isNull()))
        {
            m_diagrams_list[i] -> border_and_titleblock.setFolioData(i + 1, total_folio, nCC.toRepresentedString(), project_wide_properties);
            m_diagrams_list[i]->project()->addFolioAutoNum(autopagenum,nCC.next());
        }
        else {
            m_diagrams_list[i] -> border_and_titleblock.setFolioData(i + 1, total_folio, nullptr, project_wide_properties);
        }
        
        if (i > 0)
        {
            m_diagrams_list.at(i)->border_and_titleblock.setPreviousFolioNum(m_diagrams_list.at(i-1)->border_and_titleblock.finalfolio());
            m_diagrams_list.at(i-1)->border_and_titleblock.setNextFolioNum(m_diagrams_list.at(i)->border_and_titleblock.finalfolio());
            
            if (i == total_folio-1) {
                m_diagrams_list.at(i)->border_and_titleblock.setNextFolioNum(QString());
            }
        }
        else {
            m_diagrams_list.at(i)->border_and_titleblock.setPreviousFolioNum(QString());
        }
    }
    
    for (Diagram *d : m_diagrams_list) {
        d->update();
    }
}

void QETProject::updateDiagramsTitleBlockTemplate(TitleBlockTemplatesCollection *collection, const QString &template_name) {
    Q_UNUSED(collection)
    
    foreach (Diagram *diagram, m_diagrams_list) {
        diagram -> titleBlockTemplateChanged(template_name);
    }
}

void QETProject::removeDiagramsTitleBlockTemplate(TitleBlockTemplatesCollection *collection, const QString &template_name) {
    Q_UNUSED(collection)
    
    // warn diagrams that the given template is about to be removed
    foreach (Diagram *diagram, m_diagrams_list) {
        diagram -> titleBlockTemplateRemoved(template_name);
    }
}

void QETProject::usedTitleBlockTemplateChanged(const QString &template_name) {
    emit(diagramUsedTemplate(embeddedTitleBlockTemplatesCollection(), template_name));
}