GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1315:7185ea8182da

Merge branch 'develop' of...

perrinel -

r1315:7185ea8182da

parent child

Context file:

r1315:7185ea8182da

core/src/Catalogue/CatalogueController.cpp +3 -2

              #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);
                  impl->savAllDB();
              }
              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);
                  }
                  // update event parameter
                  auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
                      QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);
                  auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
                      QString{"repository"}, impl->toWorkRepository(event->getRepository()),
                      ComparaisonOperation::EQUALEQUAL);
                  auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
                  workPred->AddRequestPredicate(uniqIdPredicate);
                  workPred->AddRequestPredicate(workRepositoryPredicate);
                  auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
                  *event = workEvent;
+                 auto uniqueId = impl->eventUniqueKey(event);
+                 impl->m_EventKeysWithChanges.insert(uniqueId);
              }
              void CatalogueController::saveEvent(std::shared_ptr<DBEvent> event)
              {
                  impl->saveEvent(event, true);
                  impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
              }
              void CatalogueController::discardEvent(std::shared_ptr<DBEvent> event, bool &removed)
              {
                  auto uniqIdPredicate = std::make_shared<ComparaisonPredicate>(
                      QString{"uniqId"}, event->getUniqId(), ComparaisonOperation::EQUALEQUAL);
                  auto syncRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
                      QString{"repository"}, impl->toSyncRepository(event->getRepository()),
                      ComparaisonOperation::EQUALEQUAL);
                  auto syncPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
                  syncPred->AddRequestPredicate(uniqIdPredicate);
                  syncPred->AddRequestPredicate(syncRepositoryPredicate);
                  auto workRepositoryPredicate = std::make_shared<ComparaisonPredicate>(
                      QString{"repository"}, impl->toWorkRepository(event->getRepository()),
                      ComparaisonOperation::EQUALEQUAL);
                  auto workPred = std::make_shared<CompoundPredicate>(CompoundOperation::AND);
                  workPred->AddRequestPredicate(uniqIdPredicate);
                  workPred->AddRequestPredicate(workRepositoryPredicate);
                  auto syncEvent = impl->m_CatalogueDao.getEvent(syncPred);
                  if (!syncEvent.getUniqId().isNull()) {
                      removed = false;
                      impl->m_CatalogueDao.copyEvent(syncEvent, impl->toWorkRepository(event->getRepository()),
                                                     true);
                      auto workEvent = impl->m_CatalogueDao.getEvent(workPred);
                      *event = workEvent;
                      impl->m_EventKeysWithChanges.remove(impl->eventUniqueKey(event));
                  }
                  else {
                      removed = true;
                      // Since the element wasn't in sync repository. Discard it means remove it
                      event->setRepository(impl->toWorkRepository(event->getRepository()));
                      impl->m_CatalogueDao.removeEvent(*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()
              {
                  qCDebug(LOG_CatalogueController()) << tr("CatalogueController init")
                                                     << QThread::currentThread();
                  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;
                      QDir dbDir(defaultRepository);
                      impl->m_RepositoryList << REPOSITORY_DEFAULT;
                      if (dbDir.exists()) {
                          auto dirName = dbDir.dirName();
                          if (impl->m_CatalogueDao.addDB(defaultRepository, dirName)) {
                              impl->copyDBtoDB(dirName, impl->toWorkRepository(dirName));
                          }
                      }
                      else {
                          qCInfo(LOG_CatalogueController()) << tr("Initialisation of Default repository detected")
                                                            << 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();
                  }
              }

gui/src/Catalogue/CatalogueActionManager.cpp +13 -6

              #include "Catalogue/CatalogueActionManager.h"
              #include <Actions/ActionsGuiController.h>
              #include <Catalogue/CatalogueController.h>
              #include <DataSource/DataSourceItem.h>
              #include <SqpApplication.h>
              #include <Variable/Variable.h>
              #include <Visualization/VisualizationGraphWidget.h>
              #include <Visualization/VisualizationSelectionZoneItem.h>
              #include <Catalogue/CatalogueEventsWidget.h>
              #include <Catalogue/CatalogueExplorer.h>
              #include <Catalogue/CatalogueSideBarWidget.h>
              #include <Catalogue/CreateEventDialog.h>
              #include <CatalogueDao.h>
              #include <DBCatalogue.h>
              #include <DBEvent.h>
              #include <DBEventProduct.h>
              #include <QBoxLayout>
              #include <QComboBox>
              #include <QDialog>
              #include <QDialogButtonBox>
              #include <QLineEdit>
              #include <memory>
              struct CatalogueActionManager::CatalogueActionManagerPrivate {
                  CatalogueExplorer *m_CatalogueExplorer = nullptr;
                  CatalogueActionManagerPrivate(CatalogueExplorer *catalogueExplorer)
                          : m_CatalogueExplorer(catalogueExplorer)
                  {
                  }
                  void createEventFromZones(const QString &eventName,
                                            const QVector<VisualizationSelectionZoneItem *> &zones,
                                            const std::shared_ptr<DBCatalogue> &catalogue = nullptr)
                  {
                      auto event = std::make_shared<DBEvent>();
                      event->setName(eventName);
                      std::list<DBEventProduct> productList;
                      for (auto zone : zones) {
                          auto graph = zone->parentGraphWidget();
                          for (auto var : graph->variables()) {
                              auto eventProduct = std::make_shared<DBEventProduct>();
                              eventProduct->setEvent(*event);
                              auto zoneRange = zone->range();
                              eventProduct->setTStart(zoneRange.m_TStart);
                              eventProduct->setTEnd(zoneRange.m_TEnd);
                              eventProduct->setProductId(
                                  var->metadata().value(DataSourceItem::ID_DATA_KEY, "UnknownID").toString());
                              productList.push_back(*eventProduct);
                          }
                      }
                      event->setEventProducts(productList);
                      sqpApp->catalogueController().addEvent(event);
                      if (catalogue) {
                          // TODO
                          // catalogue->addEvent(event);
                          m_CatalogueExplorer->sideBarWidget().setCatalogueChanges(catalogue, true);
                          if (m_CatalogueExplorer->eventsWidget().displayedCatalogues().contains(catalogue)) {
                              m_CatalogueExplorer->eventsWidget().addEvent(event);
                              m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);
                          }
                      }
                      else if (m_CatalogueExplorer->eventsWidget().isAllEventsDisplayed()) {
                          m_CatalogueExplorer->eventsWidget().addEvent(event);
                          m_CatalogueExplorer->eventsWidget().setEventChanges(event, true);
                      }
                  }
              };
              CatalogueActionManager::CatalogueActionManager(CatalogueExplorer *catalogueExplorer)
                      : impl{spimpl::make_unique_impl<CatalogueActionManagerPrivate>(catalogueExplorer)}
              {
              }
              void CatalogueActionManager::installSelectionZoneActions()
              {
                  auto &actionController = sqpApp->actionsGuiController();
                  auto createEventEnableFuntion = [](auto zones) {
-                     QSet<VisualizationGraphWidget *> usedGraphs;
+                     // Checks that all variables in the zones doesn't refer to the same product
+                     QSet<QString> usedDatasource;
                      for (auto zone : zones) {
                          auto graph = zone->parentGraphWidget();
-                         if (!usedGraphs.contains(graph)) {
-                             usedGraphs.insert(graph);
+                         }
-                         else {
-                             return false;
+                         auto variables = graph->variables();
+                         for (auto var : variables) {
+                             auto datasourceId = var->metadata().value(DataSourceItem::ID_DATA_KEY).toString();
+                             if (!usedDatasource.contains(datasourceId)) {
+                                 usedDatasource.insert(datasourceId);
+                             }
+                             else {
+                                 return false;
+                             }
                          }
                      }
                      return true;
                  };
                  auto createEventAction = actionController.addSectionZoneAction(
                      {QObject::tr("Catalogues")}, QObject::tr("New Event..."), [this](auto zones) {
                          CreateEventDialog dialog(
                              impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT));
                          dialog.hideCatalogueChoice();
                          if (dialog.exec() == QDialog::Accepted) {
                              impl->createEventFromZones(dialog.eventName(), zones);
                          }
                      });
                  createEventAction->setEnableFunction(createEventEnableFuntion);
                  auto createEventInCatalogueAction = actionController.addSectionZoneAction(
                      {QObject::tr("Catalogues")}, QObject::tr("New Event in Catalogue..."), [this](auto zones) {
                          CreateEventDialog dialog(
                              impl->m_CatalogueExplorer->sideBarWidget().getCatalogues(REPOSITORY_DEFAULT));
                          if (dialog.exec() == QDialog::Accepted) {
                              auto selectedCatalogue = dialog.selectedCatalogue();
                              if (!selectedCatalogue) {
                                  selectedCatalogue = std::make_shared<DBCatalogue>();
                                  selectedCatalogue->setName(dialog.catalogueName());
                                  // sqpApp->catalogueController().addCatalogue(selectedCatalogue); TODO
                                  impl->m_CatalogueExplorer->sideBarWidget().addCatalogue(selectedCatalogue,
                                                                                          REPOSITORY_DEFAULT);
                              }
                              impl->createEventFromZones(dialog.eventName(), zones, selectedCatalogue);
                          }
                      });
                  createEventInCatalogueAction->setEnableFunction(createEventEnableFuntion);
              }

gui/src/Catalogue/CatalogueEventsWidget.cpp +7 -3

              #include "Catalogue/CatalogueEventsWidget.h"
              #include "ui_CatalogueEventsWidget.h"
              #include <Catalogue/CatalogueController.h>
              #include <Catalogue/CatalogueEventsModel.h>
              #include <Catalogue/CatalogueExplorerHelper.h>
              #include <CatalogueDao.h>
              #include <DBCatalogue.h>
              #include <SqpApplication.h>
              #include <Visualization/VisualizationTabWidget.h>
              #include <Visualization/VisualizationWidget.h>
              #include <Visualization/VisualizationZoneWidget.h>
              #include <QDialog>
              #include <QDialogButtonBox>
              #include <QListWidget>
              #include <QMessageBox>
              Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
              /// Fixed size of the validation column
              const auto VALIDATION_COLUMN_SIZE = 35;
              struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                  CatalogueEventsModel *m_Model = nullptr;
                  QStringList m_ZonesForTimeMode;
                  QString m_ZoneForGraphMode;
                  QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
+                 bool m_AllEventDisplayed = false;
                  VisualizationWidget *m_VisualizationWidget = nullptr;
                  void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, CatalogueEventsWidget *widget)
                  {
                      widget->ui->treeView->setSortingEnabled(false);
                      m_Model->setEvents(events);
                      widget->ui->treeView->setSortingEnabled(true);
                      for (auto event : events) {
                          if (sqpApp->catalogueController().eventHasChanges(event)) {
                              auto index = m_Model->indexOf(event);
                              widget->setEventChanges(event, true);
                          }
                      }
                  }
                  void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                  {
                      treeView->setSortingEnabled(false);
                      m_Model->addEvent(event);
                      treeView->setSortingEnabled(true);
                  }
                  void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                  {
                      treeView->setSortingEnabled(false);
                      m_Model->removeEvent(event);
                      treeView->setSortingEnabled(true);
                  }
                  QStringList getAvailableVisualizationZoneList() const
                  {
                      if (m_VisualizationWidget) {
                          if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                              return tab->availableZoneWidgets();
                          }
                      }
                      return QStringList{};
                  }
                  QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
                                         bool allowMultiSelection, const QPoint &location)
                  {
                      auto availableZones = getAvailableVisualizationZoneList();
                      if (availableZones.isEmpty()) {
                          return QStringList{};
                      }
                      QDialog d(parent, Qt::Tool);
                      d.setWindowTitle("Choose a zone");
                      auto layout = new QVBoxLayout{&d};
                      layout->setContentsMargins(0, 0, 0, 0);
                      auto listWidget = new QListWidget{&d};
                      layout->addWidget(listWidget);
                      QSet<QListWidgetItem *> checkedItems;
                      for (auto zone : availableZones) {
                          auto item = new QListWidgetItem{zone};
                          item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
                          if (selectedZones.contains(zone)) {
                              item->setCheckState(Qt::Checked);
                              checkedItems << item;
                          }
                          else {
                              item->setCheckState(Qt::Unchecked);
                          }
                          listWidget->addItem(item);
                      }
                      auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
                      layout->addWidget(buttonBox);
                      QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
                      QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
                      QObject::connect(listWidget, &QListWidget::itemChanged,
                                       [&checkedItems, allowMultiSelection, listWidget](auto item) {
                                           if (item->checkState() == Qt::Checked) {
                                               if (!allowMultiSelection) {
                                                   for (auto checkedItem : checkedItems) {
                                                       listWidget->blockSignals(true);
                                                       checkedItem->setCheckState(Qt::Unchecked);
                                                       listWidget->blockSignals(false);
                                                   }
                                                   checkedItems.clear();
                                               }
                                               checkedItems << item;
                                           }
                                           else {
                                               checkedItems.remove(item);
                                           }
                                       });
                      QStringList result;
                      d.setMinimumWidth(120);
                      d.resize(d.minimumSizeHint());
                      d.move(location);
                      if (d.exec() == QDialog::Accepted) {
                          for (auto item : checkedItems) {
                              result += item->text();
                          }
                      }
                      else {
                          result = selectedZones;
                      }
                      return result;
                  }
                  void updateForTimeMode(QTreeView *treeView)
                  {
                      auto selectedRows = treeView->selectionModel()->selectedRows();
                      if (selectedRows.count() == 1) {
                          auto event = m_Model->getEvent(selectedRows.first());
                          if (event) {
                              if (m_VisualizationWidget) {
                                  if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                      for (auto zoneName : m_ZonesForTimeMode) {
                                          if (auto zone = tab->getZoneWithName(zoneName)) {
                                              SqpRange eventRange;
                                              eventRange.m_TStart = event->getTStart();
                                              eventRange.m_TEnd = event->getTEnd();
                                              zone->setZoneRange(eventRange);
                                          }
                                      }
                                  }
                                  else {
                                      qCWarning(LOG_CatalogueEventsWidget())
                                          << "updateTimeZone: no tab found in the visualization";
                                  }
                              }
                              else {
                                  qCWarning(LOG_CatalogueEventsWidget())
                                      << "updateTimeZone: visualization widget not found";
                              }
                          }
                      }
                      else {
                          qCWarning(LOG_CatalogueEventsWidget())
                              << "updateTimeZone: not compatible with multiple events selected";
                      }
                  }
                  void updateForGraphMode(QTreeView *treeView)
                  {
                      auto selectedRows = treeView->selectionModel()->selectedRows();
                      if (selectedRows.count() == 1) {
                          auto event = m_Model->getEvent(selectedRows.first());
                          if (m_VisualizationWidget) {
                              if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                  if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
                                      // TODO
                                  }
                              }
                              else {
                                  qCWarning(LOG_CatalogueEventsWidget())
                                      << "updateGraphMode: no tab found in the visualization";
                              }
                          }
                          else {
                              qCWarning(LOG_CatalogueEventsWidget())
                                  << "updateGraphMode: visualization widget not found";
                          }
                      }
                      else {
                          qCWarning(LOG_CatalogueEventsWidget())
                              << "updateGraphMode: not compatible with multiple events selected";
                      }
                  }
                  void getSelectedItems(
                      QTreeView *treeView, QVector<std::shared_ptr<DBEvent> > &events,
                      QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > &eventProducts)
                  {
                      for (auto rowIndex : treeView->selectionModel()->selectedRows()) {
                          auto itemType = m_Model->itemTypeOf(rowIndex);
                          if (itemType == CatalogueEventsModel::ItemType::Event) {
                              events << m_Model->getEvent(rowIndex);
                          }
                          else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
                              eventProducts << qMakePair(m_Model->getParentEvent(rowIndex),
                                                         m_Model->getEventProduct(rowIndex));
                          }
                      }
                  }
              };
              CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                      : QWidget(parent),
                        ui(new Ui::CatalogueEventsWidget),
                        impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
              {
                  ui->setupUi(this);
                  impl->m_Model = new CatalogueEventsModel{this};
                  ui->treeView->setModel(impl->m_Model);
                  ui->treeView->setSortingEnabled(true);
                  ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
                  ui->treeView->setDragEnabled(true);
                  connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
                      if (checked) {
                          ui->btnChart->setChecked(false);
                          impl->m_ZonesForTimeMode
                              = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
                                                 this->mapToGlobal(ui->btnTime->frameGeometry().center()));
                          impl->updateForTimeMode(ui->treeView);
                      }
                  });
                  connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
                      if (checked) {
                          ui->btnTime->setChecked(false);
                          impl->m_ZoneForGraphMode
                              = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false,
                                                 this->mapToGlobal(ui->btnChart->frameGeometry().center()))
                                    .value(0);
                          impl->updateForGraphMode(ui->treeView);
                      }
                  });
                  connect(ui->btnRemove, &QToolButton::clicked, [this]() {
                      QVector<std::shared_ptr<DBEvent> > events;
                      QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                      impl->getSelectedItems(ui->treeView, events, eventProducts);
                      if (!events.isEmpty() && eventProducts.isEmpty()) {
                          if (QMessageBox::warning(this, tr("Remove Event(s)"),
                                                   tr("The selected event(s) will be completly removed "
                                                      "from the repository!\nAre you sure you want to continue?"),
                                                   QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
                              == QMessageBox::Yes) {
                              for (auto event : events) {
                                  sqpApp->catalogueController().removeEvent(event);
                                  impl->removeEvent(event, ui->treeView);
                              }
                          }
                      }
                  });
                  connect(ui->treeView, &QTreeView::clicked, this, &CatalogueEventsWidget::emitSelection);
                  connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
                          &CatalogueEventsWidget::emitSelection);
                  ui->btnRemove->setEnabled(false); // Disabled by default when nothing is selected
                  connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
                      auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
                      ui->btnChart->setEnabled(isNotMultiSelection);
                      ui->btnTime->setEnabled(isNotMultiSelection);
                      if (isNotMultiSelection && ui->btnTime->isChecked()) {
                          impl->updateForTimeMode(ui->treeView);
                      }
                      else if (isNotMultiSelection && ui->btnChart->isChecked()) {
                          impl->updateForGraphMode(ui->treeView);
                      }
                      QVector<std::shared_ptr<DBEvent> > events;
                      QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                      impl->getSelectedItems(ui->treeView, events, eventProducts);
                      ui->btnRemove->setEnabled(!events.isEmpty() && eventProducts.isEmpty());
                  });
                  ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                  ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Tags,
                                                               QHeaderView::Stretch);
                  ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Validation,
                                                               QHeaderView::Fixed);
                  ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
                                                               QHeaderView::Interactive);
                  ui->treeView->header()->resizeSection((int)CatalogueEventsModel::Column::Validation,
                                                        VALIDATION_COLUMN_SIZE);
                  ui->treeView->header()->setSortIndicatorShown(true);
                  connect(impl->m_Model, &CatalogueEventsModel::modelSorted, [this]() {
                      auto allEvents = impl->m_Model->events();
                      for (auto event : allEvents) {
                          setEventChanges(event, sqpApp->catalogueController().eventHasChanges(event));
                      }
                  });
                  populateWithAllEvents();
              }
              CatalogueEventsWidget::~CatalogueEventsWidget()
              {
                  delete ui;
              }
              void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
              {
                  impl->m_VisualizationWidget = visualization;
              }
              void CatalogueEventsWidget::addEvent(const std::shared_ptr<DBEvent> &event)
              {
                  impl->addEvent(event, ui->treeView);
              }
              void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
              {
                  impl->m_Model->refreshEvent(event);
                  auto eventIndex = impl->m_Model->indexOf(event);
                  auto validationIndex
                      = eventIndex.sibling(eventIndex.row(), (int)CatalogueEventsModel::Column::Validation);
                  if (validationIndex.isValid()) {
                      if (hasChanges) {
                          if (ui->treeView->indexWidget(validationIndex) == nullptr) {
                              auto widget = CatalogueExplorerHelper::buildValidationWidget(
                                  ui->treeView,
                                  [this, event]() {
                                      sqpApp->catalogueController().saveEvent(event);
                                      setEventChanges(event, false);
                                  },
                                  [this, event]() {
                                      bool removed = false;
                                      sqpApp->catalogueController().discardEvent(event, removed);
                                      if (removed) {
                                          impl->m_Model->removeEvent(event);
                                      }
                                      else {
                                          setEventChanges(event, false);
                                          impl->m_Model->refreshEvent(event, true);
                                      }
                                      emitSelection();
                                  });
                              ui->treeView->setIndexWidget(validationIndex, widget);
                          }
                      }
                      else {
                          // Note: the widget is destroyed
                          ui->treeView->setIndexWidget(validationIndex, nullptr);
                      }
                  }
                  else {
                      qCWarning(LOG_CatalogueEventsWidget())
                          << "setEventChanges: the event is not displayed in the model.";
                  }
              }
              QVector<std::shared_ptr<DBCatalogue> > CatalogueEventsWidget::displayedCatalogues() const
              {
                  return impl->m_DisplayedCatalogues;
              }
              bool CatalogueEventsWidget::isAllEventsDisplayed() const
              {
-                 return impl->m_DisplayedCatalogues.isEmpty() && !impl->m_Model->events().isEmpty();
+                 return impl->m_AllEventDisplayed;
              }
              bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &event) const
              {
                  return impl->m_Model->indexOf(event).isValid();
              }
              void CatalogueEventsWidget::populateWithCatalogues(
                  const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
              {
                  impl->m_DisplayedCatalogues = catalogues;
+                 impl->m_AllEventDisplayed = false;
                  QSet<QUuid> eventIds;
                  QVector<std::shared_ptr<DBEvent> > events;
                  for (auto catalogue : catalogues) {
                      auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                      for (auto event : catalogueEvents) {
                          if (!eventIds.contains(event->getUniqId())) {
                              events << event;
                              eventIds.insert(event->getUniqId());
                          }
                      }
                  }
                  impl->setEvents(events, this);
              }
              void CatalogueEventsWidget::populateWithAllEvents()
              {
                  impl->m_DisplayedCatalogues.clear();
+                 impl->m_AllEventDisplayed = true;
                  auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
                  QVector<std::shared_ptr<DBEvent> > events;
                  for (auto event : allEvents) {
                      events << event;
                  }
                  impl->setEvents(events, this);
              }
              void CatalogueEventsWidget::clear()
              {
                  impl->m_DisplayedCatalogues.clear();
+                 impl->m_AllEventDisplayed = false;
                  impl->setEvents({}, this);
              }
              void CatalogueEventsWidget::refresh()
              {
-                 if (impl->m_DisplayedCatalogues.isEmpty()) {
+                 if (isAllEventsDisplayed()) {
                      populateWithAllEvents();
                  }
-                 else {
+                 else if (!impl->m_DisplayedCatalogues.isEmpty()) {
                      populateWithCatalogues(impl->m_DisplayedCatalogues);
                  }
              }
              void CatalogueEventsWidget::emitSelection()
              {
                  QVector<std::shared_ptr<DBEvent> > events;
                  QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                  impl->getSelectedItems(ui->treeView, events, eventProducts);
                  if (!events.isEmpty() && eventProducts.isEmpty()) {
                      emit eventsSelected(events);
                  }
                  else if (events.isEmpty() && !eventProducts.isEmpty()) {
                      emit eventProductsSelected(eventProducts);
                  }
                  else {
                      emit selectionCleared();
                  }
              }

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