GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1369:b20dcec1c57b

Fix bug time precision with catalogue

perrinel -

r1369:b20dcec1c57b

parent child

Context file:

r1369:b20dcec1c57b

core/include/Common/DateUtils.h +4 0

             #ifndef SCIQLOP_DATEUTILS_H
             #define SCIQLOP_DATEUTILS_H
             #include "CoreGlobal.h"
             #include <QDateTime>
+            /// Format for datetimes
+            const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
+            const auto DATETIME_FORMAT_ONE_LINE = QStringLiteral("dd/MM/yyyy hh:mm:ss:zzz");
             /**
              * Utility class with methods for dates
              */
             struct SCIQLOP_CORE_EXPORT DateUtils {
                 /// Converts seconds (since epoch) to datetime. By default, the datetime is in UTC
                 static QDateTime dateTime(double secs, Qt::TimeSpec timeSpec = Qt::UTC) noexcept;
                 /// Converts datetime to seconds since epoch
                 static double secondsSinceEpoch(const QDateTime &dateTime) noexcept;
             };
             #endif // SCIQLOP_DATEUTILS_H

core/src/Variable/VariableModel.cpp 0 -3

             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <Common/StringUtils.h>
             #include <Data/IDataSeries.h>
             #include <DataSource/DataSourceController.h>
             #include <Time/TimeController.h>
             #include <QMimeData>
             #include <QSize>
             #include <QTimer>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto NBPOINTS_COLUMN = 3;
             const auto UNIT_COLUMN = 4;
             const auto MISSION_COLUMN = 5;
             const auto PLUGIN_COLUMN = 6;
             const auto NB_COLUMNS = 7;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
                 {NAME_COLUMN, {QObject::tr("Name")}},      {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                 {TEND_COLUMN, {QObject::tr("tEnd"), 180}}, {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
                 {UNIT_COLUMN, {QObject::tr("Unit")}},      {MISSION_COLUMN, {QObject::tr("Mission")}},
                 {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
-            /// Format for datetimes
-            const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             QString uniqueName(const QString &defaultName,
                                const std::vector<std::shared_ptr<Variable> > &variables)
             {
                 auto forbiddenNames = std::vector<QString>(variables.size());
                 std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
                                [](const auto &variable) { return variable->name(); });
                 auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
                 Q_ASSERT(!uniqueName.isEmpty());
                 return uniqueName;
             }
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 VariableController *m_VariableController;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(VariableController *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
                 impl->m_VariableController = parent;
             }
             void VariableModel::addVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 // Generates unique name for the variable
                 variable->setName(uniqueName(variable->name(), impl->m_Variables));
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
             }
             bool VariableModel::containsVariable(std::shared_ptr<Variable> variable) const noexcept
             {
                 auto end = impl->m_Variables.cend();
                 return std::find(impl->m_Variables.cbegin(), end, variable) != end;
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto variable = std::make_shared<Variable>(name, metadata);
                 addVariable(variable);
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0u && static_cast<size_t>(index) < impl->m_Variables.size())
                            ? impl->m_Variables[index]
                            : nullptr;
             }
             std::vector<std::shared_ptr<Variable> > VariableModel::variables() const
             {
                 return impl->m_Variables;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case TEND_COLUMN: {
                                 auto range = variable->realRange();
                                 return range != INVALID_RANGE
                                            ? DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             case NBPOINTS_COLUMN:
                                 return variable->nbPoints();
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:
                                 return variable->metadata().value(QStringLiteral("mission"));
                             case PLUGIN_COLUMN:
                                 return variable->metadata().value(QStringLiteral("plugin"));
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             Qt::ItemFlags VariableModel::flags(const QModelIndex &index) const
             {
                 return QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
             }
             Qt::DropActions VariableModel::supportedDropActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             Qt::DropActions VariableModel::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList VariableModel::mimeTypes() const
             {
                 return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *VariableModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 QList<std::shared_ptr<Variable> > variableList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto variable = impl->m_Variables.at(index.row());
                         if (variable.get() && index.isValid()) {
                             if (variableList.isEmpty()) {
                                 // Gets the range of the first variable
                                 firstTimeRange = std::move(variable->range());
                             }
                             variableList << variable;
                         }
                     }
                 }
                 auto variablesEncodedData = impl->m_VariableController->mimeDataForVariables(variableList);
                 mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
                 if (variableList.count() == 1) {
                     // No time range MIME data if multiple variables are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             bool VariableModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
                                                 int column, const QModelIndex &parent) const
             {
                 // drop of a product
                 return data->hasFormat(MIME_TYPE_PRODUCT_LIST)
                        || (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()
                            && !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
             }
             bool VariableModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                              const QModelIndex &parent)
             {
                 auto dropDone = false;
                 if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                     auto productList
                         = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
                     for (auto metaData : productList) {
                         emit requestVariable(metaData.toHash());
                     }
                     dropDone = true;
                 }
                 else if (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()) {
                     auto variable = this->variable(parent.row());
                     auto range = TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
                     emit requestVariableRangeUpdate(variable, range);
                     dropDone = true;
                 }
                 return dropDone;
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

gui/src/Catalogue/CatalogueEventsModel.cpp +12 -6

             #include "Catalogue/CatalogueEventsModel.h"
             #include <Catalogue/CatalogueController.h>
             #include <Common/DateUtils.h>
             #include <Common/MimeTypesDef.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             #include <Data/SqpRange.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <list>
             #include <unordered_map>
             #include <QHash>
             #include <QMimeData>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsModel, "CatalogueEventsModel")
             const auto EVENT_ITEM_TYPE = 1;
             const auto EVENT_PRODUCT_ITEM_TYPE = 2;
             struct CatalogueEventsModel::CatalogueEventsModelPrivate {
                 QVector<std::shared_ptr<DBEvent> > m_Events;
                 std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
                 QVector<std::shared_ptr<DBCatalogue> > m_SourceCatalogue;
                 QStringList columnNames()
                 {
                     return QStringList{tr("Event"), tr("TStart"),  tr("TEnd"),
                                        tr("Tags"),  tr("Product"), tr("")};
                 }
                 QVariant sortData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     if (col == (int)CatalogueEventsModel::Column::Validation) {
                         auto hasChanges = sqpApp->catalogueController().eventHasChanges(event);
                         return hasChanges ? true : QVariant();
                     }
                     return eventData(col, event);
                 }
                 QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return event->getName();
                         case CatalogueEventsModel::Column::TStart:
-                            return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTStart())
+                            return nbEventProducts(event) > 0
-                                                              : QVariant{};
+                                       ? DateUtils::dateTime(event->getTStart())
+                                             .toString(DATETIME_FORMAT_ONE_LINE)
+                                       : QVariant{};
                         case CatalogueEventsModel::Column::TEnd:
