##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Handle selection of trash and repository items
trabillard -
r1234:f48f3e7d295f
parent child
Show More
Side by Side Unified
Context file:
r1234:f48f3e7d295f Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,54 +1,55
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 addEvent(const std::shared_ptr<DBEvent> &event);
36 36 void setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges);
37 37
38 38 QVector<std::shared_ptr<DBCatalogue> > displayedCatalogues() const;
39 39 bool isAllEventsDisplayed() const;
40 40 bool isEventDisplayed(const std::shared_ptr<DBEvent> &event) const;
41 41
42 42 public slots:
43 43 void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
44 44 void populateWithAllEvents();
45 void clear();
45 46 void refresh();
46 47
47 48 private:
48 49 Ui::CatalogueEventsWidget *ui;
49 50
50 51 class CatalogueEventsWidgetPrivate;
51 52 spimpl::unique_impl_ptr<CatalogueEventsWidgetPrivate> impl;
52 53 };
53 54
54 55 #endif // SCIQLOP_CATALOGUEEVENTSWIDGET_H
Show file before | Show file after | Hide comments
@@ -1,399 +1,407
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 <Catalogue/CatalogueExplorerHelper.h>
7 7 #include <CatalogueDao.h>
8 8 #include <DBCatalogue.h>
9 9 #include <SqpApplication.h>
10 10 #include <Visualization/VisualizationTabWidget.h>
11 11 #include <Visualization/VisualizationWidget.h>
12 12 #include <Visualization/VisualizationZoneWidget.h>
13 13
14 14 #include <QDialog>
15 15 #include <QDialogButtonBox>
16 16 #include <QListWidget>
17 17
18 18 Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
19 19
20 20 /// Fixed size of the validation column
21 21 const auto VALIDATION_COLUMN_SIZE = 35;
22 22
23 23 struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
24 24
25 25 CatalogueEventsModel *m_Model = nullptr;
26 26 QStringList m_ZonesForTimeMode;
27 27 QString m_ZoneForGraphMode;
28 28 QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
29 29
30 30 VisualizationWidget *m_VisualizationWidget = nullptr;
31 31
32 32 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTreeView *treeView)
33 33 {
34 34 treeView->setSortingEnabled(false);
35 35 m_Model->setEvents(events);
36 36 treeView->setSortingEnabled(true);
37 37 }
38 38
39 39 void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
40 40 {
41 41 treeView->setSortingEnabled(false);
42 42 m_Model->addEvent(event);
43 43 treeView->setSortingEnabled(true);
44 44 }
45 45
46 46 void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
47 47 {
48 48 treeView->setSortingEnabled(false);
49 49 m_Model->removeEvent(event);
50 50 treeView->setSortingEnabled(true);
51 51 }
52 52
53 53 QStringList getAvailableVisualizationZoneList() const
54 54 {
55 55 if (m_VisualizationWidget) {
56 56 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
57 57 return tab->availableZoneWidgets();
58 58 }
59 59 }
60 60
61 61 return QStringList{};
62 62 }
63 63
64 64 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
65 65 bool allowMultiSelection, const QPoint &location)
66 66 {
67 67 auto availableZones = getAvailableVisualizationZoneList();
68 68 if (availableZones.isEmpty()) {
69 69 return QStringList{};
70 70 }
71 71
72 72 QDialog d(parent, Qt::Tool);
73 73 d.setWindowTitle("Choose a zone");
74 74 auto layout = new QVBoxLayout{&d};
75 75 layout->setContentsMargins(0, 0, 0, 0);
76 76 auto listWidget = new QListWidget{&d};
77 77 layout->addWidget(listWidget);
78 78
79 79 QSet<QListWidgetItem *> checkedItems;
80 80 for (auto zone : availableZones) {
81 81 auto item = new QListWidgetItem{zone};
82 82 item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
83 83 if (selectedZones.contains(zone)) {
84 84 item->setCheckState(Qt::Checked);
85 85 checkedItems << item;
86 86 }
87 87 else {
88 88 item->setCheckState(Qt::Unchecked);
89 89 }
90 90
91 91 listWidget->addItem(item);
92 92 }
93 93
94 94 auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
95 95 layout->addWidget(buttonBox);
96 96
97 97 QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
98 98 QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
99 99
100 100 QObject::connect(listWidget, &QListWidget::itemChanged,
101 101 [&checkedItems, allowMultiSelection, listWidget](auto item) {
102 102 if (item->checkState() == Qt::Checked) {
103 103 if (!allowMultiSelection) {
104 104 for (auto checkedItem : checkedItems) {
105 105 listWidget->blockSignals(true);
106 106 checkedItem->setCheckState(Qt::Unchecked);
107 107 listWidget->blockSignals(false);
108 108 }
109 109
110 110 checkedItems.clear();
111 111 }
112 112 checkedItems << item;
113 113 }
114 114 else {
115 115 checkedItems.remove(item);
116 116 }
117 117 });
118 118
119 119 QStringList result;
120 120
121 121 d.setMinimumWidth(120);
122 122 d.resize(d.minimumSizeHint());
123 123 d.move(location);
124 124 if (d.exec() == QDialog::Accepted) {
125 125 for (auto item : checkedItems) {
126 126 result += item->text();
127 127 }
128 128 }
129 129 else {
130 130 result = selectedZones;
131 131 }
132 132
133 133 return result;
134 134 }
135 135
136 136 void updateForTimeMode(QTreeView *treeView)
137 137 {
138 138 auto selectedRows = treeView->selectionModel()->selectedRows();
139 139
140 140 if (selectedRows.count() == 1) {
141 141 auto event = m_Model->getEvent(selectedRows.first());
142 142 if (event) {
143 143 if (m_VisualizationWidget) {
144 144 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
145 145
146 146 for (auto zoneName : m_ZonesForTimeMode) {
147 147 if (auto zone = tab->getZoneWithName(zoneName)) {
148 148 SqpRange eventRange;
149 149 eventRange.m_TStart = event->getTStart();
150 150 eventRange.m_TEnd = event->getTEnd();
151 151 zone->setZoneRange(eventRange);
152 152 }
153 153 }
154 154 }
155 155 else {
156 156 qCWarning(LOG_CatalogueEventsWidget())
157 157 << "updateTimeZone: no tab found in the visualization";
158 158 }
159 159 }
160 160 else {
161 161 qCWarning(LOG_CatalogueEventsWidget())
162 162 << "updateTimeZone: visualization widget not found";
163 163 }
164 164 }
165 165 }
166 166 else {
167 167 qCWarning(LOG_CatalogueEventsWidget())
168 168 << "updateTimeZone: not compatible with multiple events selected";
169 169 }
170 170 }
171 171
172 172 void updateForGraphMode(QTreeView *treeView)
173 173 {
174 174 auto selectedRows = treeView->selectionModel()->selectedRows();
175 175
176 176 if (selectedRows.count() == 1) {
177 177 auto event = m_Model->getEvent(selectedRows.first());
178 178 if (m_VisualizationWidget) {
179 179 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
180 180 if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
181 181 // TODO
182 182 }
183 183 }
184 184 else {
185 185 qCWarning(LOG_CatalogueEventsWidget())
186 186 << "updateGraphMode: no tab found in the visualization";
187 187 }
188 188 }
189 189 else {
190 190 qCWarning(LOG_CatalogueEventsWidget())
191 191 << "updateGraphMode: visualization widget not found";
192 192 }
193 193 }
194 194 else {
195 195 qCWarning(LOG_CatalogueEventsWidget())
196 196 << "updateGraphMode: not compatible with multiple events selected";
197 197 }
198 198 }
199 199 };
200 200
201 201 CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
202 202 : QWidget(parent),
203 203 ui(new Ui::CatalogueEventsWidget),
204 204 impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
205 205 {
206 206 ui->setupUi(this);
207 207
208 208 impl->m_Model = new CatalogueEventsModel{this};
209 209 ui->treeView->setModel(impl->m_Model);
210 210
211 211 ui->treeView->setSortingEnabled(true);
212 212 ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
213 213 ui->treeView->setDragEnabled(true);
214 214
215 215 connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
216 216 if (checked) {
217 217 ui->btnChart->setChecked(false);
218 218 impl->m_ZonesForTimeMode
219 219 = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
220 220 this->mapToGlobal(ui->btnTime->frameGeometry().center()));
221 221
222 222 impl->updateForTimeMode(ui->treeView);
223 223 }
224 224 });
225 225
226 226 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
227 227 if (checked) {
228 228 ui->btnTime->setChecked(false);
229 229 impl->m_ZoneForGraphMode
230 230 = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false,
231 231 this->mapToGlobal(ui->btnChart->frameGeometry().center()))
232 232 .value(0);
233 233
234 234 impl->updateForGraphMode(ui->treeView);
235 235 }
236 236 });
237 237
238 238 auto emitSelection = [this]() {
239 239 QVector<std::shared_ptr<DBEvent> > events;
240 240 QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
241 241
242 242 for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
243 243
244 244 auto itemType = impl->m_Model->itemTypeOf(rowIndex);
245 245 if (itemType == CatalogueEventsModel::ItemType::Event) {
246 246 events << impl->m_Model->getEvent(rowIndex);
247 247 }
248 248 else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
249 249 eventProducts << qMakePair(impl->m_Model->getParentEvent(rowIndex),
250 250 impl->m_Model->getEventProduct(rowIndex));
251 251 }
252 252 }
253 253
254 254 if (!events.isEmpty() && eventProducts.isEmpty()) {
255 255 emit this->eventsSelected(events);
256 256 }
257 257 else if (events.isEmpty() && !eventProducts.isEmpty()) {
258 258 emit this->eventProductsSelected(eventProducts);
259 259 }
260 260 else {
261 261 emit this->selectionCleared();
262 262 }
263 263 };
264 264
265 265 connect(ui->treeView, &QTreeView::clicked, emitSelection);
266 266 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, emitSelection);
267 267
268 268 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
269 269 auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
270 270 ui->btnChart->setEnabled(isNotMultiSelection);
271 271 ui->btnTime->setEnabled(isNotMultiSelection);
272 272
273 273 if (isNotMultiSelection && ui->btnTime->isChecked()) {
274 274 impl->updateForTimeMode(ui->treeView);
275 275 }
276 276 else if (isNotMultiSelection && ui->btnChart->isChecked()) {
277 277 impl->updateForGraphMode(ui->treeView);
278 278 }
279 279 });
280 280
281 281 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
282 282 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
283 283 QHeaderView::Stretch);
284 284 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Validation,
285 285 QHeaderView::Fixed);
286 286 ui->treeView->header()->resizeSection((int)CatalogueEventsModel::Column::Validation,
287 287 VALIDATION_COLUMN_SIZE);
288 288 ui->treeView->header()->setSortIndicatorShown(true);
289 289
290 290 connect(impl->m_Model, &CatalogueEventsModel::modelSorted, [this]() {
291 291 auto allEvents = impl->m_Model->events();
292 292 for (auto event : allEvents) {
293 293 setEventChanges(event, impl->m_Model->eventsHasChanges(event));
294 294 }
295 295 });
296
297 populateWithAllEvents();
296 298 }
297 299
298 300 CatalogueEventsWidget::~CatalogueEventsWidget()
299 301 {
300 302 delete ui;
301 303 }
302 304
303 305 void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
304 306 {
305 307 impl->m_VisualizationWidget = visualization;
306 308 }
307 309
308 310 void CatalogueEventsWidget::addEvent(const std::shared_ptr<DBEvent> &event)
309 311 {
310 312 impl->addEvent(event, ui->treeView);
311 313 }
312 314
313 315 void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
314 316 {
315 317 impl->m_Model->refreshEvent(event);
316 318
317 319 auto eventIndex = impl->m_Model->indexOf(event);
318 320 auto validationIndex
319 321 = eventIndex.sibling(eventIndex.row(), (int)CatalogueEventsModel::Column::Validation);
320 322
321 323 if (hasChanges) {
322 324 if (ui->treeView->indexWidget(validationIndex) == nullptr) {
323 325 auto widget = CatalogueExplorerHelper::buildValidationWidget(
324 326 ui->treeView,
325 327 [this, event]() {
326 328 sqpApp->catalogueController().saveEvent(event);
327 329 setEventChanges(event, false);
328 330 },
329 331 [this, event]() { setEventChanges(event, false); });
330 332 ui->treeView->setIndexWidget(validationIndex, widget);
331 333 }
332 334
333 335 impl->m_Model->setEventHasChanges(event, hasChanges);
334 336 }
335 337 else {
336 338 qCWarning(LOG_CatalogueEventsWidget())
337 339 << "setEventChanges: the event is not displayed in the model.";
338 340 }
339 341 }
340 342
341 343 QVector<std::shared_ptr<DBCatalogue> > CatalogueEventsWidget::displayedCatalogues() const
342 344 {
343 345 return impl->m_DisplayedCatalogues;
344 346 }
345 347
346 348 bool CatalogueEventsWidget::isAllEventsDisplayed() const
347 349 {
348 return impl->m_DisplayedCatalogues.isEmpty();
350 return impl->m_DisplayedCatalogues.isEmpty() && !impl->m_Model->events().isEmpty();
349 351 }
350 352
351 353 bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &event) const
352 354 {
353 355 return impl->m_Model->indexOf(event).isValid();
354 356 }
355 357
356 358 void CatalogueEventsWidget::populateWithCatalogues(
357 359 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
358 360 {
359 361 impl->m_DisplayedCatalogues = catalogues;
360 362
361 363 QSet<QUuid> eventIds;
362 364 QVector<std::shared_ptr<DBEvent> > events;
363 365
364 366 for (auto catalogue : catalogues) {
365 367 auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
366 368 for (auto event : catalogueEvents) {
367 369 if (!eventIds.contains(event->getUniqId())) {
368 370 events << event;
369 371 eventIds.insert(event->getUniqId());
370 372 }
371 373 }
372 374 }
373 375
374 376 impl->setEvents(events, ui->treeView);
375 377 }
376 378
377 379 void CatalogueEventsWidget::populateWithAllEvents()
378 380 {
379 381 impl->m_DisplayedCatalogues.clear();
380 382
381 383 auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
382 384
383 385 QVector<std::shared_ptr<DBEvent> > events;
384 386 for (auto event : allEvents) {
385 387 events << event;
386 388 }
387 389
388 390 impl->setEvents(events, ui->treeView);
389 391 }
390 392
393 void CatalogueEventsWidget::clear()
394 {
395 impl->m_DisplayedCatalogues.clear();
396 impl->setEvents({}, ui->treeView);
397 }
398
391 399 void CatalogueEventsWidget::refresh()
392 400 {
393 401 if (impl->m_DisplayedCatalogues.isEmpty()) {
394 402 populateWithAllEvents();
395 403 }
396 404 else {
397 405 populateWithCatalogues(impl->m_DisplayedCatalogues);
398 406 }
399 407 }
Show file before | Show file after | Hide comments
@@ -1,113 +1,126
1 1 #include "Catalogue/CatalogueExplorer.h"
2 2 #include "ui_CatalogueExplorer.h"
3 3
4 4 #include <Catalogue/CatalogueActionManager.h>
5 5 #include <Catalogue/CatalogueController.h>
6 6 #include <SqpApplication.h>
7 7 #include <Visualization/VisualizationWidget.h>
8 8
9 9 #include <DBCatalogue.h>
10 10 #include <DBEvent.h>
11 11
12 12 struct CatalogueExplorer::CatalogueExplorerPrivate {
13 13 CatalogueActionManager m_ActionManager;
14 14
15 15 CatalogueExplorerPrivate(CatalogueExplorer *catalogueExplorer)
16 16 : m_ActionManager(catalogueExplorer)
17 17 {
18 18 }
19 19 };
20 20
21 21 CatalogueExplorer::CatalogueExplorer(QWidget *parent)
22 22 : QDialog(parent, Qt::Dialog | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint),
23 23 ui(new Ui::CatalogueExplorer),
24 24 impl{spimpl::make_unique_impl<CatalogueExplorerPrivate>(this)}
25 25 {
26 26 ui->setupUi(this);
27 27
28 28 impl->m_ActionManager.installSelectionZoneActions();
29 29
30 30 connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto catalogues) {
31 31 if (catalogues.count() == 1) {
32 32 ui->inspector->setCatalogue(catalogues.first());
33 33 }
34 34 else {
35 35 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
36 36 }
37 37
38 38 ui->events->populateWithCatalogues(catalogues);
39 39 });
40 40
41 41 connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databases) {
42 42 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
43 43 });
44 44
45 connect(ui->catalogues, &CatalogueSideBarWidget::trashSelected,
46 [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
45 connect(ui->catalogues, &CatalogueSideBarWidget::trashSelected, [this]() {
46 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
47 ui->events->clear();
48 });
47 49
48 50 connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected, [this]() {
49 51 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
50 52 ui->events->populateWithAllEvents();
51 53 });
52 54
53 connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared,
54 [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
55 connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databaseList) {
56 QVector<std::shared_ptr<DBCatalogue> > catalogueList;
57 for (auto database : databaseList) {
58 catalogueList.append(ui->catalogues->getCatalogues(database));
59 }
60 ui->events->populateWithCatalogues(catalogueList);
61 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
62 });
63
64 connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared, [this]() {
65 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
66 ui->events->clear();
67 });
55 68
56 69 connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
57 70 if (events.count() == 1) {
58 71 ui->inspector->setEvent(events.first());
59 72 }
60 73 else {
61 74 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
62 75 }
63 76 });
64 77
65 78 connect(ui->events, &CatalogueEventsWidget::eventProductsSelected, [this](auto eventProducts) {
66 79 if (eventProducts.count() == 1) {
67 80 ui->inspector->setEventProduct(eventProducts.first().first,
68 81 eventProducts.first().second);
69 82 }
70 83 else {
71 84 ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
72 85 }
73 86 });
74 87
75 88 connect(ui->events, &CatalogueEventsWidget::selectionCleared,
76 89 [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
77 90
78 91 connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated, [this](auto catalogue) {
79 92 sqpApp->catalogueController().updateCatalogue(catalogue);
80 93 ui->catalogues->setCatalogueChanges(catalogue, true);
81 94 });
82 95
83 96 connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated, [this](auto event) {
84 97 sqpApp->catalogueController().updateEvent(event);
85 98 ui->events->setEventChanges(event, true);
86 99 });
87 100
88 101 connect(ui->inspector, &CatalogueInspectorWidget::eventProductUpdated,
89 102 [this](auto event, auto eventProduct) {
90 103 sqpApp->catalogueController().updateEventProduct(eventProduct);
91 104 ui->events->setEventChanges(event, true);
92 105 });
93 106 }
94 107
95 108 CatalogueExplorer::~CatalogueExplorer()
96 109 {
97 110 delete ui;
98 111 }
99 112
100 113 void CatalogueExplorer::setVisualizationWidget(VisualizationWidget *visualization)
101 114 {
102 115 ui->events->setVisualizationWidget(visualization);
103 116 }
104 117
105 118 CatalogueEventsWidget &CatalogueExplorer::eventsWidget() const
106 119 {
107 120 return *ui->events;
108 121 }
109 122
110 123 CatalogueSideBarWidget &CatalogueExplorer::sideBarWidget() const
111 124 {
112 125 return *ui->catalogues;
113 126 }
General Comments 0
You need to be logged in to leave comments. Login now