1140 lines
41 KiB
C++
Executable File
1140 lines
41 KiB
C++
Executable File
/**
|
|
*@RDE_HEADER@
|
|
* GUI Plugin for Building - Info
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by hjl, SLSE, 2017-04-05
|
|
*/
|
|
|
|
//#define PP_TEST
|
|
|
|
#include "bld_info_dialog.h"
|
|
#include "ui_bld_info_dialog.h"
|
|
#include "bld_history_dialog.h"
|
|
#include "egcu_info_dialog.h"
|
|
|
|
#include <ServiceMonitor/smo_operator_rights.h>
|
|
|
|
// Translations
|
|
#include <ParticipantManagement/ppm_translation.h>
|
|
#include <ProjectDataManagement/pdm_translation.h>
|
|
|
|
// DDS
|
|
#include <CentralEffectSimulation/ces_data_plugin_interface.h>
|
|
#include <AreaEffectSimulation/aes_data_plugin_interface.h>
|
|
#include <ParticipantManagement/ppm_data_plugin_interface.h>
|
|
#include <ProjectDataManagement/pdm_data_plugin_interface.h>
|
|
#include <InfrastructureManagement/ism_data_plugin_interface.h>
|
|
#include <Buildings/bld_data_plugin_interface.h>
|
|
|
|
// Lts
|
|
#include <LtsSession/lts_session.h>
|
|
#include <LtsSession/lts_session_data.h>
|
|
#include <LtsAppManager/lts_app_manager.h>
|
|
#include <LtsUtilsSettings/settings.h>
|
|
|
|
// Qt
|
|
#include <QPainter>
|
|
#include <QPainterPath>
|
|
#include <QTimer>
|
|
#include <QTextDocument>
|
|
#include <QStyledItemDelegate>
|
|
|
|
#ifdef PP_TEST
|
|
#include <QMenu>
|
|
#include <QDebug>
|
|
#endif
|
|
|
|
// Std
|
|
#include <algorithm>
|
|
|
|
|
|
using namespace InfrastructureManagement;
|
|
using namespace ParticipantManagement;
|
|
|
|
|
|
class HtmlDelegate : public QStyledItemDelegate
|
|
{
|
|
public:
|
|
HtmlDelegate(QObject *parent = nullptr)
|
|
: QStyledItemDelegate(parent)
|
|
{}
|
|
|
|
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
|
|
{
|
|
//qWarning() << "col" << index.column() << "rect" << option.rect;
|
|
|
|
painter->save();
|
|
QTextDocument doc;
|
|
doc.setHtml(index.data().toString());
|
|
doc.setTextWidth(-1); // prevents wordwrap
|
|
painter->translate(option.rect.topLeft());
|
|
painter->setClipRect(0, 0, option.rect.width(), option.rect.height());
|
|
doc.drawContents(painter);
|
|
painter->restore();
|
|
}
|
|
|
|
// QSize sizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& index) const override
|
|
// {
|
|
// QTextDocument doc;
|
|
// doc.setHtml(index.data().toString());
|
|
// doc.setTextWidth(-1); // prevents wordwrap
|
|
// return QSize(doc.idealWidth(), doc.size().height());
|
|
// }
|
|
};
|
|
|
|
|
|
namespace Buildings
|
|
{
|
|
BldInfoDialog::BldInfoDialog(int bldEntityId, const QString &menuGroup, QWidget *parent)
|
|
: InfoDialogBase(bldEntityId, menuGroup, QStringLiteral("BldInfoDialog"), LtsWidgets::ButtonCombination::CloseOnly, parent)
|
|
, m_ui(new Ui::BldInfoDialog)
|
|
{
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " START" << ", bldEntityId=" << bldEntityId;
|
|
|
|
m_ui->setupUi(this);
|
|
|
|
#ifndef LTS_DEBUG
|
|
m_ui->lblAssetId->hide();
|
|
m_ui->lbAssetId->hide();
|
|
m_ui->lblBldId->hide();
|
|
m_ui->lbBldId->hide();
|
|
m_ui->lblOrganisatorParticipantId->hide();
|
|
m_ui->lbOrganisatorParticipantId->hide();
|
|
m_ui->lblStructElementId->hide();
|
|
m_ui->lbStructElementId->hide();
|
|
m_ui->lbDamagePercentOld->hide();
|
|
m_ui->lblDamagePercentOld->hide();
|
|
#endif
|
|
|
|
m_ui->lbStatus->hide();
|
|
m_ui->lblStatus->hide();
|
|
|
|
m_ui->pbFindOnMap->setToolTip(tr("Locate building on map"));
|
|
m_ui->pbHistory->setToolTip(tr("Show building history"));
|
|
m_ui->pbDetails->setToolTip(tr("Set building status"));
|
|
m_ui->pbBuildingViewer->setToolTip(tr("Show building in BuildingViewer"));
|
|
m_ui->pbMonitor->setToolTip(tr("Show EGCU monitor"));
|
|
|
|
connect(m_ui->pbHistory, &QToolButton::clicked, this, &BldInfoDialog::onOpenHistory);
|
|
connect(m_ui->pbFindOnMap, &QToolButton::clicked, this, &BldInfoDialog::onFindOnMap);
|
|
connect(m_ui->pbDetails, &QToolButton::clicked, this, &BldInfoDialog::onShowDetails);
|
|
connect(m_ui->pbBuildingViewer, &QToolButton::clicked, this, &BldInfoDialog::onShowBuildingViewer);
|
|
connect(m_ui->pbMonitor, &QToolButton::clicked, this, &BldInfoDialog::onShowEgcuMonitor);
|
|
|
|
setOnlineHelpFilename(QStringLiteral("Info_Dialog-Building_Viewer"));
|
|
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " END" << ", bldEntityId=" << bldEntityId;
|
|
} // end of ctor()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BldInfoDialog::~BldInfoDialog()
|
|
{
|
|
delete m_ui;
|
|
} // end of dtor()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::retranslate()
|
|
{
|
|
constexpr int resolution = ICON_RESOLUTION;
|
|
const QVector<QPointF> polyHouse =
|
|
{
|
|
QPointF(resolution / 4, resolution),
|
|
QPointF(resolution / 4 * 3, resolution),
|
|
QPointF(resolution / 4 * 3, resolution / 4 * 2),
|
|
QPointF(resolution / 4 * 3.5, resolution / 4 * 2),
|
|
QPointF(resolution / 4 * 2, resolution / 4 * 0.5),
|
|
QPointF(resolution / 4 * 0.5, resolution / 4 * 2),
|
|
QPointF(resolution / 4, resolution / 4 * 2),
|
|
QPointF(resolution / 4, resolution)
|
|
}; // return to start point
|
|
|
|
QPainterPath pPath;
|
|
pPath.addPolygon(polyHouse);
|
|
|
|
// TODO: get party color!
|
|
// TODO2: move icon to tab title!
|
|
|
|
// Buildings::BuildingState bldState = m_dtc->buildingState(m_bldEntityId);
|
|
// CentralEffectSimulation::BuildingOwnership ownership = m_cesDtc->buildingOwnership(bldState.id());
|
|
|
|
// ERROR_LOG(m_logger) << "OWNERSHIP SIZE->" << ownership.ownerships().size();
|
|
// for(const CentralEffectSimulation::Ownership &os : qAsConst(ownership.ownerships()))
|
|
// {
|
|
// ERROR_LOG(m_logger) << "OWNERSHIP PARTY ID->" << os.partyId();
|
|
// }
|
|
|
|
// QColor partyColor = partyColor(partyId);
|
|
|
|
QColor partyColor = Qt::red;
|
|
const auto dpr = devicePixelRatioF();
|
|
QPixmap preIcon(QSize(ICON_RESOLUTION, ICON_RESOLUTION) * dpr);
|
|
preIcon.fill(Qt::transparent);
|
|
preIcon.setDevicePixelRatio(dpr);
|
|
m_ui->lblIcon->setPixmap(preIcon);
|
|
QImage img = m_ui->lblIcon->pixmap()->toImage();
|
|
QPainter painter(&img);
|
|
painter.setPen(QPen(Qt::black, 3, Qt::SolidLine, Qt::FlatCap, Qt::RoundJoin));
|
|
painter.setBrush(Qt::transparent);
|
|
painter.drawPath(pPath);
|
|
painter.fillPath(pPath, partyColor);
|
|
painter.end();
|
|
m_ui->lblIcon->setPixmap(QPixmap::fromImage(img));
|
|
|
|
translate(m_ui, tr("Building: %1").arg(m_ismDtc->getBuildingDisplayName(m_mse)));
|
|
}
|
|
|
|
bool BldInfoDialog::init(LtsSession::LtsSession *session)
|
|
{
|
|
if (!InfoDialogBase::init(session))
|
|
return false;
|
|
|
|
connect(m_dtc.get(), &Buildings::Interface::Dtc::buildingStateChanged,
|
|
this, &BldInfoDialog::onBuildingStateChanged);
|
|
|
|
if (!m_session->getDtc<CentralEffectSimulation::DataInterface>(m_cesDtc))
|
|
return false;
|
|
connect(m_cesDtc.get(), &CentralEffectSimulation::Interface::Dtc::buildingOwnershipChanged,
|
|
this, &BldInfoDialog::onBuildingOwnershipChanged);
|
|
|
|
|
|
m_session->getDtc<AreaEffectSimulation::DataInterface>(m_aesDtc);
|
|
m_session->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc);
|
|
m_session->getDtc<ProjectDataManagement::DataInterface>(m_pdmDtc);
|
|
|
|
const bool isBridge = m_mse.structureElementTypeId() == InfrastructureManagement::StructureElementType::Bridge;
|
|
const bool isResourceManagerApp = m_session->app() == LtsAppDescriptor::App::ResourceManager;
|
|
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " m_mse" << m_mse
|
|
<< ", isBridge=" << isBridge;
|
|
|
|
// Main Structure Elements
|
|
connect(m_ismDtc.get(), &InfrastructureManagement::Interface::Dtc::mainStructureElementChanged,
|
|
this, &BldInfoDialog::onMainStructureElementChanged);
|
|
m_mse = m_ismDtc->mainStructureElement(m_mseId);
|
|
|
|
// (lbOrganisatorParticipantId, lblOrganisatorParticipantId just visible if LTS_DEBUG)
|
|
m_ui->lbDamagePercent->setVisible(m_session->partitionType() != IDL::PartitionType::Global);
|
|
m_ui->lblDamagePercent->setVisible(m_session->partitionType() != IDL::PartitionType::Global);
|
|
|
|
showBuildingInfos();
|
|
|
|
auto predicate = [](const InfrastructureManagement::InstrumentationAsset & a)
|
|
{
|
|
return (!a.isDeleted() && (a.mountingPointTypeId() == InfrastructureManagement::MountingPointType::EffectGenerationControlUnit));
|
|
};
|
|
QMap<int, QVector<InfrastructureManagement::InstrumentationAsset>> assetsMapBuilding;
|
|
m_ismDtc->waitForHistoricalDataInstrumentationAsset(500); // to create 'm_dtcInstrumentationAsset' and avoid coredump at getAllAssetsPerBuilding
|
|
m_ismDtc->getAllAssetsPerBuilding(predicate, assetsMapBuilding);
|
|
|
|
QVBoxLayout *l = new QVBoxLayout(m_ui->gbSegments);
|
|
m_ui->gbSegments->setLayout(l);
|
|
if (assetsMapBuilding.contains(m_mseId))
|
|
{
|
|
const QVector<InfrastructureManagement::InstrumentationAsset> &instrumentationAssets = assetsMapBuilding[m_mseId];
|
|
const QMap<qint32, InfrastructureManagement::MountingPointAsset> &mountingPointAssets = m_ismDtc->mountingPointAssets();
|
|
for (const auto &instrumentationAsset : qAsConst(instrumentationAssets))
|
|
{
|
|
InfrastructureManagement::MountingPointAsset mpa;
|
|
for (const auto &mpax : qAsConst(mountingPointAssets))
|
|
{
|
|
if (mpax.assetId() == instrumentationAsset.id())
|
|
{
|
|
mpa = mpax;
|
|
break;
|
|
}
|
|
}
|
|
if (mpa.assetId() != instrumentationAsset.id())
|
|
continue;
|
|
|
|
std::string name = mpa.name().empty() ? instrumentationAsset.name() : mpa.name();
|
|
int assetId = mpa.assetId();
|
|
QPushButton *w = new QPushButton(QString::fromStdString(name), this);
|
|
w->setProperty("assetId", assetId);
|
|
w->setProperty("assetName", QString::fromStdString(instrumentationAsset.name()));
|
|
l->addWidget(w);
|
|
connect(w, &QPushButton::clicked, this, &BldInfoDialog::onEgcuInfoDialogRequested);
|
|
}
|
|
}
|
|
m_ui->gbSegments->setVisible(egcuVisibility());
|
|
bool editable = true; // LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::EgcuMonitorShow);
|
|
m_ui->pbMonitor->setVisible(editable && egcuVisibility());
|
|
|
|
if ((m_session->app() == LtsAppDescriptor::App::OC) || isResourceManagerApp)
|
|
{
|
|
m_ui->pbDetails->hide();
|
|
m_ui->pbHistory->hide();
|
|
m_ui->pbBuildingViewer->hide();
|
|
}
|
|
|
|
if (m_session->isReplayPartition()) // is replay?
|
|
m_ui->pbDetails->hide();
|
|
m_ui->pbBuildingViewer->hide();
|
|
|
|
if (LtsAppManager::LtsAppManager::getInstance()->hasApp(LtsAppDescriptor::App::BuildingViewer))
|
|
m_ui->pbBuildingViewer->setVisible(m_bdvGuiIfc != nullptr && LtsAppManager::LtsAppManager::getInstance()->hasApp(LtsAppDescriptor::App::BuildingViewer));
|
|
|
|
m_ui->lblIcon->setVisible(true);
|
|
m_ui->lblIcon->setFixedSize(ICON_RESOLUTION, ICON_RESOLUTION);
|
|
|
|
m_ui->lblBldName->setText(buildingDisplayName());
|
|
|
|
const bool ownershipFunc = LtsUtils::ProjectSettings::isFunctionEnabled(QStringLiteral("Buildings"),
|
|
QStringLiteral("Ownership"));
|
|
|
|
const bool bShowBuildingOwnership = ownershipFunc && !isResourceManagerApp && !isBridge;
|
|
m_ui->lbOwnership->setVisible(bShowBuildingOwnership);
|
|
m_ui->twOwnership->setVisible(bShowBuildingOwnership);
|
|
|
|
connect(m_ismDtc.get(), &InfrastructureManagement::Interface::Dtc::mountingPointAssetChanged,
|
|
this, &BldInfoDialog::onMountingPointAssetChanged);
|
|
|
|
|
|
|
|
// FloorParticipantCount stuff:
|
|
LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
|
|
const bool enableFloorParticipantCount = ps->value(QStringLiteral("bld"), QStringLiteral("enableFloorParticipantCount")).toBool();
|
|
|
|
if (enableFloorParticipantCount)
|
|
{
|
|
m_ui->twFloorParticipantCount->setItemDelegate(new HtmlDelegate);
|
|
|
|
#ifdef PP_TEST
|
|
#warning PP_TEST ACTIVE!
|
|
static int pid = 1;
|
|
|
|
struct PPData
|
|
{
|
|
int roomId;
|
|
int partyId;
|
|
int dataMod;
|
|
int participantId = pid++;
|
|
QString changeDesc = {};
|
|
};
|
|
|
|
const auto ppDatas = QVector<PPData>() << PPData{190, 1, 0} << PPData{190, 2, 0} << PPData{190, 3, 0} << PPData{190, 3, 0} << PPData{234, 1, 0} << PPData{234, 1, 0} << PPData{234, 3, 0};
|
|
|
|
|
|
auto fn = [this](const PPData & ppData)
|
|
{
|
|
ParticipantPosition pp;
|
|
pp.roomId(ppData.roomId);
|
|
pp.participantId(ppData.participantId);
|
|
pp.partyId(ppData.partyId);
|
|
pp.buildingId(m_mse.id());
|
|
if (!ppData.changeDesc.isEmpty())
|
|
{
|
|
m_ui->lbFloorParticipantCount->setText(QStringLiteral("%1: %2").arg(ppData.participantId).arg(ppData.changeDesc));
|
|
onPositionChanged(pp, ppData.dataMod == 0 ? DataModification::eAdded : DataModification::eModified);
|
|
return;
|
|
}
|
|
qWarning() << "id" << ppData.participantId;
|
|
addParticipantPosition(pp, ppData.dataMod == 0 ? DataModification::eAdded : DataModification::eModified);
|
|
};
|
|
|
|
for (const PPData &ppData : ppDatas)
|
|
fn(ppData);
|
|
|
|
updateFloorParticipantTable();
|
|
|
|
|
|
m_ui->twFloorParticipantCount->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(m_ui->twFloorParticipantCount, &QWidget::customContextMenuRequested,
|
|
this, [this, fn](const QPoint & p)
|
|
{
|
|
QMenu *m = new QMenu(this);
|
|
m->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
m->addAction(QStringLiteral("[next test]"), this, [fn]()
|
|
{
|
|
static int step = 0;
|
|
static auto ppDatas = QVector<PPData>()
|
|
// floor, party, [mod], participant
|
|
<< PPData{190, 1, 1, 1, QStringLiteral("something changed, but nothing relevant")}
|
|
<< PPData{234, 2, 1, 2, QStringLiteral("changed from floor_1 to floor_2")}
|
|
<< PPData{190, 2, 1, 3, QStringLiteral("changed party to 2")}
|
|
<< PPData{234, 2, 1, 4, QStringLiteral("changed party to 2 AND to floor_2")}
|
|
<< PPData{190, 3, 1, 1, QStringLiteral("change party to 3")}
|
|
<< PPData{277, 3, 1, 5, QStringLiteral("change party to (new) floor_3")}
|
|
;
|
|
|
|
if (step >= ppDatas.count())
|
|
return;
|
|
|
|
fn(ppDatas.at(step++));
|
|
});
|
|
|
|
m->popup(m_ui->twFloorParticipantCount->mapToGlobal(p));
|
|
});
|
|
|
|
#else
|
|
// m_ppmDtc->enableParticipantPosition(); // will be enabled implicit
|
|
const QMap<qint32, ParticipantManagement::ParticipantPosition> &participantPosition =
|
|
m_ppmDtc->participantPositions();
|
|
for (const ParticipantPosition &pp : qAsConst(participantPosition))
|
|
addParticipantPosition(pp, DataModification::eAdded);
|
|
updateFloorParticipantTable();
|
|
#endif
|
|
|
|
|
|
connect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::participantPositionChanged, // ... update on position changed
|
|
this, &BldInfoDialog::onPositionChanged);
|
|
}
|
|
else
|
|
{
|
|
m_ui->lbFloorParticipantCount->hide();
|
|
m_ui->twFloorParticipantCount->hide();
|
|
}
|
|
|
|
|
|
return true;
|
|
} // end of init()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString BldInfoDialog::buildingDisplayName() const
|
|
{
|
|
return m_ismDtc->getBuildingDisplayName(m_mse);
|
|
}
|
|
|
|
bool BldInfoDialog::egcuVisibility()
|
|
{
|
|
if (!m_ui || !m_ui->gbSegments)
|
|
return false;
|
|
|
|
QVBoxLayout *l = qobject_cast<QVBoxLayout *>(m_ui->gbSegments->layout());
|
|
if (!l)
|
|
return false;
|
|
|
|
return (l->count() > 0) &&
|
|
!m_session->isReplayPartition() &&
|
|
!((m_session->app() == LtsAppDescriptor::App::OC) || (m_session->app() == LtsAppDescriptor::App::ResourceManager));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::showBuildingInfos()
|
|
{
|
|
showBuildingInfos(m_dtc->buildingState(m_mseId));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::onPositionChanged(const ParticipantManagement::ParticipantPosition &data, DataModification modType)
|
|
{
|
|
addParticipantPosition(data, modType);
|
|
updateFloorParticipantTable();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString BldInfoDialog::getFloorName(int floorSeId)
|
|
{
|
|
auto it = m_floorNames.find(floorSeId);
|
|
if (it != m_floorNames.end())
|
|
return *it;
|
|
|
|
InfrastructureManagement::StructureElement floorSe;
|
|
if (!getRoom(floorSeId, floorSe))
|
|
return QStringLiteral("<unknown floor>");
|
|
return QString::fromStdString(floorSe.displayName());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool BldInfoDialog::getRoom(int roomSeId, InfrastructureManagement::StructureElement &roomSe)
|
|
{
|
|
auto it = m_roomStructureElementCache.find(roomSeId);
|
|
if (it != m_roomStructureElementCache.end())
|
|
{
|
|
//qWarning() << "getRoom: cache hit!";
|
|
roomSe = *it;
|
|
return true;
|
|
}
|
|
|
|
if (m_ismDtc->getStructureElementById(roomSeId, roomSe))
|
|
{
|
|
//qWarning() << "getRoom: cache miss - adding to cache";
|
|
m_roomStructureElementCache.insert(roomSeId, roomSe);
|
|
return true;
|
|
}
|
|
|
|
return false; // not found :((((
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int BldInfoDialog::findFloorIdByRoomId(int roomId) noexcept(false)
|
|
{
|
|
// get the floor by getting the parent of the room
|
|
auto roomToFloorCache = m_roomToFloorCache.constFind(roomId); // try to find the floor in the cache first
|
|
if (roomToFloorCache != m_roomToFloorCache.constEnd())
|
|
{
|
|
//qWarning() << ":) cache hit for room" << roomId;
|
|
return roomToFloorCache.value();
|
|
}
|
|
|
|
//qWarning() << ":( cache miss for room" << roomId;
|
|
|
|
StructureElement roomSe;
|
|
if (!m_ismDtc->getStructureElementById(roomId, roomSe))
|
|
{
|
|
ERROR_LOG(m_logger) << "getStructureElementById roomId=" << roomId << " not found";
|
|
return -1;
|
|
}
|
|
|
|
const std::vector<int32_t> path = roomSe.path();
|
|
|
|
for (const int parentSeId : path)
|
|
{
|
|
StructureElement parentSe;
|
|
if (!getRoom(parentSeId, parentSe))
|
|
continue;
|
|
//qWarning() << "seId" << seId << "type" << structureElement2.structureElementTypeId().underlying();
|
|
|
|
if (parentSe.structureElementTypeId().underlying() != StructureElementType_def::Floor)
|
|
continue;
|
|
|
|
// there can only be one floor per room (duh), so we can break after that and finally know the se id for the floor the participant is in
|
|
|
|
m_floorNames.insert(parentSeId, QString::fromStdString(parentSe.displayName())); // also add the name of the floor for filling the table later (does nothing if already exists, so no need to check)
|
|
m_roomToFloorCache.insert(roomId, parentSeId);
|
|
return parentSeId;
|
|
}
|
|
|
|
throw QStringLiteral("findFloorId: floor id for room %1 not found").arg(roomSe.id());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::addParticipantPosition(const ParticipantManagement::ParticipantPosition &data, DataModification /*modType*/)
|
|
{
|
|
if (data.buildingId() != m_mse.id())
|
|
{
|
|
//qWarning() << "building irrelevant";
|
|
return;
|
|
}
|
|
|
|
const int roomId = data.roomId();
|
|
const int participantId = data.participantId();
|
|
const int participantPartyId = data.partyId();
|
|
int participantFloorId;
|
|
|
|
participantFloorId = findFloorIdByRoomId(roomId);
|
|
if (participantFloorId < 0 )
|
|
{
|
|
ERROR_LOG(m_logger) << "addParticipantPosition: cannot find floor id roomId=" << roomId;
|
|
return;
|
|
}
|
|
|
|
m_rawParticipantCount.insert(participantId, QPair<int, int>(participantFloorId, participantPartyId));
|
|
|
|
|
|
|
|
// code that works PER CHANGE:
|
|
// if (!m_floorToPartyMapping.contains(participantFloorId))
|
|
// {
|
|
// m_floorToPartyMapping.insert(participantFloorId, QVector<int>()); // insert empty vector for the new floor
|
|
// qWarning() << "added new, empty floor-to-party mapping (without parties) to floor" << getFloorName(participantFloorId);
|
|
// }
|
|
|
|
// if (!m_floorNames.contains(participantFloorId))
|
|
// m_floorNames.insert(participantFloorId, floorDisplayName); // also add the name of the floor for filling the table later (does nothing if already exists, so no need to check)
|
|
|
|
// if (!m_roomToFloorCache.contains(roomId))
|
|
// m_roomToFloorCache.insert(roomId, QPair<int,QString>(participantFloorId, floorDisplayName));
|
|
|
|
|
|
// if (modType == DataModification::eModified) // check if floor and/or party for participant changed - if yes: remove old m_participantToPartyMapping, remove old m_participantToFloorMapping and finally remove m_floorPartyParticipantCount, then (re)add
|
|
// {
|
|
// // check if floor and/or party for participant changed
|
|
|
|
// int oldPartyId = m_participantToPartyMapping.value(participantId, -1);
|
|
// int oldFloorId = m_participantToFloorMapping.value(participantId, -1);
|
|
|
|
// if (oldPartyId != participantPartyId ||
|
|
// oldFloorId != participantFloorId)
|
|
// {
|
|
// qWarning() << "floor & party don't match for" << participantId << "anymore. Floor was" << getFloorName(oldFloorId) << "is" << getFloorName(participantFloorId) << "- Party was" << oldPartyId << "is" << participantPartyId;
|
|
|
|
// // party for participant changed - remove count from m_floorPartyParticipantCount (using old partyId)
|
|
// int &val = m_floorPartyParticipantCount.find(QPair<int,int>(oldFloorId, oldPartyId)).value();
|
|
|
|
// if (val == 1) // about to remove the last participant from the floor + party? then remove the key
|
|
// {
|
|
// m_floorPartyParticipantCount.remove(QPair<int,int>(oldFloorId, oldPartyId));
|
|
// qWarning() << "last participant removed from for floor" << getFloorName(oldFloorId) << "and party" << oldPartyId;
|
|
|
|
// auto it = m_floorToPartyMapping.find(oldFloorId);
|
|
// if (it != m_floorToPartyMapping.end())
|
|
// {
|
|
// it.value().removeAll(oldPartyId);
|
|
// qWarning() << "removed old party" << oldPartyId << "from old floor" << getFloorName(oldFloorId) << "because it was the last participant in that floor-to-party";
|
|
// }
|
|
// else
|
|
// {
|
|
// qWarning() << "FLOOR TO PARTY MAPPING FOR OLD FLOOR" << getFloorName(oldFloorId) << "NOT FOUND!";
|
|
// }
|
|
// }
|
|
// else // otherwise (more than 1), remove one participant
|
|
// {
|
|
// val--;
|
|
// qWarning() << "decreased count for floor" << getFloorName(oldFloorId) << "and party" << oldPartyId;
|
|
// }
|
|
|
|
// // also, m_floorToPartyMapping needs to get the party from the floor removed (using old party id)
|
|
// if (oldFloorId != participantFloorId)
|
|
// {
|
|
// auto it = m_floorToPartyMapping.find(oldFloorId);
|
|
// if (it != m_floorToPartyMapping.end())
|
|
// {
|
|
// it.value().removeAll(oldPartyId);
|
|
// qWarning() << "removed old party" << oldPartyId << "from old floor" << getFloorName(oldFloorId) << "because the floor changed";
|
|
// }
|
|
// else
|
|
// {
|
|
// qWarning() << "FLOOR TO PARTY MAPPING FOR OLD FLOOR" << getFloorName(oldFloorId) << "NOT FOUND!";
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// qWarning() << "neither floor ("<<getFloorName(participantFloorId)<<") or party ("<<participantPartyId<<") changed for participant" << participantId << "- doing nothing";
|
|
// return; // nothing changed, no need to do anything
|
|
// }
|
|
// }
|
|
|
|
|
|
// m_participantToPartyMapping.insert(participantId, participantPartyId); // change to new partyId (no-op if same value)
|
|
// m_participantToFloorMapping.insert(participantId, participantFloorId); // change to new floorId (no-op if same value)
|
|
|
|
// QVector<int> &parties = m_floorToPartyMapping.find(participantFloorId).value();
|
|
// if (!parties.contains(participantPartyId))
|
|
// {
|
|
// parties += participantPartyId; // insert new party id (is either a new list (floor seen first time), or has the old party removed from it (if modified and party or floor changed))
|
|
// qWarning() << "added new party" << participantPartyId << "to floor" << getFloorName(participantFloorId);
|
|
// }
|
|
|
|
|
|
// auto it = m_floorPartyParticipantCount.find(QPair<int, int>(participantFloorId, participantPartyId));
|
|
// if (it == m_floorPartyParticipantCount.end())
|
|
// {
|
|
// m_floorPartyParticipantCount.insert(QPair<int, int>(participantFloorId, participantPartyId), 1); // first instance of floor + party in map, add THIS (1) participant
|
|
// qWarning() << "added new floor-to-party count for party" << participantPartyId << "and floor" << getFloorName(participantFloorId);
|
|
// }
|
|
// else
|
|
// {
|
|
// it.value()++; // floor + party already in map, add THIS (1) participant
|
|
// qWarning() << "added participant to floor-to-party count for party" << participantPartyId << "and floor" << getFloorName(participantFloorId) << "- is now" << it.value();
|
|
// }
|
|
|
|
// qWarning() << "normal exit";
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::updateFloorParticipantTable()
|
|
{
|
|
// now fill the table
|
|
const QMap<qint32, ParticipantManagement::Party> parties(m_ppmDtc->partys());
|
|
|
|
m_ui->twFloorParticipantCount->setUpdatesEnabled(false);
|
|
m_ui->twFloorParticipantCount->clearContents();
|
|
m_ui->twFloorParticipantCount->setRowCount(0);
|
|
int row = 0;
|
|
|
|
|
|
// gather unique floors
|
|
QVector<int> floors;
|
|
{
|
|
QMapIterator<int /* participant */, QPair<int /* floor */, int /* party */> > it(m_rawParticipantCount);
|
|
while (it.hasNext())
|
|
{
|
|
it.next();
|
|
//const int participant = it.key();
|
|
const QPair<int, int> &data = it.value();
|
|
const int floor = data.first;
|
|
|
|
if (!floors.contains(floor))
|
|
floors += floor;
|
|
}
|
|
}
|
|
|
|
|
|
// now count how many partypeople :D per floor ... in a map-map :)
|
|
QMap<int /* floor */, QMap<int /* party */, int /* count */>> floorPartyPeople;
|
|
for (const int floor : qAsConst(floors))
|
|
{
|
|
QMapIterator<int /* participant */, QPair<int /* floor */, int /* party */> > it(m_rawParticipantCount);
|
|
while (it.hasNext())
|
|
{
|
|
it.next();
|
|
const QPair<int /* floor */, int /* party */> &pair = it.value();
|
|
const int rawFloor = pair.first;
|
|
|
|
if (floor != rawFloor)
|
|
continue;
|
|
|
|
const int party = pair.second;
|
|
|
|
auto it1 = floorPartyPeople.find(floor);
|
|
if (it1 == floorPartyPeople.end())
|
|
{
|
|
QMap<int /* party */, int /* count */> partyPeople;
|
|
partyPeople.insert(party, 1);
|
|
floorPartyPeople.insert(floor, partyPeople);
|
|
}
|
|
else
|
|
{
|
|
QMap<int /* party */, int /* count */> &partyPeopleRef = it1.value();
|
|
|
|
auto it2 = partyPeopleRef.find(party);
|
|
|
|
if (it2 == partyPeopleRef.end())
|
|
partyPeopleRef.insert(party, 1);
|
|
else
|
|
it2.value()++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// finally, create the rows ... (PER FLOOR)
|
|
QMapIterator<int /* floor */, QMap<int /* party */, int /* count */>> it1(floorPartyPeople);
|
|
while (it1.hasNext())
|
|
{
|
|
it1.next();
|
|
const int floor = it1.key();
|
|
|
|
int column = 0;
|
|
m_ui->twFloorParticipantCount->insertRow(row);
|
|
QTableWidgetItem *pItem = new QTableWidgetItem(m_floorNames.value(floor, tr("<unknown>")));
|
|
m_ui->twFloorParticipantCount->setItem(row, column++, pItem);
|
|
|
|
|
|
// one column, all parties (participant count)
|
|
const QMap<int /* party */, int /* count */> &partyPeople = it1.value();
|
|
|
|
QStringList floorPartyParticipantCountStrings;
|
|
QMapIterator<int /* party */, int /* count */> it2(partyPeople);
|
|
while (it2.hasNext())
|
|
{
|
|
it2.next();
|
|
|
|
const int party = it2.key();
|
|
const int count = it2.value();
|
|
|
|
floorPartyParticipantCountStrings += QStringLiteral("<font color='#%1'>%2</font>").arg(QString::number((unsigned int)parties.value(party).color(), 16)).arg(count);
|
|
//qWarning() << "floor:" << floor << "party:" << party << "count:" << count;
|
|
}
|
|
|
|
//qWarning() << "final html" << floorPartyParticipantCountStrings;
|
|
pItem = new QTableWidgetItem(floorPartyParticipantCountStrings.join(QStringLiteral(" ")));
|
|
m_ui->twFloorParticipantCount->setItem(row, column, pItem);
|
|
|
|
row++;
|
|
}
|
|
|
|
|
|
|
|
// code that works PER CHANGE:
|
|
// QMapIterator<int /* floor */, QVector<int> /* parties */> it(m_floorToPartyMapping); // this map doesn't have floor as exclusive key, so we need to look for ALL keys that have the current floor id
|
|
// while (it.hasNext())
|
|
// {
|
|
// it.next();
|
|
|
|
// const int floorId = it.key();
|
|
|
|
// int column = 0;
|
|
// m_ui->twFloorParticipantCount->insertRow(row);
|
|
// QTableWidgetItem *pItem = new QTableWidgetItem(m_floorNames.value(floorId, tr("<unknown>")));
|
|
// m_ui->twFloorParticipantCount->setItem(row, column++, pItem);
|
|
|
|
|
|
// // one column, all parties (participant count)
|
|
// QVector<int> partyIds = it.value();
|
|
|
|
// std::sort(partyIds.begin(), partyIds.end()); // guarantee always the same order in view
|
|
|
|
// QStringList floorPartyParticipantCountStrings;
|
|
// for (const int partyId : partyIds)
|
|
// {
|
|
// const int floorPartyParticipantCount = m_floorPartyParticipantCount.value(QPair<int,int>(floorId, partyId), -1);
|
|
|
|
// if (floorPartyParticipantCount == -1)
|
|
// {
|
|
// qWarning() << "WHOOPS!!" << floorId << partyId;
|
|
// }
|
|
|
|
// floorPartyParticipantCountStrings += QStringLiteral("<font color='#%1'>%2</font>").arg(QString::number((unsigned int)parties.value(partyId).color(), 16)).arg(floorPartyParticipantCount);
|
|
// qWarning() << "floor:" << floorId << "party:" << partyId << "count:" << floorPartyParticipantCount;
|
|
// }
|
|
|
|
// //qWarning() << "final html" << floorPartyParticipantCountStrings;
|
|
// pItem = new QTableWidgetItem(floorPartyParticipantCountStrings.join(QStringLiteral(" ")));
|
|
// m_ui->twFloorParticipantCount->setItem(row, column, pItem);
|
|
|
|
// row++;
|
|
// }
|
|
|
|
|
|
|
|
m_ui->twFloorParticipantCount->setUpdatesEnabled(true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::showBuildingInfos(const Buildings::BuildingState &bldState)
|
|
{
|
|
if (bldState.id() <= 0)
|
|
{
|
|
m_ui->lblBldId->clear();
|
|
m_ui->lblStructElementId->clear();
|
|
m_ui->lblAssetId->clear();
|
|
m_ui->lblOrganisatorParticipantId->clear();
|
|
m_ui->lblDamagePercent->clear();
|
|
m_ui->lblDamagePercentOld->clear();
|
|
m_ui->lblStatus->clear();
|
|
m_ui->lblContamination->clear();
|
|
fillOwnership({});
|
|
return;
|
|
}
|
|
|
|
m_ui->lblBldId->setText(QString::number(bldState.id()));
|
|
m_ui->lblStructElementId->setText(QString::number(bldState.structureElementId()));
|
|
m_ui->lblAssetId->setText(QString::number(bldState.assetId()));
|
|
|
|
m_ui->lblOrganisatorParticipantId->clear();
|
|
if (bldState.originatorParticipantId())
|
|
{
|
|
if (m_ppmDtc)
|
|
{
|
|
ParticipantManagement::Participant player = m_ppmDtc->participant(bldState.originatorParticipantId());
|
|
if (player.equipmentNumber().is_set())
|
|
m_ui->lblOrganisatorParticipantId->setText(QString::number(player.equipmentNumber().get()));
|
|
}
|
|
}
|
|
else if (bldState.aesId())
|
|
{
|
|
if (m_aesDtc)
|
|
{
|
|
AreaEffectSimulation::AesItem aesItem;
|
|
m_aesDtc->aesItemFromId(bldState.aesId(), aesItem);
|
|
m_ui->lblOrganisatorParticipantId->setText(QString::fromStdString(aesItem.name()));
|
|
}
|
|
}
|
|
else
|
|
m_ui->lblOrganisatorParticipantId->setText(tr("EXCON"));
|
|
|
|
m_ui->lblDamagePercent->setText(QString::number(bldState.damagePercent()));
|
|
m_ui->lblDamagePercentOld->setText(QString::number(bldState.damagePercentOld()));
|
|
|
|
QStringList contaminationList;
|
|
for (const auto &cs : bldState.contaminationStates())
|
|
{
|
|
AreaEffectSimulation::AesItem item;
|
|
m_aesDtc->aesItemFromId(cs.aesId(), item);
|
|
const ProjectDataManagement::GearClass &gc = m_pdmDtc->gearClassFromChargeTypeId(item.chargeStruct().chargeTypeId());
|
|
if (gc == ProjectDataManagement::GearClass::Unknown)
|
|
continue;
|
|
QString gearClassName = ProjectDataManagement::toString(gc).trimmed();
|
|
gearClassName.chop(gearClassName.size() - 1); // get only the First letter: Nuclear -> 'N'
|
|
if (!contaminationList.contains(gearClassName))
|
|
contaminationList.append(gearClassName);
|
|
}
|
|
m_ui->lbContamination->setHidden(contaminationList.isEmpty());
|
|
m_ui->lblContamination->setHidden(contaminationList.isEmpty());
|
|
m_ui->lblContamination->setText(contaminationList.join(QStringLiteral("+")));
|
|
|
|
ProjectDataManagement::VulnerabilityState st = bldState.vulnerabilityState();
|
|
m_ui->lblStatus->setText(toString(st));
|
|
|
|
m_ui->twFloorParticipantCount->hideColumn(2);
|
|
DEBUG_LOG(m_logger) << "fillOwnership";
|
|
fillOwnership(bldState.id());
|
|
DEBUG_LOG(m_logger) << "Vor fillContaminationTable";
|
|
fillContaminationTable(bldState);
|
|
DEBUG_LOG(m_logger) << "Nach fillContaminationTable";
|
|
|
|
|
|
} // end of showBuildingInfos()
|
|
|
|
void BldInfoDialog::fillContaminationTable(const Buildings::BuildingState &bldState)
|
|
{
|
|
clearColumn(2);
|
|
bool showContaminationCol = false;
|
|
DEBUG_LOG(m_logger) << "fillContaminationTable bldState.contaminationStates().size()=" << bldState.contaminationStates().size();
|
|
for (const auto &cs : bldState.contaminationStates())
|
|
{
|
|
DEBUG_LOG(m_logger) << "cs.rooms().size()=" << cs.rooms().size();
|
|
/////////////////////////////////////////////
|
|
// Set Contamination State to ownership-Table
|
|
/////////////////////////////////////////////
|
|
for (unsigned int i = 0; i < cs.rooms().size(); i++)
|
|
{
|
|
int floorIdContamination = findFloorIdByRoomId(cs.rooms()[i]);
|
|
DEBUG_LOG(m_logger) << "floorIdContamination=" << floorIdContamination;
|
|
if ( floorIdContamination == -1)
|
|
{
|
|
DEBUG_LOG(m_logger) << "floorIdContamination=" << floorIdContamination << "continue";
|
|
continue;
|
|
}
|
|
QString floorNameConatmaniation = getFloorName(floorIdContamination);
|
|
DEBUG_LOG(m_logger) << "Floor:" << floorNameConatmaniation
|
|
<< " id=" << floorIdContamination
|
|
<< " m_rowToFloorId=" << floorIdContamination ;
|
|
if (!m_floorIdToRow.contains(floorIdContamination))
|
|
{
|
|
DEBUG_LOG(m_logger) << "!m_floorIdToRow.contains(" << floorIdContamination << ")";
|
|
continue;
|
|
}
|
|
int row = m_floorIdToRow.value(floorIdContamination);
|
|
int column = 2;
|
|
DEBUG_LOG(m_logger) << "floorIdContamination=" << floorIdContamination
|
|
<< " row=" << row;
|
|
|
|
QTableWidgetItem *pItem = m_ui->twOwnership->item(row, column);
|
|
if (pItem == nullptr)
|
|
{
|
|
DEBUG_LOG(m_logger) << "pItem == nullptr";
|
|
pItem = new QTableWidgetItem();
|
|
}
|
|
const QColor color = Qt::yellow;
|
|
pItem->setData(Qt::BackgroundRole,
|
|
color);
|
|
m_ui->twOwnership->setItem(row, column, pItem);
|
|
showContaminationCol = true;
|
|
}
|
|
}
|
|
if (showContaminationCol)
|
|
m_ui->twOwnership->showColumn(2);
|
|
else
|
|
m_ui->twOwnership->hideColumn(2);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void BldInfoDialog::fillOwnership(int buildingId)
|
|
{
|
|
CentralEffectSimulation::BuildingOwnership ownership = m_cesDtc->buildingOwnership(buildingId);
|
|
if (ownership.buildingId() == buildingId)
|
|
fillOwnership(ownership);
|
|
}
|
|
|
|
void BldInfoDialog::clearColumn(int column)
|
|
{
|
|
int rowCount = m_ui->twOwnership->rowCount();
|
|
for (int row = 0; row < rowCount; row++)
|
|
{
|
|
QTableWidgetItem *item = m_ui->twOwnership->item(row, column);
|
|
if (item != nullptr)
|
|
{
|
|
const QColor color = Qt::white;
|
|
item->setData(Qt::BackgroundRole,
|
|
color);
|
|
item->setData(Qt::DisplayRole, QString());
|
|
//m_ui->twOwnership->setItem(row, column, item);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void BldInfoDialog::fillOwnership(const CentralEffectSimulation::BuildingOwnership &ownership)
|
|
{
|
|
m_ui->twOwnership->setUpdatesEnabled(false);
|
|
// m_ui->twOwnership->clearContents();
|
|
clearColumn(1);
|
|
m_ui->twOwnership->setRowCount(ownership.ownerships().size());
|
|
int row = m_ui->twOwnership->rowCount();
|
|
|
|
for (const auto &data : ownership.ownerships())
|
|
{
|
|
--row;
|
|
int column = 0;
|
|
QTableWidgetItem *pItem = nullptr;
|
|
|
|
// column (floor)
|
|
for (const InfrastructureManagement::StructureElement &elem : m_mse.elements())
|
|
{
|
|
if (elem.id() == data.floorId())
|
|
{
|
|
QString name = QString::fromStdString(elem.displayName());
|
|
if (name.isEmpty())
|
|
name = QString::fromStdString(elem.name());
|
|
pItem = new QTableWidgetItem(name);
|
|
break;
|
|
}
|
|
}
|
|
if (!pItem) // no ism, no data?
|
|
pItem = new QTableWidgetItem(QString::number(data.floorId()));
|
|
m_rowToFloorId.insert(row, data.floorId());
|
|
m_floorIdToRow.insert(data.floorId(), row);
|
|
|
|
DEBUG_LOG(m_logger) << "m_rowToFloorId.insert"
|
|
<< " row=" << row
|
|
<< " column=" << column
|
|
<< " data.floorId()=" << data.floorId();
|
|
m_ui->twOwnership->setItem(row, column++, pItem);
|
|
|
|
// column (ownwership)
|
|
pItem = new QTableWidgetItem();
|
|
if (m_ppmDtc && data.partyId() > 0)
|
|
{
|
|
const auto &party = m_ppmDtc->party(data.partyId());
|
|
pItem->setData(Qt::BackgroundRole,
|
|
QColor::fromRgb(QRgb(party.color())));
|
|
pItem->setData(Qt::DisplayRole, ParticipantManagement::trPartyName(party.name()));
|
|
}
|
|
m_ui->twOwnership->setItem(row, column++, pItem);
|
|
|
|
} // for
|
|
|
|
|
|
m_ui->twOwnership->setUpdatesEnabled(true);
|
|
}// end of fillOwnership()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void BldInfoDialog::onBuildingStateChanged(const Buildings::BuildingState &data, const DataModification &modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " id:" << data.id();
|
|
if (data.id() != m_mseId)
|
|
return;
|
|
|
|
showBuildingInfos(data);
|
|
} // end of onBuildingStateChanged()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::onBuildingOwnershipChanged(
|
|
const CentralEffectSimulation::BuildingOwnership &data, const DataModification &modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " id:" << data.buildingId();
|
|
if (data.buildingId() != m_mseId)
|
|
return;
|
|
|
|
fillOwnership(data);
|
|
|
|
} // end of onBuildingOwnershipChanged()
|
|
|
|
void BldInfoDialog::onMainStructureElementChanged(const InfrastructureManagement::MainStructureElement &data,
|
|
const DataModification &modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " id:" << data.id();
|
|
if (data.id() != m_mseId)
|
|
return;
|
|
|
|
m_mse = data;
|
|
m_ui->lblBldName->setText(buildingDisplayName());
|
|
showBuildingInfos();
|
|
}
|
|
|
|
void BldInfoDialog::onMountingPointAssetChanged(const InfrastructureManagement::MountingPointAsset &data, const DataModification &modType)
|
|
{
|
|
InfrastructureManagement::StructureElement se;
|
|
m_ismDtc->getStructureElementById(data.structureElementId(), se);
|
|
if (se.mainStructureElementId() != m_mseId)
|
|
return;
|
|
|
|
if (modType == DataModification::eAdded)
|
|
{
|
|
auto instrumentationAsset = m_ismDtc->instrumentationAsset(data.assetId());
|
|
if (instrumentationAsset.mountingPointTypeId() != InfrastructureManagement::MountingPointType::EffectGenerationControlUnit)
|
|
return;
|
|
QString name = QString::fromStdString(data.name());
|
|
if (name.isNull())
|
|
name = QString::fromStdString(instrumentationAsset.hostname());
|
|
|
|
QVBoxLayout *l = qobject_cast<QVBoxLayout *>(m_ui->gbSegments->layout());
|
|
QPushButton *w = new QPushButton(name, this);
|
|
w->setProperty("assetId", data.assetId());
|
|
l->addWidget(w);
|
|
connect(w, &QPushButton::clicked, this, &BldInfoDialog::onEgcuInfoDialogRequested);
|
|
m_ui->gbSegments->setVisible(egcuVisibility());
|
|
bool editable = true; // LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::EgcuMonitorShow);
|
|
m_ui->pbMonitor->setVisible(editable && egcuVisibility());
|
|
}
|
|
else if (modType == DataModification::eRemoved)
|
|
{
|
|
const QList<QPushButton *> &list = m_ui->gbSegments->findChildren<QPushButton *>();
|
|
for (QPushButton *pb : qAsConst(list))
|
|
{
|
|
if (pb->property("assetId").toInt() == data.assetId())
|
|
{
|
|
// Letztes Element?
|
|
if (m_ui->gbSegments->layout()->count() == 1)
|
|
{
|
|
m_ui->gbSegments->setVisible(false);
|
|
m_ui->pbMonitor->hide();
|
|
}
|
|
pb->deleteLater();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (modType == DataModification::eModified)
|
|
{
|
|
const QList<QPushButton *> &list = m_ui->gbSegments->findChildren<QPushButton *>();
|
|
for (QPushButton *pb : qAsConst(list))
|
|
{
|
|
if (pb->property("assetId").toInt() == data.assetId())
|
|
pb->setText(data.name().empty() ? pb->property("assetName").toString() : QString::fromStdString(data.name()));
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void BldInfoDialog::onOpenHistory()
|
|
{
|
|
BuildingHistoryDialog *diag = new BuildingHistoryDialog(buildingDisplayName(), this);
|
|
if (diag->init(m_mseId, m_session))
|
|
addDialog(diag, m_menuGroup, QStringLiteral("BuildingHistory") + QString::number(m_mseId), LtsWidgets::LayoutArea::eDialogTab);
|
|
else
|
|
delete diag;
|
|
}
|
|
|
|
void BldInfoDialog::onEgcuInfoDialogRequested()
|
|
{
|
|
QPushButton *sender = qobject_cast<QPushButton *>(QObject::sender());
|
|
if (!sender)
|
|
return;
|
|
|
|
QVariant temp = sender->property("assetId");
|
|
if (temp.isNull())
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " missing property , return";
|
|
return;
|
|
}
|
|
const int assetId = temp.toInt();
|
|
|
|
temp = sender->property("assetName");
|
|
if (temp.isNull())
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " missing property, return";
|
|
return;
|
|
}
|
|
const QString name = temp.toString();
|
|
|
|
if (assetId < 0 || name.isEmpty())
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " missing properties, return";
|
|
return;
|
|
}
|
|
|
|
EgcuInfoDialog *dialog = new EgcuInfoDialog(assetId, menuGroup());
|
|
if (!dialog->init(m_session))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
m_session->addWidget(dialog, menuGroup(), name, LtsWidgets::LayoutArea::eInfoTab);
|
|
}
|
|
|
|
} // namespace Bridges
|