ProjectDocument.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Project/ProjectDocument.cpp
//! @brief     Implements class ProjectDocument
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Project/ProjectDocument.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Model/JobModel.h"
#include "GUI/Model/Model/RealDataModel.h"
#include "GUI/Model/Project/IOService.h"
#include "GUI/Model/Project/LinkInstrumentManager.h"
#include "GUI/Model/Sample/ItemWithMaterial.h"
#include "GUI/Model/Sample/MaterialItem.h"
#include "GUI/Model/Sample/MultiLayerItem.h"
#include "GUI/Support/Data/SimulationOptionsItem.h"
#include "GUI/Support/IO/ProjectUtils.h"
#include "GUI/Support/XML/Streamer.h"
#include "GUI/Support/XML/UtilXML.h"
#include "GUI/Util/DeserializationException.h"
#include "GUI/Util/Error.h"
#include "GUI/Util/MessageService.h"
#include "GUI/Util/Path.h"
#include <QElapsedTimer>
#include <QStandardPaths>
#include <QXmlStreamReader>
#include <memory>
 
namespace {
 
const QString minimal_supported_version = "1.6.0";
const QString BornAgainTag("BornAgain");
const QString BornAgainVersionAttribute("Version");
const QString InfoTag("DocumentInfo");
const QString InfoNameAttribute("ProjectName");
const QString SimulationOptionsTag("SimulationOptions");
const QString SamplesTag("Samples");
const QString InstrumentsTag("Instruments");
const QString FormatVersionTag("FormatVersion");
 
} // namespace
 
 
ProjectDocument::ProjectDocument()
    : m_modified(false)
    , m_dataService(new DatafieldIOService(this))
    , m_singleInstrumentMode(false)
    , m_singleSampleMode(false)
    , m_functionalities(All)
    , m_instrumentEditController(&m_instruments)
{
    connect(&m_instrumentEditController, &InstrumentsEditController::instrumentAddedOrRemoved, this,
            &ProjectDocument::onModelChanged, Qt::UniqueConnection);
    connect(&m_instrumentEditController, &InstrumentsEditController::instrumentChanged, this,
            &ProjectDocument::onModelChanged, Qt::UniqueConnection);
 
 
    m_linkManager = std::make_unique<LinkInstrumentManager>(this);
    setObjectName("ProjectDocument");
 
    m_dataService->setApplicationModels(&m_applicationModels);
    connectModels();
}
 
QString ProjectDocument::projectName() const
{
    return m_project_name;
}
 
void ProjectDocument::setProjectName(const QString& text)
{
    if (m_project_name != text) {
        m_project_name = text;
        emit modified();
    }
}
 
QString ProjectDocument::projectDir() const
{
    return m_project_dir;
}
 
QString ProjectDocument::validProjectDir() const
{
    if (m_project_name.isEmpty())
        return "";
    return m_project_dir;
}
 
void ProjectDocument::setProjectDir(const QString& text)
{
    m_project_dir = text;
}
 
//! Returns directory name suitable for saving plots.
 
QString ProjectDocument::userExportDir() const
{
    if (QString dir = validProjectDir(); !dir.isEmpty())
        return dir;
    return QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
}
 
QString ProjectDocument::projectFileName() const
{
    if (!projectName().isEmpty())
        return projectDir() + "/" + projectName() + GUI::Project::Utils::projectFileExtension;
    return "";
}
 
void ProjectDocument::setProjectFileName(const QString& projectFileName)
{
    setProjectName(GUI::Project::Utils::projectName(projectFileName));
    setProjectDir(GUI::Project::Utils::projectDir(projectFileName));
}
 
InstrumentCollection* ProjectDocument::collectedItems() const
{
    return const_cast<InstrumentCollection*>(&m_instruments);
}
 
MultiLayerItems* ProjectDocument::sampleItems()
{
    return &m_sampleItems;
}
 
RealDataModel* ProjectDocument::realDataModel() const
{
    return m_applicationModels.realDataModel();
}
 
JobModel* ProjectDocument::jobModel() const
{
    return m_applicationModels.jobModel();
}
 
SimulationOptionsItem* ProjectDocument::simulationOptionsItem()
{
    return &m_simulationOptionsItem;
}
 