-                            return nbEventProducts(event) > 0 ? DateUtils::dateTime(event->getTEnd())
+                            return nbEventProducts(event) > 0
-                                                              : QVariant{};
+                                       ? DateUtils::dateTime(event->getTEnd())
+                                             .toString(DATETIME_FORMAT_ONE_LINE)
+                                       : QVariant{};
                         case CatalogueEventsModel::Column::Product: {
                             auto eventProducts = event->getEventProducts();
                             QStringList eventProductList;
                             for (auto evtProduct : eventProducts) {
                                 eventProductList << evtProduct.getProductId();
                             }
                             return eventProductList.join(";");
                         }
                         case CatalogueEventsModel::Column::Tags: {
                             QString tagList;
                             auto tags = event->getTags();
                             for (auto tag : tags) {
                                 tagList += tag.getName();
                                 tagList += ' ';
                             }
                             return tagList;
                         }
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
                 void parseEventProduct(const std::shared_ptr<DBEvent> &event)
                 {
                     for (auto product : event->getEventProducts()) {
                         m_EventProducts[event.get()].append(std::make_shared<DBEventProduct>(product));
                     }
                 }
                 int nbEventProducts(const std::shared_ptr<DBEvent> &event) const
                 {
                     auto eventProductsIt = m_EventProducts.find(event.get());
                     if (eventProductsIt != m_EventProducts.cend()) {
                         return m_EventProducts.at(event.get()).count();
                     }
                     else {
                         return 0;
                     }
                 }
                 QVariant eventProductData(int col, const std::shared_ptr<DBEventProduct> &eventProduct) const
                 {
                     switch (static_cast<Column>(col)) {
                         case CatalogueEventsModel::Column::Name:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::TStart:
-                            return DateUtils::dateTime(eventProduct->getTStart());
+                            return DateUtils::dateTime(eventProduct->getTStart())
+                                .toString(DATETIME_FORMAT_ONE_LINE);
                         case CatalogueEventsModel::Column::TEnd:
-                            return DateUtils::dateTime(eventProduct->getTEnd());
+                            return DateUtils::dateTime(eventProduct->getTEnd())
+                                .toString(DATETIME_FORMAT_ONE_LINE);
                         case CatalogueEventsModel::Column::Product:
                             return eventProduct->getProductId();
                         case CatalogueEventsModel::Column::Tags:
                             return QString();
                         case CatalogueEventsModel::Column::Validation:
                             return QVariant();
                         default:
                             break;
                     }
                     Q_ASSERT(false);
                     return QStringLiteral("Unknown Data");
                 }
                 void refreshChildrenOfIndex(CatalogueEventsModel *model, const QModelIndex &index) const
                 {
                     auto childCount = model->rowCount(index);
                     auto colCount = model->columnCount();
                     emit model->dataChanged(model->index(0, 0, index),
                                             model->index(childCount, colCount, index));
                 }
             };
             CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
             {
             }
             void CatalogueEventsModel::setSourceCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
                 impl->m_SourceCatalogue = catalogues;
             }
             void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 impl->m_EventProducts.clear();
                 for (auto event : events) {
                     impl->parseEventProduct(event);
                 }
                 endResetModel();
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::Event) {
                     return impl->m_Events.value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEvent> CatalogueEventsModel::getParentEvent(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     return getEvent(index.parent());
                 }
                 else {
                     return nullptr;
                 }
             }
             std::shared_ptr<DBEventProduct>
             CatalogueEventsModel::getEventProduct(const QModelIndex &index) const
             {
                 if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) {
                     auto event = static_cast<DBEvent *>(index.internalPointer());
                     return impl->m_EventProducts.at(event).value(index.row());
                 }
                 else {
                     return nullptr;
                 }
             }
             void CatalogueEventsModel::addEvent(const std::shared_ptr<DBEvent> &event)
             {
                 beginInsertRows(QModelIndex(), impl->m_Events.count(), impl->m_Events.count());
                 impl->m_Events.append(event);
                 impl->parseEventProduct(event);
                 endInsertRows();
                 // Also refreshes its children event products
                 auto eventIndex = index(impl->m_Events.count(), 0);
                 impl->refreshChildrenOfIndex(this, eventIndex);
             }
             void CatalogueEventsModel::removeEvent(const std::shared_ptr<DBEvent> &event)
             {
                 auto index = impl->m_Events.indexOf(event);
                 if (index >= 0) {
                     beginRemoveRows(QModelIndex(), index, index);
                     impl->m_Events.removeAt(index);
                     impl->m_EventProducts.erase(event.get());
                     endRemoveRows();
                 }
             }
             QVector<std::shared_ptr<DBEvent> > CatalogueEventsModel::events() const
             {
                 return impl->m_Events;
             }
             void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event,
                                                     bool refreshEventProducts)
             {
                 auto eventIndex = indexOf(event);
                 if (eventIndex.isValid()) {
                     if (refreshEventProducts) {
                         // Reparse the associated event products
                         auto nbEventProducts = impl->nbEventProducts(event);
                         auto newNbOfEventProducts = event->getEventProducts().size();
                         if (newNbOfEventProducts < nbEventProducts) {
                             beginRemoveRows(eventIndex, newNbOfEventProducts, nbEventProducts - 1);
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                             endRemoveRows();
                         }
                         else if (newNbOfEventProducts > nbEventProducts) {
                             beginInsertRows(eventIndex, nbEventProducts, newNbOfEventProducts - 1);
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                             endInsertRows();
                         }
                         else { // newNbOfEventProducts == nbEventProducts
                             impl->m_EventProducts.erase(event.get());
                             impl->parseEventProduct(event);
                         }
                     }
                     // Refreshes the event line
                     auto colCount = columnCount();
                     emit dataChanged(eventIndex, index(eventIndex.row(), colCount));
                     // Also refreshes its children event products
                     impl->refreshChildrenOfIndex(this, eventIndex);
                 }
                 else {
                     qCWarning(LOG_CatalogueEventsModel()) << "refreshEvent: event not found.";
                 }
             }
             QModelIndex CatalogueEventsModel::indexOf(const std::shared_ptr<DBEvent> &event) const
             {
                 auto row = impl->m_Events.indexOf(event);
                 if (row >= 0) {
                     return index(row, 0);
                 }
                 return QModelIndex();
             }
             QModelIndex CatalogueEventsModel::index(int row, int column, const QModelIndex &parent) const
             {
                 if (!hasIndex(row, column, parent)) {
                     return QModelIndex();
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return createIndex(row, column);
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return createIndex(row, column, event.get());
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const
             {
                 switch (itemTypeOf(index)) {
                     case CatalogueEventsModel::ItemType::EventProduct: {
                         auto parentEvent = static_cast<DBEvent *>(index.internalPointer());
                         auto it
                             = std::find_if(impl->m_Events.cbegin(), impl->m_Events.cend(),
                                            [parentEvent](auto event) { return event.get() == parentEvent; });
                         if (it != impl->m_Events.cend()) {
                             return createIndex(it - impl->m_Events.cbegin(), 0);
                         }
                         else {
                             return QModelIndex();
                         }
                     }
                     case CatalogueEventsModel::ItemType::Root:
                         break;
                     case CatalogueEventsModel::ItemType::Event:
                         break;
                     default:
                         break;
                 }
                 return QModelIndex();
             }
             int CatalogueEventsModel::rowCount(const QModelIndex &parent) const
             {
                 if (parent.column() > 0) {
                     return 0;
                 }
                 switch (itemTypeOf(parent)) {
                     case CatalogueEventsModel::ItemType::Root:
                         return impl->m_Events.count();
                     case CatalogueEventsModel::ItemType::Event: {
                         auto event = getEvent(parent);
                         return impl->m_EventProducts[event.get()].count();
                     }
                     case CatalogueEventsModel::ItemType::EventProduct:
                         break;
                     default:
                         break;
                 }
                 return 0;
             }
             int CatalogueEventsModel::columnCount(const QModelIndex &parent) const
             {
                 return static_cast<int>(CatalogueEventsModel::Column::NbColumn);
             }
             Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
             {
                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
             }
             QVariant CatalogueEventsModel::data(const QModelIndex &index, int role) const
             {
                 if (index.isValid()) {
                     auto type = itemTypeOf(index);
                     if (type == CatalogueEventsModel::ItemType::Event) {
                         auto event = getEvent(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventData(index.column(), event);
                                 break;
                         }
                     }
                     else if (type == CatalogueEventsModel::ItemType::EventProduct) {
                         auto product = getEventProduct(index);
                         switch (role) {
                             case Qt::DisplayRole:
                                 return impl->eventProductData(index.column(), product);
                                 break;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
                     return impl->columnNames().value(section);
                 }
                 return QVariant();
             }
             void CatalogueEventsModel::sort(int column, Qt::SortOrder order)
             {
                 beginResetModel();
                 std::sort(impl->m_Events.begin(), impl->m_Events.end(),
                           [this, column, order](auto e1, auto e2) {
                               auto data1 = impl->sortData(column, e1);
                               auto data2 = impl->sortData(column, e2);
                               auto result = data1.toString() < data2.toString();
                               return order == Qt::AscendingOrder ? result : !result;
                           });
                 endResetModel();
                 emit modelSorted();
             }
             Qt::DropActions CatalogueEventsModel::supportedDragActions() const
             {
                 return Qt::CopyAction | Qt::MoveAction;
             }
             QStringList CatalogueEventsModel::mimeTypes() const
             {
                 return {MIME_TYPE_EVENT_LIST, MIME_TYPE_SOURCE_CATALOGUE_LIST, MIME_TYPE_TIME_RANGE};
             }
             QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const
             {
                 auto mimeData = new QMimeData;
                 bool isFirst = true;
                 QVector<std::shared_ptr<DBEvent> > eventList;
                 QVector<std::shared_ptr<DBEventProduct> > eventProductList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                     if (index.column() == 0) { // only the first column
                         auto type = itemTypeOf(index);
                         if (type == ItemType::Event) {
                             auto event = getEvent(index);
                             eventList << event;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = event->getTStart();
                                 firstTimeRange.m_TEnd = event->getTEnd();
                             }
                         }
                         else if (type == ItemType::EventProduct) {
                             auto product = getEventProduct(index);
                             eventProductList << product;
                             if (isFirst) {
                                 isFirst = false;
                                 firstTimeRange.m_TStart = product->getTStart();
                                 firstTimeRange.m_TEnd = product->getTEnd();
                             }
                         }
                     }
                 }
                 if (!eventList.isEmpty() && eventProductList.isEmpty()) {
                     auto eventsEncodedData = sqpApp->catalogueController().mimeDataForEvents(eventList);
                     mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData);
                     auto sourceCataloguesEncodedData
                         = sqpApp->catalogueController().mimeDataForCatalogues(impl->m_SourceCatalogue);
                     mimeData->setData(MIME_TYPE_SOURCE_CATALOGUE_LIST, sourceCataloguesEncodedData);
                 }
                 if (eventList.count() + eventProductList.count() == 1) {
                     // No time range MIME data if multiple events are dragged
                     auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
                 }
                 return mimeData;
             }
             CatalogueEventsModel::ItemType CatalogueEventsModel::itemTypeOf(const QModelIndex &index) const
             {
                 if (!index.isValid()) {
                     return ItemType::Root;
                 }
                 else if (index.internalPointer() == nullptr) {
                     return ItemType::Event;
                 }
                 else {
                     return ItemType::EventProduct;
                 }
             }

gui/src/Catalogue/CatalogueEventsWidget.cpp +5 0

             #include "Catalogue/CatalogueEventsWidget.h"
             #include "ui_CatalogueEventsWidget.h"
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueEventsModel.h>
             #include <Catalogue/CatalogueExplorerHelper.h>
             #include <CatalogueDao.h>
             #include <DBCatalogue.h>
             #include <DBEventProduct.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Visualization/VisualizationGraphWidget.h>
             #include <Visualization/VisualizationTabWidget.h>
             #include <Visualization/VisualizationWidget.h>
             #include <Visualization/VisualizationZoneWidget.h>
             #include <QDialog>
             #include <QDialogButtonBox>
             #include <QKeyEvent>
             #include <QListWidget>
             #include <QMessageBox>
             Q_LOGGING_CATEGORY(LOG_CatalogueEventsWidget, "CatalogueEventsWidget")
             /// Fixed size of the validation column
             const auto VALIDATION_COLUMN_SIZE = 35;
             /// Percentage added to the range of a event when it is displayed
             const auto EVENT_RANGE_MARGE = 30; // in %
             struct CatalogueEventsWidget::CatalogueEventsWidgetPrivate {
                 CatalogueEventsModel *m_Model = nullptr;
                 QStringList m_ZonesForTimeMode;
                 QString m_ZoneForGraphMode;
                 QVector<std::shared_ptr<DBCatalogue> > m_DisplayedCatalogues;
                 bool m_AllEventDisplayed = false;
                 QVector<VisualizationGraphWidget *> m_CustomGraphs;
                 VisualizationWidget *m_VisualizationWidget = nullptr;
                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, CatalogueEventsWidget *widget)
                 {
                     widget->ui->treeView->setSortingEnabled(false);
                     m_Model->setSourceCatalogues(m_DisplayedCatalogues);
                     m_Model->setEvents(events);
                     widget->ui->treeView->setSortingEnabled(true);
                     for (auto event : events) {
                         if (sqpApp->catalogueController().eventHasChanges(event)) {
                             auto index = m_Model->indexOf(event);
                             widget->setEventChanges(event, true);
                         }
                     }
                 }
                 void addEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->addEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 void removeEvent(const std::shared_ptr<DBEvent> &event, QTreeView *treeView)
                 {
                     treeView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
                     treeView->setSortingEnabled(true);
                 }
                 QStringList getAvailableVisualizationZoneList() const
                 {
                     if (m_VisualizationWidget) {
                         if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                             return tab->availableZoneWidgets();
                         }
                     }
                     return QStringList{};
                 }
                 QStringList selectZone(QWidget *parent, const QStringList &selectedZones,
                                        bool allowMultiSelection, const QPoint &location)
                 {
                     auto availableZones = getAvailableVisualizationZoneList();
                     if (availableZones.isEmpty()) {
                         return QStringList{};
                     }
                     QDialog d(parent, Qt::Tool);
                     d.setWindowTitle("Choose a zone");
                     auto layout = new QVBoxLayout{&d};
                     layout->setContentsMargins(0, 0, 0, 0);
                     auto listWidget = new QListWidget{&d};
                     layout->addWidget(listWidget);
                     QSet<QListWidgetItem *> checkedItems;
                     for (auto zone : availableZones) {
                         auto item = new QListWidgetItem{zone};
                         item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
                         if (selectedZones.contains(zone)) {
                             item->setCheckState(Qt::Checked);
                             checkedItems << item;
                         }
                         else {
                             item->setCheckState(Qt::Unchecked);
                         }
                         listWidget->addItem(item);
                     }
                     auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok, &d};
                     layout->addWidget(buttonBox);
                     QObject::connect(buttonBox, &QDialogButtonBox::accepted, &d, &QDialog::accept);
                     QObject::connect(buttonBox, &QDialogButtonBox::rejected, &d, &QDialog::reject);
                     QObject::connect(listWidget, &QListWidget::itemChanged,
                                      [&checkedItems, allowMultiSelection, listWidget](auto item) {
                                          if (item->checkState() == Qt::Checked) {
                                              if (!allowMultiSelection) {
                                                  for (auto checkedItem : checkedItems) {
                                                      listWidget->blockSignals(true);
                                                      checkedItem->setCheckState(Qt::Unchecked);
                                                      listWidget->blockSignals(false);
                                                  }
                                                  checkedItems.clear();
                                              }
                                              checkedItems << item;
                                          }
                                          else {
                                              checkedItems.remove(item);
                                          }
                                      });
                     QStringList result;
                     d.setMinimumWidth(120);
                     d.resize(d.minimumSizeHint());
                     d.move(location);
                     if (d.exec() == QDialog::Accepted) {
                         for (auto item : checkedItems) {
                             result += item->text();
                         }
                     }
                     else {
                         result = selectedZones;
                     }
                     return result;
                 }
                 void updateForTimeMode(QTreeView *treeView)
                 {
                     auto selectedRows = treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() == 1) {
                         auto event = m_Model->getEvent(selectedRows.first());
                         if (event) {
                             if (m_VisualizationWidget) {
                                 if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                     for (auto zoneName : m_ZonesForTimeMode) {
                                         if (auto zone = tab->getZoneWithName(zoneName)) {
                                             SqpRange eventRange;
                                             eventRange.m_TStart = event->getTStart();
                                             eventRange.m_TEnd = event->getTEnd();
                                             zone->setZoneRange(eventRange);
                                         }
                                     }
                                 }
                                 else {
                                     qCWarning(LOG_CatalogueEventsWidget())
                                         << "updateTimeZone: no tab found in the visualization";
                                 }
                             }
                             else {
                                 qCWarning(LOG_CatalogueEventsWidget())
                                     << "updateTimeZone: visualization widget not found";
                             }
                         }
                     }
                     else {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateTimeZone: not compatible with multiple events selected";
                     }
                 }
                 QVector<SqpRange> getGraphRanges(const std::shared_ptr<DBEvent> &event)
                 {
                     // Retrieves the range of each product and the maximum size
                     QVector<SqpRange> graphRanges;
                     double maxDt = 0;
                     for (auto eventProduct : event->getEventProducts()) {
                         SqpRange eventRange;
                         eventRange.m_TStart = eventProduct.getTStart();
                         eventRange.m_TEnd = eventProduct.getTEnd();
                         graphRanges << eventRange;
                         auto dt = eventRange.m_TEnd - eventRange.m_TStart;
                         if (dt > maxDt) {
                             maxDt = dt;
                         }
                     }
                     // Adds the marge
                     maxDt *= (100.0 + EVENT_RANGE_MARGE) / 100.0;
                     // Corrects the graph ranges so that they all have the same size
                     QVector<SqpRange> correctedGraphRanges;
                     for (auto range : graphRanges) {
                         auto dt = range.m_TEnd - range.m_TStart;
                         auto diff = qAbs((maxDt - dt) / 2.0);
                         SqpRange correctedRange;
                         correctedRange.m_TStart = range.m_TStart - diff;
                         correctedRange.m_TEnd = range.m_TEnd + diff;
                         correctedGraphRanges << correctedRange;
                     }
                     return correctedGraphRanges;
                 }
                 void updateForGraphMode(CatalogueEventsWidget *catalogueEventWidget)
                 {
                     auto selectedRows = catalogueEventWidget->ui->treeView->selectionModel()->selectedRows();
                     if (selectedRows.count() != 1) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: not compatible with multiple events selected";
                         return;
                     }
                     if (!m_VisualizationWidget) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: visualization widget not found";
                         return;
                     }
                     auto event = m_Model->getEvent(selectedRows.first());
                     if (!event) {
                         // A event product is probably selected
                         qCInfo(LOG_CatalogueEventsWidget()) << "updateGraphMode: no events are selected";
                         return;
                     }
                     auto tab = m_VisualizationWidget->currentTabWidget();
                     if (!tab) {
                         qCWarning(LOG_CatalogueEventsWidget())
                             << "updateGraphMode: no tab found in the visualization";
                         return;
                     }
                     auto zone = tab->getZoneWithName(m_ZoneForGraphMode);
                     if (!zone) {
                         qCWarning(LOG_CatalogueEventsWidget()) << "updateGraphMode: zone not found";
                         return;
                     }
                     // Closes the previous graph and delete the asociated variables
                     for (auto graph : m_CustomGraphs) {
                         graph->close();
                         auto variables = graph->variables().toVector();
                         QMetaObject::invokeMethod(&sqpApp->variableController(), "deleteVariables",
                                                   Qt::QueuedConnection,
                                                   Q_ARG(QVector<std::shared_ptr<Variable> >, variables));
                     }
                     m_CustomGraphs.clear();
                     // Closes the remaining graphs inside the zone
                     zone->closeAllGraphs();
                     // Calculates the range of each graph which will be created
                     auto graphRange = getGraphRanges(event);
                     // Loops through the event products and create the graph
                     auto itRange = graphRange.cbegin();
                     for (auto eventProduct : event->getEventProducts()) {
                         auto productId = eventProduct.getProductId();
                         auto range = *itRange;
                         ++itRange;
                         SqpRange productRange;
                         productRange.m_TStart = eventProduct.getTStart();
                         productRange.m_TEnd = eventProduct.getTEnd();
                         auto context = new QObject{catalogueEventWidget};
                         QObject::connect(
                             &sqpApp->variableController(), &VariableController::variableAdded, context,
                             [this, catalogueEventWidget, zone, context, event, range, productRange,
                              productId](auto variable) {
                                 if (variable->metadata().value(DataSourceItem::ID_DATA_KEY).toString()
                                     == productId) {
                                     auto graph = zone->createGraph(variable);
                                     graph->setAutoRangeOnVariableInitialization(false);
                                     auto selectionZone
                                         = graph->addSelectionZone(event->getName(), productRange);
                                     emit catalogueEventWidget->selectionZoneAdded(event, productId,
                                                                                   selectionZone);
                                     m_CustomGraphs << graph;
                                     graph->setGraphRange(range, true);
                                     // Removes the graph from the graph list if it is closed manually
                                     QObject::connect(graph, &VisualizationGraphWidget::destroyed,
                                                      [this, graph]() { m_CustomGraphs.removeAll(graph); });
                                     delete context; // removes the connection
                                 }
                             },
                             Qt::QueuedConnection);
                         QMetaObject::invokeMethod(&sqpApp->dataSourceController(),
                                                   "requestVariableFromProductIdKey", Qt::QueuedConnection,
                                                   Q_ARG(QString, productId));
                     }
                 }
                 void getSelectedItems(
                     QTreeView *treeView, QVector<std::shared_ptr<DBEvent> > &events,
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > &eventProducts)
                 {
                     for (auto rowIndex : treeView->selectionModel()->selectedRows()) {
                         auto itemType = m_Model->itemTypeOf(rowIndex);
                         if (itemType == CatalogueEventsModel::ItemType::Event) {
                             events << m_Model->getEvent(rowIndex);
                         }
                         else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
                             eventProducts << qMakePair(m_Model->getParentEvent(rowIndex),
                                                        m_Model->getEventProduct(rowIndex));
                         }
                     }
                 }
             };
             CatalogueEventsWidget::CatalogueEventsWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueEventsWidget),
                       impl{spimpl::make_unique_impl<CatalogueEventsWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->m_Model = new CatalogueEventsModel{this};
                 ui->treeView->setModel(impl->m_Model);
                 ui->treeView->setSortingEnabled(true);
                 ui->treeView->setDragDropMode(QAbstractItemView::DragDrop);
                 ui->treeView->setDragEnabled(true);
                 connect(ui->btnTime, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnChart->setChecked(false);
                         impl->m_ZonesForTimeMode
                             = impl->selectZone(this, impl->m_ZonesForTimeMode, true,
                                                this->mapToGlobal(ui->btnTime->frameGeometry().center()));
                         impl->updateForTimeMode(ui->treeView);
                     }
                 });
                 connect(ui->btnChart, &QToolButton::clicked, [this](auto checked) {
                     if (checked) {
                         ui->btnTime->setChecked(false);
                         impl->m_ZoneForGraphMode
                             = impl->selectZone(this, {impl->m_ZoneForGraphMode}, false,
                                                this->mapToGlobal(ui->btnChart->frameGeometry().center()))
                                   .value(0);
                         impl->updateForGraphMode(this);
                     }
                 });
                 connect(ui->btnRemove, &QToolButton::clicked, [this]() {
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                     impl->getSelectedItems(ui->treeView, events, eventProducts);
                     if (!events.isEmpty() && eventProducts.isEmpty()) {
                         auto canRemoveEvent
                             = !this->isAllEventsDisplayed()
                               || (QMessageBox::warning(
                                       this, tr("Remove Event(s)"),
                                       tr("The selected event(s) will be permanently removed "
                                          "from the repository!\nAre you sure you want to continue?"),
                                       QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
                                   == QMessageBox::Yes);
                         if (canRemoveEvent) {
                             for (auto event : events) {
                                 if (this->isAllEventsDisplayed()) {
                                     sqpApp->catalogueController().removeEvent(event);
                                     impl->removeEvent(event, ui->treeView);
                                 }
                                 else {
                                     QVector<std::shared_ptr<DBCatalogue> > modifiedCatalogues;
                                     for (auto catalogue : this->displayedCatalogues()) {
                                         if (catalogue->removeEvent(event->getUniqId())) {
                                             sqpApp->catalogueController().updateCatalogue(catalogue);
                                             modifiedCatalogues << catalogue;
                                         }
                                     }
                                     if (!modifiedCatalogues.empty()) {
                                         emit eventCataloguesModified(modifiedCatalogues);
                                     }
                                 }
                                 impl->m_Model->removeEvent(event);
                             }
                             emit this->eventsRemoved(events);
                         }
                     }
                 });
                 connect(ui->treeView, &QTreeView::clicked, this, &CatalogueEventsWidget::emitSelection);
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
                         &CatalogueEventsWidget::emitSelection);
                 ui->btnRemove->setEnabled(false); // Disabled by default when nothing is selected
                 connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, [this]() {
                     auto isNotMultiSelection = ui->treeView->selectionModel()->selectedRows().count() <= 1;
                     ui->btnChart->setEnabled(isNotMultiSelection);
                     ui->btnTime->setEnabled(isNotMultiSelection);
                     if (isNotMultiSelection && ui->btnTime->isChecked()) {
                         impl->updateForTimeMode(ui->treeView);
                     }
                     else if (isNotMultiSelection && ui->btnChart->isChecked()) {
                         impl->updateForGraphMode(this);
                     }
                     QVector<std::shared_ptr<DBEvent> > events;
                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                     impl->getSelectedItems(ui->treeView, events, eventProducts);
                     ui->btnRemove->setEnabled(!events.isEmpty() && eventProducts.isEmpty());
                 });
                 ui->treeView->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Tags,
                                                              QHeaderView::Stretch);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Validation,
                                                              QHeaderView::Fixed);
                 ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::Name,
                                                              QHeaderView::Interactive);
                 ui->treeView->header()->resizeSection((int)CatalogueEventsModel::Column::Validation,
                                                       VALIDATION_COLUMN_SIZE);
