HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1150:ecfb65cac0fa

Edition of event products via the inspector

trabillard -

r1150:ecfb65cac0fa

parent child

Context file:

r1150:ecfb65cac0fa

gui/include/Catalogue/CatalogueEventsModel.h +9 -5

              #include <QAbstractItemModel>
              class DBEvent;
+             class DBEventProduct;
              class CatalogueEventsModel : public QAbstractItemModel {
              public:
                  CatalogueEventsModel(QObject *parent = nullptr);
                  void setEvents(const QVector<std::shared_ptr<DBEvent> > &events);
-                 std::shared_ptr<DBEvent> getEvent(int row) const;
                  void addEvent(const std::shared_ptr<DBEvent> &event);
                  void removeEvent(const std::shared_ptr<DBEvent> &event);
+                 enum class ItemType { Root, Event, EventProduct };
+                 ItemType itemTypeOf(const QModelIndex &index) const;
+                 std::shared_ptr<DBEvent> getEvent(const QModelIndex &index) const;
+                 std::shared_ptr<DBEvent> getParentEvent(const QModelIndex &index) const;
+                 std::shared_ptr<DBEventProduct> getEventProduct(const QModelIndex &index) const;
                  void refreshEvent(const std::shared_ptr<DBEvent> &event);
                  // Model
                  QMimeData *mimeData(const QModelIndexList &indexes) const override;
              private:
-                 class CatalogueEventsTableModelPrivate;
-                 spimpl::unique_impl_ptr<CatalogueEventsTableModelPrivate> impl;
+                 class CatalogueEventsModelPrivate;
+                 spimpl::unique_impl_ptr<CatalogueEventsModelPrivate> impl;
              };
              #endif // SCIQLOP_CATALOGUEEVENTSMODEL_H

gui/include/Catalogue/CatalogueEventsWidget.h +5 0

              class DBCatalogue;
              class DBEvent;
+             class DBEventProduct;
              class VisualizationWidget;
              namespace Ui {
              signals:
                  void eventsSelected(const QVector<std::shared_ptr<DBEvent> > &event);
+                 void eventProductsSelected(
+                     const QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > >
+                         &eventproducts);
+                 void selectionCleared();
              public:
                  explicit CatalogueEventsWidget(QWidget *parent = 0);

gui/include/Catalogue/CatalogueInspectorWidget.h +5 0

              class DBCatalogue;
              class DBEvent;
+             class DBEventProduct;
              class CatalogueInspectorWidget : public QWidget {
                  Q_OBJECT
              signals:
                  void catalogueUpdated(const std::shared_ptr<DBCatalogue> &catalogue);
                  void eventUpdated(const std::shared_ptr<DBEvent> &event);
+                 void eventProductUpdated(const std::shared_ptr<DBEvent> &event,
+                                          const std::shared_ptr<DBEventProduct> &eventProduct);
              public:
                  explicit CatalogueInspectorWidget(QWidget *parent = 0);
                  Page currentPage() const;
                  void setEvent(const std::shared_ptr<DBEvent> &event);
+                 void setEventProduct(const std::shared_ptr<DBEvent> &event,
+                                      const std::shared_ptr<DBEventProduct> &eventProduct);
                  void setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue);
              public slots:

gui/src/Catalogue/CatalogueEventsModel.cpp +74 -50

              const auto EVENT_ITEM_TYPE = 1;
              const auto EVENT_PRODUCT_ITEM_TYPE = 2;
-             struct CatalogueEventsModel::CatalogueEventsTableModelPrivate {
+             struct CatalogueEventsModel::CatalogueEventsModelPrivate {
                  QVector<std::shared_ptr<DBEvent> > m_Events;
                  std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts;
                      Q_ASSERT(false);
                      return QStringLiteral("Unknown Data");
                  }
-                 enum class ItemType { Root, Event, EventProduct };
-                 ItemType indexItemType(const QModelIndex &index) const
+                 {
-                     if (!index.isValid()) {
-                         return ItemType::Root;
+                     }
-                     else if (index.internalPointer() == nullptr) {
-                         return ItemType::Event;
+                     }
-                     else {
-                         return ItemType::EventProduct;
+                     }
+                 }
-                 std::shared_ptr<DBEventProduct> getEventProduct(const QModelIndex &index)
+                 {
-                     auto event = static_cast<DBEvent *>(index.internalPointer());
-                     return m_EventProducts.at(event).value(index.row());
+                 }
              };
              CatalogueEventsModel::CatalogueEventsModel(QObject *parent)
-                     : QAbstractItemModel(parent),
-                       impl{spimpl::make_unique_impl<CatalogueEventsTableModelPrivate>()}
+                     : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()}
              {
              }
                  beginResetModel();
                  impl->m_Events = events;