LinkInstrumentManager* ProjectDocument::linkInstrumentManager()
{
    return m_linkManager.get();
}
 
InstrumentsEditController* ProjectDocument::instrumentsEditController()
{
    return &m_instrumentEditController;
}
 
void ProjectDocument::save(const QString& project_file_name, bool autoSave)
{
    saveProjectData(project_file_name);
    saveProjectFile(project_file_name, autoSave);
}
 
void ProjectDocument::saveProjectFile(const QString& project_file_name, bool autoSave)
{
    QElapsedTimer timer;
    timer.start();
 
    QFile file(project_file_name);
    if (!file.open(QFile::ReadWrite | QIODevice::Truncate | QFile::Text))
        throw Error("ProjectDocument::save_project_file() -> Error. Can't open "
                    "file '"
                    + project_file_name + "' for writing.");
 
    writeTo(&file);
    file.close();
 
    if (!autoSave) {
        setProjectFileName(project_file_name);
        m_modified = false;
        emit modified();
    }
}
 
void ProjectDocument::saveProjectData(const QString& project_file_name)
{
    for (auto* d : realDataModel()->realDataItems())
        d->updateNonXMLDataFileNames();
 
    QElapsedTimer timer;
    timer.start();
 
    m_dataService->save(GUI::Project::Utils::projectDir(project_file_name));
}
 
ProjectDocument::ReadResult ProjectDocument::loadProjectFile(const QString& project_file_name,
                                                             MessageService& messageService)
{
    setProjectFileName(project_file_name);
 
    QFile file(projectFileName());
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        QString message = QString("Open file error '%1'").arg(file.errorString());
        messageService.addError(this, message);
        return ReadResult::error;
    }
 
    try {
        disconnectModels();
        auto result = readProject(&file, messageService);
        file.close();
        if (result == ReadResult::error)
            return result;
 
        m_dataService->loadDataFiles(projectDir(), &messageService);
        connectModels();
 
        if (!messageService.warnings().empty())
            result = ReadResult::warning;
        return result;
    } catch (const std::exception& ex) {
        QString message = QString("Exception thrown '%1'").arg(QString(ex.what()));
        messageService.addError(this, message);
        return ReadResult::error;
    }
}
 
bool ProjectDocument::hasValidNameAndPath()
{
    return (!m_project_name.isEmpty() && !m_project_dir.isEmpty());
}
 
bool ProjectDocument::isModified() const
{
    return m_modified;
}
 
void ProjectDocument::setModified()
{
    m_modified = true;
    emit modified();
}
 
void ProjectDocument::clearModified()
{
    m_modified = false;
}
 
bool ProjectDocument::hasData() const
{
    return !m_dataService->dataInterfaces().isEmpty();
}
 
QString ProjectDocument::documentVersion() const
{
    QString result(m_currentVersion);
    if (result.isEmpty())
        result = GUI::Util::Path::getBornAgainVersionString();
    return result;
}
 
bool ProjectDocument::singleInstrumentMode() const
{
    return m_singleInstrumentMode;
}
 
void ProjectDocument::setSingleInstrumentMode(bool b)
{
    if (b != m_singleInstrumentMode) {
        m_singleInstrumentMode = b;
        emit modified();
        emit singleInstrumentModeChanged();
        setModified();
    }
}
 
bool ProjectDocument::singleSampleMode() const
{
    return m_singleSampleMode;
}
 
void ProjectDocument::setSingleSampleMode(bool b)
{
    if (b != m_singleSampleMode) {
        m_singleSampleMode = b;
        emit modified();
        emit singleSampleModeChanged();
        setModified();
    }
}
 
ProjectDocument::Functionalities ProjectDocument::functionalities() const
{
    return m_functionalities;
}
 
void ProjectDocument::setFunctionalities(const Functionalities& f)
{
    if (m_functionalities != f) {
        m_functionalities = f;
        emit modified();
        emit functionalitiesChanged();
        setModified();
    }
}
 
void ProjectDocument::onModelChanged()
{
    m_modified = true;
    emit modified();
}
 
