HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1239:af6db233f5d0

Check unsaved data on close

trabillard -

r1239:af6db233f5d0

parent child

Context file:

r1239:af6db233f5d0

app/include/MainWindow.h +1 0

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program 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.
             --
             -- This program 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 this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef SCIQLOP_MAINWINDOW_H
             #define SCIQLOP_MAINWINDOW_H
             #include <QListWidgetItem>
             #include <QLoggingCategory>
             #include <QMainWindow>
             #include <QProgressBar>
             #include <QProgressDialog>
             #include <QThread>
             #include <QVBoxLayout>
             #include <QWidget>
             #include <Common/spimpl.h>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_MainWindow)
             namespace Ui {
             class MainWindow;
             } // namespace Ui
             class MainWindow : public QMainWindow {
                 Q_OBJECT
             public:
                 explicit MainWindow(QWidget *parent = 0);
                 virtual ~MainWindow();
             public slots:
             protected:
                 void changeEvent(QEvent *e);
+                void closeEvent(QCloseEvent *event);
             private:
                 std::unique_ptr<Ui::MainWindow> m_Ui;
                 //    QWidget *m_progressWidget;
                 //    QVBoxLayout *m_progressLayout;
                 // QList<QLopService*> m_qlopServices;
                 class MainWindowPrivate;
                 spimpl::unique_impl_ptr<MainWindowPrivate> impl;
             };
             #endif // SCIQLOP_MAINWINDOW_H

