|
|
/*
|
|
|
This file is part of SciQLop.
|
|
|
|
|
|
SciQLop is free software: you can redistribute it and/or modify
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
(at your option) any later version.
|
|
|
|
|
|
SciQLop is distributed in the hope that it will be useful,
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
along with SciQLop. If not, see <https://www.gnu.org/licenses/>.
|
|
|
*/
|
|
|
#include "Catalogue2/eventsmodel.h"
|
|
|
#include <Common/containers.h>
|
|
|
#include <SqpApplication.h>
|
|
|
|
|
|
EventsModel::EventsModel(QObject* parent) : QAbstractItemModel(parent) {}
|
|
|
|
|
|
EventsModel::ItemType EventsModel::type(const QModelIndex& index) const
|
|
|
{
|
|
|
if (EventsModelItem* item = to_item(index))
|
|
|
{
|
|
|
return item->type;
|
|
|
}
|
|
|
return ItemType::None;
|
|
|
}
|
|
|
|
|
|
QVariant EventsModel::data(const QModelIndex& index, int role) const
|
|
|
{
|
|
|
if (index.isValid())
|
|
|
{
|
|
|
return to_item(index)->data(index.column(), role);
|
|
|
}
|
|
|
return QVariant {};
|
|
|
}
|
|
|
|
|
|
QModelIndex EventsModel::index(int row, int column, const QModelIndex& parent) const
|
|
|
{
|
|
|
if (!hasIndex(row, column, parent))
|
|
|
{
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
switch (type(parent))
|
|
|
{
|
|
|
case ItemType::None: // is an event
|
|
|
return createIndex(row, column, _items[row].get());
|
|
|
case ItemType::Event: // is a product
|
|
|
return createIndex(row, column, to_item(parent)->children[row].get());
|
|
|
case ItemType::Product:
|
|
|
QModelIndex();
|
|
|
}
|
|
|
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
QModelIndex EventsModel::parent(const QModelIndex& index) const
|
|
|
{
|
|
|
auto item = to_item(index);
|
|
|
if (item->type == ItemType::Product)
|
|
|
{
|
|
|
auto repoIndex = SciQLop::containers::index_of(_items, item->parent);
|
|
|
return createIndex(repoIndex, 0, item->parent);
|
|
|
}
|
|
|
return QModelIndex();
|
|
|
}
|
|
|
|
|
|
int EventsModel::rowCount(const QModelIndex& parent) const
|
|
|
{
|
|
|
if (parent.column() > 0)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
switch (type(parent))
|
|
|
{
|
|
|
case ItemType::None:
|
|
|
return _items.size();
|
|
|
case ItemType::Event:
|
|
|
return to_item(parent)->children.size();
|
|
|
case ItemType::Product:
|
|
|
break;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int EventsModel::columnCount(const QModelIndex& parent) const
|
|
|
{
|
|
|
return static_cast<int>(EventsModel::Columns::NbColumn);
|
|
|
}
|
|
|
|
|
|
QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int role) const
|
|
|
{
|
|
|
if (orientation == Qt::Horizontal && role == Qt::DisplayRole && section < ColumnsNames.size())
|
|
|
{
|
|
|
return ColumnsNames[section];
|
|
|
}
|
|
|
|
|
|
return QVariant();
|
|
|
}
|
|
|
|
|
|
void EventsModel::sort(int column, Qt::SortOrder order)
|
|
|
{
|
|
|
beginResetModel();
|
|
|
switch (static_cast<Columns>(column))
|
|
|
{
|
|
|
case EventsModel::Columns::Name:
|
|
|
std::sort(std::begin(_items), std::end(_items),
|
|
|
[inverse = order != Qt::SortOrder::AscendingOrder](
|
|
|
const std::unique_ptr<EventsModelItem>& a,
|
|
|
const std::unique_ptr<EventsModelItem>& b) {
|
|
|
return (a->event()->name < b->event()->name) xor inverse;
|
|
|
});
|
|
|
break;
|
|
|
case EventsModel::Columns::TStart:
|
|
|
std::sort(std::begin(_items), std::end(_items),
|
|
|
[inverse = order != Qt::SortOrder::AscendingOrder](
|
|
|
const std::unique_ptr<EventsModelItem>& a,
|
|
|
const std::unique_ptr<EventsModelItem>& b) {
|
|
|
if (auto t1 = a->event()->startTime(); auto t2 = b->event()->startTime())
|
|
|
{
|
|
|
if (t1 and t2)
|
|
|
return bool((t1.value() < t2.value()) xor inverse);
|
|
|
}
|
|
|
return true;
|
|
|
});
|
|
|
break;
|
|
|
case EventsModel::Columns::TEnd:
|
|
|
std::sort(std::begin(_items), std::end(_items),
|
|
|
[inverse = order != Qt::SortOrder::AscendingOrder](
|
|
|
const std::unique_ptr<EventsModelItem>& a,
|
|
|
const std::unique_ptr<EventsModelItem>& b) {
|
|
|
if (auto t1 = a->event()->stopTime(); auto t2 = b->event()->stopTime())
|
|
|
{
|
|
|
if (t1 and t2)
|
|
|
return bool((t1.value() < t2.value()) xor inverse);
|
|
|
}
|
|
|
return true;
|
|
|
});
|
|
|
break;
|
|
|
case EventsModel::Columns::Product:
|
|
|
break;
|
|
|
case EventsModel::Columns::Tags:
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
endResetModel();
|
|
|
}
|
|
|
|