ProjectDocument::ReadResult ProjectDocument::readProject(QIODevice* device,
                                                         MessageService& messageService)
{
    const int warningsBefore = messageService.warnings().size();
 
    QXmlStreamReader reader(device);
    try {
        while (!reader.atEnd()) {
            reader.readNext();
            if (reader.isStartElement()) {
                if (reader.name() == BornAgainTag) {
                    Streamer(&reader).assertVersion(2);
                    m_currentVersion =
                        reader.attributes().value(BornAgainVersionAttribute).toString();
 
                    if (!GUI::Util::Path::isVersionMatchMinimal(m_currentVersion,
                                                                minimal_supported_version)) {
                        QString message = QString("Can't open document version '%1', "
                                                  "minimal supported version '%2'")
                                              .arg(m_currentVersion)
                                              .arg(minimal_supported_version);
                        messageService.addError(this, message);
                        return ReadResult::error;
                    }
 
                    while (reader.readNextStartElement())
                        if (reader.name() == InfoTag)
                            reader.skipCurrentElement();
                        else if (reader.name() == SimulationOptionsTag) {
                            m_simulationOptionsItem.readContentFrom(&reader);
                            reader.skipCurrentElement();
                            GUI::Session::XML::assertExpectedTag(&reader, SimulationOptionsTag);
                        } else if (reader.name() == SamplesTag) {
                            Streamer s(&reader);
                            m_sampleItems.serialize(s);
                            // cleanup
                            if (reader.name() != SamplesTag) {
                                if (!reader.isEndElement())
                                    reader.skipCurrentElement();
                                reader.skipCurrentElement();
                            }
                            GUI::Session::XML::assertExpectedTag(&reader, SamplesTag);
                            ASSERT(reader.isEndElement());
 
                            GUI::Session::XML::assertExpectedTag(&reader, SamplesTag);
                        } else if (reader.name() == InstrumentsTag) {
                            Streamer s(&reader);
                            m_instruments.serialize(s);
                            // cleanup
                            if (reader.name() != InstrumentsTag) {
                                if (!reader.isEndElement())
                                    reader.skipCurrentElement();
                                reader.skipCurrentElement();
                            }
                            GUI::Session::XML::assertExpectedTag(&reader, InstrumentsTag);
                            ASSERT(reader.isEndElement());
 
                            GUI::Session::XML::assertExpectedTag(&reader, InstrumentsTag);
                        } else
                            m_applicationModels.readFrom(&reader, &messageService);
                }
            }
        }
 
    } catch (DeserializationException& ex) {
        reader.raiseError(ex.text());
    }
 
    if (reader.hasError()) {
        QString message = QString("Format error '%1'").arg(reader.errorString());
        messageService.addError(this, message);
        return ReadResult::error;
    }
 
    // return "ReadResult::warning" only if warnings have been issued _in here_
    return warningsBefore != messageService.warnings().size() ? ReadResult::warning
                                                              : ReadResult::ok;
}
 
void ProjectDocument::writeTo(QIODevice* device)
{
    QXmlStreamWriter writer(device);
    writer.setAutoFormatting(true);
    writer.writeStartDocument();
    writer.writeStartElement(BornAgainTag);
    QString version_string = GUI::Util::Path::getBornAgainVersionString();
    writer.writeAttribute(BornAgainVersionAttribute, version_string);
    Streamer(&writer).writeVersion(2);
 
    writer.writeStartElement(InfoTag);
    writer.writeAttribute(InfoNameAttribute, projectName());
    writer.writeEndElement(); // InfoTag
 
    writer.writeStartElement(SimulationOptionsTag);
    m_simulationOptionsItem.writeContentTo(&writer);
    writer.writeEndElement();
 
    writer.writeStartElement(SamplesTag);
    Streamer s(&writer);
    m_sampleItems.serialize(s);
    writer.writeEndElement();
 
    writer.writeStartElement(InstrumentsTag);
    Streamer sInstruments(&writer);
    m_instruments.serialize(sInstruments);
    writer.writeEndElement();
 
    m_applicationModels.writeTo(&writer);
 
    writer.writeEndElement(); // BornAgain tag
    writer.writeEndDocument();
}
 
void ProjectDocument::disconnectModels()
{
    disconnect(&m_applicationModels, &ApplicationModels::modelChanged, this,
               &ProjectDocument::onModelChanged);
}
 
void ProjectDocument::connectModels()
{
    connect(&m_applicationModels, &ApplicationModels::modelChanged, this,
            &ProjectDocument::onModelChanged, Qt::UniqueConnection);
}