app/src/MainWindow.cpp +39 0

             /*------------------------------------------------------------------------------
             -- This file is a part of the SciQLop Software
             -- Copyright (C) 2017, Plasma Physics Laboratory - CNRS
             --
             -- This program 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.
             --
             -- This program 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 this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include "ui_MainWindow.h"
+            #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueExplorer.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceWidget.h>
             #include <Settings/SqpSettingsDialog.h>
             #include <Settings/SqpSettingsGeneralWidget.h>
             #include <SidePane/SqpSidePane.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <TimeWidget/TimeWidget.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationController.h>
             #include <QAction>
+            #include <QCloseEvent>
             #include <QDate>
             #include <QDir>
             #include <QFileDialog>
+            #include <QMessageBox>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             #include "iostream"
             Q_LOGGING_CATEGORY(LOG_MainWindow, "MainWindow")
             namespace {
             const auto LEFTMAININSPECTORWIDGETSPLITTERINDEX = 0;
             const auto LEFTINSPECTORSIDEPANESPLITTERINDEX = 1;
             const auto VIEWPLITTERINDEX = 2;
             const auto RIGHTINSPECTORSIDEPANESPLITTERINDEX = 3;
             const auto RIGHTMAININSPECTORWIDGETSPLITTERINDEX = 4;
             }
             class MainWindow::MainWindowPrivate {
             public:
                 explicit MainWindowPrivate(MainWindow *mainWindow)
                         : m_LastOpenLeftInspectorSize{},
                           m_LastOpenRightInspectorSize{},
                           m_GeneralSettingsWidget{new SqpSettingsGeneralWidget{mainWindow}},
                           m_SettingsDialog{new SqpSettingsDialog{mainWindow}},
                           m_CatalogExplorer{new CatalogueExplorer{mainWindow}}
                 {
                 }
                 QSize m_LastOpenLeftInspectorSize;
                 QSize m_LastOpenRightInspectorSize;
                 /// General settings widget. MainWindow has the ownership
                 SqpSettingsGeneralWidget *m_GeneralSettingsWidget;
                 /// Settings dialog. MainWindow has the ownership
                 SqpSettingsDialog *m_SettingsDialog;
                 /// Catalogue dialog. MainWindow has the ownership
                 CatalogueExplorer *m_CatalogExplorer;
+                bool checkDataToSave(QWidget *parentWidget);
             };
             MainWindow::MainWindow(QWidget *parent)
                     : QMainWindow{parent},
                       m_Ui{new Ui::MainWindow},
                       impl{spimpl::make_unique_impl<MainWindowPrivate>(this)}
             {
                 m_Ui->setupUi(this);
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 impl->m_CatalogExplorer->setVisualizationWidget(m_Ui->view);
                 auto leftSidePane = m_Ui->leftInspectorSidePane->sidePane();
                 auto openLeftInspectorAction = new QAction{QIcon{
                                                                ":/icones/previous.png",
                                                            },
                                                            tr("Show/hide the left inspector"), this};
                 auto spacerLeftTop = new QWidget{};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget{};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 leftSidePane->addWidget(spacerLeftTop);
                 leftSidePane->addAction(openLeftInspectorAction);
                 leftSidePane->addWidget(spacerLeftBottom);
                 auto rightSidePane = m_Ui->rightInspectorSidePane->sidePane();
                 auto openRightInspectorAction = new QAction{QIcon{
                                                                 ":/icones/next.png",
                                                             },
                                                             tr("Show/hide the right inspector"), this};
                 auto spacerRightTop = new QWidget{};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget{};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 rightSidePane->addWidget(spacerRightTop);
                 rightSidePane->addAction(openRightInspectorAction);
                 rightSidePane->addWidget(spacerRightBottom);
                 openLeftInspectorAction->setCheckable(true);
                 openRightInspectorAction->setCheckable(true);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(QIcon{(checked xor right) ? ":/icones/next.png" : ":/icones/previous.png"});
                     auto &lastInspectorSize
                         = right ? impl->m_LastOpenRightInspectorSize : impl->m_LastOpenLeftInspectorSize;
                     auto nextInspectorSize = right ? m_Ui->rightMainInspectorWidget->size()
                                                    : m_Ui->leftMainInspectorWidget->size();
                     // Update of the last opened geometry
                     if (checked) {
                         lastInspectorSize = nextInspectorSize;
                     }
                     auto startSize = lastInspectorSize;
                     auto endSize = startSize;
                     endSize.setWidth(0);
                     auto splitterInspectorIndex
                         = right ? RIGHTMAININSPECTORWIDGETSPLITTERINDEX : LEFTMAININSPECTORWIDGETSPLITTERINDEX;
                     auto currentSizes = m_Ui->splitter->sizes();
                     if (checked) {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] -= lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] += lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                     else {
                         // adjust sizes individually here, e.g.
                         currentSizes[splitterInspectorIndex] += lastInspectorSize.width();
                         currentSizes[VIEWPLITTERINDEX] -= lastInspectorSize.width();
                         m_Ui->splitter->setSizes(currentSizes);
                     }
                 };
                 connect(openLeftInspectorAction, &QAction::triggered,
                         [openInspector, openLeftInspectorAction](bool checked) {
                             openInspector(checked, false, openLeftInspectorAction);
                         });
                 connect(openRightInspectorAction, &QAction::triggered,
                         [openInspector, openRightInspectorAction](bool checked) {
                             openInspector(checked, true, openRightInspectorAction);
                         });
                 // //////////////// //
                 // Menu and Toolbar //
                 // //////////////// //
                 this->menuBar()->addAction(tr("File"));
                 auto toolsMenu = this->menuBar()->addMenu(tr("Tools"));
                 toolsMenu->addAction(tr("Settings..."), [this]() {
                     // Loads settings
                     impl->m_SettingsDialog->loadSettings();
                     // Open settings dialog and save settings if the dialog is accepted
                     if (impl->m_SettingsDialog->exec() == QDialog::Accepted) {
                         impl->m_SettingsDialog->saveSettings();
                     }
                 });
                 auto mainToolBar = this->addToolBar(QStringLiteral("MainToolBar"));
                 auto timeWidget = new TimeWidget{};
                 mainToolBar->addWidget(timeWidget);
                 // Interaction modes
                 auto actionPointerMode = new QAction{QIcon(":/icones/pointer.png"), "Move", this};
                 actionPointerMode->setCheckable(true);
                 actionPointerMode->setChecked(sqpApp->plotsInteractionMode()
                                               == SqpApplication::PlotsInteractionMode::None);
                 connect(actionPointerMode, &QAction::triggered,
                         []() { sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::None); });
                 auto actionZoomMode = new QAction{QIcon(":/icones/zoom.png"), "Zoom", this};
                 actionZoomMode->setCheckable(true);
                 actionZoomMode->setChecked(sqpApp->plotsInteractionMode()
                                            == SqpApplication::PlotsInteractionMode::ZoomBox);
                 connect(actionZoomMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::ZoomBox);
                 });
                 auto actionOrganisationMode = new QAction{QIcon(":/icones/drag.png"), "Organize", this};
                 actionOrganisationMode->setCheckable(true);
                 actionOrganisationMode->setChecked(sqpApp->plotsInteractionMode()
                                                    == SqpApplication::PlotsInteractionMode::DragAndDrop);
                 connect(actionOrganisationMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::DragAndDrop);
                 });
                 auto actionZonesMode = new QAction{QIcon(":/icones/rectangle.png"), "Zones", this};
                 actionZonesMode->setCheckable(true);
                 actionZonesMode->setChecked(sqpApp->plotsInteractionMode()
                                             == SqpApplication::PlotsInteractionMode::SelectionZones);
                 connect(actionZonesMode, &QAction::triggered, []() {
                     sqpApp->setPlotsInteractionMode(SqpApplication::PlotsInteractionMode::SelectionZones);
                 });
                 auto modeActionGroup = new QActionGroup{this};
                 modeActionGroup->addAction(actionZoomMode);
                 modeActionGroup->addAction(actionZonesMode);
                 modeActionGroup->addAction(actionOrganisationMode);
                 modeActionGroup->addAction(actionPointerMode);
                 modeActionGroup->setExclusive(true);
                 mainToolBar->addSeparator();
                 mainToolBar->addAction(actionPointerMode);
                 mainToolBar->addAction(actionZoomMode);
                 mainToolBar->addAction(actionOrganisationMode);
                 mainToolBar->addAction(actionZonesMode);
                 mainToolBar->addSeparator();
                 // Cursors
                 auto btnCursor = new QToolButton{this};
                 btnCursor->setIcon(QIcon(":/icones/cursor.png"));
                 btnCursor->setText("Cursor");
                 btnCursor->setToolTip("Cursor");
                 btnCursor->setPopupMode(QToolButton::InstantPopup);
                 auto cursorMenu = new QMenu("CursorMenu", this);
                 btnCursor->setMenu(cursorMenu);
                 auto noCursorAction = cursorMenu->addAction("No Cursor");
                 noCursorAction->setCheckable(true);
                 noCursorAction->setChecked(sqpApp->plotsCursorMode()
                                            == SqpApplication::PlotsCursorMode::NoCursor);
                 connect(noCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::NoCursor); });
                 cursorMenu->addSeparator();
                 auto verticalCursorAction = cursorMenu->addAction("Vertical Cursor");
                 verticalCursorAction->setCheckable(true);
                 verticalCursorAction->setChecked(sqpApp->plotsCursorMode()
                                                  == SqpApplication::PlotsCursorMode::Vertical);
                 connect(verticalCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Vertical); });
                 auto temporalCursorAction = cursorMenu->addAction("Temporal Cursor");
                 temporalCursorAction->setCheckable(true);
                 temporalCursorAction->setChecked(sqpApp->plotsCursorMode()
                                                  == SqpApplication::PlotsCursorMode::Temporal);
                 connect(temporalCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Temporal); });
                 auto horizontalCursorAction = cursorMenu->addAction("Horizontal Cursor");
                 horizontalCursorAction->setCheckable(true);
                 horizontalCursorAction->setChecked(sqpApp->plotsCursorMode()
                                                    == SqpApplication::PlotsCursorMode::Horizontal);
                 connect(horizontalCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Horizontal); });
                 auto crossCursorAction = cursorMenu->addAction("Cross Cursor");
                 crossCursorAction->setCheckable(true);
                 crossCursorAction->setChecked(sqpApp->plotsCursorMode()
                                               == SqpApplication::PlotsCursorMode::Cross);
                 connect(crossCursorAction, &QAction::triggered,
                         []() { sqpApp->setPlotsCursorMode(SqpApplication::PlotsCursorMode::Cross); });
                 mainToolBar->addWidget(btnCursor);
                 auto cursorModeActionGroup = new QActionGroup{this};
                 cursorModeActionGroup->setExclusive(true);
                 cursorModeActionGroup->addAction(noCursorAction);
                 cursorModeActionGroup->addAction(verticalCursorAction);
                 cursorModeActionGroup->addAction(temporalCursorAction);
                 cursorModeActionGroup->addAction(horizontalCursorAction);
                 cursorModeActionGroup->addAction(crossCursorAction);
                 // Catalog
                 mainToolBar->addSeparator();
                 mainToolBar->addAction(QIcon(":/icones/catalogue.png"), "Catalogues",
                                        [this]() { impl->m_CatalogExplorer->show(); });
                 // //////// //
                 // Settings //
                 // //////// //
                 // Registers "general settings" widget to the settings dialog
                 impl->m_SettingsDialog->registerWidget(QStringLiteral("General"),
                                                        impl->m_GeneralSettingsWidget);
                 // /////////// //
                 // Connections //
                 // /////////// //
                 // Controllers / controllers connections
                 connect(&sqpApp->timeController(), SIGNAL(timeUpdated(SqpRange)), &sqpApp->variableController(),
                         SLOT(onDateTimeOnSelection(SqpRange)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem *)),
                         m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem *)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(SqpRange)), &sqpApp->timeController(),
                         SLOT(onTimeToUpdate(SqpRange)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
                         SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
                 connect(&sqpApp->visualizationController(),
                         SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)), m_Ui->view,
                         SLOT(onRangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                 // Widgets / widgets connections
                 // For the following connections, we use DirectConnection to allow each widget that can
                 // potentially attach a menu to the variable's menu to do so before this menu is displayed.
                 // The order of connections is also important, since it determines the order in which each
                 // widget will attach its menu
                 connect(
                     m_Ui->variableInspectorWidget,
                     SIGNAL(tableMenuAboutToBeDisplayed(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     m_Ui->view, SLOT(attachVariableMenu(QMenu *, const QVector<std::shared_ptr<Variable> > &)),
                     Qt::DirectConnection);
             }
             MainWindow::~MainWindow()
             {
             }
             void MainWindow::changeEvent(QEvent *e)
             {
                 QMainWindow::changeEvent(e);
                 switch (e->type()) {
                     case QEvent::LanguageChange:
                         m_Ui->retranslateUi(this);
                         break;
                     default:
                         break;
                 }
             }
+            void MainWindow::closeEvent(QCloseEvent *event)
+            {
+                if (!impl->checkDataToSave(this)) {
+                    event->ignore();
+                }
+                else {
+                    event->accept();
+                }
+            }
+            bool MainWindow::MainWindowPrivate::checkDataToSave(QWidget *parentWidget)
+            {
+                auto hasChanges = sqpApp->catalogueController().hasChanges();
+                if (hasChanges) {
+                    // There are some unsaved changes
+                    switch (QMessageBox::question(
+                        parentWidget, "Save changes",
+                        tr("The catalogue controller unsaved changes.\nDo you want to save them ?"),
+                        QMessageBox::SaveAll | QMessageBox::Discard | QMessageBox::Cancel,
+                        QMessageBox::SaveAll)) {
+                        case QMessageBox::SaveAll:
+                            sqpApp->catalogueController().saveAll();
+                            break;
+                        case QMessageBox::Discard:
+                            break;
+                        case QMessageBox::Cancel:
+                        default:
+                            return false;
+                    }
+                }
+                return true;
+            }

core/include/Catalogue/CatalogueController.h +1 0

             #ifndef SCIQLOP_CATALOGUECONTROLLER_H
             #define SCIQLOP_CATALOGUECONTROLLER_H
             #include "CoreGlobal.h"
             #include <Data/SqpRange.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Common/spimpl.h>
             #include <memory>
             class DBCatalogue;
             class DBEvent;
             class DBEventProduct;
             Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueController)
             class DataSourceItem;
             class Variable;
             /**
              * @brief The CatalogueController class aims to handle catalogues and event using the CatalogueAPI
              * library.
              */
             class SCIQLOP_CORE_EXPORT CatalogueController : public QObject {
                 Q_OBJECT
             public:
                 explicit CatalogueController(QObject *parent = 0);
                 virtual ~CatalogueController();
                 // DB
                 QStringList getRepositories() const;
                 void addDB(const QString &dbPath);
                 void saveDB(const QString &destinationPath, const QString &repository);
                 // Event
                 /// retrieveEvents with empty repository retrieve them from the default repository
                 std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
                 std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
                 std::list<std::shared_ptr<DBEvent> >
                 retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
                 void addEvent(std::shared_ptr<DBEvent> event);
                 void updateEvent(std::shared_ptr<DBEvent> event);
                 void updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct);
                 void removeEvent(std::shared_ptr<DBEvent> event);
                 //    void trashEvent(std::shared_ptr<DBEvent> event);
                 //    void restore(QUuid eventId);
                 void saveEvent(std::shared_ptr<DBEvent> event);
                 bool eventHasChanges(std::shared_ptr<DBEvent> event) const;
                 // Catalogue
                 //    bool createCatalogue(const QString &name, QVector<QUuid> eventList);
                 /// retrieveEvents with empty repository retrieve them from the default repository
                 std::list<std::shared_ptr<DBCatalogue> > retrieveCatalogues(const QString &repository
                                                                             = QString()) const;
                 void updateCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void removeCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue);
                 void saveAll();