+                ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::TStart,
+                                                             QHeaderView::ResizeToContents);
+                ui->treeView->header()->setSectionResizeMode((int)CatalogueEventsModel::Column::TEnd,
+                                                             QHeaderView::ResizeToContents);
                 ui->treeView->header()->setSortIndicatorShown(true);
                 connect(impl->m_Model, &CatalogueEventsModel::modelSorted, [this]() {
                     auto allEvents = impl->m_Model->events();
                     for (auto event : allEvents) {
                         setEventChanges(event, sqpApp->catalogueController().eventHasChanges(event));
                     }
                 });
                 populateWithAllEvents();
             }
             CatalogueEventsWidget::~CatalogueEventsWidget()
             {
                 delete ui;
             }
             void CatalogueEventsWidget::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 impl->m_VisualizationWidget = visualization;
             }
             void CatalogueEventsWidget::addEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->addEvent(event, ui->treeView);
             }
             void CatalogueEventsWidget::setEventChanges(const std::shared_ptr<DBEvent> &event, bool hasChanges)
             {
                 impl->m_Model->refreshEvent(event);
                 auto eventIndex = impl->m_Model->indexOf(event);
                 auto validationIndex
                     = eventIndex.sibling(eventIndex.row(), (int)CatalogueEventsModel::Column::Validation);
                 if (validationIndex.isValid()) {
                     if (hasChanges) {
                         if (ui->treeView->indexWidget(validationIndex) == nullptr) {
                             auto widget = CatalogueExplorerHelper::buildValidationWidget(
                                 ui->treeView,
                                 [this, event]() {
                                     sqpApp->catalogueController().saveEvent(event);
                                     setEventChanges(event, false);
                                 },
                                 [this, event]() {
                                     bool removed = false;
                                     sqpApp->catalogueController().discardEvent(event, removed);
                                     if (removed) {
                                         impl->m_Model->removeEvent(event);
                                     }
                                     else {
                                         setEventChanges(event, false);
                                         impl->m_Model->refreshEvent(event, true);
                                     }
                                     emitSelection();
                                 });
                             ui->treeView->setIndexWidget(validationIndex, widget);
                         }
                     }
                     else {
                         // Note: the widget is destroyed
                         ui->treeView->setIndexWidget(validationIndex, nullptr);
                     }
                 }
                 else {
                     qCWarning(LOG_CatalogueEventsWidget())
                         << "setEventChanges: the event is not displayed in the model.";
                 }
             }
             QVector<std::shared_ptr<DBCatalogue> > CatalogueEventsWidget::displayedCatalogues() const
             {
                 return impl->m_DisplayedCatalogues;
             }
             bool CatalogueEventsWidget::isAllEventsDisplayed() const
             {
                 return impl->m_AllEventDisplayed;
             }
             bool CatalogueEventsWidget::isEventDisplayed(const std::shared_ptr<DBEvent> &event) const
             {
                 return impl->m_Model->indexOf(event).isValid();
             }
             void CatalogueEventsWidget::refreshEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->m_Model->refreshEvent(event, true);
             }
             void CatalogueEventsWidget::populateWithCatalogues(
                 const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
                 impl->m_DisplayedCatalogues = catalogues;
                 impl->m_AllEventDisplayed = false;
                 QSet<QUuid> eventIds;
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
                     auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
                         if (!eventIds.contains(event->getUniqId())) {
                             events << event;
                             eventIds.insert(event->getUniqId());
                         }
                     }
                 }
                 impl->setEvents(events, this);
             }
             void CatalogueEventsWidget::populateWithAllEvents()
             {
                 impl->m_DisplayedCatalogues.clear();
                 impl->m_AllEventDisplayed = true;
                 auto allEvents = sqpApp->catalogueController().retrieveAllEvents();
                 QVector<std::shared_ptr<DBEvent> > events;
                 for (auto event : allEvents) {
                     events << event;
                 }
                 impl->setEvents(events, this);
             }
             void CatalogueEventsWidget::clear()
             {
                 impl->m_DisplayedCatalogues.clear();
                 impl->m_AllEventDisplayed = false;
                 impl->setEvents({}, this);
             }
             void CatalogueEventsWidget::refresh()
             {
                 if (isAllEventsDisplayed()) {
                     populateWithAllEvents();
                 }
                 else if (!impl->m_DisplayedCatalogues.isEmpty()) {
                     populateWithCatalogues(impl->m_DisplayedCatalogues);
                 }
             }
             void CatalogueEventsWidget::emitSelection()
             {
                 QVector<std::shared_ptr<DBEvent> > events;
                 QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                 impl->getSelectedItems(ui->treeView, events, eventProducts);
                 if (!events.isEmpty() && eventProducts.isEmpty()) {
                     emit eventsSelected(events);
                 }
                 else if (events.isEmpty() && !eventProducts.isEmpty()) {
                     emit eventProductsSelected(eventProducts);
                 }
                 else {
                     emit selectionCleared();
                 }
             }
             void CatalogueEventsWidget::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Delete: {
                         ui->btnRemove->click();
                     }
                     default:
                         break;
                 }
             }

