MainWindow.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Main/MainWindow.cpp
//! @brief     Implements class MainWindow
//!
//! @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/View/Main/MainWindow.h"
#include "GUI/Application/ApplicationSettings.h"
#include "GUI/Model/Data/SessionData.h"
#include "GUI/Model/Model/JobModel.h"
#include "GUI/Util/Path.h"
#include "GUI/View/Import/ImportDataView.h"
#include "GUI/View/Instrument/InstrumentView.h"
#include "GUI/View/Job/JobView.h"
#include "GUI/View/Main/ActionManager.h"
#include "GUI/View/Project/ProjectManager.h"
#include "GUI/View/SampleDesigner/SampleView.h"
#include "GUI/View/Tool/mainwindow_constants.h"
#include "GUI/View/Toplevel/ProjectSettingsView.h"
#include "GUI/View/Toplevel/SessionModelView.h"
#include "GUI/View/Toplevel/SimulationView.h"
#include "GUI/View/Toplevel/WelcomeView.h"
#include <QAction>
#include <QApplication>
#include <QBoxLayout>
#include <QButtonGroup>
#include <QCloseEvent>
#include <QMessageBox>
#include <QProgressBar>
#include <QPushButton>
#include <QSettings>
#include <QStackedLayout>
#include <QStatusBar>
#include <QToolButton>
 
MainWindow::MainWindow()
    : QMainWindow(nullptr)
    , m_progressBar(new QProgressBar)
    , m_viewSelectionButtons(new QButtonGroup(this))
    , m_viewsStack(new QStackedLayout)
    , m_viewSelectionButtonsLayout(new QVBoxLayout)
    , m_projectManager(new ProjectManager(this))
    , m_actionManager(new ActionManager(this))
    , m_welcomeView(nullptr)
    , m_instrumentView(nullptr)
    , m_sampleView(nullptr)
    , m_importDataView(nullptr)
    , m_simulationView(nullptr)
    , m_projectSettingsView(nullptr)
    , m_jobView(nullptr)
    , m_sessionModelView(nullptr)
{
    auto* centralWidget = new QWidget(this);
    auto* mainLayout = new QHBoxLayout(centralWidget);
    mainLayout->setMargin(0);
    mainLayout->setSpacing(0);
 
    m_viewSelectionButtonsLayout->setMargin(0);
    m_viewSelectionButtonsLayout->setSpacing(0);
 
    auto* fillerButton = createViewSelectionButton();
    fillerButton->setMinimumSize(5, 5);
    fillerButton->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
    fillerButton->setEnabled(false);
    m_viewSelectionButtonsLayout->insertWidget(-1, fillerButton);
 
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
    connect(m_viewSelectionButtons, &QButtonGroup::idClicked, this, &MainWindow::raiseView);
#else
    connect(m_viewSelectionButtons, QOverload<int>::of(&QButtonGroup::buttonClicked), this,
            &MainWindow::raiseView);
#endif
 
    auto* vlayout = new QVBoxLayout;
    vlayout->setMargin(0);
    vlayout->setSpacing(0);
    vlayout->addLayout(m_viewsStack);
 
    mainLayout->addLayout(m_viewSelectionButtonsLayout);
    mainLayout->addLayout(vlayout);
 
    setCentralWidget(centralWidget);
 
    initApplication();
    readSettings();
    initProgressBar();
    initViews();
 
    connect(m_projectManager, &ProjectManager::documentOpenedOrClosed, this,
            &MainWindow::onDocumentOpenedOrClosed);
 
    connect(m_projectManager, &ProjectManager::documentModified, this,
            &MainWindow::onDocumentModified);
 
    connect(m_projectManager, &ProjectManager::aboutToCloseDocument, this,
            &MainWindow::onAboutToCloseDocument);
 
    ASSERT(m_viewSelectionButtons->button(ViewId::WELCOME) != nullptr);
    m_viewSelectionButtons->button(ViewId::WELCOME)->setChecked(true);
 
    updateTitle();
 
    if (appSettings->createNewProjectOnStartup())
        m_projectManager->newProject();
}
 
MainWindow::~MainWindow() = default;
 
QProgressBar* MainWindow::progressBar()
{
    return m_progressBar;
}
 
ProjectManager* MainWindow::projectManager()
{
    return m_projectManager;
}
 
QWidget* MainWindow::currentView() const
{
    return m_viewsStack->currentWidget();
}
 
void MainWindow::setCurrentView(int viewId)
{
    if (auto* btn = m_viewSelectionButtons->button(viewId); btn != nullptr)
        btn->click();
}
 
void MainWindow::raiseView(int viewId)
{
    if (m_viewsStack->currentIndex() != viewId) {
        m_viewsStack->setCurrentIndex(viewId);
        emit currentViewChanged(ViewId(viewId));
    }
}
 
