berrux-dev
52df1c8ae9
- LogViewModels: replace deprecated invalidateFilter() with begin/endFilterChange() (11 sites) - LogViewTelegramEdit: move m_logger to match member declaration order (-Wreorder) and consume QFile::open results - PrtCnvBroadcastMgr: move m_logger to match member declaration order (-Wreorder) - PrtCnvCentralThread: add remaining AreaEffectSimulationType values to the silent-ignore switch group (-Wswitch) - PrtCnvMain: consume freopen results in daemonize (-Wunused-result)
582 lines
16 KiB
C++
582 lines
16 KiB
C++
|
|
|
|
|
|
#include "LogViewModels.hpp"
|
|
|
|
#include <QtGui/QFont>
|
|
#include <QtGui/QPalette>
|
|
#include <QtGui/QGuiApplication>
|
|
|
|
namespace N_LogView
|
|
{
|
|
|
|
|
|
|
|
int ParticipantModel::rowCount(const QModelIndex &parent) const
|
|
{
|
|
return parent.isValid() ? 0 : m_particpants.size();
|
|
}
|
|
|
|
|
|
int ParticipantModel::columnCount(const QModelIndex &parent) const
|
|
{
|
|
return parent.isValid() ? 0 : 3;
|
|
}
|
|
|
|
|
|
QVariant ParticipantModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
if (index.isValid() && index.row() < m_particpants.size())
|
|
{
|
|
const auto &p = m_particpants.at(index.row());
|
|
if (role == Qt::DisplayRole)
|
|
{
|
|
switch (index.column())
|
|
{
|
|
case 0:
|
|
return p.first;
|
|
case 1:
|
|
return p.second;
|
|
case 2:
|
|
return m_particpantMap.value(p.first);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (role == Qt::ToolTipRole)
|
|
{
|
|
switch (index.column())
|
|
{
|
|
case 0:
|
|
return tr("hex: 0x%1").arg(p.first, 4, 16, QLatin1Char('0'));
|
|
case 1:
|
|
return tr("hex: 0x%1").arg(p.second, 4, 16, QLatin1Char('0'));
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (role == Qt::BackgroundRole)
|
|
{
|
|
if (p.first == 0)
|
|
return QVariant();
|
|
if (m_participantHeatmap.isEmpty())
|
|
updateHeatMap();
|
|
return m_participantHeatmap.value(p.first);
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
|
|
QVariant ParticipantModel::headerData(int section,
|
|
Qt::Orientation orientation,
|
|
int role) const
|
|
{
|
|
if (role == Qt::DisplayRole && orientation == Qt::Horizontal)
|
|
{
|
|
switch (section)
|
|
{
|
|
case 0:
|
|
return tr("Equip. No.");
|
|
case 1:
|
|
return tr("ISSI");
|
|
case 2:
|
|
return tr("#");
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return QAbstractTableModel::headerData(section, orientation, role);
|
|
}
|
|
|
|
|
|
void ParticipantModel::clearParticipants()
|
|
{
|
|
beginResetModel();
|
|
m_particpantMap.clear();
|
|
m_particpants.clear();
|
|
m_participantHeatmap.clear();
|
|
endResetModel();
|
|
}
|
|
|
|
|
|
bool ParticipantModel::addUpdateParticipants(const QVector<int> &eqIds,
|
|
const QVector<int> &issis,
|
|
const QVector<int> &numberOfTelegrams)
|
|
{
|
|
QVector<QPair<int, int> > newParticpants;
|
|
for (int i = 0; i < eqIds.size(); ++i)
|
|
{
|
|
const int eqId = eqIds.at(i);
|
|
const int issi = issis.at(i);
|
|
const int cntTelegrams = numberOfTelegrams.at(i);
|
|
auto it = m_particpantMap.find(eqId);
|
|
if (it != m_particpantMap.end())
|
|
{
|
|
it.value() = cntTelegrams;
|
|
continue;
|
|
}
|
|
newParticpants.push_back(qMakePair(eqId, issi));
|
|
m_particpantMap[eqId] = cntTelegrams;
|
|
}
|
|
|
|
if (!newParticpants.isEmpty())
|
|
{
|
|
beginInsertRows(QModelIndex(), m_particpants.size(), m_particpants.size() + newParticpants.size() - 1);
|
|
m_particpants.append(newParticpants);
|
|
endInsertRows();
|
|
}
|
|
m_participantHeatmap.clear();
|
|
return true;
|
|
}
|
|
|
|
|
|
void ParticipantModel::updateHeatMap() const
|
|
{
|
|
int maxNumberOfTelegrams = 0;
|
|
for (auto it = m_particpantMap.begin(); it != m_particpantMap.end(); ++it)
|
|
{
|
|
if (it.key() == 0)
|
|
continue;
|
|
maxNumberOfTelegrams = std::max(it.value(), maxNumberOfTelegrams);
|
|
}
|
|
|
|
const QColor backgroundColor = QGuiApplication::palette().base().color();
|
|
const QColor redColor = Qt::red;
|
|
for (auto it = m_particpantMap.begin(); it != m_particpantMap.end(); ++it)
|
|
{
|
|
const int eqId = it.key();
|
|
if (eqId == 0)
|
|
continue;
|
|
|
|
const int nbrTelegrams = it.value();
|
|
QColor curColor;
|
|
double percent = static_cast<double>(nbrTelegrams) / maxNumberOfTelegrams;
|
|
curColor.setRed(backgroundColor.red() - ((backgroundColor.red() - redColor.red()) * percent));
|
|
curColor.setGreen(backgroundColor.green() - ((backgroundColor.green() - redColor.green()) * percent));
|
|
curColor.setBlue(backgroundColor.blue() - ((backgroundColor.blue() - redColor.blue()) * percent));
|
|
m_participantHeatmap[eqId] = curColor;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int TelegramModel::rowCount(const QModelIndex &parent) const
|
|
{
|
|
return parent.isValid() ? 0 : m_telegrams.size();
|
|
}
|
|
|
|
|
|
int TelegramModel::columnCount(const QModelIndex &parent) const
|
|
{
|
|
return parent.isValid() ? 0 : 6;
|
|
}
|
|
|
|
|
|
QVariant TelegramModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
if (index.isValid() && index.row() < m_telegrams.size())
|
|
{
|
|
if (role == Qt::DisplayRole)
|
|
{
|
|
const QSharedPointer<LogViewTelegram> &telegram = m_telegrams.at(index.row());
|
|
switch (index.column())
|
|
{
|
|
case 0:
|
|
return telegram->getDestinationText();
|
|
case 1:
|
|
return telegram->getName();
|
|
case 2:
|
|
return telegram->getParticipantId();
|
|
case 3:
|
|
return telegram->getLogTimeText();
|
|
case 4:
|
|
return telegram->getGpsTimeText();
|
|
case 5:
|
|
return telegram->getDelay();
|
|
}
|
|
}
|
|
if (role == Qt::DecorationRole)
|
|
{
|
|
const QSharedPointer<LogViewTelegram> telegram = m_telegrams.at(index.row());
|
|
switch (index.column())
|
|
{
|
|
case 0:
|
|
return telegram->getIcon();
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (role == Qt::ToolTipRole)
|
|
{
|
|
const QSharedPointer<LogViewTelegram> telegram = m_telegrams.at(index.row());
|
|
switch (index.column())
|
|
{
|
|
case 1:
|
|
return telegram->getToolTipText(LogViewTelegram::e_ColName);
|
|
case 3:
|
|
return telegram->getToolTipText(LogViewTelegram::e_ColLogTime);
|
|
case 4:
|
|
return telegram->getToolTipText(LogViewTelegram::e_ColGpsTime);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
|
|
QVariant TelegramModel::headerData(int section,
|
|
Qt::Orientation orientation,
|
|
int role) const
|
|
{
|
|
if (orientation == Qt::Horizontal)
|
|
{
|
|
if (role == Qt::DisplayRole)
|
|
{
|
|
switch (section)
|
|
{
|
|
case 0:
|
|
return tr("Dest.");
|
|
case 1:
|
|
return tr("Description");
|
|
case 2:
|
|
return tr("Equip. No.");
|
|
case 3:
|
|
return tr("Send/Recieve time");
|
|
case 4:
|
|
return tr("GPS time");
|
|
case 5:
|
|
return tr("Delay");
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return QAbstractTableModel::headerData(section, orientation, role);
|
|
}
|
|
|
|
|
|
void TelegramModel::clearTelegrams()
|
|
{
|
|
beginResetModel();
|
|
m_telegrams.clear();
|
|
endResetModel();
|
|
}
|
|
|
|
|
|
void TelegramModel::appendTelegrams(const QVector<QSharedPointer<LogViewTelegram> > &telegrams)
|
|
{
|
|
if (telegrams.isEmpty())
|
|
return;
|
|
beginInsertRows(QModelIndex(), m_telegrams.size(), m_telegrams.size() + telegrams.size() - 1);
|
|
m_telegrams += telegrams;
|
|
endInsertRows();
|
|
}
|
|
|
|
|
|
void TelegramModel::appendTelegram(const QSharedPointer<LogViewTelegram> &telegram)
|
|
{
|
|
beginInsertRows(QModelIndex(), m_telegrams.size(), m_telegrams.size());
|
|
m_telegrams.push_back(telegram);
|
|
endInsertRows();
|
|
}
|
|
|
|
|
|
QSharedPointer<LogViewTelegram> TelegramModel::telegram(int row) const
|
|
{
|
|
if (row >= 0 && row < m_telegrams.size())
|
|
return m_telegrams.at(row);
|
|
return QSharedPointer<LogViewTelegram>();
|
|
}
|
|
|
|
|
|
|
|
void TelegramProxyModel::setFilterByEquipmentIds(bool bFilterByEquipmentIds)
|
|
{
|
|
if (m_bFilterByEquipmentIds == bFilterByEquipmentIds)
|
|
return;
|
|
m_bFilterByEquipmentIds = bFilterByEquipmentIds;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setAllowedEquipmentIds(const std::set<int> &allowedEquipmentIds)
|
|
{
|
|
if (m_allowedEquipmentIds == allowedEquipmentIds)
|
|
return;
|
|
m_allowedEquipmentIds = allowedEquipmentIds;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setFilteredCentralTelegramIds(const std::set<int> &filteredCentralTelegramIds)
|
|
{
|
|
if (m_filteredCentralTelegramIds == filteredCentralTelegramIds)
|
|
return;
|
|
m_filteredCentralTelegramIds = filteredCentralTelegramIds;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setFilteredTetraTelegramIds(const std::set<int> &filteredTetraTelegramIds)
|
|
{
|
|
if (m_filteredTetraTelegramIds == filteredTetraTelegramIds)
|
|
return;
|
|
m_filteredTetraTelegramIds = filteredTetraTelegramIds;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setFilteredWlsTelegramIds(const std::set<int> &filteredWlsTelegramIds)
|
|
{
|
|
if (m_filteredWlsTelegramIds == filteredWlsTelegramIds)
|
|
return;
|
|
m_filteredWlsTelegramIds = filteredWlsTelegramIds;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
|
|
void TelegramProxyModel::setFilterCentralTelegrams(N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol direction,
|
|
bool bFilter)
|
|
{
|
|
std::set<N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol> curFilter = m_filterCentralTelegrams;
|
|
if (bFilter)
|
|
curFilter.insert(direction);
|
|
else
|
|
curFilter.erase(direction);
|
|
if (curFilter == m_filterCentralTelegrams)
|
|
return;
|
|
m_filterCentralTelegrams = curFilter;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setFilterTetraTelegrams(N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol direction,
|
|
bool bFilter)
|
|
{
|
|
std::set<N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol> curFilter = m_filterTetraTelegrams;
|
|
if (bFilter)
|
|
curFilter.insert(direction);
|
|
else
|
|
curFilter.erase(direction);
|
|
if (curFilter == m_filterTetraTelegrams)
|
|
return;
|
|
m_filterTetraTelegrams = curFilter;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setFilterTetraPDU(N_CoPrtCnv::CoPrtCnvRadioTelegram::E_PDU_Type pduType,
|
|
bool bFilter)
|
|
{
|
|
std::set<N_CoPrtCnv::CoPrtCnvRadioTelegram::E_PDU_Type> curFilter = m_filterTetraPDU;
|
|
if (bFilter)
|
|
curFilter.insert(pduType);
|
|
else
|
|
curFilter.erase(pduType);
|
|
if (curFilter == m_filterTetraPDU)
|
|
return;
|
|
m_filterTetraPDU = curFilter;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
void TelegramProxyModel::setFilterWlsTelegrams(N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol direction,
|
|
bool bFilter)
|
|
{
|
|
std::set<N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol> curFilter = m_filterWlsTelegrams;
|
|
if (bFilter)
|
|
curFilter.insert(direction);
|
|
else
|
|
curFilter.erase(direction);
|
|
if (curFilter == m_filterWlsTelegrams)
|
|
return;
|
|
m_filterWlsTelegrams = curFilter;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setFilterTetraLogin(bool bFilter)
|
|
{
|
|
if (m_bFilterLoginTelegrams == bFilter)
|
|
return;
|
|
m_bFilterLoginTelegrams = bFilter;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
void TelegramProxyModel::setFilterTetraFragmented(bool bFilter)
|
|
{
|
|
if (m_bFilterFragmentedTelegrams == bFilter)
|
|
return;
|
|
m_bFilterFragmentedTelegrams = bFilter;
|
|
// invalidateFilter() is deprecated in Qt6 - begin/endFilterChange() is the
|
|
// documented replacement (re-filters the model)
|
|
beginFilterChange();
|
|
endFilterChange();
|
|
}
|
|
|
|
|
|
QSharedPointer<LogViewTelegram> TelegramProxyModel::telegram(int row) const
|
|
{
|
|
const TelegramModel *tm = qobject_cast<TelegramModel *>(sourceModel());
|
|
if (!tm)
|
|
return {};
|
|
const int srcRow = mapToSource(index(row, 0)).row();
|
|
return tm->telegram(srcRow);
|
|
}
|
|
|
|
|
|
bool TelegramProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
|
|
{
|
|
if (left.column() != right.column())
|
|
return QSortFilterProxyModel::lessThan(left, right);
|
|
const TelegramModel *tm = qobject_cast<TelegramModel *>(sourceModel());
|
|
if (!tm)
|
|
return QSortFilterProxyModel::lessThan(left, right);
|
|
QSharedPointer<LogViewTelegram> teleLeft = tm->telegram(left.row());
|
|
QSharedPointer<LogViewTelegram> teleRight = tm->telegram(right.row());
|
|
if (!teleLeft || !teleRight)
|
|
return QSortFilterProxyModel::lessThan(left, right);
|
|
|
|
switch (left.column())
|
|
{
|
|
case 0:
|
|
return teleLeft->getDestination() < teleRight->getDestination();
|
|
case 1:
|
|
return teleLeft->getName() < teleRight->getName();
|
|
case 2:
|
|
return teleLeft->getParticipantId() < teleRight->getParticipantId();
|
|
case 3:
|
|
return teleLeft->getLogTime() < teleRight->getLogTime();
|
|
case 4:
|
|
return teleLeft->getGpsTime() < teleRight->getGpsTime();
|
|
case 5:
|
|
return teleLeft->getDelay() < teleRight->getDelay();
|
|
}
|
|
return QSortFilterProxyModel::lessThan(left, right);
|
|
}
|
|
|
|
|
|
bool TelegramProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
|
|
{
|
|
|
|
const TelegramModel *tm = qobject_cast<TelegramModel *>(sourceModel());
|
|
if (!tm)
|
|
return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
|
|
|
|
QSharedPointer<LogViewTelegram> tele = tm->telegram(source_row);
|
|
if (!tele)
|
|
return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
|
|
|
|
if (m_bFilterByEquipmentIds)
|
|
{
|
|
int equipId = tele->getParticipantId();
|
|
if (m_allowedEquipmentIds.find(equipId) == m_allowedEquipmentIds.end())
|
|
return false;
|
|
}
|
|
switch (tele->getProtocol())
|
|
{
|
|
case N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolCentral:
|
|
if (!m_filteredCentralTelegramIds.empty())
|
|
{
|
|
const int telegramId = tele->getTelId();
|
|
if (m_filteredCentralTelegramIds.find(telegramId) != m_filteredCentralTelegramIds.end())
|
|
return false;
|
|
}
|
|
if (!m_filterCentralTelegrams.empty())
|
|
{
|
|
N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol direction = tele->getDirection();
|
|
if (m_filterCentralTelegrams.find(direction) != m_filterCentralTelegrams.end())
|
|
return false;
|
|
}
|
|
break;
|
|
case N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolTetra:
|
|
{
|
|
if (!m_filteredTetraTelegramIds.empty())
|
|
{
|
|
const int telegramId = tele->getTelId();
|
|
if (m_filteredTetraTelegramIds.find(telegramId) != m_filteredTetraTelegramIds.end())
|
|
return false;
|
|
}
|
|
if (!m_filterTetraTelegrams.empty())
|
|
{
|
|
N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol direction = tele->getDirection();
|
|
if (m_filterTetraTelegrams.find(direction) != m_filterTetraTelegrams.end())
|
|
return false;
|
|
}
|
|
const N_CoPrtCnv::CoPrtCnvRadioTelegram *tetraTelegram = tele->getTetraTelegram();
|
|
if (tetraTelegram)
|
|
{
|
|
if (!m_filterTetraPDU.empty())
|
|
{
|
|
N_CoPrtCnv::CoPrtCnvRadioTelegram::E_PDU_Type pduType = tetraTelegram->getPDU_Type();
|
|
if (m_filterTetraPDU.find(pduType) != m_filterTetraPDU.end())
|
|
return false;
|
|
}
|
|
if (m_bFilterLoginTelegrams)
|
|
{
|
|
if (tetraTelegram->isLoginTelegram())
|
|
return false;
|
|
}
|
|
if (m_bFilterFragmentedTelegrams)
|
|
{
|
|
if (!tetraTelegram->isLoginTelegram() && !tetraTelegram->isNormalTelegram())
|
|
return false;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolWls:
|
|
if (!m_filteredWlsTelegramIds.empty())
|
|
{
|
|
const int telegramId = tele->getTelId();
|
|
if (m_filteredWlsTelegramIds.find(telegramId) != m_filteredWlsTelegramIds.end())
|
|
return false;
|
|
}
|
|
if (!m_filterWlsTelegrams.empty())
|
|
{
|
|
N_CoPrtCnv::CoPrtCnvLogHeader::E_CoPrtCnvProtocol direction = tele->getDirection();
|
|
if (m_filterWlsTelegrams.find(direction) != m_filterWlsTelegrams.end())
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
}
|