gui/src/Catalogue/CatalogueInspectorWidget.cpp +3 0

             #include "Catalogue/CatalogueInspectorWidget.h"
             #include "ui_CatalogueInspectorWidget.h"
             #include <Common/DateUtils.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             struct CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate {
                 std::shared_ptr<DBCatalogue> m_DisplayedCatalogue = nullptr;
                 std::shared_ptr<DBEvent> m_DisplayedEvent = nullptr;
                 std::shared_ptr<DBEventProduct> m_DisplayedEventProduct = nullptr;
                 void connectCatalogueUpdateSignals(CatalogueInspectorWidget *inspector,
                                                    Ui::CatalogueInspectorWidget *ui);
                 void connectEventUpdateSignals(CatalogueInspectorWidget *inspector,
                                                Ui::CatalogueInspectorWidget *ui);
             };
             CatalogueInspectorWidget::CatalogueInspectorWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueInspectorWidget),
                       impl{spimpl::make_unique_impl<CatalogueInspectorWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 showPage(Page::Empty);
                 impl->connectCatalogueUpdateSignals(this, ui);
                 impl->connectEventUpdateSignals(this, ui);
+                ui->dateTimeEventTStart->setDisplayFormat(DATETIME_FORMAT);
+                ui->dateTimeEventTEnd->setDisplayFormat(DATETIME_FORMAT);
             }
             CatalogueInspectorWidget::~CatalogueInspectorWidget()
             {
                 delete ui;
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectCatalogueUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leCatalogueName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueName->text() != m_DisplayedCatalogue->getName()) {
                         m_DisplayedCatalogue->setName(ui->leCatalogueName->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
                 connect(ui->leCatalogueAuthor, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueAuthor->text() != m_DisplayedCatalogue->getAuthor()) {
                         m_DisplayedCatalogue->setAuthor(ui->leCatalogueAuthor->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectEventUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leEventName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventName->text() != m_DisplayedEvent->getName()) {
                         m_DisplayedEvent->setName(ui->leEventName->text());
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     auto tags = ui->leEventTags->text().split(QRegExp("\\s+"), QString::SkipEmptyParts);
                     std::list<QString> tagNames;
                     for (auto tag : tags) {
                         tagNames.push_back(tag);
                     }
                     if (m_DisplayedEvent->getTagsNames() != tagNames) {
                         m_DisplayedEvent->setTagsNames(tagNames);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventProduct->text() != m_DisplayedEventProduct->getProductId()) {
                         auto oldProductId = m_DisplayedEventProduct->getProductId();
                         m_DisplayedEventProduct->setProductId(ui->leEventProduct->text());
                         auto eventProducts = m_DisplayedEvent->getEventProducts();
                         for (auto &eventProduct : eventProducts) {
                             if (eventProduct.getProductId() == oldProductId) {
                                 eventProduct.setProductId(m_DisplayedEventProduct->getProductId());
                             }
                         }
                         m_DisplayedEvent->setEventProducts(eventProducts);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
                     if (time != m_DisplayedEventProduct->getTStart()) {
                         m_DisplayedEventProduct->setTStart(time);
                         auto eventProducts = m_DisplayedEvent->getEventProducts();
                         for (auto &eventProduct : eventProducts) {
                             if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
                                 eventProduct.setTStart(m_DisplayedEventProduct->getTStart());
                             }
                         }
                         m_DisplayedEvent->setEventProducts(eventProducts);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
                     if (time != m_DisplayedEventProduct->getTEnd()) {
                         m_DisplayedEventProduct->setTEnd(time);
                         auto eventProducts = m_DisplayedEvent->getEventProducts();
                         for (auto &eventProduct : eventProducts) {
                             if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
                                 eventProduct.setTEnd(m_DisplayedEventProduct->getTEnd());
                             }
                         }
                         m_DisplayedEvent->setEventProducts(eventProducts);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
             }
             void CatalogueInspectorWidget::showPage(CatalogueInspectorWidget::Page page)
             {
                 ui->stackedWidget->setCurrentIndex(static_cast<int>(page));
             }
             CatalogueInspectorWidget::Page CatalogueInspectorWidget::currentPage() const
             {
                 return static_cast<Page>(ui->stackedWidget->currentIndex());
             }
             void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->m_DisplayedEvent = event;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setEnabled(true);
                 ui->leEventName->setText(event->getName());
                 ui->leEventProduct->setEnabled(false);
                 auto eventProducts = event->getEventProducts();
                 QStringList eventProductList;
                 for (auto evtProduct : eventProducts) {
                     eventProductList << evtProduct.getProductId();
                 }
                 ui->leEventProduct->setText(eventProductList.join(";"));
                 QString tagList;
                 auto tags = event->getTagsNames();
                 for (auto tag : tags) {
                     tagList += tag;
                     tagList += ' ';
                 }
                 ui->leEventTags->setEnabled(true);
                 ui->leEventTags->setText(tagList);
                 ui->dateTimeEventTStart->setEnabled(false);
                 ui->dateTimeEventTEnd->setEnabled(false);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setEventProduct(const std::shared_ptr<DBEvent> &event,
                                                            const std::shared_ptr<DBEventProduct> &eventProduct)
             {
                 impl->m_DisplayedEvent = event;
                 impl->m_DisplayedEventProduct = eventProduct;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setEnabled(false);
                 ui->leEventName->setText(event->getName());
                 ui->leEventProduct->setEnabled(false);
                 ui->leEventProduct->setText(eventProduct->getProductId());
                 ui->leEventTags->setEnabled(false);
                 ui->leEventTags->clear();
                 ui->dateTimeEventTStart->setEnabled(true);
                 ui->dateTimeEventTEnd->setEnabled(true);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(eventProduct->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(eventProduct->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
             {
                 impl->m_DisplayedCatalogue = catalogue;
                 blockSignals(true);
                 showPage(Page::CatalogueProperties);
                 ui->leCatalogueName->setText(catalogue->getName());
                 ui->leCatalogueAuthor->setText(catalogue->getAuthor());
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::refresh()
             {
                 switch (static_cast<Page>(ui->stackedWidget->currentIndex())) {
                     case Page::CatalogueProperties:
                         setCatalogue(impl->m_DisplayedCatalogue);
                         break;
                     case Page::EventProperties: {
                         auto isEventShowed = ui->leEventName->isEnabled();
                         setEvent(impl->m_DisplayedEvent);
                         if (!isEventShowed && impl->m_DisplayedEvent) {
                             setEventProduct(impl->m_DisplayedEvent, impl->m_DisplayedEventProduct);
                         }
                     }
                 }
             }

gui/src/Visualization/AxisRenderingUtils.cpp 0 -2

             #include "Visualization/AxisRenderingUtils.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Variable/Variable.h>
             #include <Visualization/SqpColorScale.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_AxisRenderingUtils, "AxisRenderingUtils")
             namespace {
-            const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             const auto NUMBER_FORMAT = 'g';
             const auto NUMBER_PRECISION = 9;
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis, QCPAxis::ScaleType scaleType)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else if (scaleType == QCPAxis::stLogarithmic) {
                     return QSharedPointer<QCPAxisTickerLog>::create();
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             /**
              * Sets properties of the axis passed as parameter
              * @param axis the axis to set
              * @param unit the unit to set for the axis
              * @param scaleType the scale type to set for the axis
              */
             void setAxisProperties(QCPAxis &axis, const Unit &unit,
                                    QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
             {
                 // label (unit name)
                 axis.setLabel(unit.m_Name);
                 // scale type
                 axis.setScaleType(scaleType);
                 if (scaleType == QCPAxis::stLogarithmic) {
                     // Scientific notation
                     axis.setNumberPrecision(0);
                     axis.setNumberFormat("eb");
                 }
                 // ticker (depending on the type of unit)
                 axis.setTicker(axisTicker(unit.m_TimeUnit, scaleType));
             }
             /**
              * Delegate used to set axes properties
              */
             template <typename T, typename Enabled = void>
             struct AxisSetter {
                 static void setProperties(QCustomPlot &, SqpColorScale &)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                 }
                 static void setUnits(T &, QCustomPlot &, SqpColorScale &)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis units: unmanaged type of data";
                 }
             };
             /**
              * Specialization of AxisSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                            or std::is_base_of<VectorSeries, T>::value> > {
                 static void setProperties(QCustomPlot &, SqpColorScale &)
                 {
                     // Nothing to do
                 }
                 static void setUnits(T &dataSeries, QCustomPlot &plot, SqpColorScale &)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, valuesUnit);
                 }
             };
             /**
              * Specialization of AxisSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setProperties(QCustomPlot &plot, SqpColorScale &colorScale)
                 {
                     // Displays color scale in plot
                     plot.plotLayout()->insertRow(0);
                     plot.plotLayout()->addElement(0, 0, colorScale.m_Scale);
                     colorScale.m_Scale->setType(QCPAxis::atTop);
                     colorScale.m_Scale->setMinimumMargins(QMargins{0, 0, 0, 0});
                     // Aligns color scale with axes
                     auto marginGroups = plot.axisRect()->marginGroups();
                     for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it) {
                         colorScale.m_Scale->setMarginGroup(it.key(), it.value());
                     }
                     // Set color scale properties
                     colorScale.m_AutomaticThreshold = true;
                 }
                 static void setUnits(T &dataSeries, QCustomPlot &plot, SqpColorScale &colorScale)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     auto yAxisUnit = dataSeries.yAxisUnit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
                     setAxisProperties(*colorScale.m_Scale->axis(), valuesUnit, QCPAxis::stLogarithmic);
                 }
             };
             /**
              * Default implementation of IAxisHelper, which takes data series to set axes properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct AxisHelper : public IAxisHelper {
                 explicit AxisHelper(std::shared_ptr<T> dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(QCustomPlot &plot, SqpColorScale &colorScale) override
                 {
                     AxisSetter<T>::setProperties(plot, colorScale);
                 }
                 void setUnits(QCustomPlot &plot, SqpColorScale &colorScale) override
                 {
                     if (m_DataSeries) {
                         AxisSetter<T>::setUnits(*m_DataSeries, plot, colorScale);
                     }
                     else {
                         qCCritical(LOG_AxisRenderingUtils()) << "Can't set units: inconsistency between the "
                                                                 "type of data series and the type supposed";
                     }
                 }
                 std::shared_ptr<T> m_DataSeries;
             };
             } // namespace
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
                 if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
                     return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
                 }
                 else {
                     return QString::number(value, NUMBER_FORMAT, NUMBER_PRECISION);
                 }
             }
             std::unique_ptr<IAxisHelper> IAxisHelperFactory::create(const Variable &variable) noexcept
             {
                 switch (variable.type()) {
                     case DataSeriesType::SCALAR:
                         return std::make_unique<AxisHelper<ScalarSeries> >(
                             std::dynamic_pointer_cast<ScalarSeries>(variable.dataSeries()));
                     case DataSeriesType::SPECTROGRAM:
                         return std::make_unique<AxisHelper<SpectrogramSeries> >(
                             std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()));
                     case DataSeriesType::VECTOR:
                         return std::make_unique<AxisHelper<VectorSeries> >(
                             std::dynamic_pointer_cast<VectorSeries>(variable.dataSeries()));
                     default:
                         // Creates default helper
                         break;
                 }
                 return std::make_unique<AxisHelper<IDataSeries> >(nullptr);
             }

gui/src/Visualization/VisualizationMultiZoneSelectionDialog.cpp +3 -3

             #include "Visualization/VisualizationMultiZoneSelectionDialog.h"
             #include "ui_VisualizationMultiZoneSelectionDialog.h"
             #include "Common/DateUtils.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
-            const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss");
+            const auto DATETIME_FORMAT_S = QStringLiteral("yyyy/MM/dd hh:mm:ss");
             struct VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialogPrivate {
                 QVector<VisualizationSelectionZoneItem *> m_Zones;
             };
             VisualizationMultiZoneSelectionDialog::VisualizationMultiZoneSelectionDialog(QWidget *parent)
                     : QDialog(parent, Qt::Tool),
                       ui(new Ui::VisualizationMultiZoneSelectionDialog),
                       impl{spimpl::make_unique_impl<VisualizationMultiZoneSelectionDialogPrivate>()}
             {
                 ui->setupUi(this);
                 connect(ui->buttonBox, &QDialogButtonBox::accepted, this,
                         &VisualizationMultiZoneSelectionDialog::accept);
                 connect(ui->buttonBox, &QDialogButtonBox::rejected, this,
                         &VisualizationMultiZoneSelectionDialog::reject);
             }
             VisualizationMultiZoneSelectionDialog::~VisualizationMultiZoneSelectionDialog()
             {
                 delete ui;
             }
             void VisualizationMultiZoneSelectionDialog::setZones(
                 const QVector<VisualizationSelectionZoneItem *> &zones)
             {
                 impl->m_Zones = zones;
                 // Sorts the zones to display them in temporal order
                 std::sort(impl->m_Zones.begin(), impl->m_Zones.end(), [](auto zone1, auto zone2) {
                     return zone1->range().m_TStart < zone2->range().m_TStart;
                 });
                 // Adds the zones in the listwidget
                 for (auto zone : impl->m_Zones) {
                     auto name = zone->name();
                     if (!name.isEmpty()) {
                         name += tr(": ");
                     }
                     auto range = zone->range();
-                    name += DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT);
+                    name += DateUtils::dateTime(range.m_TStart).toString(DATETIME_FORMAT_S);
                     name += " - ";
-                    name += DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT);
+                    name += DateUtils::dateTime(range.m_TEnd).toString(DATETIME_FORMAT_S);
                     auto item = new QListWidgetItem(name, ui->listWidget);
                     item->setSelected(zone->selected());
                 }
             }
             QMap<VisualizationSelectionZoneItem *, bool>
             VisualizationMultiZoneSelectionDialog::selectedZones() const
             {
                 QMap<VisualizationSelectionZoneItem *, bool> selectedZones;
                 for (auto i = 0; i < ui->listWidget->count(); ++i) {
                     auto item = ui->listWidget->item(i);
                     selectedZones[impl->m_Zones[i]] = item->isSelected();
                 }
                 return selectedZones;
             }

gui/ui/Catalogue/CatalogueEventsWidget.ui 0 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>CatalogueEventsWidget</class>
              <widget class="QWidget" name="CatalogueEventsWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>566</width>
                 <height>258</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <property name="leftMargin">
                 <number>0</number>
                </property>
                <property name="topMargin">
                 <number>0</number>
                </property>
                <property name="rightMargin">
                 <number>0</number>
                </property>
                <property name="bottomMargin">
                 <number>0</number>
                </property>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout">
                  <item>
                   <widget class="QToolButton" name="btnAdd">
                    <property name="enabled">
                     <bool>false</bool>
                    </property>
                    <property name="text">
                     <string>+</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/add.png</normaloff>:/icones/add.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnRemove">
                    <property name="text">
                     <string> - </string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/remove.png</normaloff>:/icones/remove.png</iconset>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="Line" name="line">
                    <property name="orientation">
                     <enum>Qt::Vertical</enum>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnTime">
                    <property name="text">
                     <string>T</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/time.png</normaloff>:/icones/time.png</iconset>
                    </property>
                    <property name="checkable">
                     <bool>true</bool>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="btnChart">
                    <property name="text">
                     <string>G</string>
                    </property>
                    <property name="icon">
                     <iconset resource="../../resources/sqpguiresources.qrc">
                      <normaloff>:/icones/chart.png</normaloff>:/icones/chart.png</iconset>
                    </property>
                    <property name="checkable">
                     <bool>true</bool>
                    </property>
                    <property name="autoRaise">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="Line" name="line_2">
                    <property name="orientation">
                     <enum>Qt::Vertical</enum>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QLineEdit" name="lineEdit">
                    <property name="enabled">
                     <bool>false</bool>
                    </property>
                   </widget>
                  </item>
                 </layout>
                </item>
                <item>
                 <widget class="QTreeView" name="treeView">
                  <property name="dragEnabled">
                   <bool>true</bool>
                  </property>
                  <property name="dragDropMode">
                   <enum>QAbstractItemView::DragDrop</enum>
                  </property>
                  <property name="selectionMode">
                   <enum>QAbstractItemView::ExtendedSelection</enum>
                  </property>
                  <property name="selectionBehavior">
                   <enum>QAbstractItemView::SelectRows</enum>
                  </property>
                  <attribute name="headerStretchLastSection">
                   <bool>false</bool>
                  </attribute>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources>
               <include location="../../resources/sqpguiresources.qrc"/>
-              <include location="../../resources/sqpguiresources.qrc"/>
              </resources>
              <connections/>
             </ui>

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