void MainWindow::updateTitle()
{
    auto const doc = gSessionData->projectDocument;
    if (!doc.has_value())
        setWindowTitle("BornAgain");
    else if (doc.value()->isModified())
        setWindowTitle("BornAgain - *" + doc.value()->projectName());
    else
        setWindowTitle("BornAgain - " + doc.value()->projectName());
}
 
void MainWindow::onFocusRequest(int index)
{
    m_viewSelectionButtons->button(index)->click();
}
 
void MainWindow::openRecentProject()
{
    if (const auto* action = qobject_cast<const QAction*>(sender())) {
        auto file = action->data().value<QString>();
        m_projectManager->openProject(file);
    }
}
 
void MainWindow::onRunSimulationShortcut()
{
    // This clearFocus is needed for the propagation of the current editor value,
    // since the simulate method will only change focus after finishing the simulation
    if (auto* widget = QApplication::focusWidget())
        widget->clearFocus();
    m_simulationView->simulate();
}
 
//! Inserts/removes developers SessionModelView on the left tabbar.
void MainWindow::onSessionModelViewActive(bool isActive)
{
    auto* btn = m_viewSelectionButtons->button(ViewId::SESSIONMODEL);
    ASSERT(btn != nullptr);
    if (btn == nullptr)
        return;
 
    if (!isActive && m_viewsStack->currentIndex() == SESSIONMODEL)
        m_viewSelectionButtons->buttons().first()->click();
 
    btn->setEnabled(isActive);
    btn->setVisible(isActive);
}
 
void MainWindow::closeEvent(QCloseEvent* event)
{
    if (gSessionData->projectDocument.has_value()
        && gSessionData->projectDocument.value()->jobModel()->hasUnfinishedJobs()) {
        QMessageBox::warning(this, "Can't quit the application.",
                             "Can't quit the application while jobs are running.\n"
                             "Cancel running jobs or wait until they are completed.");
        event->ignore();
        return;
    }
    if (m_projectManager->closeCurrentProject()) {
        writeSettings();
        event->accept();
    } else {
        event->ignore();
    }
}
 
void MainWindow::initApplication()
{
    setDockNestingEnabled(true);
    setAcceptDrops(true);
 
    setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
    setCorner(Qt::BottomRightCorner, Qt::BottomDockWidgetArea);
}
 
void MainWindow::initProgressBar()
{
    m_progressBar->hide();
    m_progressBar->setTextVisible(false);
    m_progressBar->setFixedHeight(QApplication::fontMetrics().boundingRect("M").height());
    m_progressBar->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
    m_viewSelectionButtonsLayout->addWidget(m_progressBar);
}
 
void MainWindow::initViews()
{
    if (m_welcomeView == nullptr) {
        m_welcomeView = new WelcomeView(this);
        addView(ViewId::WELCOME, QIcon(":/images/main_welcomeview.svg"), "Welcome",
                "Switch to Welcome View", m_welcomeView);
    }
 
    if (gSessionData->projectDocument.has_value()) {
        auto* doc = gSessionData->projectDocument.value();
        m_instrumentView = new InstrumentView(this, doc);
        m_sampleView = new SampleView(this, doc);
        m_importDataView = new ImportDataView(this, doc);
        m_simulationView = new SimulationView(this, doc);
        m_jobView = new JobView(this, doc);
        m_sessionModelView = new SessionModelView(this, doc);
        m_projectSettingsView = new ProjectSettingsView(this, doc);
 
        addView(ViewId::PROJECT, QIcon(":/images/main_sessionmodel.svg"), "Project",
                "Define project settings", m_projectSettingsView);
 
        addView(ViewId::INSTRUMENT, QIcon(":/images/main_instrumentview.svg"), "Instrument",
                "Define the beam and the  detector", m_instrumentView);
 
        addView(ViewId::SAMPLE, QIcon(":/images/main_sampleview.svg"), "Sample", "Build the sample",
                m_sampleView);
 
        addView(ViewId::IMPORT, QIcon(":/images/main_importview.svg"), "Data",
                "Import intensity data to fit", m_importDataView);
 
        addView(ViewId::SIMULATION, QIcon(":/images/main_simulationview.svg"), "Simulation",
                "Run simulation", m_simulationView);
 
        addView(ViewId::JOB, QIcon(":/images/main_jobview.svg"), "Jobs",
                "Switch to see job results, tune parameters real time,\nfit the data", m_jobView);
 
        addView(ViewId::SESSIONMODEL, QIcon(":/images/main_sessionmodel.svg"), "Models", "",
                m_sessionModelView);
 
        // enabling technical view
        QSettings settings;
        settings.beginGroup(GUI::Constants::S_SESSIONMODELVIEW);
        onSessionModelViewActive(settings.value(GUI::Constants::S_VIEWISACTIVE, false).toBool());
        settings.endGroup();
 
        connect(m_jobView, &JobView::focusRequest, this, &MainWindow::onFocusRequest);
    }
}
 
