##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Displays all events
trabillard -
r1160:74146413d633
parent child
Show More
Side by Side Unified
Context file:
r1160:74146413d633 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,47 +1,48
1 1 #ifndef SCIQLOP_CATALOGUEEVENTSWIDGET_H
2 2 #define SCIQLOP_CATALOGUEEVENTSWIDGET_H
3 3
4 4 #include <Common/spimpl.h>
5 5 #include <QLoggingCategory>
6 6 #include <QWidget>
7 7
8 8 class DBCatalogue;
9 9 class DBEvent;
10 10 class DBEventProduct;
11 11 class VisualizationWidget;
12 12
13 13 namespace Ui {
14 14 class CatalogueEventsWidget;
15 15 }
16 16
17 17 Q_DECLARE_LOGGING_CATEGORY(LOG_CatalogueEventsWidget)
18 18
19 19 class CatalogueEventsWidget : public QWidget {
20 20 Q_OBJECT
21 21
22 22 signals:
23 23 void eventsSelected(const QVector<std::shared_ptr<DBEvent> > &event);
24 24 void eventProductsSelected(
25 25 const QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > >
26 26 &eventproducts);
27 27 void selectionCleared();
28 28
29 29 public:
30 30 explicit CatalogueEventsWidget(QWidget *parent = 0);
31 31 virtual ~CatalogueEventsWidget();
32 32
33 33 void setVisualizationWidget(VisualizationWidget *visualization);
34 34
35 35 void setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges);
36 36
37 37 public slots:
38 38 void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
39 void populateWithAllEvents();
39 40
40 41 private:
41 42 Ui::CatalogueEventsWidget *ui;
42 43
43 44 class CatalogueEventsWidgetPrivate;
44 45 spimpl::unique_impl_ptr<CatalogueEventsWidgetPrivate> impl;
45 46 };
46 47
47 48 #endif // SCIQLOP_CATALOGUEEVENTSWIDGET_H
Show file before | Show file after | Hide comments
@@ -1,316 +1,328
1 1 #include "Catalogue/CatalogueEventsWidget.h"
2 2 #include "ui_CatalogueEventsWidget.h"
3 3
4 4 #include <Catalogue/CatalogueController.h>
5 5 #include <Catalogue/CatalogueEventsModel.h>
6 6 #include <CatalogueDao.h>
7 7 #include <DBCatalogue.h>
8 8 #include <SqpApplication.h>
9 9 #include <Visualization/VisualizationTabWidget.h>
10 10 #include <Visualization/VisualizationWidget.h>
11 11 #include <Visualization/VisualizationZoneWidget.h>
12 12
13 13 #include <QDialog>
14 14 #include <QDialogButtonBox>
15 15 #include <QListWidget>
16 16
17 17 Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
18 18
19 19 /// Format of the dates appearing in the label of a cursor
20 20 const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
21 21
22 22 struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
23 23
24 24 CatalogueEventsModel *m_Model = nullptr;
25 25 QStringList m_ZonesForTimeMode;
26 26 QString m_ZoneForGraphMode;
27 27
28 28 VisualizationWidget *m_VisualizationWidget = nullptr;
29 29
30 30 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
31 31 {
32 32 treeView->setSortingEnabled(false);
33 33 m_Model->setEvents(events);
34 34 treeView->setSortingEnabled(true);
35 35 }
36 36
37 37 void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
38 38 {
39 39 treeView->setSortingEnabled(false);
40 40 m_Model->addEvent(event);
41 41 treeView->setSortingEnabled(true);
42 42 }
43 43
44 44 void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
45 45 {
46 46 treeView->setSortingEnabled(false);
47 47 m_Model->removeEvent(event);
48 48 treeView->setSortingEnabled(true);
49 49 }
50 50
51 51 QStringList getAvailableVisualizationZoneList() const
52 52 {
53 53 if (m_VisualizationWidget) {
54 54 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
55 55 return tab->availableZoneWidgets();
56 56 }
57 57 }
58 58
59 59 return QStringList{};
60 60 }
61 61
62 62 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
63 63 bool allowMultiSelection, const QPoint &location)
64 64 {
65 65 auto availableZones = getAvailableVisualizationZoneList();
66 66 if (availableZones.isEmpty()) {
67 67 return QStringList{};
68 68 }
69 69
70 70 QDialog d(parent, Qt::Tool);
71 71 d.setWindowTitle("Choose a zone");
72 72 auto layout = new QVBoxLayout{&d};
73 73 layout->setContentsMargins(0, 0, 0, 0);
74 74 auto listWidget = new QListWidget{&d};
75 75 layout->addWidget(listWidget);
76 76
77 77 QSet<QListWidgetItem *> checkedItems;
78 78 for (auto zone : availableZones) {
79 79 auto item = new QListWidgetItem{zone};
80 80 item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
81 81 if (selectedZones.contains(zone)) {
82 82 item->setCheckState(Qt::Checked);
83 83 checkedItems << item;
84 84 }
85 85 else {
86 86 item->setCheckState(Qt::Unchecked);
87 87 }
88 88
89 89 listWidget->addItem(item);
90 90 }
91 91
92 92 auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
93 93 layout->addWidget(buttonBox);
94 94
95 95 QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
96 96 QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
97 97
98 98 QObject::connect(listWidget, &QListWidget::itemChanged,
99 99 [&checkedItems, allowMultiSelection, listWidget](auto item) {
100 100 if (item->checkState() == Qt::Checked) {
101 101 if (!allowMultiSelection) {
102 102 for (auto checkedItem : checkedItems) {
103 103 listWidget->blockSignals(true);
104 104 checkedItem->setCheckState(Qt::Unchecked);
105 105 listWidget->blockSignals(false);
106 106 }
107 107
108 108 checkedItems.clear();
109 109 }
110 110 checkedItems << item;
111 111 }
112 112 else {
113 113 checkedItems.remove(item);
114 114 }
115 115 });
116 116
117 117 QStringList result;
118 118
119 119 d.setMinimumWidth(120);
120 120 d.resize(d.minimumSizeHint());
121 121 d.move(location);
122 122 if (d.exec() == QDialog::Accepted) {
123 123 for (auto item : checkedItems) {
124 124 result += item->text();
125 125 }
126 126 }
127 127 else {
128 128 result = selectedZones;
129 129 }
130 130
131 131 return result;
132 132 }
133 133
134 134 void updateForTimeMode(QTreeView *treeView)
135 135 {
136 136 auto selectedRows = treeView->selectionModel()->selectedRows();
137 137
138 138 if (selectedRows.count() == 1) {
139 139 auto event = m_Model->getEvent(selectedRows.first());
140 140 if (event) {
141 141 if (m_VisualizationWidget) {
142 142 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
143 143
144 144 for (auto zoneName : m_ZonesForTimeMode) {
145 145 if (auto zone = tab->getZoneWithName(zoneName)) {
146 146 SqpRange eventRange;
147 147 eventRange.m_TStart = event->getTStart();
148 148 eventRange.m_TEnd = event->getTEnd();
149 149 zone->setZoneRange(eventRange);
150 150 }
151 151 }
152 152 }
153 153 else {
154 154 qCWarning(LOG_CatalogueEventsWidget())
155 155 << "updateTimeZone: no tab found in the visualization";
156 156 }
157 157 }
158 158 else {
159 159 qCWarning(LOG_CatalogueEventsWidget())
160 160 << "updateTimeZone: visualization widget not found";
161 161 }
162 162 }
163 163 }
164 164 else {
165 165 qCWarning(LOG_CatalogueEventsWidget())
166 166 << "updateTimeZone: not compatible with multiple events selected";
167 167 }
168 168 }
169 169
170 170 void updateForGraphMode(QTreeView *treeView)
171 171 {
172 172 auto selectedRows = treeView->selectionModel()->selectedRows();
173 173
174 174 if (selectedRows.count() == 1) {
175 175 auto event = m_Model->getEvent(selectedRows.first());
176 176 if (m_VisualizationWidget) {
177 177 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
178 178 if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
179 179 // TODO
180 180 }
181 181 }
182 182 else {
183 183 qCWarning(LOG_CatalogueEventsWidget())
184 184 << "updateGraphMode: no tab found in the visualization";
185 185 }
186 186 }
187 187 else {
188 188 qCWarning(LOG_CatalogueEventsWidget())
189 189 << "updateGraphMode: visualization widget not found";
190 190 }
191 191 }
192 192 else {
193 193 qCWarning(LOG_CatalogueEventsWidget())
194 194 << "updateGraphMode: not compatible with multiple events selected";
195 195 }
196 196 }
197 197 };
198 198
199 199 CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
200 200 : QWidget(parent),
201 201 ui(new Ui::CatalogueEventsWidget),
202 202 impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
203 203 {
204 204 ui->setupUi(this);
205 205
206 206 impl->m_Model = new CatalogueEventsModel{this};
207 207 ui->treeView->setModel(impl->m_Model);
208 208
209 209 ui->treeView->setSortingEnabled(true);
210 210 ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
211 211 ui->treeView->setDragEnabled(true);
212 212
213 213 connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
214 214 if (checked) {
215 215 ui->btnChart->setChecked(false);
216 216 impl->m_ZonesForTimeMode
217 217 = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
218 218 this->mapToGlobal(ui->btnTime->frameGeometry().center()));
219 219
220 220 impl->updateForTimeMode(ui->treeView);
221 221 }
222 222 });
223 223
224 224 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
225 225 if (checked) {
226 226 ui->btnTime->setChecked(false);
227 227 impl->m_ZoneForGraphMode
228 228 = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false,
229 229 this->mapToGlobal(ui->btnChart->frameGeometry().center()))
230 230 .value(0);
231 231
232 232 impl->updateForGraphMode(ui->treeView);
233 233 }
234 234 });
235 235
236 236 auto emitSelection = [this]() {
237 237 QVector<std::shared_ptr<DBEvent> > events;
238 238 QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
239 239
240 240 for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
241 241
242 242 auto itemType = impl->m_Model->itemTypeOf(rowIndex);
243 243 if (itemType == CatalogueEventsModel::ItemType::Event) {
244 244 events << impl->m_Model->getEvent(rowIndex);
245 245 }
246 246 else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
247 247 eventProducts << qMakePair(impl->m_Model->getParentEvent(rowIndex),
248 248 impl->m_Model->getEventProduct(rowIndex));
249 249 }
250 250 }
251 251
252 252 if (!events.isEmpty() && eventProducts.isEmpty()) {
253 253 emit this->eventsSelected(events);
254 254 }
255 255 else if (events.isEmpty() && !eventProducts.isEmpty()) {
256 256 emit this->eventProductsSelected(eventProducts);
257 257 }
258 258 else {
259 259 emit this->selectionCleared();
260 260 }
261 261 };
262 262
263 263 connect(ui->treeView, &QTreeView::clicked, emitSelection);
264 264 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
265 265
266 266 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
267 267 auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
268 268 ui->btnChart->setEnabled(isNotMultiSelection);
269 269 ui->btnTime->setEnabled(isNotMultiSelection);
270 270
271 271 if (isNotMultiSelection && ui->btnTime->isChecked()) {
272 272 impl->updateForTimeMode(ui->treeView);
273 273 }
274 274 else if (isNotMultiSelection && ui->btnChart->isChecked()) {
275 275 impl->updateForGraphMode(ui->treeView);
276 276 }
277 277 });
278 278
279 279 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
280 280 ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
281 281 ui->treeView->header()->setSortIndicatorShown(true);
282 282 }
283 283
284 284 CatalogueEventsWidget::~CatalogueEventsWidget()
285 285 {
286 286 delete ui;
287 287 }
288 288
289 289 void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
290 290 {
291 291 impl->m_VisualizationWidget = visualization;
292 292 }
293 293
294 294 void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
295 295 {
296 296 impl->m_Model->refreshEvent(event);
297 297 }
298 298
299 299 void CatalogueEventsWidget::populateWithCatalogues(
300 300 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
301 301 {
302 302 QSet<QUuid> eventIds;
303 303 QVector<std::shared_ptr<DBEvent> > events;
304 304
305 305 for (auto catalogue : catalogues) {
306 306 auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
307 307 for (auto event : catalogueEvents) {
308 308 if (!eventIds.contains(event->getUniqId())) {
309 309 events << event;
310 310 eventIds.insert(event->getUniqId());
311 311 }
312 312 }
313 313 }
314 314
315 315 impl->setEvents(events, ui->treeView);
316 316 }
317
318 void CatalogueEventsWidget::populateWithAllEvents()
319 {
320 auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
321
322 QVector<std::shared_ptr<DBEvent> > events;
323 for (auto event : allEvents) {
324 events << event;
325 }
326
327 impl->setEvents(events, ui->treeView);
328 }
Show file before | Show file after | Hide comments
@@ -1,83 +1,85
1 1 #include "Catalogue/CatalogueExplorer.h"
2 2 #include "ui_CatalogueExplorer.h"
3 3
4 4 #include <Visualization/VisualizationWidget.h>
5 5
6 6 #include <DBCatalogue.h>
7 7 #include <DBEvent.h>
8 8
9 9 struct CatalogueExplorer::CatalogueExplorerPrivate {
10 10 };
11 11
12 12 CatalogueExplorer::CatalogueExplorer(QWidget *parent)
13 13 : QDialog(parent, Qt::Dialog | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint),
14 14 ui(new Ui::CatalogueExplorer),
15 15 impl{spimpl::make_unique_impl<CatalogueExplorerPrivate>()}
16 16 {
17 17 ui->setupUi(this);
18 18
19 19 connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto catalogues) {
20 20 if (catalogues.count() == 1) {
21 21 ui->inspector->setCatalogue(catalogues.first());
22 22 }
23 23 else {
24 24 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
25 25 }
26 26
27 27 ui->events->populateWithCatalogues(catalogues);
28 28 });
29 29
30 30 connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databases) {
31 31 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
32 32 });
33 33
34 34 connect(ui->catalogues, &CatalogueSideBarWidget::trashSelected,
35 35 [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
36 36
37 connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected,
38 [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
37 connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected, [this]() {
38 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
39 ui->events->populateWithAllEvents();
40 });
39 41
40 42 connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared,
41 43 [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
42 44
43 45 connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
44 46 if (events.count() == 1) {
45 47 ui->inspector->setEvent(events.first());
46 48 }
47 49 else {
48 50 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
49 51 }
50 52 });
51 53
52 54 connect(ui->events, &CatalogueEventsWidget::eventProductsSelected, [this](auto eventProducts) {
53 55 if (eventProducts.count() == 1) {
54 56 ui->inspector->setEventProduct(eventProducts.first().first,
55 57 eventProducts.first().second);
56 58 }
57 59 else {
58 60 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
59 61 }
60 62 });
61 63
62 64 connect(ui->events, &CatalogueEventsWidget::selectionCleared,
63 65 [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
64 66
65 67 connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated,
66 68 [this](auto catalogue) { ui->catalogues->setCatalogueChanges(catalogue, true); });
67 69
68 70 connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated,
69 71 [this](auto event) { ui->events->setEventChanges(event, true); });
70 72
71 73 connect(ui->inspector, &CatalogueInspectorWidget::eventProductUpdated,
72 74 [this](auto event, auto eventProduct) { ui->events->setEventChanges(event, true); });
73 75 }
74 76
75 77 CatalogueExplorer::~CatalogueExplorer()
76 78 {
77 79 delete ui;
78 80 }
79 81
80 82 void CatalogueExplorer::setVisualizationWidget(VisualizationWidget *visualization)
81 83 {
82 84 ui->events->setVisualizationWidget(visualization);
83 85 }
General Comments 0
You need to be logged in to leave comments. Login now