HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1460:ffe37c282008

Set revision to 1.1.0 some work to bring back catalogs...

jeandet -

r1460:ffe37c282008

parent child

Context file:

r1460:ffe37c282008

CMakeLists.txt +1 -1

             cmake_minimum_required(VERSION 3.6)
-            set(SCIQLOP_VERSION 1.0.0)
+            set(SCIQLOP_VERSION 1.1.0)
             project(SciQLOP
                 VERSION ${SCIQLOP_VERSION}
                 DESCRIPTION "SciQLOP (SCIentific Qt application for Learning from Observations of Plasmas) is an ergonomic and powerful tool enabling visualization and analysis of in situ spacecraft plasma data."
                 HOMEPAGE_URL https://github.com/LaboratoryOfPlasmaPhysics/SciQLOP
                 LANGUAGES CXX)
             include(GNUInstallDirs)
             SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake")
             OPTION (CPPCHECK "Analyzes the source code with cppcheck" OFF)
             OPTION (CLANG_TIDY "Analyzes the source code with Clang Tidy" OFF)
             OPTION (IWYU "Analyzes the source code with Include What You Use" OFF)
             OPTION (Coverage "Enables code coverage" OFF)
             OPTION (BUILD_APP "Build SciQLop application" ON)
             OPTION (BUILD_CORE "Build SciQLop Core module" ON)
             OPTION (BUILD_GUI "Build SciQLop GUI module" ON)
             OPTION (BUILD_PLUGINS "Build SciQLop plugins" ON)
             OPTION (ENABLE_WIN32_CONSOLE "Enables console on Win32 platfrom" OFF)
             set(CMAKE_CXX_STANDARD 17)
             set(CMAKE_AUTOMOC ON)
             #https://gitlab.kitware.com/cmake/cmake/issues/15227
             #set(CMAKE_AUTOUIC ON)
             if(POLICY CMP0071)
                 cmake_policy(SET CMP0071 OLD)
             endif()
             set(CMAKE_AUTORCC ON)
             set(CMAKE_INCLUDE_CURRENT_DIR ON)
             if(NOT DEFINED CMAKE_INSTALL_RPATH_USE_LINK_PATH)
               set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
             endif()
             if(NOT DEFINED CMAKE_MACOSX_RPATH)
               set(CMAKE_MACOSX_RPATH TRUE)
             endif()
             if(NOT CMAKE_BUILD_TYPE)
               set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
             endif()
             set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g3")
             find_package(Qt5 COMPONENTS Core Widgets Network PrintSupport Svg Test REQUIRED)
             IF(CPPCHECK)
                 set(CMAKE_CXX_CPPCHECK "cppcheck;--enable=warning,style")
             ENDIF(CPPCHECK)
             IF(CLANG_TIDY)
                 set(CMAKE_CXX_CLANG_TIDY "clang-tidy;-style=file;-checks=*")
             ENDIF(CLANG_TIDY)
             IF(IWYU)
                 set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE "include-what-you-use")
             ENDIF(IWYU)
             IF(Coverage)
                 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -g -O0 -Wall -W -Wshadow -Wunused-variable -Wunused-parameter -Wunused-function -Wunused -Wno-system-headers -Wno-deprecated -Woverloaded-virtual -Wwrite-strings -fprofile-arcs -ftest-coverage")
                 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -O0 -Wall -W -Wshadow -Wunused-variable \
                     -Wunused-parameter -Wunused-function -Wunused -Wno-system-headers \
                     -Wno-deprecated -Woverloaded-virtual -Wwrite-strings -fprofile-arcs -ftest-coverage")
                 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
                 add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/gcov.html
                     COMMAND gcovr --exclude='.*Test.*' --exclude='.*external.*' --object-directory ${CMAKE_BINARY_DIR}  -r ${CMAKE_SOURCE_DIR}  --html  --html-details -o ${CMAKE_CURRENT_BINARY_DIR}/gcov.html
                     )
                 add_custom_target(gcovr
                     DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/gcov.html gcovr
                 )
                 add_custom_target(show_coverage
                     COMMAND xdg-open ${CMAKE_CURRENT_BINARY_DIR}/gcov.html
                     DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/gcov.html gcovr
                     )
             ENDIF(Coverage)
             enable_testing()
             add_definitions(-DSCIQLOP_VERSION="${SCIQLOP_VERSION}")
             if(BUILD_CORE)
                 find_package(SciQLOPCore CONFIG QUIET)
                 if (NOT SciQLOPCore_FOUND)
                     if(NOT IS_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/core)
                         message("Init submodule Core")
                         execute_process(COMMAND git submodule init core WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                         execute_process(COMMAND git submodule update core WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                     endif()
                     add_subdirectory(core)
                 endif()
             endif()
             if(BUILD_GUI)
                 add_subdirectory(gui)
             endif()
             if(BUILD_APP)
                 add_subdirectory(app)
             endif()
             if(BUILD_PLUGINS)
                 add_subdirectory(plugins)
             endif()
             #add_subdirectory(docs)

app/src/MainWindow.cpp +5 -5

             /*------------------------------------------------------------------------------
             -- 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 <Catalogue2/browser.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 <Visualization/VisualizationController.h>
             #include <QAction>
             #include <QCloseEvent>
             #include <QDate>
             #include <QDir>
             #include <QFileDialog>
             #include <QMessageBox>
             #include <QToolBar>
             #include <QToolButton>
             #include <memory.h>
             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 } }
+                        , m_CatalogExplorer { new CataloguesBrowser { 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;
+                CataloguesBrowser* 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);
                 setWindowTitle(QString("SciQLop v%1").arg(SCIQLOP_VERSION));
                 m_Ui->splitter->setCollapsible(LEFTINSPECTORSIDEPANESPLITTERINDEX, false);
                 m_Ui->splitter->setCollapsible(RIGHTINSPECTORSIDEPANESPLITTERINDEX, false);
                 // impl->m_CatalogExplorer->setVisualizationWidget(m_Ui->view);
                 auto spacerLeftTop = new QWidget {};
                 spacerLeftTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerLeftBottom = new QWidget {};
                 spacerLeftBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightTop = new QWidget {};
                 spacerRightTop->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto spacerRightBottom = new QWidget {};
                 spacerRightBottom->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 auto openInspector = [this](bool checked, bool right, auto action) {
                     action->setIcon(
                         QIcon { (checked ^ 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);
                     }
                 };
                 // //////////////// //
                 // 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",
+                mainToolBar->addAction(QIcon(":/icones/catalogue.png"), "Catalogues",
-                //        [this]() { impl->m_CatalogExplorer->show(); });
+                    [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(DateTimeRange)),
                 //    &sqpApp->variableController(),
                 //            SLOT(onDateTimeOnSelection(DateTimeRange)));
                 // Widgets / controllers connections
                 // DataSource
                 connect(&sqpApp->dataSourceController(), SIGNAL(dataSourceItemSet(DataSourceItem*)),
                     m_Ui->dataSourceWidget, SLOT(addDataSource(DataSourceItem*)));
                 // Time
                 connect(timeWidget, SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->timeController(),
                     SLOT(onTimeToUpdate(DateTimeRange)));
                 // Visualization
                 connect(&sqpApp->visualizationController(),
                     SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable2>)), m_Ui->view,
                     SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable2>)));
                 connect(&sqpApp->visualizationController(),
                     SIGNAL(rangeChanged(std::shared_ptr<Variable2>, const DateTimeRange&)), m_Ui->view,
                     SLOT(onRangeChanged(std::shared_ptr<Variable2>, const DateTimeRange&)));
                 // 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();
                 }
             }
             void MainWindow::keyPressEvent(QKeyEvent* event)
             {
                 switch (event->key())
                 {
                     case Qt::Key_F11:
                         if (this->isFullScreen())
                         {
                             this->showNormal();
                         }
                         else
                         {
                             this->showFullScreen();
                         }
                         break;
                     default:
                         break;
                 }
             }
             bool MainWindow::MainWindowPrivate::checkDataToSave(QWidget* parentWidget)
             {
                 //    auto hasChanges = sqpApp->catalogueController().hasChanges();
                 //    if (hasChanges)
                 //    {
                 //        // There are some unsaved changes
                 //        switch (QMessageBox::question(parentWidget, tr("Save changes"),
                 //            tr("The catalogue controller has 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 +1 -1

	@@ -1,1 +1,1
	1	Subproject commit 854c0145877d96f95e0fb6ba08e32cb15cd49cf9		1	Subproject commit 39bf3ff40b41fc01170241f3e471c708c866118b

gui/include/Catalogue2/browser.h +10 -7

             #ifndef BROWSER_H
             #define BROWSER_H
-            #include <QWidget>
             #include <Catalogue/CatalogueController.h>
+            #include <QWidget>
-            namespace Ui {
+            namespace Ui
+            {
             class Browser;
             }
-            class Browser : public QWidget
+            class CataloguesBrowser : public QWidget
             {
                 Q_OBJECT
             public:
-                explicit Browser(QWidget *parent = nullptr);
+                explicit CataloguesBrowser(QWidget* parent = nullptr);
-                ~Browser();
+                ~CataloguesBrowser();
             private slots:
                 void repositorySelected(const QString& repo);
                 void catalogueSelected(const CatalogueController::Catalogue_ptr& catalogue);
                 void eventSelected(const CatalogueController::Event_ptr& event);
-                void productSelected(const CatalogueController::Product_t& product, const CatalogueController::Event_ptr& event);
+                void productSelected(
+                    const CatalogueController::Product_t& product, const CatalogueController::Event_ptr& event);
             private:
-                Ui::Browser *ui;
+                Ui::Browser* ui;
             };
             #endif // BROWSER_H

gui/src/Catalogue2/browser.cpp +14 -11

             #include "Catalogue2/browser.h"
             #include "ui_browser.h"
             #include <SqpApplication.h>
-            Browser::Browser(QWidget* parent) : QWidget(parent), ui(new Ui::Browser)
+            CataloguesBrowser::CataloguesBrowser(QWidget* parent)
+                    : QWidget(parent, Qt::Window), ui(new Ui::Browser)
             {
                 ui->setupUi(this);
                 connect(ui->repositories, &RepositoriesTreeView::repositorySelected, this,
-                    &Browser::repositorySelected);
+                    &CataloguesBrowser::repositorySelected);
                 connect(ui->repositories, &RepositoriesTreeView::catalogueSelected, this,
-                    &Browser::catalogueSelected);
+                    &CataloguesBrowser::catalogueSelected);
-                connect(ui->events, &EventsTreeView::eventSelected, this, &Browser::eventSelected);
+                connect(ui->events, &EventsTreeView::eventSelected, this, &CataloguesBrowser::eventSelected);
-                connect(ui->events, &EventsTreeView::productSelected, this, &Browser::productSelected);
+                connect(
+                    ui->events, &EventsTreeView::productSelected, this, &CataloguesBrowser::productSelected);
             }
-            Browser::~Browser()
+            CataloguesBrowser::~CataloguesBrowser()
             {
                 delete ui;
             }
-            void Browser::repositorySelected(const QString& repo)
+            void CataloguesBrowser::repositorySelected(const QString& repo)
             {
                 this->ui->Infos->setCurrentIndex(0);
                 this->ui->events->setEvents(sqpApp->catalogueController().events(repo));
                 // TODO add a statistic API
                 this->ui->catalogues_count->setText(
                     QString::number(sqpApp->catalogueController().catalogues(repo).size()));
                 this->ui->rep_events_count->setText(
                     QString::number(sqpApp->catalogueController().events(repo).size()));
             }
-            void Browser::catalogueSelected(const CatalogueController::Catalogue_ptr& catalogue)
+            void CataloguesBrowser::catalogueSelected(const CatalogueController::Catalogue_ptr& catalogue)
             {
                 this->ui->Infos->setCurrentIndex(1);
                 this->ui->events->setEvents(sqpApp->catalogueController().events(catalogue));
                 this->ui->cat_events_count->setText(
                     QString::number(sqpApp->catalogueController().events(catalogue).size()));
             }
-            void Browser::eventSelected(const CatalogueController::Event_ptr& event)
+            void CataloguesBrowser::eventSelected(const CatalogueController::Event_ptr& event)
             {
                 this->ui->Infos->setCurrentIndex(2);
                 this->ui->Event->setEvent(event);
             }
-            void Browser::productSelected(const CatalogueController::Product_t& product, const CatalogueController::Event_ptr& event)
+            void CataloguesBrowser::productSelected(
+                const CatalogueController::Product_t& product, const CatalogueController::Event_ptr& event)
             {
                 this->ui->Infos->setCurrentIndex(2);
-                this->ui->Event->setProduct(product,event);
+                this->ui->Event->setProduct(product, event);
             }

gui/tests/catalogue/browser/main.cpp +1 -1

             #include <QMainWindow>
             #include <QObject>
             #include <QScreen>
             #include <QString>
             #include <QWheelEvent>
             #include <QtTest>
             #include <Common/cpp_utils.h>
             #include <SqpApplication.h>
             #include <GUITestUtils.h>
             #include <TestProviders.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue2/browser.h>
             class A_CatalogueBrowser : public QObject
             {
                 Q_OBJECT
             public:
                 explicit A_CatalogueBrowser(QObject* parent = Q_NULLPTR) : QObject(parent) {}
             private slots:
             };
             // QT_BEGIN_NAMESPACE
             // QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS
             // QT_END_NAMESPACE
             // int main(int argc, char* argv[])
             //{
             //    SqpApplication app { argc, argv };
             //    app.setAttribute(Qt::AA_Use96Dpi, true);
             //    QTEST_DISABLE_KEYPAD_NAVIGATION;
             //    QTEST_ADD_GPU_BLACKLIST_SUPPORT;
             //    An_EventList tc;
             //    QTEST_SET_MAIN_SOURCE_PATH;
             //    return QTest::qExec(&tc, argc, argv);
             //}
             #include "main.moc"
             int main(int argc, char* argv[])
             {
                 Q_INIT_RESOURCE(sqpguiresources);
                 QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
                 SqpApplication a { argc, argv };
-                Browser w;
+                CataloguesBrowser w;
                 sqpApp->catalogueController().add("test");
                 sqpApp->catalogueController().add("stuff");
                 sqpApp->catalogueController().add("default");
                 sqpApp->catalogueController().add("new catalogue", "default");
                 auto catalogue = sqpApp->catalogueController().add("new catalogue2", "default");
                 for (auto _ : std::array<char, 1000>())
                 {
                     static int i = 0;
                     auto event = CatalogueController::make_event_ptr();
                     event->name = std::string("Event ") + std::to_string(i++);
                     event->tags = {"tag1", "tag2"};
                     event->products = { CatalogueController::Event_t::Product_t { "Product1", 10., 11. },
                         CatalogueController::Event_t::Product_t { "Product2", 11., 12. },
                         CatalogueController::Event_t::Product_t { "Product3", 10.2, 11. } };
                     catalogue->add(event);
                 }
                 w.show();
                 return a.exec();
             }

meson.build +1 -1

             project('SciQLOP', 'cpp',default_options : ['cpp_std=c++17'], meson_version:'>=0.47.0')
-            add_global_arguments('-DSCIQLOP_VERSION="1.0.0"', language : 'cpp')
+            add_global_arguments('-DSCIQLOP_VERSION="1.1.0"', language : 'cpp')
             qt5 = import('qt5')
             qt5core = dependency('qt5', modules : 'Core')
             qt5widgets = dependency('qt5', modules : 'Widgets')
             qt5gui = dependency('qt5', modules : 'Gui')
             qt5svg = dependency('qt5', modules : 'Svg')
             qt5xml = dependency('qt5', modules : 'Xml')
             qt5network = dependency('qt5', modules : 'Network')
             qt5printsupport = dependency('qt5', modules : 'PrintSupport')
             qt5Concurrent = dependency('qt5', modules : 'Concurrent')
             qt5test = dependency('qt5', modules : 'Test')
             moc = find_program('moc-qt5','moc')
             rcc = find_program('rcc-qt5','rcc')
             if build_machine.system()=='darwin'
               add_global_link_arguments('-headerpad_max_install_names', language : 'cpp')
               install_data('build_cfg/mac/sciqlopLOGO.icns', install_dir : 'Contents/Resources')
               install_data('build_cfg/mac/Info.plist', install_dir : 'Contents')
               meson.add_install_script('build_cfg/mac/install_script.sh')
             elif host_machine.system()=='windows'
               meson.add_install_script('build_cfg/windows/install_script.sh')
             elif host_machine.system()=='linux'
               install_data('app/resources/sciqlopLOGO.svg', install_dir : 'share/icons/hicolor/scalable/')
               install_data('app/resources/SciQLOP.desktop', install_dir : 'share/applications')
               install_data('app/resources/SciQLOP.appdata.xml', install_dir : 'share/metainfo')
             endif
             # Sets AMDA server that will be used during execution.
             # Available values are:
             # - "default": default AMDA server
             # - "amdatest": AMDA test server
             # - "hybrid": use both the default server and the test server (the server used is relative to each product, according to its "server" property in the JSON file)
             # - "localhost": use local AMDA server
             # Any other value will lead to the use of the default server
             add_project_arguments('-DSCIQLOP_AMDA_SERVER="hybrid"', language : 'cpp')
             subdir('core')
             subdir('gui')
             subdir('plugins')
             subdir('app')
             cppcheck = find_program('cppcheck', required : false)
             if cppcheck.found()
               run_target('cppcheck',
                           command : [cppcheck, '--enable=all',
                           '--project=' + join_paths(meson.build_root(), 'compile_commands.json')]
                           )
             endif

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