void MainWindow::readSettings()
{
    QSettings settings;
    if (settings.childGroups().contains(GUI::Constants::S_MAINWINDOW)) {
        settings.beginGroup(GUI::Constants::S_MAINWINDOW);
        resize(settings.value(GUI::Constants::S_WINDOWSIZE, QSize(400, 400)).toSize());
        move(settings.value(GUI::Constants::S_WINDOWPOSITION, QPoint(200, 200)).toPoint());
        settings.endGroup();
    }
    m_projectManager->readSettings();
}
 
void MainWindow::writeSettings()
{
    QSettings settings;
    settings.beginGroup(GUI::Constants::S_MAINWINDOW);
    settings.setValue(GUI::Constants::S_WINDOWSIZE, size());
    settings.setValue(GUI::Constants::S_WINDOWPOSITION, pos());
    settings.endGroup();
    m_projectManager->writeSettings();
    settings.sync();
}
 
void MainWindow::addView(ViewId id, const QIcon& icon, const QString& title, const QString& tooltip,
                         QWidget* view)
{
    QToolButton* btn = createViewSelectionButton();
    m_viewSelectionButtonsLayout->insertWidget(id, btn);
 
    btn->setText(title);
    btn->setToolTip(tooltip);
    btn->setIcon(icon);
    m_viewSelectionButtons->addButton(btn, id);
 
    updateViewSelectionButtonsGeometry();
 
    m_viewsStack->insertWidget(id, view);
}
 
void MainWindow::updateViewSelectionButtonsGeometry() const
{
    if (m_viewSelectionButtons->buttons().isEmpty())
        return;
 
    const QFontMetrics fontMetrics = m_viewSelectionButtons->buttons().first()->fontMetrics();
 
    // Find the maximum text extents
    int maxTextWidth = 0;
    int maxTextHeight = 0;
    for (auto* b : m_viewSelectionButtons->buttons()) {
        const auto r = fontMetrics.boundingRect(b->text());
        maxTextWidth = std::max(maxTextWidth, r.width());
        maxTextHeight = std::max(maxTextHeight, r.height());
    }
 
    // calculate the button extent by width (width == height!). Ensure an extent of 70 for normal
    // DPI devices (legacy value)
    const int margin = fontMetrics.boundingRect("M").width();
    const int buttonExtent = std::max(70, maxTextWidth + 2 * margin);
 
    // calculate the icon extent by height (width == height!)
    const int iconExtent = buttonExtent - margin - maxTextHeight;
 
    // set new values in all buttons
    for (auto* b : m_viewSelectionButtons->buttons()) {
        b->setFixedSize(buttonExtent, buttonExtent);
        b->setIconSize({iconExtent, iconExtent});
    }
    // set fixed width in filler and progress bar
    auto* filler = m_viewSelectionButtonsLayout->itemAt(m_viewSelectionButtons->buttons().size());
    if (filler)
        if (auto* fillerBtn = dynamic_cast<QToolButton*>(filler->widget()); fillerBtn)
            fillerBtn->setFixedWidth(buttonExtent);
 
    m_progressBar->setFixedWidth(buttonExtent);
}
 
void MainWindow::onDocumentOpenedOrClosed(bool open)
{
    initViews();
    updateTitle();
    if (open)
        setCurrentView(MainWindow::PROJECT);
}
 
void MainWindow::onDocumentModified()
{
    updateTitle();
}
 
void MainWindow::onAboutToCloseDocument()
{
    setCurrentView(WELCOME);
 
    while (m_viewSelectionButtons->buttons().size() > 1)
        delete m_viewSelectionButtons->buttons().last();
 
    updateViewSelectionButtonsGeometry();
 
    delete m_instrumentView;
    m_instrumentView = nullptr;
 
    delete m_sampleView;
    m_sampleView = nullptr;
 
    delete m_importDataView;
    m_importDataView = nullptr;
 
    delete m_simulationView;
    m_simulationView = nullptr;
 
    delete m_jobView;
    m_jobView = nullptr;
 
    delete m_sessionModelView;
    m_sessionModelView = nullptr;
}
 
QToolButton* MainWindow::createViewSelectionButton() const
{
    auto* btn = new QToolButton;
    btn->setObjectName("ViewSelectionButton"); // for addressing in style sheet
    btn->setCheckable(true);
    btn->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
    return btn;
}