+                bool hasChanges() const;
                 /// Returns the MIME data associated to a list of variables
                 QByteArray mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const;
                 /// Returns the list of variables contained in a MIME data
                 QVector<std::shared_ptr<DBEvent> > eventsForMimeData(const QByteArray &mimeData) const;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();
             private:
                 class CatalogueControllerPrivate;
                 spimpl::unique_impl_ptr<CatalogueControllerPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUECONTROLLER_H

core/src/Catalogue/CatalogueController.cpp +5 0

             #include <Catalogue/CatalogueController.h>
             #include <Variable/Variable.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <CompoundPredicate.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <IRequestPredicate.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QDir>
             #include <QStandardPaths>
             Q_LOGGING_CATEGORY(LOG_CatalogueController, "CatalogueController")
             namespace {
             static QString REPOSITORY_WORK_SUFFIX = QString{"_work"};
             static QString REPOSITORY_TRASH_SUFFIX = QString{"_trash"};
             }
             class CatalogueController::CatalogueControllerPrivate {
             public:
                 explicit CatalogueControllerPrivate(CatalogueController *parent) : m_Q{parent} {}
                 CatalogueDao m_CatalogueDao;
                 QStringList m_RepositoryList;
                 CatalogueController *m_Q;
                 QSet<QString> m_EventKeysWithChanges;
                 QString eventUniqueKey(const std::shared_ptr<DBEvent> &event) const;
                 void copyDBtoDB(const QString &dbFrom, const QString &dbTo);
                 QString toWorkRepository(QString repository);
                 QString toSyncRepository(QString repository);
                 void savAllDB();
                 void saveEvent(std::shared_ptr<DBEvent> event, bool persist = true);
                 void saveCatalogue(std::shared_ptr<DBCatalogue> catalogue, bool persist = true);
             };
             CatalogueController::CatalogueController(QObject *parent)
                     : impl{spimpl::make_unique_impl<CatalogueControllerPrivate>(this)}
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController construction")
                                                    << QThread::currentThread();
             }
             CatalogueController::~CatalogueController()
             {
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController destruction")
                                                    << QThread::currentThread();
             }
             QStringList CatalogueController::getRepositories() const
             {
                 return impl->m_RepositoryList;
             }
             void CatalogueController::addDB(const QString &dbPath)
             {
                 QDir dbDir(dbPath);
                 if (dbDir.exists()) {
                     auto dirName = dbDir.dirName();
                     if (std::find(impl->m_RepositoryList.cbegin(), impl->m_RepositoryList.cend(), dirName)
                         != impl->m_RepositoryList.cend()) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB that is already loaded");
                     }
                     if (!impl->m_CatalogueDao.addDB(dbPath, dirName)) {
                         qCCritical(LOG_CatalogueController())
                             << tr("Impossible to addDB %1 from %2 ").arg(dirName, dbPath);
                     }
                     else {
                         impl->m_RepositoryList << dirName;
                         impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
                     }
                 }
                 else {
                     qCCritical(LOG_CatalogueController()) << tr("Impossible to addDB that not exists: ")
                                                           << dbPath;
                 }
             }
             void CatalogueController::saveDB(const QString &destinationPath, const QString &repository)
             {
                 if (!impl->m_CatalogueDao.saveDB(destinationPath, repository)) {
                     qCCritical(LOG_CatalogueController())
                         << tr("Impossible to saveDB %1 from %2 ").arg(repository, destinationPath);
                 }
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEvents(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getEvents(impl->toWorkRepository(dbDireName));
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> > CatalogueController::retrieveAllEvents() const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 for (auto repository : impl->m_RepositoryList) {
                     eventsShared.splice(eventsShared.end(), retrieveEvents(repository));
                 }
                 return eventsShared;
             }
             std::list<std::shared_ptr<DBEvent> >
             CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);
                 for (auto event : events) {
                     eventsShared.push_back(std::make_shared<DBEvent>(event));
                 }
                 return eventsShared;
             }
             void CatalogueController::updateEvent(std::shared_ptr<DBEvent> event)
             {
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 auto uniqueId = impl->eventUniqueKey(event);
                 impl->m_EventKeysWithChanges.insert(uniqueId);
                 impl->m_CatalogueDao.updateEvent(*event);
             }
             void CatalogueController::updateEventProduct(std::shared_ptr<DBEventProduct> eventProduct)
             {
                 impl->m_CatalogueDao.updateEventProduct(*eventProduct);
             }
             void CatalogueController::removeEvent(std::shared_ptr<DBEvent> event)
             {
                 // Remove it from both repository and repository_work
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
                 event->setRepository(impl->toSyncRepository(event->getRepository()));
                 impl->m_CatalogueDao.removeEvent(*event);
             }
             void CatalogueController::addEvent(std::shared_ptr<DBEvent> event)
             {
                 event->setRepository(impl->toWorkRepository(event->getRepository()));
                 auto eventTemp = *event;
                 impl->m_CatalogueDao.addEvent(eventTemp);
                 // Call update is necessary at the creation of add Event if it has some tags or some event
                 // products
                 if (!event->getEventProducts().empty() || !event->getTags().empty()) {
                     auto eventProductsTemp = eventTemp.getEventProducts();
                     auto eventProductTempUpdated = std::list<DBEventProduct>{};
                     for (auto eventProductTemp : eventProductsTemp) {
                         eventProductTemp.setEvent(eventTemp);
                         eventProductTempUpdated.push_back(eventProductTemp);
                     }
                     eventTemp.setEventProducts(eventProductTempUpdated);
                     impl->m_CatalogueDao.updateEvent(eventTemp);
                 }
             }
             void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
             {
                 impl->saveEvent(event, true);
                 impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
             }
             bool CatalogueController::eventHasChanges(std::shared_ptr<DBEvent> event) const
             {
                 return impl->m_EventKeysWithChanges.contains(impl->eventUniqueKey(event));
             }
             std::list<std::shared_ptr<DBCatalogue> >
             CatalogueController::retrieveCatalogues(const QString &repository) const
             {
                 QString dbDireName = repository.isEmpty() ? REPOSITORY_DEFAULT : repository;
                 auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = impl->m_CatalogueDao.getCatalogues(impl->toWorkRepository(dbDireName));
                 for (auto catalogue : catalogues) {
                     cataloguesShared.push_back(std::make_shared<DBCatalogue>(catalogue));
                 }
                 return cataloguesShared;
             }
             void CatalogueController::updateCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.updateCatalogue(*catalogue);
             }
             void CatalogueController::removeCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 // Remove it from both repository and repository_work
                 catalogue->setRepository(impl->toWorkRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
                 catalogue->setRepository(impl->toSyncRepository(catalogue->getRepository()));
                 impl->m_CatalogueDao.removeCatalogue(*catalogue);
             }
             void CatalogueController::saveCatalogue(std::shared_ptr<DBCatalogue> catalogue)
             {
                 impl->saveCatalogue(catalogue, true);
             }
             void CatalogueController::saveAll()
             {
                 for (auto repository : impl->m_RepositoryList) {
                     // Save Event
                     auto events = this->retrieveEvents(repository);
                     for (auto event : events) {
                         impl->saveEvent(event, false);
                     }
                     // Save Catalogue
                     auto catalogues = this->retrieveCatalogues(repository);
                     for (auto catalogue : catalogues) {
                         impl->saveCatalogue(catalogue, false);
                     }
                 }
                 impl->savAllDB();
                 impl->m_EventKeysWithChanges.clear();
             }
