Auto status change to "Under Review"
@@ -0,0 +1,34 | |||
|
1 | #ifndef SCIQLOP_CATALOGUEABSTRACTTREEITEM_H | |
|
2 | #define SCIQLOP_CATALOGUEABSTRACTTREEITEM_H | |
|
3 | ||
|
4 | #include <Common/spimpl.h> | |
|
5 | #include <QVariant> | |
|
6 | #include <QVector> | |
|
7 | ||
|
8 | class QMimeData; | |
|
9 | ||
|
10 | class CatalogueAbstractTreeItem { | |
|
11 | public: | |
|
12 | constexpr static const int DEFAULT_TYPE = -1; | |
|
13 | ||
|
14 | CatalogueAbstractTreeItem(int type = DEFAULT_TYPE); | |
|
15 | virtual ~CatalogueAbstractTreeItem(); | |
|
16 | ||
|
17 | void addChild(CatalogueAbstractTreeItem *child); | |
|
18 | QVector<CatalogueAbstractTreeItem *> children() const; | |
|
19 | CatalogueAbstractTreeItem *parent() const; | |
|
20 | ||
|
21 | int type() const; | |
|
22 | QString text(int column = 0) const; | |
|
23 | ||
|
24 | virtual QVariant data(int column, int role) const; | |
|
25 | virtual Qt::ItemFlags flags(int column) const; | |
|
26 | virtual bool setData(int column, int role, const QVariant &value); | |
|
27 | virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action); | |
|
28 | ||
|
29 | private: | |
|
30 | class CatalogueAbstractTreeItemPrivate; | |
|
31 | spimpl::unique_impl_ptr<CatalogueAbstractTreeItemPrivate> impl; | |
|
32 | }; | |
|
33 | ||
|
34 | #endif // SCIQLOP_CATALOGUEABSTRACTTREEITEM_H |
@@ -0,0 +1,23 | |||
|
1 | #ifndef SCIQLOP_CATALOGUETEXTTREEITEM_H | |
|
2 | #define SCIQLOP_CATALOGUETEXTTREEITEM_H | |
|
3 | ||
|
4 | #include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h> | |
|
5 | #include <Common/spimpl.h> | |
|
6 | ||
|
7 | class CatalogueTextTreeItem : public CatalogueAbstractTreeItem { | |
|
8 | public: | |
|
9 | CatalogueTextTreeItem(const QIcon &icon, const QString &text, int type); | |
|
10 | ||
|
11 | QVariant data(int column, int role) const override; | |
|
12 | Qt::ItemFlags flags(int column) const override; | |
|
13 | ||
|
14 | QString text() const; | |
|
15 | ||
|
16 | void setEnabled(bool value); | |
|
17 | ||
|
18 | private: | |
|
19 | class CatalogueTextTreeItemPrivate; | |
|
20 | spimpl::unique_impl_ptr<CatalogueTextTreeItemPrivate> impl; | |
|
21 | }; | |
|
22 | ||
|
23 | #endif // SCIQLOP_CATALOGUETEXTTREEITEM_H |
@@ -0,0 +1,27 | |||
|
1 | #ifndef SCIQLOP_CATALOGUETREEITEM_H | |
|
2 | #define SCIQLOP_CATALOGUETREEITEM_H | |
|
3 | ||
|
4 | #include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h> | |
|
5 | #include <Common/spimpl.h> | |
|
6 | ||
|
7 | class DBCatalogue; | |
|
8 | ||
|
9 | ||
|
10 | class CatalogueTreeItem : public CatalogueAbstractTreeItem { | |
|
11 | public: | |
|
12 | CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon, int type); | |
|
13 | ||
|
14 | QVariant data(int column, int role) const override; | |
|
15 | bool setData(int column, int role, const QVariant &value) override; | |
|
16 | Qt::ItemFlags flags(int column) const override; | |
|
17 | bool canDropMimeData(const QMimeData *data, Qt::DropAction action) override; | |
|
18 | ||
|
19 | /// Returns the catalogue represented by the item | |
|
20 | std::shared_ptr<DBCatalogue> catalogue() const; | |
|
21 | ||
|
22 | private: | |
|
23 | class CatalogueTreeItemPrivate; | |
|
24 | spimpl::unique_impl_ptr<CatalogueTreeItemPrivate> impl; | |
|
25 | }; | |
|
26 | ||
|
27 | #endif // SCIQLOP_CATALOGUETREEITEM_H |
@@ -0,0 +1,74 | |||
|
1 | #include "Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h" | |
|
2 | ||
|
3 | struct CatalogueAbstractTreeItem::CatalogueAbstractTreeItemPrivate { | |
|
4 | int m_Type; | |
|
5 | QVector<CatalogueAbstractTreeItem *> m_Children; | |
|
6 | CatalogueAbstractTreeItem *m_Parent = nullptr; | |
|
7 | ||
|
8 | CatalogueAbstractTreeItemPrivate(int type) : m_Type(type) {} | |
|
9 | }; | |
|
10 | ||
|
11 | CatalogueAbstractTreeItem::CatalogueAbstractTreeItem(int type) | |
|
12 | : impl{spimpl::make_unique_impl<CatalogueAbstractTreeItemPrivate>(type)} | |
|
13 | { | |
|
14 | } | |
|
15 | ||
|
16 | CatalogueAbstractTreeItem::~CatalogueAbstractTreeItem() | |
|
17 | { | |
|
18 | qDeleteAll(impl->m_Children); | |
|
19 | } | |
|
20 | ||
|
21 | void CatalogueAbstractTreeItem::addChild(CatalogueAbstractTreeItem *child) | |
|
22 | { | |
|
23 | impl->m_Children << child; | |
|
24 | child->impl->m_Parent = this; | |
|
25 | } | |
|
26 | ||
|
27 | QVector<CatalogueAbstractTreeItem *> CatalogueAbstractTreeItem::children() const | |
|
28 | { | |
|
29 | return impl->m_Children; | |
|
30 | } | |
|
31 | ||
|
32 | CatalogueAbstractTreeItem *CatalogueAbstractTreeItem::parent() const | |
|
33 | { | |
|
34 | return impl->m_Parent; | |
|
35 | } | |
|
36 | ||
|
37 | int CatalogueAbstractTreeItem::type() const | |
|
38 | { | |
|
39 | return impl->m_Type; | |
|
40 | } | |
|
41 | ||
|
42 | QString CatalogueAbstractTreeItem::text(int column) const | |
|
43 | { | |
|
44 | return data(0, Qt::DisplayRole).toString(); | |
|
45 | } | |
|
46 | ||
|
47 | QVariant CatalogueAbstractTreeItem::data(int column, int role) const | |
|
48 | { | |
|
49 | Q_UNUSED(column); | |
|
50 | Q_UNUSED(role); | |
|
51 | return QVariant(); | |
|
52 | } | |
|
53 | ||
|
54 | Qt::ItemFlags CatalogueAbstractTreeItem::flags(int column) const | |
|
55 | { | |
|
56 | Q_UNUSED(column); | |
|
57 | return Qt::NoItemFlags; | |
|
58 | } | |
|
59 | ||
|
60 | bool CatalogueAbstractTreeItem::setData(int column, int role, const QVariant &value) | |
|
61 | { | |
|
62 | Q_UNUSED(column); | |
|
63 | Q_UNUSED(role); | |
|
64 | Q_UNUSED(value); | |
|
65 | ||
|
66 | return false; | |
|
67 | } | |
|
68 | ||
|
69 | bool CatalogueAbstractTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action) | |
|
70 | { | |
|
71 | Q_UNUSED(data); | |
|
72 | Q_UNUSED(action); | |
|
73 | return false; | |
|
74 | } |
@@ -0,0 +1,59 | |||
|
1 | #include "Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h" | |
|
2 | ||
|
3 | #include <QIcon> | |
|
4 | ||
|
5 | struct CatalogueTextTreeItem::CatalogueTextTreeItemPrivate { | |
|
6 | ||
|
7 | QString m_Text; | |
|
8 | QIcon m_Icon; | |
|
9 | bool m_IsEnabled = true; | |
|
10 | ||
|
11 | CatalogueTextTreeItemPrivate(const QIcon &icon, const QString &text) | |
|
12 | : m_Text(text), m_Icon(icon) | |
|
13 | { | |
|
14 | } | |
|
15 | }; | |
|
16 | ||
|
17 | ||
|
18 | CatalogueTextTreeItem::CatalogueTextTreeItem(const QIcon &icon, const QString &text, int type) | |
|
19 | : CatalogueAbstractTreeItem(type), | |
|
20 | impl{spimpl::make_unique_impl<CatalogueTextTreeItemPrivate>(icon, text)} | |
|
21 | { | |
|
22 | } | |
|
23 | ||
|
24 | QVariant CatalogueTextTreeItem::data(int column, int role) const | |
|
25 | { | |
|
26 | if (column > 0) { | |
|
27 | return QVariant(); | |
|
28 | } | |
|
29 | ||
|
30 | switch (role) { | |
|
31 | case Qt::DisplayRole: | |
|
32 | return impl->m_Text; | |
|
33 | case Qt::DecorationRole: | |
|
34 | return impl->m_Icon; | |
|
35 | } | |
|
36 | ||
|
37 | return QVariant(); | |
|
38 | } | |
|
39 | ||
|
40 | Qt::ItemFlags CatalogueTextTreeItem::flags(int column) const | |
|
41 | { | |
|
42 | Q_UNUSED(column); | |
|
43 | ||
|
44 | if (!impl->m_IsEnabled) { | |
|
45 | return Qt::NoItemFlags; | |
|
46 | } | |
|
47 | ||
|
48 | return Qt::ItemIsEnabled | Qt::ItemIsSelectable; | |
|
49 | } | |
|
50 | ||
|
51 | QString CatalogueTextTreeItem::text() const | |
|
52 | { | |
|
53 | return impl->m_Text; | |
|
54 | } | |
|
55 | ||
|
56 | void CatalogueTextTreeItem::setEnabled(bool value) | |
|
57 | { | |
|
58 | impl->m_IsEnabled = value; | |
|
59 | } |
@@ -1,47 +1,55 | |||
|
1 | 1 | #ifndef SCIQLOP_CATALOGUETREEMODEL_H |
|
2 | 2 | #define SCIQLOP_CATALOGUETREEMODEL_H |
|
3 | 3 | |
|
4 | 4 | #include <Common/spimpl.h> |
|
5 | 5 | #include <QAbstractItemModel> |
|
6 | #include <QTreeWidgetItem> | |
|
6 | ||
|
7 | class CatalogueAbstractTreeItem; | |
|
7 | 8 | |
|
8 | 9 | /** |
|
9 | 10 | * @brief Model to display catalogue items based on QTreeWidgetItem |
|
10 |
* @warning Do not use the method QTreeWidgetItem::treeWidget for an item added to this model or the |
|
|
11 | * @warning Do not use the method QTreeWidgetItem::treeWidget for an item added to this model or the | |
|
12 | * application will crash | |
|
11 | 13 | */ |
|
12 | 14 | class CatalogueTreeModel : public QAbstractItemModel { |
|
13 | 15 | Q_OBJECT |
|
14 | 16 | |
|
15 | 17 | signals: |
|
16 | 18 | void itemRenamed(const QModelIndex &index); |
|
17 | 19 | |
|
18 | 20 | public: |
|
19 | 21 | CatalogueTreeModel(QObject *parent = nullptr); |
|
20 | 22 | |
|
21 | 23 | enum class Column { Name, Validation, Count }; |
|
22 | 24 | |
|
23 |
QModelIndex addTopLevelItem( |
|
|
24 | int topLevelItemCount() const; | |
|
25 | QTreeWidgetItem *topLevelItem(int i) const; | |
|
25 | QModelIndex addTopLevelItem(CatalogueAbstractTreeItem *item); | |
|
26 | QVector<CatalogueAbstractTreeItem *> topLevelItems() const; | |
|
26 | 27 | |
|
27 |
void addChildItem( |
|
|
28 | void addChildItem(CatalogueAbstractTreeItem *child, const QModelIndex &parentIndex); | |
|
28 | 29 | |
|
29 |
|
|
|
30 |
QModelIndex indexOf( |
|
|
30 | CatalogueAbstractTreeItem *item(const QModelIndex &index) const; | |
|
31 | QModelIndex indexOf(CatalogueAbstractTreeItem *item, int column = 0) const; | |
|
31 | 32 | |
|
32 | 33 | // model |
|
33 | 34 | QModelIndex index(int row, int column, |
|
34 | 35 | const QModelIndex &parent = QModelIndex()) const override; |
|
35 | 36 | QModelIndex parent(const QModelIndex &index) const override; |
|
36 | 37 | int rowCount(const QModelIndex &parent) const override; |
|
37 | 38 | int columnCount(const QModelIndex &parent) const override; |
|
38 | 39 | Qt::ItemFlags flags(const QModelIndex &index) const override; |
|
39 | 40 | QVariant data(const QModelIndex &index, int role) const override; |
|
40 | 41 | bool setData(const QModelIndex &index, const QVariant &value, int role) override; |
|
41 | 42 | |
|
43 | bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, | |
|
44 | const QModelIndex &parent) const override; | |
|
45 | bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, | |
|
46 | const QModelIndex &parent) override; | |
|
47 | Qt::DropActions supportedDropActions() const; | |
|
48 | QStringList mimeTypes() const; | |
|
49 | ||
|
42 | 50 | private: |
|
43 | 51 | class CatalogueTreeModelPrivate; |
|
44 | 52 | spimpl::unique_impl_ptr<CatalogueTreeModelPrivate> impl; |
|
45 | 53 | }; |
|
46 | 54 | |
|
47 | 55 | #endif // CATALOGUETREEMODEL_H |
@@ -1,145 +1,147 | |||
|
1 | 1 | qxorm_dep = dependency('QxOrm', required : true, fallback:['QxOrm','qxorm_dep']) |
|
2 | 2 | catalogueapi_dep = dependency('CatalogueAPI', required : true, fallback:['CatalogueAPI','CatalogueAPI_dep']) |
|
3 | 3 | |
|
4 | 4 | gui_moc_headers = [ |
|
5 | 5 | 'include/DataSource/DataSourceWidget.h', |
|
6 | 6 | 'include/Settings/SqpSettingsDialog.h', |
|
7 | 7 | 'include/Settings/SqpSettingsGeneralWidget.h', |
|
8 | 8 | 'include/SidePane/SqpSidePane.h', |
|
9 | 9 | 'include/SqpApplication.h', |
|
10 | 10 | 'include/DragAndDrop/DragDropScroller.h', |
|
11 | 11 | 'include/DragAndDrop/DragDropTabSwitcher.h', |
|
12 | 12 | 'include/TimeWidget/TimeWidget.h', |
|
13 | 13 | 'include/Variable/VariableInspectorWidget.h', |
|
14 | 14 | 'include/Variable/RenameVariableDialog.h', |
|
15 | 15 | 'include/Visualization/qcustomplot.h', |
|
16 | 16 | 'include/Visualization/VisualizationGraphWidget.h', |
|
17 | 17 | 'include/Visualization/VisualizationTabWidget.h', |
|
18 | 18 | 'include/Visualization/VisualizationWidget.h', |
|
19 | 19 | 'include/Visualization/VisualizationZoneWidget.h', |
|
20 | 20 | 'include/Visualization/VisualizationDragDropContainer.h', |
|
21 | 21 | 'include/Visualization/VisualizationDragWidget.h', |
|
22 | 22 | 'include/Visualization/ColorScaleEditor.h', |
|
23 | 23 | 'include/Actions/SelectionZoneAction.h', |
|
24 | 24 | 'include/Visualization/VisualizationMultiZoneSelectionDialog.h', |
|
25 | 25 | 'include/Catalogue/CatalogueExplorer.h', |
|
26 | 26 | 'include/Catalogue/CatalogueEventsWidget.h', |
|
27 | 27 | 'include/Catalogue/CatalogueSideBarWidget.h', |
|
28 | 28 | 'include/Catalogue/CatalogueInspectorWidget.h', |
|
29 | 29 | 'include/Catalogue/CatalogueEventsModel.h', |
|
30 | 30 | 'include/Catalogue/CreateEventDialog.h', |
|
31 | 31 | 'include/Catalogue/CatalogueTreeModel.h' |
|
32 | 32 | ] |
|
33 | 33 | |
|
34 | 34 | gui_ui_files = [ |
|
35 | 35 | 'ui/DataSource/DataSourceWidget.ui', |
|
36 | 36 | 'ui/Settings/SqpSettingsDialog.ui', |
|
37 | 37 | 'ui/Settings/SqpSettingsGeneralWidget.ui', |
|
38 | 38 | 'ui/SidePane/SqpSidePane.ui', |
|
39 | 39 | 'ui/TimeWidget/TimeWidget.ui', |
|
40 | 40 | 'ui/Variable/VariableInspectorWidget.ui', |
|
41 | 41 | 'ui/Variable/RenameVariableDialog.ui', |
|
42 | 42 | 'ui/Variable/VariableMenuHeaderWidget.ui', |
|
43 | 43 | 'ui/Visualization/VisualizationGraphWidget.ui', |
|
44 | 44 | 'ui/Visualization/VisualizationTabWidget.ui', |
|
45 | 45 | 'ui/Visualization/VisualizationWidget.ui', |
|
46 | 46 | 'ui/Visualization/VisualizationZoneWidget.ui', |
|
47 | 47 | 'ui/Visualization/ColorScaleEditor.ui', |
|
48 | 48 | 'ui/Visualization/VisualizationMultiZoneSelectionDialog.ui', |
|
49 | 49 | 'ui/Catalogue/CatalogueExplorer.ui', |
|
50 | 50 | 'ui/Catalogue/CatalogueEventsWidget.ui', |
|
51 | 51 | 'ui/Catalogue/CatalogueSideBarWidget.ui', |
|
52 | 52 | 'ui/Catalogue/CatalogueInspectorWidget.ui', |
|
53 | 53 | 'ui/Catalogue/CreateEventDialog.ui' |
|
54 | 54 | ] |
|
55 | 55 | |
|
56 | 56 | gui_qresources = ['resources/sqpguiresources.qrc'] |
|
57 | 57 | |
|
58 | 58 | rcc_gen = generator(rcc, |
|
59 | 59 | output : 'qrc_@BASENAME@.cpp', |
|
60 | 60 | arguments : [ |
|
61 | 61 | '--output', |
|
62 | 62 | '@OUTPUT@', |
|
63 | 63 | '@INPUT@', |
|
64 | 64 | '@EXTRA_ARGS@']) |
|
65 | 65 | |
|
66 | 66 | rcc_files = rcc_gen.process(gui_qresources, extra_args : ['-name', 'sqpguiresources']) |
|
67 | 67 | |
|
68 | 68 | gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers, |
|
69 | 69 | ui_files : gui_ui_files) |
|
70 | 70 | |
|
71 | 71 | gui_sources = [ |
|
72 | 72 | 'src/SqpApplication.cpp', |
|
73 | 73 | 'src/DragAndDrop/DragDropGuiController.cpp', |
|
74 | 74 | 'src/DragAndDrop/DragDropScroller.cpp', |
|
75 | 75 | 'src/DragAndDrop/DragDropTabSwitcher.cpp', |
|
76 | 76 | 'src/Common/ColorUtils.cpp', |
|
77 | 77 | 'src/Common/VisualizationDef.cpp', |
|
78 | 78 | 'src/DataSource/DataSourceTreeWidgetItem.cpp', |
|
79 | 79 | 'src/DataSource/DataSourceTreeWidgetHelper.cpp', |
|
80 | 80 | 'src/DataSource/DataSourceWidget.cpp', |
|
81 | 81 | 'src/DataSource/DataSourceTreeWidget.cpp', |
|
82 | 82 | 'src/Settings/SqpSettingsDialog.cpp', |
|
83 | 83 | 'src/Settings/SqpSettingsGeneralWidget.cpp', |
|
84 | 84 | 'src/SidePane/SqpSidePane.cpp', |
|
85 | 85 | 'src/TimeWidget/TimeWidget.cpp', |
|
86 | 86 | 'src/Variable/VariableInspectorWidget.cpp', |
|
87 | 87 | 'src/Variable/VariableInspectorTableView.cpp', |
|
88 | 88 | 'src/Variable/VariableMenuHeaderWidget.cpp', |
|
89 | 89 | 'src/Variable/RenameVariableDialog.cpp', |
|
90 | 90 | 'src/Visualization/VisualizationGraphHelper.cpp', |
|
91 | 91 | 'src/Visualization/VisualizationGraphRenderingDelegate.cpp', |
|
92 | 92 | 'src/Visualization/VisualizationGraphWidget.cpp', |
|
93 | 93 | 'src/Visualization/VisualizationTabWidget.cpp', |
|
94 | 94 | 'src/Visualization/VisualizationWidget.cpp', |
|
95 | 95 | 'src/Visualization/VisualizationZoneWidget.cpp', |
|
96 | 96 | 'src/Visualization/qcustomplot.cpp', |
|
97 | 97 | 'src/Visualization/QCustomPlotSynchronizer.cpp', |
|
98 | 98 | 'src/Visualization/operations/FindVariableOperation.cpp', |
|
99 | 99 | 'src/Visualization/operations/GenerateVariableMenuOperation.cpp', |
|
100 | 100 | 'src/Visualization/operations/MenuBuilder.cpp', |
|
101 | 101 | 'src/Visualization/operations/RemoveVariableOperation.cpp', |
|
102 | 102 | 'src/Visualization/operations/RescaleAxeOperation.cpp', |
|
103 | 103 | 'src/Visualization/VisualizationDragDropContainer.cpp', |
|
104 | 104 | 'src/Visualization/VisualizationDragWidget.cpp', |
|
105 | 105 | 'src/Visualization/AxisRenderingUtils.cpp', |
|
106 | 106 | 'src/Visualization/PlottablesRenderingUtils.cpp', |
|
107 | 107 | 'src/Visualization/MacScrollBarStyle.cpp', |
|
108 | 108 | 'src/Visualization/VisualizationCursorItem.cpp', |
|
109 | 109 | 'src/Visualization/ColorScaleEditor.cpp', |
|
110 | 110 | 'src/Visualization/SqpColorScale.cpp', |
|
111 | 111 | 'src/Visualization/QCPColorMapIterator.cpp', |
|
112 | 112 | 'src/Visualization/VisualizationSelectionZoneItem.cpp', |
|
113 | 113 | 'src/Visualization/VisualizationSelectionZoneManager.cpp', |
|
114 | 114 | 'src/Actions/SelectionZoneAction.cpp', |
|
115 | 115 | 'src/Actions/ActionsGuiController.cpp', |
|
116 | 116 | 'src/Visualization/VisualizationActionManager.cpp', |
|
117 | 117 | 'src/Visualization/VisualizationMultiZoneSelectionDialog.cpp', |
|
118 | 118 | 'src/Catalogue/CatalogueExplorer.cpp', |
|
119 | 119 | 'src/Catalogue/CatalogueEventsWidget.cpp', |
|
120 | 120 | 'src/Catalogue/CatalogueSideBarWidget.cpp', |
|
121 | 121 | 'src/Catalogue/CatalogueInspectorWidget.cpp', |
|
122 |
'src/Catalogue/CatalogueTree |
|
|
122 | 'src/Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.cpp', | |
|
123 | 'src/Catalogue/CatalogueTreeItems/CatalogueTreeItem.cpp', | |
|
124 | 'src/Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.cpp', | |
|
123 | 125 | 'src/Catalogue/CatalogueEventsModel.cpp', |
|
124 | 126 | 'src/Catalogue/CatalogueExplorerHelper.cpp', |
|
125 | 127 | 'src/Catalogue/CatalogueActionManager.cpp', |
|
126 | 128 | 'src/Catalogue/CreateEventDialog.cpp', |
|
127 | 129 | 'src/Catalogue/CatalogueTreeModel.cpp' |
|
128 | 130 | ] |
|
129 | 131 | |
|
130 | 132 | gui_inc = include_directories(['include']) |
|
131 | 133 | |
|
132 | 134 | sciqlop_gui_lib = library('sciqlopgui', |
|
133 | 135 | gui_sources, |
|
134 | 136 | gui_moc_files, |
|
135 | 137 | rcc_files, |
|
136 | 138 | include_directories : [gui_inc], |
|
137 | 139 | dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep], |
|
138 | 140 | install : true |
|
139 | 141 | ) |
|
140 | 142 | |
|
141 | 143 | sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib, |
|
142 | 144 | include_directories : gui_inc, |
|
143 | 145 | dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core, catalogueapi_dep]) |
|
144 | 146 | |
|
145 | 147 |
@@ -1,298 +1,295 | |||
|
1 | 1 | #include "Catalogue/CatalogueSideBarWidget.h" |
|
2 | 2 | #include "ui_CatalogueSideBarWidget.h" |
|
3 | 3 | #include <SqpApplication.h> |
|
4 | 4 | |
|
5 | 5 | #include <Catalogue/CatalogueController.h> |
|
6 | 6 | #include <Catalogue/CatalogueExplorerHelper.h> |
|
7 | #include <Catalogue/CatalogueTreeItems/CatalogueTextTreeItem.h> | |
|
8 | #include <Catalogue/CatalogueTreeItems/CatalogueTreeItem.h> | |
|
7 | 9 | #include <Catalogue/CatalogueTreeModel.h> |
|
8 | #include <Catalogue/CatalogueTreeWidgetItem.h> | |
|
9 | 10 | #include <CatalogueDao.h> |
|
10 | 11 | #include <ComparaisonPredicate.h> |
|
11 | 12 | #include <DBCatalogue.h> |
|
12 | 13 | |
|
13 | 14 | #include <QMenu> |
|
14 | 15 | |
|
15 | 16 | Q_LOGGING_CATEGORY(LOG_CatalogueSideBarWidget, "CatalogueSideBarWidget") |
|
16 | 17 | |
|
17 | 18 | |
|
18 |
constexpr auto ALL_EVENT_ITEM_TYPE = |
|
|
19 |
constexpr auto TRASH_ITEM_TYPE = |
|
|
20 |
constexpr auto CATALOGUE_ITEM_TYPE = |
|
|
21 |
constexpr auto DATABASE_ITEM_TYPE = |
|
|
19 | constexpr auto ALL_EVENT_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 1; | |
|
20 | constexpr auto TRASH_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 2; | |
|
21 | constexpr auto CATALOGUE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 3; | |
|
22 | constexpr auto DATABASE_ITEM_TYPE = CatalogueAbstractTreeItem::DEFAULT_TYPE + 4; | |
|
22 | 23 | |
|
23 | 24 | |
|
24 | 25 | struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate { |
|
25 | 26 | |
|
26 | 27 | CatalogueTreeModel *m_TreeModel = nullptr; |
|
27 | 28 | |
|
28 | 29 | void configureTreeWidget(QTreeView *treeView); |
|
29 | 30 | QModelIndex addDatabaseItem(const QString &name); |
|
30 |
|
|
|
31 | CatalogueAbstractTreeItem *getDatabaseItem(const QString &name); | |
|
31 | 32 | void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue, |
|
32 | 33 | const QModelIndex &databaseIndex); |
|
33 | 34 | |
|
34 |
CatalogueTree |
|
|
35 | CatalogueTreeItem *getCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue) const; | |
|
35 | 36 | void setHasChanges(bool value, const QModelIndex &index, QTreeView *treeView); |
|
36 | 37 | bool hasChanges(const QModelIndex &index, QTreeView *treeView); |
|
37 | 38 | }; |
|
38 | 39 | |
|
39 | 40 | CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent) |
|
40 | 41 | : QWidget(parent), |
|
41 | 42 | ui(new Ui::CatalogueSideBarWidget), |
|
42 | 43 | impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()} |
|
43 | 44 | { |
|
44 | 45 | ui->setupUi(this); |
|
45 | 46 | |
|
46 | 47 | impl->m_TreeModel = new CatalogueTreeModel(this); |
|
47 | 48 | ui->treeView->setModel(impl->m_TreeModel); |
|
48 | 49 | |
|
49 | 50 | impl->configureTreeWidget(ui->treeView); |
|
50 | 51 | |
|
51 | 52 | ui->treeView->header()->setStretchLastSection(false); |
|
52 | 53 | ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents); |
|
53 | 54 | ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch); |
|
54 | 55 | |
|
55 | 56 | auto emitSelection = [this]() { |
|
56 | 57 | |
|
57 | 58 | auto selectedItems = ui->treeView->selectionModel()->selectedRows(); |
|
58 | 59 | if (selectedItems.isEmpty()) { |
|
59 | 60 | emit this->selectionCleared(); |
|
60 | 61 | } |
|
61 | 62 | else { |
|
62 | 63 | QVector<std::shared_ptr<DBCatalogue> > catalogues; |
|
63 | 64 | QStringList databases; |
|
64 | 65 | auto firstIndex = selectedItems.first(); |
|
65 | 66 | auto firstItem = impl->m_TreeModel->item(firstIndex); |
|
66 | 67 | if (!firstItem) { |
|
67 | 68 | Q_ASSERT(false); |
|
68 | 69 | return; |
|
69 | 70 | } |
|
70 | 71 | auto selectionType = firstItem->type(); |
|
71 | 72 | |
|
72 | 73 | for (auto itemIndex : selectedItems) { |
|
73 | 74 | auto item = impl->m_TreeModel->item(itemIndex); |
|
74 | 75 | if (item && item->type() == selectionType) { |
|
75 | 76 | switch (selectionType) { |
|
76 | 77 | case CATALOGUE_ITEM_TYPE: |
|
77 | catalogues.append( | |
|
78 | static_cast<CatalogueTreeWidgetItem *>(item)->catalogue()); | |
|
78 | catalogues.append(static_cast<CatalogueTreeItem *>(item)->catalogue()); | |
|
79 | 79 | break; |
|
80 | 80 | case DATABASE_ITEM_TYPE: |
|
81 | selectionType = DATABASE_ITEM_TYPE; | |
|
82 | databases.append(item->text(0)); | |
|
81 | databases.append(item->text()); | |
|
83 | 82 | case ALL_EVENT_ITEM_TYPE: // fallthrough |
|
84 | 83 | case TRASH_ITEM_TYPE: // fallthrough |
|
85 | 84 | default: |
|
86 | 85 | break; |
|
87 | 86 | } |
|
88 | 87 | } |
|
89 | 88 | else { |
|
90 | 89 | // Incoherent multi selection |
|
91 | 90 | selectionType = -1; |
|
92 | 91 | break; |
|
93 | 92 | } |
|
94 | 93 | } |
|
95 | 94 | |
|
96 | 95 | switch (selectionType) { |
|
97 | 96 | case CATALOGUE_ITEM_TYPE: |
|
98 | 97 | emit this->catalogueSelected(catalogues); |
|
99 | 98 | break; |
|
100 | 99 | case DATABASE_ITEM_TYPE: |
|
101 | 100 | emit this->databaseSelected(databases); |
|
102 | 101 | break; |
|
103 | 102 | case ALL_EVENT_ITEM_TYPE: |
|
104 | 103 | emit this->allEventsSelected(); |
|
105 | 104 | break; |
|
106 | 105 | case TRASH_ITEM_TYPE: |
|
107 | 106 | emit this->trashSelected(); |
|
108 | 107 | break; |
|
109 | 108 | default: |
|
110 | 109 | emit this->selectionCleared(); |
|
111 | 110 | break; |
|
112 | 111 | } |
|
113 | 112 | } |
|
114 | 113 | |
|
115 | 114 | |
|
116 | 115 | }; |
|
117 | 116 | |
|
118 | 117 | connect(ui->treeView, &QTreeView::clicked, emitSelection); |
|
119 | 118 | connect(ui->treeView->selectionModel(), &QItemSelectionModel::currentChanged, emitSelection); |
|
120 | 119 | connect(impl->m_TreeModel, &CatalogueTreeModel::itemRenamed, [emitSelection, this](auto index) { |
|
121 | 120 | auto selectedIndexes = ui->treeView->selectionModel()->selectedRows(); |
|
122 | 121 | if (selectedIndexes.contains(index)) { |
|
123 | 122 | emitSelection(); |
|
124 | 123 | } |
|
125 | 124 | |
|
126 | 125 | auto item = impl->m_TreeModel->item(index); |
|
127 | 126 | impl->setHasChanges(true, index, ui->treeView); |
|
128 | 127 | }); |
|
129 | 128 | |
|
130 | 129 | ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu); |
|
131 |
connect(ui->treeView, &QTree |
|
|
130 | connect(ui->treeView, &QTreeView::customContextMenuRequested, this, | |
|
132 | 131 | &CatalogueSideBarWidget::onContextMenuRequested); |
|
133 | 132 | } |
|
134 | 133 | |
|
135 | 134 | CatalogueSideBarWidget::~CatalogueSideBarWidget() |
|
136 | 135 | { |
|
137 | 136 | delete ui; |
|
138 | 137 | } |
|
139 | 138 | |
|
140 | 139 | void CatalogueSideBarWidget::setCatalogueChanges(const std::shared_ptr<DBCatalogue> &catalogue, |
|
141 | 140 | bool hasChanges) |
|
142 | 141 | { |
|
143 | 142 | if (auto catalogueItem = impl->getCatalogueItem(catalogue)) { |
|
144 | 143 | auto index = impl->m_TreeModel->indexOf(catalogueItem); |
|
145 | 144 | impl->setHasChanges(hasChanges, index, ui->treeView); |
|
146 | catalogueItem->refresh(); | |
|
145 | // catalogueItem->refresh(); | |
|
147 | 146 | } |
|
148 | 147 | } |
|
149 | 148 | |
|
150 | 149 | void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos) |
|
151 | 150 | { |
|
152 | 151 | QMenu menu{this}; |
|
153 | 152 | |
|
154 | 153 | auto currentIndex = ui->treeView->currentIndex(); |
|
155 | 154 | auto currentItem = impl->m_TreeModel->item(currentIndex); |
|
156 | 155 | if (!currentItem) { |
|
157 | 156 | return; |
|
158 | 157 | } |
|
159 | 158 | |
|
160 | 159 | switch (currentItem->type()) { |
|
161 | 160 | case CATALOGUE_ITEM_TYPE: |
|
162 | 161 | menu.addAction("Rename", [this, currentIndex]() { ui->treeView->edit(currentIndex); }); |
|
163 | 162 | break; |
|
164 | 163 | case DATABASE_ITEM_TYPE: |
|
165 | 164 | break; |
|
166 | 165 | case ALL_EVENT_ITEM_TYPE: |
|
167 | 166 | break; |
|
168 | 167 | case TRASH_ITEM_TYPE: |
|
169 | 168 | menu.addAction("Empty Trash", []() { |
|
170 | 169 | // TODO |
|
171 | 170 | }); |
|
172 | 171 | break; |
|
173 | 172 | default: |
|
174 | 173 | break; |
|
175 | 174 | } |
|
176 | 175 | |
|
177 | 176 | if (!menu.isEmpty()) { |
|
178 | 177 | menu.exec(ui->treeView->mapToGlobal(pos)); |
|
179 | 178 | } |
|
180 | 179 | } |
|
181 | 180 | |
|
182 | 181 | void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(QTreeView *treeView) |
|
183 | 182 | { |
|
184 | auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE}; | |
|
185 | allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png")); | |
|
183 | auto allEventsItem = new CatalogueTextTreeItem{QIcon{":/icones/allEvents.png"}, "All Events", | |
|
184 | ALL_EVENT_ITEM_TYPE}; | |
|
186 | 185 | m_TreeModel->addTopLevelItem(allEventsItem); |
|
187 | 186 | |
|
188 | auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE}; | |
|
189 | trashItem->setIcon(0, QIcon(":/icones/trash.png")); | |
|
187 | auto trashItem | |
|
188 | = new CatalogueTextTreeItem{QIcon{":/icones/trash.png"}, "Trash", TRASH_ITEM_TYPE}; | |
|
190 | 189 | m_TreeModel->addTopLevelItem(trashItem); |
|
191 | 190 | |
|
192 | 191 | auto separator = new QFrame{treeView}; |
|
193 | 192 | separator->setFrameShape(QFrame::HLine); |
|
194 |
auto separatorItem |
|
|
195 | separatorItem->setFlags(Qt::NoItemFlags); | |
|
193 | auto separatorItem | |
|
194 | = new CatalogueTextTreeItem{QIcon{}, QString{}, CatalogueAbstractTreeItem::DEFAULT_TYPE}; | |
|
195 | separatorItem->setEnabled(false); | |
|
196 | 196 | auto separatorIndex = m_TreeModel->addTopLevelItem(separatorItem); |
|
197 | 197 | treeView->setIndexWidget(separatorIndex, separator); |
|
198 | 198 | |
|
199 | 199 | auto repositories = sqpApp->catalogueController().getRepositories(); |
|
200 | 200 | for (auto dbname : repositories) { |
|
201 | 201 | auto dbIndex = addDatabaseItem(dbname); |
|
202 | 202 | auto catalogues = sqpApp->catalogueController().retrieveCatalogues(dbname); |
|
203 | 203 | for (auto catalogue : catalogues) { |
|
204 | 204 | addCatalogueItem(catalogue, dbIndex); |
|
205 | 205 | } |
|
206 | 206 | } |
|
207 | 207 | |
|
208 | 208 | treeView->expandAll(); |
|
209 | 209 | } |
|
210 | 210 | |
|
211 | 211 | QModelIndex |
|
212 | 212 | CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name) |
|
213 | 213 | { |
|
214 | auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE}; | |
|
215 | databaseItem->setIcon(0, QIcon{":/icones/database.png"}); | |
|
214 | auto databaseItem | |
|
215 | = new CatalogueTextTreeItem{QIcon{":/icones/database.png"}, {name}, DATABASE_ITEM_TYPE}; | |
|
216 | 216 | auto databaseIndex = m_TreeModel->addTopLevelItem(databaseItem); |
|
217 | 217 | |
|
218 | 218 | return databaseIndex; |
|
219 | 219 | } |
|
220 | 220 | |
|
221 | QTreeWidgetItem * | |
|
221 | CatalogueAbstractTreeItem * | |
|
222 | 222 | CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name) |
|
223 | 223 | { |
|
224 |
for (auto i |
|
|
225 | auto item = m_TreeModel->topLevelItem(i); | |
|
226 | if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) { | |
|
224 | for (auto item : m_TreeModel->topLevelItems()) { | |
|
225 | if (item->type() == DATABASE_ITEM_TYPE && item->text() == name) { | |
|
227 | 226 | return item; |
|
228 | 227 | } |
|
229 | 228 | } |
|
230 | 229 | |
|
231 | 230 | return nullptr; |
|
232 | 231 | } |
|
233 | 232 | |
|
234 | 233 | void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem( |
|
235 | 234 | const std::shared_ptr<DBCatalogue> &catalogue, const QModelIndex &databaseIndex) |
|
236 | 235 | { |
|
237 | auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE}; | |
|
238 | catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"}); | |
|
236 | auto catalogueItem | |
|
237 | = new CatalogueTreeItem{catalogue, QIcon{":/icones/catalogue.png"}, CATALOGUE_ITEM_TYPE}; | |
|
239 | 238 | m_TreeModel->addChildItem(catalogueItem, databaseIndex); |
|
240 | 239 | } |
|
241 | 240 | |
|
242 |
CatalogueTree |
|
|
241 | CatalogueTreeItem *CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getCatalogueItem( | |
|
243 | 242 | const std::shared_ptr<DBCatalogue> &catalogue) const |
|
244 | 243 | { |
|
245 |
for (auto i |
|
|
246 | auto item = m_TreeModel->topLevelItem(i); | |
|
244 | for (auto item : m_TreeModel->topLevelItems()) { | |
|
247 | 245 | if (item->type() == DATABASE_ITEM_TYPE) { |
|
248 |
for (auto |
|
|
249 | auto childItem = item->child(j); | |
|
246 | for (auto childItem : item->children()) { | |
|
250 | 247 | if (childItem->type() == CATALOGUE_ITEM_TYPE) { |
|
251 |
auto catalogueItem = static_cast<CatalogueTree |
|
|
248 | auto catalogueItem = static_cast<CatalogueTreeItem *>(childItem); | |
|
252 | 249 | if (catalogueItem->catalogue() == catalogue) { |
|
253 | 250 | return catalogueItem; |
|
254 | 251 | } |
|
255 | 252 | } |
|
256 | 253 | else { |
|
257 | 254 | qCWarning(LOG_CatalogueSideBarWidget()) << "getCatalogueItem: Invalid tree " |
|
258 | 255 | "structure. A database item should " |
|
259 | 256 | "only contain catalogues."; |
|
260 | 257 | Q_ASSERT(false); |
|
261 | 258 | } |
|
262 | 259 | } |
|
263 | 260 | } |
|
264 | 261 | } |
|
265 | 262 | |
|
266 | 263 | return nullptr; |
|
267 | 264 | } |
|
268 | 265 | |
|
269 | 266 | void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::setHasChanges(bool value, |
|
270 | 267 | const QModelIndex &index, |
|
271 | 268 | QTreeView *treeView) |
|
272 | 269 | { |
|
273 | 270 | auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation); |
|
274 | 271 | if (value) { |
|
275 | 272 | if (!hasChanges(validationIndex, treeView)) { |
|
276 | 273 | auto widget = CatalogueExplorerHelper::buildValidationWidget( |
|
277 | 274 | treeView, |
|
278 | 275 | [this, validationIndex, treeView]() { |
|
279 | 276 | setHasChanges(false, validationIndex, treeView); |
|
280 | 277 | }, |
|
281 | 278 | [this, validationIndex, treeView]() { |
|
282 | 279 | setHasChanges(false, validationIndex, treeView); |
|
283 | 280 | }); |
|
284 | 281 | treeView->setIndexWidget(validationIndex, widget); |
|
285 | 282 | } |
|
286 | 283 | } |
|
287 | 284 | else { |
|
288 | 285 | // Note: the widget is destroyed |
|
289 | 286 | treeView->setIndexWidget(validationIndex, nullptr); |
|
290 | 287 | } |
|
291 | 288 | } |
|
292 | 289 | |
|
293 | 290 | bool CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::hasChanges(const QModelIndex &index, |
|
294 | 291 | QTreeView *treeView) |
|
295 | 292 | { |
|
296 | 293 | auto validationIndex = index.sibling(index.row(), (int)CatalogueTreeModel::Column::Validation); |
|
297 | 294 | return treeView->indexWidget(validationIndex) != nullptr; |
|
298 | 295 | } |
@@ -1,69 +1,85 | |||
|
1 |
#include "Catalogue/CatalogueTree |
|
|
1 | #include "Catalogue/CatalogueTreeItems/CatalogueTreeItem.h" | |
|
2 | 2 | #include <Catalogue/CatalogueExplorerHelper.h> |
|
3 | 3 | |
|
4 | 4 | #include <Catalogue/CatalogueController.h> |
|
5 | #include <Common/MimeTypesDef.h> | |
|
6 | #include <QIcon> | |
|
7 | #include <QMimeData> | |
|
5 | 8 | #include <SqpApplication.h> |
|
6 | 9 | |
|
7 | 10 | #include <memory> |
|
8 | 11 | |
|
9 | 12 | #include <DBCatalogue.h> |
|
10 | 13 | |
|
11 | /// Column in the tree widget where the apply and cancel buttons must appear | |
|
12 | const auto APPLY_CANCEL_BUTTONS_COLUMN = 1; | |
|
13 | ||
|
14 | struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate { | |
|
14 | struct CatalogueTreeItem::CatalogueTreeItemPrivate { | |
|
15 | 15 | |
|
16 | 16 | std::shared_ptr<DBCatalogue> m_Catalogue; |
|
17 | QIcon m_Icon; | |
|
17 | 18 | |
|
18 |
CatalogueTree |
|
|
19 | CatalogueTreeItemPrivate(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon) | |
|
20 | : m_Catalogue(catalogue), m_Icon(icon) | |
|
19 | 21 | { |
|
20 | 22 | } |
|
21 | 23 | }; |
|
22 | 24 | |
|
23 | 25 | |
|
24 |
CatalogueTree |
|
|
25 | : QTreeWidgetItem(type), | |
|
26 | impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)} | |
|
26 | CatalogueTreeItem::CatalogueTreeItem(std::shared_ptr<DBCatalogue> catalogue, const QIcon &icon, | |
|
27 | int type) | |
|
28 | : CatalogueAbstractTreeItem(type), | |
|
29 | impl{spimpl::make_unique_impl<CatalogueTreeItemPrivate>(catalogue, icon)} | |
|
27 | 30 | { |
|
28 | setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDropEnabled); | |
|
29 | 31 | } |
|
30 | 32 | |
|
31 |
QVariant CatalogueTree |
|
|
33 | QVariant CatalogueTreeItem::data(int column, int role) const | |
|
32 | 34 | { |
|
33 | 35 | if (column == 0) { |
|
34 | 36 | switch (role) { |
|
35 | 37 | case Qt::EditRole: // fallthrough |
|
36 | 38 | case Qt::DisplayRole: |
|
37 | 39 | return impl->m_Catalogue->getName(); |
|
40 | case Qt::DecorationRole: | |
|
41 | return impl->m_Icon; | |
|
38 | 42 | default: |
|
39 | 43 | break; |
|
40 | 44 | } |
|
41 | 45 | } |
|
42 | 46 | |
|
43 | return QTreeWidgetItem::data(column, role); | |
|
47 | return QVariant(); | |
|
44 | 48 | } |
|
45 | 49 | |
|
46 |
|
|
|
50 | bool CatalogueTreeItem::setData(int column, int role, const QVariant &value) | |
|
47 | 51 | { |
|
52 | bool result = false; | |
|
53 | ||
|
48 | 54 | if (role == Qt::EditRole && column == 0) { |
|
49 | 55 | auto newName = value.toString(); |
|
50 | 56 | if (newName != impl->m_Catalogue->getName()) { |
|
51 | setText(0, newName); | |
|
52 | 57 | impl->m_Catalogue->setName(newName); |
|
53 | 58 | sqpApp->catalogueController().updateCatalogue(impl->m_Catalogue); |
|
59 | result = true; | |
|
60 | } | |
|
61 | } | |
|
62 | ||
|
63 | return result; | |
|
54 | 64 | } |
|
65 | ||
|
66 | Qt::ItemFlags CatalogueTreeItem::flags(int column) const | |
|
67 | { | |
|
68 | if (column == 0) { | |
|
69 | return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | |
|
70 | | Qt::ItemIsDropEnabled; | |
|
55 | 71 | } |
|
56 | 72 | else { |
|
57 | QTreeWidgetItem::setData(column, role, value); | |
|
73 | return Qt::ItemIsEnabled | Qt::ItemIsSelectable; | |
|
58 | 74 | } |
|
59 | 75 | } |
|
60 | 76 | |
|
61 | std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const | |
|
77 | bool CatalogueTreeItem::canDropMimeData(const QMimeData *data, Qt::DropAction action) | |
|
62 | 78 | { |
|
63 | return impl->m_Catalogue; | |
|
79 | return data->hasFormat(MIME_TYPE_EVENT_LIST); | |
|
64 | 80 | } |
|
65 | 81 | |
|
66 | void CatalogueTreeWidgetItem::refresh() | |
|
82 | std::shared_ptr<DBCatalogue> CatalogueTreeItem::catalogue() const | |
|
67 | 83 | { |
|
68 | emitDataChanged(); | |
|
84 | return impl->m_Catalogue; | |
|
69 | 85 | } |
@@ -1,169 +1,190 | |||
|
1 | 1 | #include "Catalogue/CatalogueTreeModel.h" |
|
2 | #include <Catalogue/CatalogueTreeItems/CatalogueAbstractTreeItem.h> | |
|
2 | 3 | |
|
3 |
#include <Q |
|
|
4 | #include <QMimeData> | |
|
4 | 5 | #include <memory> |
|
5 | 6 | |
|
7 | #include <Common/MimeTypesDef.h> | |
|
8 | ||
|
6 | 9 | struct CatalogueTreeModel::CatalogueTreeModelPrivate { |
|
7 |
std::unique_ptr< |
|
|
10 | std::unique_ptr<CatalogueAbstractTreeItem> m_RootItem = nullptr; | |
|
8 | 11 | |
|
9 |
CatalogueTreeModelPrivate() : m_RootItem{std::make_unique< |
|
|
12 | CatalogueTreeModelPrivate() : m_RootItem{std::make_unique<CatalogueAbstractTreeItem>()} {} | |
|
10 | 13 | }; |
|
11 | 14 | |
|
12 | 15 | CatalogueTreeModel::CatalogueTreeModel(QObject *parent) |
|
13 | 16 | : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueTreeModelPrivate>()} |
|
14 | 17 | { |
|
15 | 18 | } |
|
16 | 19 | |
|
17 |
QModelIndex CatalogueTreeModel::addTopLevelItem( |
|
|
20 | QModelIndex CatalogueTreeModel::addTopLevelItem(CatalogueAbstractTreeItem *item) | |
|
18 | 21 | { |
|
19 | beginInsertRows(QModelIndex(), impl->m_RootItem->childCount(), impl->m_RootItem->childCount()); | |
|
22 | auto nbTopLevelItems = impl->m_RootItem->children().count(); | |
|
23 | beginInsertRows(QModelIndex(), nbTopLevelItems, nbTopLevelItems); | |
|
20 | 24 | impl->m_RootItem->addChild(item); |
|
21 | 25 | endInsertRows(); |
|
22 | 26 | |
|
23 | return index(impl->m_RootItem->childCount() - 1, 0); | |
|
24 | } | |
|
27 | emit dataChanged(QModelIndex(), QModelIndex()); | |
|
25 | 28 | |
|
26 | int CatalogueTreeModel::topLevelItemCount() const | |
|
27 | { | |
|
28 | return impl->m_RootItem->childCount(); | |
|
29 | return index(nbTopLevelItems, 0); | |
|
29 | 30 | } |
|
30 | 31 | |
|
31 |
Q |
|
|
32 | QVector<CatalogueAbstractTreeItem *> CatalogueTreeModel::topLevelItems() const | |
|
32 | 33 | { |
|
33 |
return impl->m_RootItem->child( |
|
|
34 | return impl->m_RootItem->children(); | |
|
34 | 35 | } |
|
35 | 36 | |
|
36 |
void CatalogueTreeModel::addChildItem( |
|
|
37 | void CatalogueTreeModel::addChildItem(CatalogueAbstractTreeItem *child, | |
|
38 | const QModelIndex &parentIndex) | |
|
37 | 39 | { |
|
38 | 40 | auto parentItem = item(parentIndex); |
|
39 | beginInsertRows(parentIndex, parentItem->childCount(), parentItem->childCount()); | |
|
41 | int c = parentItem->children().count(); | |
|
42 | beginInsertRows(parentIndex, c, c); | |
|
40 | 43 | parentItem->addChild(child); |
|
41 | 44 | endInsertRows(); |
|
45 | ||
|
46 | emit dataChanged(QModelIndex(), QModelIndex()); | |
|
42 | 47 | } |
|
43 | 48 | |
|
44 |
|
|
|
49 | CatalogueAbstractTreeItem *CatalogueTreeModel::item(const QModelIndex &index) const | |
|
45 | 50 | { |
|
46 |
return static_cast< |
|
|
51 | return static_cast<CatalogueAbstractTreeItem *>(index.internalPointer()); | |
|
47 | 52 | } |
|
48 | 53 | |
|
49 |
QModelIndex CatalogueTreeModel::indexOf( |
|
|
54 | QModelIndex CatalogueTreeModel::indexOf(CatalogueAbstractTreeItem *item, int column) const | |
|
50 | 55 | { |
|
51 | 56 | auto parentItem = item->parent(); |
|
52 | 57 | if (!parentItem) { |
|
53 | 58 | return QModelIndex(); |
|
54 | 59 | } |
|
55 | 60 | |
|
56 |
auto row = parentItem->indexOf |
|
|
61 | auto row = parentItem->children().indexOf(item); | |
|
57 | 62 | return createIndex(row, column, item); |
|
58 | 63 | } |
|
59 | 64 | |
|
60 | 65 | QModelIndex CatalogueTreeModel::index(int row, int column, const QModelIndex &parent) const |
|
61 | 66 | { |
|
67 | if (column > 0) { | |
|
68 | int a = 0; | |
|
69 | } | |
|
70 | ||
|
62 | 71 | if (!hasIndex(row, column, parent)) { |
|
63 | 72 | return QModelIndex(); |
|
64 | 73 | } |
|
65 | 74 | |
|
66 |
|
|
|
75 | CatalogueAbstractTreeItem *parentItem = nullptr; | |
|
67 | 76 | |
|
68 | 77 | if (!parent.isValid()) { |
|
69 | 78 | parentItem = impl->m_RootItem.get(); |
|
70 | 79 | } |
|
71 | 80 | else { |
|
72 |
parentItem = |
|
|
81 | parentItem = item(parent); | |
|
73 | 82 | } |
|
74 | 83 | |
|
75 |
|
|
|
84 | auto childItem = parentItem->children().value(row); | |
|
76 | 85 | if (childItem) { |
|
77 | 86 | return createIndex(row, column, childItem); |
|
78 | 87 | } |
|
79 | 88 | |
|
80 | 89 | return QModelIndex(); |
|
81 | 90 | } |
|
82 | 91 | |
|
83 | 92 | |
|
84 | 93 | QModelIndex CatalogueTreeModel::parent(const QModelIndex &index) const |
|
85 | 94 | { |
|
86 | 95 | if (!index.isValid()) { |
|
87 | 96 | return QModelIndex(); |
|
88 | 97 | } |
|
89 | 98 | |
|
90 |
auto childItem = |
|
|
99 | auto childItem = item(index); | |
|
91 | 100 | auto parentItem = childItem->parent(); |
|
92 | 101 | |
|
93 | 102 | if (parentItem == nullptr || parentItem->parent() == nullptr) { |
|
94 | 103 | return QModelIndex(); |
|
95 | 104 | } |
|
96 | 105 | |
|
97 |
auto row = parentItem->parent()->indexOf |
|
|
106 | auto row = parentItem->parent()->children().indexOf(parentItem); | |
|
98 | 107 | return createIndex(row, 0, parentItem); |
|
99 | 108 | } |
|
100 | 109 | |
|
101 | 110 | int CatalogueTreeModel::rowCount(const QModelIndex &parent) const |
|
102 | 111 | { |
|
103 |
|
|
|
104 | if (parent.column() > 0) { | |
|
105 | return 0; | |
|
106 | } | |
|
112 | CatalogueAbstractTreeItem *parentItem = nullptr; | |
|
107 | 113 | |
|
108 | 114 | if (!parent.isValid()) { |
|
109 | 115 | parentItem = impl->m_RootItem.get(); |
|
110 | 116 | } |
|
111 | 117 | else { |
|
112 |
parentItem = |
|
|
118 | parentItem = item(parent); | |
|
113 | 119 | } |
|
114 | 120 | |
|
115 |
return parentItem->child |
|
|
121 | return parentItem->children().count(); | |
|
116 | 122 | } |
|
117 | 123 | |
|
118 | 124 | int CatalogueTreeModel::columnCount(const QModelIndex &parent) const |
|
119 | 125 | { |
|
120 | 126 | return (int)Column::Count; |
|
121 | 127 | } |
|
122 | 128 | |
|
123 | 129 | Qt::ItemFlags CatalogueTreeModel::flags(const QModelIndex &index) const |
|
124 | 130 | { |
|
125 | if (index.column() == (int)Column::Validation) { | |
|
126 | return Qt::NoItemFlags; | |
|
127 | } | |
|
128 | ||
|
129 | auto item = static_cast<QTreeWidgetItem *>(index.internalPointer()); | |
|
130 | if (item) { | |
|
131 | return item->flags(); | |
|
131 | auto treeItem = item(index); | |
|
132 | if (treeItem) { | |
|
133 | return treeItem->flags(index.column()); | |
|
132 | 134 | } |
|
133 | 135 | |
|
134 | 136 | return Qt::NoItemFlags; |
|
135 | 137 | } |
|
136 | 138 | |
|
137 | 139 | QVariant CatalogueTreeModel::data(const QModelIndex &index, int role) const |
|
138 | 140 | { |
|
139 | if (!index.isValid()) { | |
|
140 | return QModelIndex(); | |
|
141 | } | |
|
142 | ||
|
143 | auto item = static_cast<QTreeWidgetItem *>(index.internalPointer()); | |
|
144 | if (item) { | |
|
145 | return item->data(index.column(), role); | |
|
141 | auto treeItem = item(index); | |
|
142 | if (treeItem) { | |
|
143 | return treeItem->data(index.column(), role); | |
|
146 | 144 | } |
|
147 | 145 | |
|
148 | 146 | return QModelIndex(); |
|
149 | 147 | } |
|
150 | 148 | |
|
151 | 149 | bool CatalogueTreeModel::setData(const QModelIndex &index, const QVariant &value, int role) |
|
152 | 150 | { |
|
153 | if (!index.isValid()) { | |
|
154 | return false; | |
|
151 | auto treeItem = item(index); | |
|
152 | if (treeItem) { | |
|
153 | auto result = treeItem->setData(index.column(), role, value); | |
|
154 | ||
|
155 | if (result && index.column() == (int)Column::Name) { | |
|
156 | emit itemRenamed(index); | |
|
155 | 157 | } |
|
156 | 158 | |
|
157 | auto item = static_cast<QTreeWidgetItem *>(index.internalPointer()); | |
|
158 | if (item) { | |
|
159 | item->setData(index.column(), role, value); | |
|
159 | return result; | |
|
160 | } | |
|
160 | 161 | |
|
161 | if (index.column() == (int)Column::Name) { | |
|
162 | emit itemRenamed(index); | |
|
162 | return false; | |
|
163 | } | |
|
164 | bool CatalogueTreeModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, | |
|
165 | int column, const QModelIndex &parent) const | |
|
166 | { | |
|
167 | auto draggedIndex = parent; | |
|
168 | auto draggedItem = item(draggedIndex); | |
|
169 | if (draggedItem) { | |
|
170 | return draggedItem->canDropMimeData(data, action); | |
|
163 | 171 |
|
|
164 | 172 | |
|
165 |
|
|
|
173 | return false; | |
|
166 | 174 | } |
|
167 | 175 | |
|
176 | bool CatalogueTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, | |
|
177 | int column, const QModelIndex &parent) | |
|
178 | { | |
|
168 | 179 | return false; |
|
169 | 180 | } |
|
181 | ||
|
182 | Qt::DropActions CatalogueTreeModel::supportedDropActions() const | |
|
183 | { | |
|
184 | return Qt::CopyAction | Qt::MoveAction; | |
|
185 | } | |
|
186 | ||
|
187 | QStringList CatalogueTreeModel::mimeTypes() const | |
|
188 | { | |
|
189 | return {MIME_TYPE_EVENT_LIST}; | |
|
190 | } |
@@ -1,103 +1,97 | |||
|
1 | 1 | <?xml version="1.0" encoding="UTF-8"?> |
|
2 | 2 | <ui version="4.0"> |
|
3 | 3 | <class>CatalogueSideBarWidget</class> |
|
4 | 4 | <widget class="QWidget" name="CatalogueSideBarWidget"> |
|
5 | 5 | <property name="geometry"> |
|
6 | 6 | <rect> |
|
7 | 7 | <x>0</x> |
|
8 | 8 | <y>0</y> |
|
9 | 9 | <width>330</width> |
|
10 | 10 | <height>523</height> |
|
11 | 11 | </rect> |
|
12 | 12 | </property> |
|
13 | 13 | <property name="windowTitle"> |
|
14 | 14 | <string>Form</string> |
|
15 | 15 | </property> |
|
16 | 16 | <layout class="QVBoxLayout" name="verticalLayout"> |
|
17 | 17 | <property name="leftMargin"> |
|
18 | 18 | <number>0</number> |
|
19 | 19 | </property> |
|
20 | 20 | <property name="topMargin"> |
|
21 | 21 | <number>0</number> |
|
22 | 22 | </property> |
|
23 | 23 | <property name="rightMargin"> |
|
24 | 24 | <number>0</number> |
|
25 | 25 | </property> |
|
26 | 26 | <property name="bottomMargin"> |
|
27 | 27 | <number>0</number> |
|
28 | 28 | </property> |
|
29 | 29 | <item> |
|
30 | 30 | <layout class="QHBoxLayout" name="horizontalLayout"> |
|
31 | 31 | <item> |
|
32 | 32 | <widget class="QToolButton" name="btnAdd"> |
|
33 | 33 | <property name="text"> |
|
34 | 34 | <string>+</string> |
|
35 | 35 | </property> |
|
36 | 36 | <property name="icon"> |
|
37 | 37 | <iconset resource="../../resources/sqpguiresources.qrc"> |
|
38 | 38 | <normaloff>:/icones/add.png</normaloff>:/icones/add.png</iconset> |
|
39 | 39 | </property> |
|
40 | 40 | <property name="autoRaise"> |
|
41 | 41 | <bool>true</bool> |
|
42 | 42 | </property> |
|
43 | 43 | </widget> |
|
44 | 44 | </item> |
|
45 | 45 | <item> |
|
46 | 46 | <widget class="QToolButton" name="btnRemove"> |
|
47 | 47 | <property name="text"> |
|
48 | 48 | <string> - </string> |
|
49 | 49 | </property> |
|
50 | 50 | <property name="icon"> |
|
51 | 51 | <iconset resource="../../resources/sqpguiresources.qrc"> |
|
52 | 52 | <normaloff>:/icones/remove.png</normaloff>:/icones/remove.png</iconset> |
|
53 | 53 | </property> |
|
54 | 54 | <property name="autoRaise"> |
|
55 | 55 | <bool>true</bool> |
|
56 | 56 | </property> |
|
57 | 57 | </widget> |
|
58 | 58 | </item> |
|
59 | 59 | <item> |
|
60 | 60 | <spacer name="horizontalSpacer"> |
|
61 | 61 | <property name="orientation"> |
|
62 | 62 | <enum>Qt::Horizontal</enum> |
|
63 | 63 | </property> |
|
64 | 64 | <property name="sizeHint" stdset="0"> |
|
65 | 65 | <size> |
|
66 | 66 | <width>40</width> |
|
67 | 67 | <height>20</height> |
|
68 | 68 | </size> |
|
69 | 69 | </property> |
|
70 | 70 | </spacer> |
|
71 | 71 | </item> |
|
72 | 72 | </layout> |
|
73 | 73 | </item> |
|
74 | 74 | <item> |
|
75 | 75 | <widget class="QTreeView" name="treeView"> |
|
76 | 76 | <property name="acceptDrops"> |
|
77 | 77 | <bool>true</bool> |
|
78 | 78 | </property> |
|
79 | 79 | <property name="dragDropMode"> |
|
80 |
<enum>QAbstractItemView::Drop |
|
|
80 | <enum>QAbstractItemView::DragDrop</enum> | |
|
81 | 81 | </property> |
|
82 | <property name="defaultDropAction"> | |
|
83 | <enum>Qt::CopyAction</enum> | |
|
84 |
</ |
|
|
85 | <property name="selectionMode"> | |
|
86 | <enum>QAbstractItemView::ExtendedSelection</enum> | |
|
87 | </property> | |
|
88 | <property name="headerHidden"> | |
|
89 | <bool>true</bool> | |
|
90 | </property> | |
|
91 | <attribute name="headerDefaultSectionSize"> | |
|
92 | <number>0</number> | |
|
82 | <attribute name="headerVisible"> | |
|
83 | <bool>false</bool> | |
|
84 | </attribute> | |
|
85 | <attribute name="headerStretchLastSection"> | |
|
86 | <bool>false</bool> | |
|
93 | 87 | </attribute> |
|
94 | 88 | </widget> |
|
95 | 89 | </item> |
|
96 | 90 | </layout> |
|
97 | 91 | </widget> |
|
98 | 92 | <resources> |
|
99 | 93 | <include location="../../resources/sqpguiresources.qrc"/> |
|
100 | 94 | <include location="../../resources/sqpguiresources.qrc"/> |
|
101 | 95 | </resources> |
|
102 | 96 | <connections/> |
|
103 | 97 | </ui> |
|
1 | NO CONTENT: file was removed |
General Comments 3
Status change > Approved
You need to be logged in to leave comments.
Login now