+                 impl->m_EventProducts.clear();
                  for (auto event : events) {
                      impl->parseEventProduct(event);
                  }
                  endResetModel();
              }
-             std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(int row) const
+             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
              {
-                 return impl->m_Events.value(row);
+                 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)
              void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event)
              {
-                 auto eventIndex = impl->m_Events.indexOf(event);
-                 if (eventIndex >= 0) {
-                     emit dataChanged(index(eventIndex, 0), index(eventIndex, columnCount()));
+                 auto i = impl->m_Events.indexOf(event);
+                 if (i >= 0) {
+                     auto eventIndex = index(i, 0);
+                     auto colCount = columnCount();
+                     emit dataChanged(eventIndex, index(i, colCount));
+                     auto childCount = rowCount(eventIndex);
+                     emit dataChanged(index(0, 0, eventIndex), index(childCount, colCount, eventIndex));
                  }
              }
                      return QModelIndex();
                  }
-                 switch (impl->indexItemType(parent)) {
-                     case CatalogueEventsTableModelPrivate::ItemType::Root:
+                 switch (itemTypeOf(parent)) {
+                     case CatalogueEventsModel::ItemType::Root:
                          return createIndex(row, column);
-                     case CatalogueEventsTableModelPrivate::ItemType::Event: {
-                         auto event = getEvent(parent.row());
+                     case CatalogueEventsModel::ItemType::Event: {
+                         auto event = getEvent(parent);
                          return createIndex(row, column, event.get());
                      }
-                     case CatalogueEventsTableModelPrivate::ItemType::EventProduct:
+                     case CatalogueEventsModel::ItemType::EventProduct:
                          break;
                      default:
                          break;
              QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const
              {
-                 switch (impl->indexItemType(index)) {
-                     case CatalogueEventsTableModelPrivate::ItemType::EventProduct: {
+                 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(),
                              return QModelIndex();
                          }
                      }
-                     case CatalogueEventsTableModelPrivate::ItemType::Root:
+                     case CatalogueEventsModel::ItemType::Root:
                          break;
-                     case CatalogueEventsTableModelPrivate::ItemType::Event:
+                     case CatalogueEventsModel::ItemType::Event:
                          break;
                      default:
                          break;
                      return 0;
                  }
-                 switch (impl->indexItemType(parent)) {
-                     case CatalogueEventsTableModelPrivate::ItemType::Root:
+                 switch (itemTypeOf(parent)) {
+                     case CatalogueEventsModel::ItemType::Root:
                          return impl->m_Events.count();
-                     case CatalogueEventsTableModelPrivate::ItemType::Event: {
-                         auto event = getEvent(parent.row());
+                     case CatalogueEventsModel::ItemType::Event: {
+                         auto event = getEvent(parent);
                          return impl->m_EventProducts[event.get()].count();
                      }
-                     case CatalogueEventsTableModelPrivate::ItemType::EventProduct:
+                     case CatalogueEventsModel::ItemType::EventProduct:
                          break;
                      default:
                          break;
              int CatalogueEventsModel::columnCount(const QModelIndex &parent) const
              {
-                 return static_cast<int>(CatalogueEventsTableModelPrivate::Column::NbColumn);
+                 return static_cast<int>(CatalogueEventsModelPrivate::Column::NbColumn);
              }
              Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const
              {
                  if (index.isValid()) {
-                     auto type = impl->indexItemType(index);
-                     if (type == CatalogueEventsTableModelPrivate::ItemType::Event) {
-                         auto event = getEvent(index.row());
+                     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 == CatalogueEventsTableModelPrivate::ItemType::EventProduct) {
-                         auto product = impl->getEventProduct(index);
+                     else if (type == CatalogueEventsModel::ItemType::EventProduct) {
+                         auto product = getEventProduct(index);
                          switch (role) {
                              case Qt::DisplayRole:
                                  return impl->eventProductData(index.column(), product);
                  SqpRange firstTimeRange;
                  for (const auto &index : indexes) {
                      if (index.column() == 0) { // only the first column
-                         auto event = getEvent(index.row());
+                         auto event = getEvent(index);
                          if (eventList.isEmpty()) {
                              // Gets the range of the first variable
                              // firstTimeRange.m_TStart = event->getTStart();
                  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 +22 -4

                      auto selectedRows = treeView->selectionModel()->selectedRows();
                      if (selectedRows.count() == 1) {
-                         auto event = m_Model->getEvent(selectedRows.first().row());
+                         auto event = m_Model->getEvent(selectedRows.first());
                          if (m_VisualizationWidget) {
                              if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                      auto selectedRows = treeView->selectionModel()->selectedRows();
                      if (selectedRows.count() == 1) {
-                         auto event = m_Model->getEvent(selectedRows.first().row());
+                         auto event = m_Model->getEvent(selectedRows.first());
                          if (m_VisualizationWidget) {
                              if (auto tab = m_VisualizationWidget->currentTabWidget()) {
                                  if (auto zone = tab->getZoneWithName(m_ZoneForGraphMode)) {
                  auto emitSelection = [this]() {
                      QVector<std::shared_ptr<DBEvent> > events;
+                     QVector<QPair<std::shared_ptr<DBEvent>, std::shared_ptr<DBEventProduct> > > eventProducts;
                      for (auto rowIndex : ui->treeView->selectionModel()->selectedRows()) {
-                         events << impl->m_Model->getEvent(rowIndex.row());
+                         auto itemType = impl->m_Model->itemTypeOf(rowIndex);
+                         if (itemType == CatalogueEventsModel::ItemType::Event) {
+                             events << impl->m_Model->getEvent(rowIndex);
+                         }
+                         else if (itemType == CatalogueEventsModel::ItemType::EventProduct) {
+                             eventProducts << qMakePair(impl->m_Model->getParentEvent(rowIndex),
+                                                        impl->m_Model->getEventProduct(rowIndex));
+                         }
                      }
-                     emit this->eventsSelected(events);
+                     if (!events.isEmpty() && eventProducts.isEmpty()) {
+                         emit this->eventsSelected(events);
+                     }
+                     else if (events.isEmpty() && !eventProducts.isEmpty()) {
+                         emit this->eventProductsSelected(eventProducts);
+                     }
+                     else {
+                         emit this->selectionCleared();
+                     }
                  };
                  connect(ui->treeView, &QTreeView::clicked, emitSelection);

gui/src/Catalogue/CatalogueExplorer.cpp +16 0

                      }
                  });
+                 connect(ui->events, &CatalogueEventsWidget::eventProductsSelected, [this](auto eventProducts) {
+                     if (eventProducts.count() == 1) {
+                         ui->inspector->setEventProduct(eventProducts.first().first,
+                                                        eventProducts.first().second);
+                     }
+                     else {
+                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
+                     }
+                 });
+                 connect(ui->events, &CatalogueEventsWidget::selectionCleared,
+                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
                  connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated,
                          [this](auto catalogue) { ui->catalogues->setCatalogueChanges(catalogue, true); });
                  connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated,
                          [this](auto event) { ui->events->setEventChanges(event, true); });
+                 connect(ui->inspector, &CatalogueInspectorWidget::eventProductUpdated,
+                         [this](auto event, auto eventProduct) { ui->events->setEventChanges(event, true); });
              }
              CatalogueExplorer::~CatalogueExplorer()

gui/src/Catalogue/CatalogueInspectorWidget.cpp +49 -23

              #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);
                      }
                  });
-                 connect(ui->leEventMission, &QLineEdit::editingFinished, [ui, inspector, this]() {
-                     //        if (ui->leEventMission->text() != m_DisplayedEvent->getMission()) {
-                     //            m_DisplayedEvent->setMission(ui->leEventMission->text());
-                     //            emit inspector->eventUpdated(m_DisplayedEvent);
-                     //        }
-                 });
                  connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
-                     //        if (ui->leEventProduct->text() != m_DisplayedEvent->getProduct()) {
-                     //            m_DisplayedEvent->setProduct(ui->leEventProduct->text());
-                     //            emit inspector->eventUpdated(m_DisplayedEvent);
-                     //        }
+                     if (ui->leEventProduct->text() != m_DisplayedEventProduct->getProductId()) {
+                         m_DisplayedEventProduct->setProductId(ui->leEventProduct->text());
+                         emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                     }
                  });
                  connect(ui->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
                  });
                  connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
-                     //        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
-                     //        if (time != m_DisplayedEvent->getTStart()) {
-                     //            m_DisplayedEvent->setTStart(time);
-                     //            emit inspector->eventUpdated(m_DisplayedEvent);
-                     //        }
+                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
+                     if (time != m_DisplayedEventProduct->getTStart()) {
+                         m_DisplayedEventProduct->setTStart(time);
+                         emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                     }
                  });
                  connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
-                     //        auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
-                     //        if (time != m_DisplayedEvent->getTEnd()) {
-                     //            m_DisplayedEvent->setTEnd(time);
-                     //            emit inspector->eventUpdated(m_DisplayedEvent);
-                     //        }
+                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
+                     if (time != m_DisplayedEventProduct->getTEnd()) {
+                         m_DisplayedEventProduct->setTEnd(time);
+                         emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                     }
                  });
              }
                  blockSignals(true);
                  showPage(Page::EventProperties);
+                 ui->leEventName->setEnabled(true);
                  ui->leEventName->setText(event->getName());
-                 //    ui->leEventMission->setText(event->getMission());
-                 //    ui->leEventProduct->setText(event->getProduct());
+                 ui->leEventProduct->setEnabled(false);
+                 ui->leEventProduct->setText(
+                     QString::number(event->getEventProducts().size()).append(" product(s)"));
                  QString tagList;
                  auto tags = event->getTags();
                      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_DisplayedEventProduct = eventProduct;
+                 blockSignals(true);
+                 showPage(Page::EventProperties);
+                 ui->leEventName->setEnabled(false);
+                 ui->leEventName->setText(event->getName());
+                 ui->leEventProduct->setEnabled(true);
+                 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;

gui/ui/Catalogue/CatalogueEventsWidget.ui +3 0

                   <property name="dragDropMode">
                    <enum>QAbstractItemView::DragDrop</enum>
                   </property>
+                  <property name="selectionMode">
+                   <enum>QAbstractItemView::ExtendedSelection</enum>
+                  </property>
                   <property name="selectionBehavior">
                    <enum>QAbstractItemView::SelectRows</enum>
                   </property>

gui/ui/Catalogue/CatalogueInspectorWidget.ui +53 -56

                    <item>
                     <widget class="QStackedWidget" name="stackedWidget">
                      <property name="currentIndex">
-                      <number>1</number>
+                      <number>2</number>
                      </property>
                      <widget class="QWidget" name="emptyPage"/>
                      <widget class="QWidget" name="catalogueInspectorPage">
                      </widget>
                      <widget class="QWidget" name="eventInspectorPage">
                       <layout class="QGridLayout" name="gridLayout">
-                       <item row="5" column="1">
-                        <widget class="QDateTimeEdit" name="dateTimeEventTEnd">
-                         <property name="timeSpec">
-                          <enum>Qt::UTC</enum>
+                       <item row="4" column="0">
+                        <widget class="QLabel" name="label_3">
+                         <property name="text">
+                          <string>Product</string>
                          </property>
                         </widget>
                        </item>
-                       <item row="4" column="0">
+                       <item row="5" column="0">
                         <widget class="QLabel" name="label_4">
                          <property name="text">
                           <string>TStart</string>
                          </property>
                         </widget>
                        </item>
-                       <item row="6" column="0">
-                        <widget class="QLabel" name="label_6">
+                       <item row="1" column="0">
+                        <widget class="QLabel" name="label">
                          <property name="text">
-                          <string>Tags</string>
+                          <string>Name</string>
                          </property>
                         </widget>
                        </item>
-                       <item row="3" column="0">
-                        <widget class="QLabel" name="label_3">
+                       <item row="0" column="0" colspan="2">
+                        <widget class="QLabel" name="label_10">
+                         <property name="font">
+                          <font>
+                           <pointsize>10</pointsize>
+                           <weight>75</weight>
+                           <bold>true</bold>
+                          </font>
+                         </property>
                          <property name="text">
-                          <string>Product</string>
+                          <string>Event Properties</string>
                          </property>
                         </widget>
                        </item>
-                       <item row="3" column="1">
-                        <widget class="QLineEdit" name="leEventProduct"/>
-                       </item>
-                       <item row="5" column="0">
-                        <widget class="QLabel" name="label_5">
-                         <property name="text">
-                          <string>Tend</string>
+                       <item row="8" column="1">
+                        <spacer name="verticalSpacer">
+                         <property name="orientation">
+                          <enum>Qt::Vertical</enum>
                          </property>
-                        </widget>
+                         <property name="sizeHint" stdset="0">
+                          <size>
+                           <width>20</width>
+                           <height>40</height>
+                          </size>
+                         </property>
+                        </spacer>
                        </item>
-                       <item row="4" column="1">
+                       <item row="1" column="1">
+                        <widget class="QLineEdit" name="leEventName"/>
+                       </item>
+                       <item row="5" column="1">
                         <widget class="QDateTimeEdit" name="dateTimeEventTStart">
                          <property name="timeSpec">
                           <enum>Qt::UTC</enum>
                          </property>
                         </widget>
                        </item>
-                       <item row="2" column="0">
-                        <widget class="QLabel" name="label_2">
+                       <item row="4" column="1">
+                        <widget class="QLineEdit" name="leEventProduct"/>
+                       </item>
+                       <item row="6" column="0">
+                        <widget class="QLabel" name="label_5">
                          <property name="text">
-                          <string>Mission</string>
+                          <string>Tend</string>
                          </property>
                         </widget>
                        </item>
-                       <item row="1" column="1">
-                        <widget class="QLineEdit" name="leEventName"/>
-                       </item>
-                       <item row="1" column="0">
-                        <widget class="QLabel" name="label">
-                         <property name="text">
-                          <string>Name</string>
+                       <item row="6" column="1">
+                        <widget class="QDateTimeEdit" name="dateTimeEventTEnd">
+                         <property name="timeSpec">
+                          <enum>Qt::UTC</enum>
                          </property>
                         </widget>
                        </item>
                        <item row="2" column="1">
-                        <widget class="QLineEdit" name="leEventMission"/>
-                       </item>
-                       <item row="6" column="1">
                         <widget class="QLineEdit" name="leEventTags"/>
                        </item>
-                       <item row="7" column="1">
-                        <spacer name="verticalSpacer">
-                         <property name="orientation">
-                          <enum>Qt::Vertical</enum>
-                         </property>
-                         <property name="sizeHint" stdset="0">
-                          <size>
-                           <width>20</width>
-                           <height>40</height>
-                          </size>
+                       <item row="2" column="0">
+                        <widget class="QLabel" name="label_6">
+                         <property name="text">
+                          <string>Tags</string>
                          </property>
-                        </spacer>
+                        </widget>
                        </item>
-                       <item row="0" column="0" colspan="2">
-                        <widget class="QLabel" name="label_10">
-                         <property name="font">
-                          <font>
-                           <pointsize>10</pointsize>
-                           <weight>75</weight>
-                           <bold>true</bold>
-                          </font>
-                         </property>
-                         <property name="text">
-                          <string>Event Properties</string>
+                       <item row="3" column="0" colspan="2">
+                        <widget class="Line" name="line">
+                         <property name="orientation">
+                          <enum>Qt::Horizontal</enum>
                          </property>
                         </widget>
                        </item>

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