+            bool CatalogueController::hasChanges() const
+            {
+                return !impl->m_EventKeysWithChanges.isEmpty(); // TODO: catalogues
+            }
             QByteArray
             CatalogueController::mimeDataForEvents(const QVector<std::shared_ptr<DBEvent> > &events) const
             {
                 auto encodedData = QByteArray{};
                 QMap<QString, QVariantList> idsPerRepository;
                 for (auto event : events) {
                     idsPerRepository[event->getRepository()] << event->getUniqId();
                 }
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << idsPerRepository;
                 return encodedData;
             }
             QVector<std::shared_ptr<DBEvent> >
             CatalogueController::eventsForMimeData(const QByteArray &mimeData) const
             {
                 auto events = QVector<std::shared_ptr<DBEvent> >{};
                 QDataStream stream{mimeData};
                 QMap<QString, QVariantList> idsPerRepository;
                 stream >> idsPerRepository;
                 for (auto it = idsPerRepository.cbegin(); it != idsPerRepository.cend(); ++it) {
                     auto repository = it.key();
                     auto allRepositoryEvent = retrieveEvents(repository);
                     for (auto uuid : it.value()) {
                         for (auto repositoryEvent : allRepositoryEvent) {
                             if (uuid.toUuid() == repositoryEvent->getUniqId()) {
                                 events << repositoryEvent;
                             }
                         }
                     }
                 }
                 return events;
             }
             void CatalogueController::initialize()
             {
             <<<<<<< HEAD
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                                    << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
             =======
                 qCDebug(LOG_CatalogueController())
                     << tr("CatalogueController init") << QThread::currentThread();
             >>>>>>> 286decc... unthread the catalogue controller
                 impl->m_CatalogueDao.initialize();
                 auto defaultRepositoryLocation
                     = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                 QDir defaultRepositoryLocationDir;
                 if (defaultRepositoryLocationDir.mkpath(defaultRepositoryLocation)) {
                     defaultRepositoryLocationDir.cd(defaultRepositoryLocation);
                     auto defaultRepository = defaultRepositoryLocationDir.absoluteFilePath(REPOSITORY_DEFAULT);
                     qCInfo(LOG_CatalogueController()) << tr("Persistant data loading from: ")
                                                       << defaultRepository;
                     this->addDB(defaultRepository);
                 }
                 else {
                     qCWarning(LOG_CatalogueController())
                         << tr("Cannot load the persistent default repository from ")
                         << defaultRepositoryLocation;
                 }
                 qCDebug(LOG_CatalogueController()) << tr("CatalogueController init END");
             }
             QString CatalogueController::CatalogueControllerPrivate::eventUniqueKey(
                 const std::shared_ptr<DBEvent> &event) const
             {
                 return event->getUniqId().toString().append(event->getRepository());
             }
             void CatalogueController::CatalogueControllerPrivate::copyDBtoDB(const QString &dbFrom,
                                                                              const QString &dbTo)
             {
                 //    auto cataloguesShared = std::list<std::shared_ptr<DBCatalogue> >{};
                 auto catalogues = m_CatalogueDao.getCatalogues(dbFrom);
                 auto events = m_CatalogueDao.getEvents(dbFrom);
                 for (auto catalogue : catalogues) {
                     m_CatalogueDao.copyCatalogue(catalogue, dbTo, true);
                 }
                 for (auto event : events) {
                     m_CatalogueDao.copyEvent(event, dbTo, true);
                 }
             }
             QString CatalogueController::CatalogueControllerPrivate::toWorkRepository(QString repository)
             {
                 auto syncRepository = toSyncRepository(repository);
                 return QString("%1%2").arg(syncRepository, REPOSITORY_WORK_SUFFIX);
             }
             QString CatalogueController::CatalogueControllerPrivate::toSyncRepository(QString repository)
             {
                 auto syncRepository = repository;
                 if (repository.endsWith(REPOSITORY_WORK_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_WORK_SUFFIX);
                 }
                 else if (repository.endsWith(REPOSITORY_TRASH_SUFFIX)) {
                     syncRepository.remove(REPOSITORY_TRASH_SUFFIX);
                 }
                 return syncRepository;
             }
             void CatalogueController::CatalogueControllerPrivate::savAllDB()
             {
                 for (auto repository : m_RepositoryList) {
                     auto defaultRepositoryLocation
                         = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
                     m_CatalogueDao.saveDB(defaultRepositoryLocation, repository);
                 }
             }
             void CatalogueController::CatalogueControllerPrivate::saveEvent(std::shared_ptr<DBEvent> event,
                                                                             bool persist)
             {
                 m_CatalogueDao.copyEvent(*event, toSyncRepository(event->getRepository()), true);
                 if (persist) {
                     savAllDB();
                 }
             }
             void CatalogueController::CatalogueControllerPrivate::saveCatalogue(
                 std::shared_ptr<DBCatalogue> catalogue, bool persist)
             {
                 m_CatalogueDao.copyCatalogue(*catalogue, toSyncRepository(catalogue->getRepository()), true);
                 if (persist) {
                     savAllDB();
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages