HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1407:fb115035b41a

Converted catalogue gui tests to manual tests...

jeandet -

r1407:fb115035b41a

parent child

Context file:

r1407:fb115035b41a

gui/include/Catalogue2/repositoriestreeview.h created 644 +41 0

@@ -0,0 +1,41
	1	/*
	2	This file is part of SciQLop.
	3
	4	SciQLop is free software: you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation, either version 3 of the License, or
	7	(at your option) any later version.
	8
	9	SciQLop is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with SciQLop. If not, see <https://www.gnu.org/licenses/>.
	16	*/
	17	#ifndef REPOSITORIESTREEVIEW_H
	18	#define REPOSITORIESTREEVIEW_H
	19
	20	#include <QObject>
	21	#include <QTreeView>
	22	#include <Catalogue2/repositoriesmodel.h>
	23
	24	class RepositoriesTreeView : public QTreeView
	25	{
	26	Q_OBJECT
	27	public:
	28	RepositoriesTreeView(QWidget* parent = nullptr);
	29
	30	public slots:
	31	void refresh()
	32	{
	33	static_cast<RepositoriesModel*>(model())->refresh();
	34	}
	35
	36	signals:
	37	void repositorySelected(const QString& repository);
	38
	39	};
	40
	41	#endif // REPOSITORIESTREEVIEW_H

gui/src/Catalogue2/repositoriestreeview.cpp created 644 +27 0

@@ -0,0 +1,27
	1	/*
	2	This file is part of SciQLop.
	3
	4	SciQLop is free software: you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation, either version 3 of the License, or
	7	(at your option) any later version.
	8
	9	SciQLop is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with SciQLop. If not, see <https://www.gnu.org/licenses/>.
	16	*/
	17	#include <Catalogue2/repositoriesmodel.h>
	18	#include <Catalogue2/repositoriestreeview.h>
	19
	20	RepositoriesTreeView::RepositoriesTreeView(QWidget* parent) : QTreeView(parent)
	21	{
	22	auto m = model();
	23	this->setModel(new RepositoriesModel(this));
	24	delete m;
	25	}
	26
	27

cmake/sciqlop_tests.cmake +6 0

             macro(declare_test testname testexe sources libraries)
                 add_executable(${testexe} ${sources})
                 target_link_libraries(${testexe} ${libraries})
                 add_test(NAME ${testname} COMMAND ${testexe})
             endmacro(declare_test)
+            macro(declare_manual_test testname testexe sources libraries)
+                add_executable(${testexe} ${sources})
+                target_link_libraries(${testexe} ${libraries})
+            endmacro(declare_manual_test)

gui/CMakeLists.txt +2 0

             FILE (GLOB_RECURSE gui_SRCS
                 include/DataSource/DataSourceWidget.h
                 include/DataSource/DataSourceTreeWidget.h
                 include/DataSource/DataSourceTreeWidgetItem.h
                 include/DataSource/DataSourceTreeWidgetHelper.h
                 include/SqpApplication.h
                 include/Common/ColorUtils.h
                 include/Common/VisualizationDef.h
                 include/SidePane/SqpSidePane.h
                 include/Catalogue2/eventsmodel.h
                 include/Catalogue2/eventstreeview.h
+                include/Catalogue2/repositoriestreeview.h
                 include/Catalogue2/repositoriesmodel.h
             #    include/Catalogue/CatalogueActionManager.h
             #    include/Catalogue/CatalogueTreeModel.h
             #    include/Catalogue/CatalogueExplorer.h
             #    include/Catalogue/CatalogueSideBarWidget.h
             #    include/Catalogue/CatalogueInspectorWidget.h
             #    include/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h
             #    include/Catalogue/CatalogueTreeItems/CatalogueTreeItem.h
             #    include/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h
             #    include/Catalogue/CatalogueEventsModel.h
             #    include/Catalogue/CatalogueEventsWidget.h
             #    include/Catalogue/CatalogueExplorerHelper.h
                 include/Visualization/VisualizationGraphHelper.h
                 include/Visualization/VisualizationTabWidget.h
                 include/Visualization/VisualizationDefs.h
                 include/Visualization/QCustomPlotSynchronizer.h
                 include/Visualization/QCPColorMapIterator.h
                 include/Visualization/operations/GenerateVariableMenuOperation.h
                 include/Visualization/operations/RemoveVariableOperation.h
                 include/Visualization/operations/FindVariableOperation.h
                 include/Visualization/operations/MenuBuilder.h
                 include/Visualization/operations/RescaleAxeOperation.h
                 include/Visualization/PlottablesRenderingUtils.h
                 include/Visualization/IVisualizationWidgetVisitor.h
                 include/Visualization/VisualizationGraphWidget.h
                 include/Visualization/IVisualizationWidget.h
                 include/Visualization/IVariableContainer.h
                 include/Visualization/SqpColorScale.h
                 include/Visualization/VisualizationWidget.h
                 include/Visualization/VisualizationZoneWidget.h
                 include/Visualization/VisualizationMultiZoneSelectionDialog.h
                 include/Visualization/VisualizationGraphRenderingDelegate.h
                 include/Visualization/AxisRenderingUtils.h
                 include/Visualization/VisualizationSelectionZoneItem.h
                 include/Visualization/VisualizationDragWidget.h
                 include/Visualization/VisualizationActionManager.h
                 include/Visualization/IGraphSynchronizer.h
                 include/Visualization/ColorScaleEditor.h
                 include/Visualization/MacScrollBarStyle.h
                 include/Visualization/VisualizationSelectionZoneManager.h
                 include/Visualization/qcustomplot.h
                 include/Visualization/VisualizationDragDropContainer.h
                 include/Visualization/VisualizationCursorItem.h
                 include/Settings/SqpSettingsDialog.h
                 include/Settings/SqpSettingsGeneralWidget.h
                 include/Variable/VariableMenuHeaderWidget.h
                 include/Variable/VariableInspectorTableView.h
                 include/Variable/VariableInspectorWidget.h
                 include/Variable/RenameVariableDialog.h
                 include/TimeWidget/TimeWidget.h
                 include/DragAndDrop/DragDropScroller.h
                 include/DragAndDrop/DragDropTabSwitcher.h
                 include/DragAndDrop/DragDropGuiController.h
                 include/Actions/FilteringAction.h
                 include/Actions/ActionsGuiController.h
                 include/Actions/SelectionZoneAction.h
                     src/DataSource/DataSourceTreeWidgetItem.cpp
                     src/DataSource/DataSourceWidget.cpp
                     src/DataSource/DataSourceTreeWidget.cpp
                     src/DataSource/DataSourceTreeWidgetHelper.cpp
                     src/Common/ColorUtils.cpp
                     src/Common/VisualizationDef.cpp
                     src/SidePane/SqpSidePane.cpp
                     src/Catalogue2/eventsmodel.cpp
                     src/Catalogue2/eventstreeview.cpp
+                    src/Catalogue2/repositoriestreeview.cpp
                     src/Catalogue2/repositoriesmodel.cpp
                     #src/Catalogue/CatalogueEventsWidget.cpp
                     #src/Catalogue/CatalogueSideBarWidget.cpp
                     #src/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp
                     #src/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.cpp
                     #src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp
                     #src/Catalogue/CatalogueExplorerHelper.cpp
                     #src/Catalogue/CatalogueExplorer.cpp
                     #src/Catalogue/CatalogueTreeModel.cpp
                     #src/Catalogue/CatalogueInspectorWidget.cpp
                     #src/Catalogue/CatalogueEventsModel.cpp
                     #src/Catalogue/CatalogueActionManager.cpp
                     src/Visualization/VisualizationDragDropContainer.cpp
                     src/Visualization/VisualizationTabWidget.cpp
                     src/Visualization/VisualizationWidget.cpp
                     src/Visualization/MacScrollBarStyle.cpp
                     src/Visualization/VisualizationCursorItem.cpp
                     src/Visualization/operations/MenuBuilder.cpp
                     src/Visualization/operations/RemoveVariableOperation.cpp
                     src/Visualization/operations/FindVariableOperation.cpp
                     src/Visualization/operations/GenerateVariableMenuOperation.cpp
                     src/Visualization/operations/RescaleAxeOperation.cpp
                     src/Visualization/AxisRenderingUtils.cpp
                     src/Visualization/PlottablesRenderingUtils.cpp
                     src/Visualization/VisualizationGraphRenderingDelegate.cpp
                     src/Visualization/VisualizationSelectionZoneManager.cpp
                     src/Visualization/QCPColorMapIterator.cpp
                     src/Visualization/ColorScaleEditor.cpp
                     src/Visualization/VisualizationGraphHelper.cpp
                     src/Visualization/VisualizationGraphWidget.cpp
                     src/Visualization/VisualizationDragWidget.cpp
                     src/Visualization/VisualizationZoneWidget.cpp
                     src/Visualization/VisualizationActionManager.cpp
                     src/Visualization/VisualizationSelectionZoneItem.cpp
                     src/Visualization/QCustomPlotSynchronizer.cpp
                     src/Visualization/qcustomplot.cpp
                     src/Visualization/VisualizationMultiZoneSelectionDialog.cpp
                     src/Visualization/SqpColorScale.cpp
                     src/Settings/SqpSettingsGeneralWidget.cpp
                     src/Settings/SqpSettingsDialog.cpp
                     src/SqpApplication.cpp
                     src/Variable/VariableInspectorWidget.cpp
                     src/Variable/VariableMenuHeaderWidget.cpp
                     src/Variable/RenameVariableDialog.cpp
                     src/Variable/VariableInspectorTableView.cpp
                     src/TimeWidget/TimeWidget.cpp
                     src/DragAndDrop/DragDropScroller.cpp
                     src/DragAndDrop/DragDropTabSwitcher.cpp
                     src/DragAndDrop/DragDropGuiController.cpp
                     src/Actions/ActionsGuiController.cpp
                     src/Actions/SelectionZoneAction.cpp
                     src/Actions/FilteringAction.cpp
                     ./resources/sqpguiresources.qrc
                     )
             QT5_WRAP_UI(
                 UiGenerated_SRCS
                 ui/DataSource/DataSourceWidget.ui
                 ui/Settings/SqpSettingsDialog.ui
                 ui/Settings/SqpSettingsGeneralWidget.ui
                 ui/SidePane/SqpSidePane.ui
                 ui/TimeWidget/TimeWidget.ui
                 ui/Variable/RenameVariableDialog.ui
                 ui/Variable/VariableInspectorWidget.ui
                 ui/Variable/VariableMenuHeaderWidget.ui
                 ui/Visualization/ColorScaleEditor.ui
                 ui/Visualization/VisualizationGraphWidget.ui
                 ui/Visualization/VisualizationTabWidget.ui
                 ui/Visualization/VisualizationWidget.ui
                 ui/Visualization/VisualizationZoneWidget.ui
                 ui/Visualization/VisualizationMultiZoneSelectionDialog.ui
                 #ui/Catalogue/CatalogueEventsWidget.ui
                 #ui/Catalogue/CatalogueExplorer.ui
                 #ui/Catalogue/CatalogueInspectorWidget.ui
                 #ui/Catalogue/CatalogueSideBarWidget.ui
             )
             add_library(sciqlopgui ${gui_SRCS} ${UiGenerated_SRCS})
             SET_TARGET_PROPERTIES(sciqlopgui PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
             target_include_directories(sciqlopgui PUBLIC
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/Visualization>
                 $<INSTALL_INTERFACE:include/SciQLOP>
                 )
             target_link_libraries(sciqlopgui PUBLIC
               Qt5::Widgets
               Qt5::PrintSupport
               Qt5::Svg
               sciqlopcore
             )
             install(TARGETS sciqlopgui EXPORT SciQLOPGuiConfig
                 ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
                 LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
                 RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR})
             install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/SciQLOP)
             install(EXPORT SciQLOPGuiConfig DESTINATION share/SciQLOPGui/cmake)
             export(TARGETS sciqlopgui FILE SciQLOPGuiConfig.cmake)
             subdirs(tests)

gui/include/Catalogue2/eventsmodel.h +16 0

+            /*
+                This file is part of SciQLop.
+                SciQLop 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 3 of the License, or
+                (at your option) any later version.
+                SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
+            */
             #ifndef EVENTSMODEL_H
             #define EVENTSMODEL_H
             #include <Catalogue/CatalogueController.h>
             #include <QAbstractItemModel>
             #include <array>
             class EventsModel : public QAbstractItemModel
             {
                 Q_OBJECT
                 std::vector<CatalogueController::Event_ptr> _events;
                 enum class ItemType
                 {
                     None,
                     Event,
                     Product
                 };
                 enum class Columns
                 {
                     Name = 0,
                     TStart = 1,
                     TEnd = 2,
                     Tags = 3,
                     Product = 4,
                     Validation = 5,
                     NbColumn = 6
                 };
                 const std::array<QString, static_cast<int>(Columns::NbColumn)> ColumnsNames
                     = { "Name", "Start time", "Stop time", "Tags", "Product(s)", "" };
             public:
                 EventsModel(QObject* parent = nullptr);
                 ItemType type(const QModelIndex& index) const;
                 Qt::ItemFlags flags(const QModelIndex& index) const override
                 {
                     return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
                 }
                 QVariant data(int col, const CatalogueController::Event_ptr& event) const;
                 QVariant data(int col, const CatalogueController::Product_t& product) const;
                 QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
                 QModelIndex index(
                     int row, int column, const QModelIndex& parent = QModelIndex()) const override;
                 QModelIndex parent(const QModelIndex& index) const override;
                 int rowCount(const QModelIndex& parent = QModelIndex()) const override;
                 int columnCount(const QModelIndex& parent = QModelIndex()) const override;
                 QVariant headerData(
                     int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
                 void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
             public slots:
                 void setEvents(std::vector<CatalogueController::Event_ptr> events)
                 {
                     beginResetModel();
                     std::swap(_events, events);
                     endResetModel();
                 }
             };
             #endif // EVENTSMODEL_H

gui/include/Catalogue2/eventstreeview.h +16 0

+            /*
+                This file is part of SciQLop.
+                SciQLop 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 3 of the License, or
+                (at your option) any later version.
+                SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
+            */
             #ifndef EVENTSTREEVIEW_H
             #define EVENTSTREEVIEW_H
             #include <Catalogue/CatalogueController.h>
             #include <QObject>
             #include <QTreeView>
             class EventsTreeView : public QTreeView
             {
                 Q_OBJECT
             public:
                 EventsTreeView(QWidget* parent = nullptr);
             public slots:
                 void setEvents(std::vector<CatalogueController::Event_ptr> events);
             };
             #endif // EVENTSTREEVIEW_H

gui/include/Catalogue2/repositoriesmodel.h +16 0

+            /*
+                This file is part of SciQLop.
+                SciQLop 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 3 of the License, or
+                (at your option) any later version.
+                SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
+            */
             #ifndef REPOSITORIESMODEL_H
             #define REPOSITORIESMODEL_H
             #include <Catalogue/CatalogueController.h>
             #include <QAbstractItemModel>
             #include <QIcon>
             #include <QObject>
             class RepositoriesModel : public QAbstractItemModel
             {
                 Q_OBJECT
                 enum class ItemType
                 {
                     None,
                     Catalogue,
                     Repository
                 };
                 struct RepoModelItem
                 {
                     ItemType type;
                     std::variant<QString, CatalogueController::Catalogue_ptr> item;
                     RepoModelItem() : type { ItemType::None } {}
                     RepoModelItem(const QString& repo);
                     RepoModelItem(const CatalogueController::Catalogue_ptr& catalogue, RepoModelItem* parent)
                             : type { ItemType::Catalogue }
                             , item { catalogue }
                             , parent { parent }
                             , icon { ":/icones/catalogue.png" }
                     {
                     }
                     QString repository() const { return std::get<QString>(item); }
                     CatalogueController::Catalogue_ptr catalogue() const
                     {
                         return std::get<CatalogueController::Catalogue_ptr>(item);
                     }
                     QVariant data(int role) const;
                     QString text() const
                     {
                         if (type == ItemType::Catalogue)
                             return QString::fromStdString(catalogue()->name);
                         if (type == ItemType::Repository)
                             return repository();
                         return QString();
                     }
                     std::vector<std::unique_ptr<RepoModelItem>> children;
                     RepoModelItem* parent = nullptr;
                     QIcon icon;
                 };
                 std::vector<std::unique_ptr<RepoModelItem>> _items;
                 inline RepoModelItem* to_item(const QModelIndex& index) const
                 {
                     return static_cast<RepoModelItem*>(index.internalPointer());
                 }
             public:
                 RepositoriesModel(QObject* parent = nullptr);
                 ItemType type(const QModelIndex& index) const;
                 Qt::ItemFlags flags(const QModelIndex& index) const override
                 {
                     return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
                 }
                 QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
                 QModelIndex index(
                     int row, int column, const QModelIndex& parent = QModelIndex()) const override;
                 QModelIndex parent(const QModelIndex& index) const override;
                 int rowCount(const QModelIndex& parent = QModelIndex()) const override;
                 int columnCount(const QModelIndex& parent = QModelIndex()) const override { return 1; }
             public slots:
                 void refresh();
             };
             #endif // REPOSITORIESMODEL_H

gui/src/Catalogue2/eventsmodel.cpp +16 0

+            /*
+                This file is part of SciQLop.
+                SciQLop 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 3 of the License, or
+                (at your option) any later version.
+                SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
+            */
             #include "Catalogue2/eventsmodel.h"
             #include <SqpApplication.h>
             EventsModel::EventsModel(QObject* parent) : QAbstractItemModel(parent) {}
             EventsModel::ItemType EventsModel::type(const QModelIndex& index) const
             {
                 if (!index.isValid())
                 {
                     return ItemType::None;
                 }
                 else if (index.internalPointer() == nullptr)
                 {
                     return ItemType::Event;
                 }
                 else
                 {
                     return ItemType::Product;
                 }
             }
             QVariant EventsModel::data(int col, const CatalogueController::Event_ptr& event) const
             {
                 switch (static_cast<Columns>(col))
                 {
                     case EventsModel::Columns::Name:
                         return QString::fromStdString(event->name);
                     case EventsModel::Columns::TStart:
                         if (auto start = event->startTime())
                             return DateUtils::dateTime(*start).toString(DATETIME_FORMAT_ONE_LINE);
                         else
                             return QVariant {};
                     case EventsModel::Columns::TEnd:
                         if (auto stop = event->stopTime())
                             return DateUtils::dateTime(*stop).toString(DATETIME_FORMAT_ONE_LINE);
                         else
                             return QVariant {};
                     case EventsModel::Columns::Product:
                     {
                         QStringList eventProductList;
                         for (const auto& evtProduct : event->products)
                         {
                             eventProductList << QString::fromStdString(evtProduct.name);
                         }
                         return eventProductList.join(";");
                     }
                     case EventsModel::Columns::Tags:
                     {
                         QString tagList;
                         for (const auto& tag : event->tags)
                         {
                             tagList += QString::fromStdString(tag);
                             tagList += ' ';
                         }
                         return tagList;
                     }
                     default:
                         break;
                 }
                 return QVariant {};
             }
             QVariant EventsModel::data(int col, const CatalogueController::Product_t& product) const
             {
                 switch (static_cast<Columns>(col))
                 {
                     case EventsModel::Columns::Name:
                         return QString::fromStdString(product.name);
                     case EventsModel::Columns::TStart:
                         return DateUtils::dateTime(product.startTime).toString(DATETIME_FORMAT_ONE_LINE);
                     case EventsModel::Columns::TEnd:
                         return DateUtils::dateTime(product.stopTime).toString(DATETIME_FORMAT_ONE_LINE);
                     case EventsModel::Columns::Product:
                         return QString::fromStdString(product.name);
                     default:
                         break;
                 }
                 return QVariant {};
             }
             QVariant EventsModel::data(const QModelIndex& index, int role) const
             {
                 if (_events.size() && index.isValid() && role == Qt::DisplayRole)
                 {
                     switch (type(index))
                     {
                         case EventsModel::ItemType::Event:
                             return data(index.column(), _events[index.row()]);
                         case EventsModel::ItemType::Product:
                         {
                             auto event = static_cast<CatalogueController::Event_t*>(index.internalPointer());
                             return data(index.column(), event->products[index.row()]);
                         }
                         default:
                             break;
                     }
                 }
                 return QVariant {};
             }
             QModelIndex EventsModel::index(int row, int column, const QModelIndex& parent) const
             {
                 if (!hasIndex(row, column, parent))
                 {
                     return QModelIndex();
                 }
                 switch (type(parent))
                 {
                     case EventsModel::ItemType::None:
                         return createIndex(row, column, nullptr);
                     case EventsModel::ItemType::Event:
                     {
                         return createIndex(row, column, _events[parent.row()].get());
                     }
                     case EventsModel::ItemType::Product:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             QModelIndex EventsModel::parent(const QModelIndex& index) const
             {
                 switch (type(index))
                 {
                     case EventsModel::ItemType::None:
                         break;
                     case EventsModel::ItemType::Event:
                         break;
                     case EventsModel::ItemType::Product:
                     {
                         auto parentEvent = static_cast<CatalogueController::Event_t*>(index.internalPointer());
                         auto pos = std::distance(std::cbegin(_events),
                             std::find_if(std::cbegin(_events), std::cend(_events),
                                 [parentEvent](auto event) { return event.get() == parentEvent; }));
                         if (pos >= 0 && pos < _events.size())
                         {
                             return createIndex(pos, 0);
                         }
                     }
                 }
                 return QModelIndex();
             }
             int EventsModel::rowCount(const QModelIndex& parent) const
             {
                 if (parent.column() > 0)
                 {
                     return 0;
                 }
                 switch (type(parent))
                 {
                     case EventsModel::ItemType::None:
                         return _events.size();
                     case EventsModel::ItemType::Event:
                         return _events[parent.row()]->products.size();
                         break;
                     case EventsModel::ItemType::Product:
                         break;
                     default:
                         break;
                 }
                 return 0;
             }
             int EventsModel::columnCount(const QModelIndex& parent) const
             {
                 return static_cast<int>(EventsModel::Columns::NbColumn);
             }
             QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (orientation == Qt::Horizontal && role == Qt::DisplayRole && section < ColumnsNames.size())
                 {
                     return ColumnsNames[section];
                 }
                 return QVariant();
             }
             void EventsModel::sort(int column, Qt::SortOrder order) {}

gui/src/Catalogue2/eventstreeview.cpp +16 0

+            /*
+                This file is part of SciQLop.
+                SciQLop 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 3 of the License, or
+                (at your option) any later version.
+                SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
+            */
             #include <Catalogue2/eventsmodel.h>
             #include <Catalogue2/eventstreeview.h>
             EventsTreeView::EventsTreeView(QWidget* parent) : QTreeView(parent)
             {
                 this->setModel(new EventsModel());
             }
             void EventsTreeView::setEvents(std::vector<CatalogueController::Event_ptr> events)
             {
                 static_cast<EventsModel*>(this->model())->setEvents(events);
             }

gui/src/Catalogue2/repositoriesmodel.cpp +16 0

+            /*
+                This file is part of SciQLop.
+                SciQLop 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 3 of the License, or
+                (at your option) any later version.
+                SciQLop 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 SciQLop.  If not, see <https://www.gnu.org/licenses/>.
+            */
             #include <Catalogue2/repositoriesmodel.h>
             #include <Common/containers.h>
             #include <SqpApplication.h>
             RepositoriesModel::RepositoriesModel(QObject* parent) : QAbstractItemModel(parent)
             {
                 refresh();
             }
             RepositoriesModel::ItemType RepositoriesModel::type(const QModelIndex& index) const
             {
                 if (RepoModelItem* item = to_item(index))
                 {
                     return item->type;
                 }
                 return ItemType::None;
             }
             void RepositoriesModel::refresh()
             {
                 beginResetModel();
                 _items.clear();
                 _items.push_back(std::make_unique<RepoModelItem>("All"));
                 _items.push_back(std::make_unique<RepoModelItem>("Trash"));
                 auto repo_list = sqpApp->catalogueController().repositories();
                 std::transform(std::begin(repo_list), std::end(repo_list), std::back_inserter(_items),
                     [](const auto& repo_name) { return std::make_unique<RepoModelItem>(repo_name); });
                 endResetModel();
             }
             QVariant RepositoriesModel::data(const QModelIndex& index, int role) const
             {
                 if (index.isValid() && index.column() == 0)
                 {
                     return to_item(index)->data(role);
                 }
                 return QVariant {};
             }
             QModelIndex RepositoriesModel::index(int row, int column, const QModelIndex& parent) const
             {
                 if (!hasIndex(row, column, parent))
                 {
                     return QModelIndex();
                 }
                 switch (type(parent))
                 {
                     case RepositoriesModel::ItemType::None: // is a repo
                         return createIndex(row, column, _items[row].get());
                     case RepositoriesModel::ItemType::Repository: // is a catalogue
                         return createIndex(row, column, to_item(parent)->children[row].get());
                     case RepositoriesModel::ItemType::Catalogue:
                         return createIndex(row, column, new RepoModelItem());
                 }
                 return QModelIndex();
             }
             QModelIndex RepositoriesModel::parent(const QModelIndex& index) const
             {
                 auto item = to_item(index);
                 if (item->type == ItemType::Catalogue)
                 {
                     auto repoIndex = SciQLop::containers::index_of(_items, item->parent);
                     return createIndex(repoIndex, 0, item->parent);
                 }
                 return QModelIndex();
             }
             int RepositoriesModel::rowCount(const QModelIndex& parent) const
             {
                 switch (type(parent))
                 {
                     case RepositoriesModel::ItemType::None:
                         return _items.size();
                     case RepositoriesModel::ItemType::Repository:
                         return to_item(parent)->children.size();
                     case RepositoriesModel::ItemType::Catalogue:
                         break;
                 }
                 return 0;
             }
             RepositoriesModel::RepoModelItem::RepoModelItem(const QString& repo)
                     : type { ItemType::Repository }, item { repo }, icon { ":/icones/database.png" }
             {
                 auto catalogues = sqpApp->catalogueController().catalogues(repo);
                 std::transform(std::begin(catalogues), std::end(catalogues), std::back_inserter(children),
                     [this](auto& catalogue) { return std::make_unique<RepoModelItem>(catalogue, this); });
             }
             QVariant RepositoriesModel::RepoModelItem::data(int role) const
             {
                 switch (role)
                 {
                     case Qt::EditRole:
                     case Qt::DisplayRole:
                         return text();
                     case Qt::DecorationRole:
                         return QVariant { icon };
                     default:
                         break;
                 }
                 return QVariant {};
             }

gui/tests/CMakeLists.txt +3 -2

+            include(sciqlop_tests)
             subdirs(GUITestUtils)
             declare_test(simple_graph simple_graph simple_graph/main.cpp "sciqlopgui;TestUtils;GUITestUtils;Qt5::Test")
             declare_test(multiple_sync_graph multiple_sync_graph multiple_sync_graph/main.cpp "sciqlopgui;TestUtils;GUITestUtils;Qt5::Test")
-            declare_test(event_list event_list catalogue/event_list/main.cpp "sciqlopgui;TestUtils;GUITestUtils;Qt5::Test")
+            declare_manual_test(event_list event_list catalogue/event_list/main.cpp "sciqlopgui;TestUtils;GUITestUtils;Qt5::Test")
-            declare_test(repository_list repository_list catalogue/repository_list/main.cpp "sciqlopgui;TestUtils;GUITestUtils;Qt5::Test")
+            declare_manual_test(repository_list repository_list catalogue/repository_list/main.cpp "sciqlopgui;TestUtils;GUITestUtils;Qt5::Test")

gui/tests/catalogue/repository_list/main.cpp +3 -7

             #include <QMainWindow>
             #include <QObject>
             #include <QScreen>
             #include <QString>
             #include <QWheelEvent>
             #include <QtTest>
             #include <QTreeView>
             #include <Common/cpp_utils.h>
             #include <SqpApplication.h>
             #include <GUITestUtils.h>
             #include <TestProviders.h>
-            //#include <Catalogue/CatalogueEventsWidget.h>
+            #include <Catalogue2/repositoriestreeview.h>
-            #include <Catalogue2/eventstreeview.h>
-            #include <Catalogue2/repositoriesmodel.h>
             class An_EventList : public QObject
             {
                 Q_OBJECT
             public:
                 explicit An_EventList(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 };
-                QTreeView w;
+                RepositoriesTreeView w;
                 sqpApp->catalogueController().add("test");
                 sqpApp->catalogueController().add("stuff");
                 sqpApp->catalogueController().add("default");
                 sqpApp->catalogueController().add("new catalogue", "default");
                 sqpApp->catalogueController().add("new catalogue2", "default");
-                RepositoriesModel* model = new RepositoriesModel();
-                w.setModel(model);
                 w.show();
+                w.refresh();
                 return a.exec();
             }

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