636 lines
22 KiB
C++
Executable File
636 lines
22 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* HMI Plugin for Observer Controller - OcParticipantInfo Dialog
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Patric Karwat, SLSE, 2018-03-17
|
|
*/
|
|
|
|
#include "osc_participant_info.h"
|
|
#include "ui_osc_participant_info.h"
|
|
|
|
#include <ProjectDataManagement/pdm_to_string.h>
|
|
#include <ParticipantManagement/ppm_translation.h>
|
|
|
|
#include <LtsCoordTrans/lts_coord_trans.h>
|
|
#include <LtsSession/lts_session_data.h>
|
|
#include <LtsUtilsCore/outdated_position.h>
|
|
#include <PluginInterfaces/gui_plugin_interface.h>
|
|
|
|
namespace OcSituationClient
|
|
{
|
|
|
|
OcParticipantInfo::OcParticipantInfo(int participantId, LtsSession::LtsSession *session, QWidget *parent)
|
|
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
|
|
, m_roomId(0)
|
|
, m_session(session)
|
|
, m_ui(new Ui::OcParticipantInfo)
|
|
, m_logger(getLogger("OcOcParticipantInfo"))
|
|
{
|
|
m_ui->setupUi(this);
|
|
m_participant.id(participantId);
|
|
m_participant.partyId(-1);
|
|
m_symbolWatcher = new AdvancedSymbology::SymbolResultWatcherLabel(m_ui->lblIcon);
|
|
|
|
//hide first
|
|
setBuildingPosVisible(false);
|
|
setSpecialSensorVisible(false);
|
|
setChargeVisible(false);
|
|
setKindVisible(false);
|
|
m_ui->pbHistory->setVisible(false);
|
|
|
|
//config movement track button
|
|
m_ui->pbMovementTrack->setCheckable(true);
|
|
|
|
//connects
|
|
connect(m_ui->pbFindOnMap, &QToolButton::clicked, this, &OcParticipantInfo::onFindOnMap);
|
|
connect(m_ui->pbMovementTrack, &QToolButton::clicked, this, &OcParticipantInfo::onMovementTrack);
|
|
|
|
}
|
|
|
|
OcParticipantInfo::~OcParticipantInfo()
|
|
{
|
|
delete m_ui;
|
|
}
|
|
|
|
bool OcParticipantInfo::init()
|
|
{
|
|
if (!m_session->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc))
|
|
return false;
|
|
if (!m_session->getDtc<ProjectDataManagement::DataInterface>(m_pdmDtc))
|
|
return false;
|
|
if (!m_session->getForeignDataInterface<AdvancedSymbology::DataInterface>(m_asbiIfc))
|
|
return false;
|
|
//optional
|
|
m_session->getForeignGuiInterface<SituationMap::ForeignGuiInterface>(m_sitMapGuiIfc);
|
|
m_session->getDtc<InfrastructureManagement::DataInterface>(m_ismDtc);
|
|
|
|
|
|
return setUiValues();
|
|
}
|
|
|
|
void OcParticipantInfo::retranslate()
|
|
{
|
|
translate(m_ui, tr("Participant Info") );
|
|
}
|
|
|
|
void OcParticipantInfo::setRed(QWidget *w, bool bRed)
|
|
{
|
|
if (!w)
|
|
return;
|
|
|
|
if (bRed)
|
|
{
|
|
QPalette pal = QApplication::palette(w);
|
|
pal.setColor(QPalette::Window, Qt::red);
|
|
w->setPalette(pal);
|
|
w->setAutoFillBackground(true);
|
|
}
|
|
else
|
|
{
|
|
// reset to default palette
|
|
w->setPalette(QApplication::palette(w));
|
|
w->setAutoFillBackground(false);
|
|
}
|
|
}
|
|
|
|
void OcParticipantInfo::updateIcon(const ParticipantManagement::Participant &participant)
|
|
{
|
|
m_symbolWatcher->setSymbolResult(m_asbiIfc->findImage(participant));
|
|
}
|
|
|
|
void OcParticipantInfo::updateIcon(const QColor &color, const QString &sidc)
|
|
{
|
|
AdvancedSymbology::SymbolDataToRender symDataToRender(sidc);
|
|
|
|
symDataToRender.injury = AdvancedSymbology::Injury::NoInjury;
|
|
symDataToRender.injuryColor = QColor();
|
|
symDataToRender.fillColor = color;
|
|
symDataToRender.fillColorReplace = true;
|
|
|
|
m_symbolWatcher->setSymbolResult(m_asbiIfc->findImage(symDataToRender));
|
|
}
|
|
|
|
bool OcParticipantInfo::setUiValues()
|
|
{
|
|
if (!m_ppmDtc || m_participant.id() < 0)
|
|
return false;
|
|
|
|
//hide findOnMap if no interface available
|
|
m_ui->pbFindOnMap->setVisible(m_sitMapGuiIfc != nullptr);
|
|
m_ui->tbNbc->setVisible(false); //show only if visible
|
|
|
|
// m_participant.id() was given within ctor
|
|
const ParticipantManagement::Participant participantData = m_ppmDtc->participant(m_participant.id());
|
|
m_typeClass = m_ppmDtc->type(participantData.typeId()).typeClass();
|
|
|
|
bool bUpdateDynamicParticipantData = true;
|
|
switch (m_typeClass.underlying())
|
|
{
|
|
case ParticipantManagement::TypeClass::Human:
|
|
case ParticipantManagement::TypeClass::GroundVehicle:
|
|
case ParticipantManagement::TypeClass::VehicleWithGear:
|
|
case ParticipantManagement::TypeClass::WeaponSystem:
|
|
case ParticipantManagement::TypeClass::Aircraft:
|
|
case ParticipantManagement::TypeClass::SupportEntity:
|
|
{
|
|
onParticipantChanged(participantData);
|
|
connect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::participantChanged,
|
|
this, &OcParticipantInfo::onParticipantChanged);
|
|
connect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::participantPositionChanged,
|
|
this, &OcParticipantInfo::onPositionChanged);
|
|
onPositionChanged(m_ppmDtc->participantPosition(participantData.id()));
|
|
|
|
if (m_sitMapGuiIfc)
|
|
{
|
|
const int32_t participantId = participantData.id();
|
|
|
|
m_ui->pbFindOnMap->setVisible(true);
|
|
|
|
m_ui->pbMovementTrack->setVisible(true);
|
|
m_ui->pbMovementTrack->setChecked(m_sitMapGuiIfc->isMovementTrackEnabled(participantId));
|
|
// set MovementTrackCallback:
|
|
std::function<void(const QVector<int32_t> &activeSimIds)> onMovementTrackChangedFunc = [this, participantId](const QVector<int32_t> &activeSimIds)
|
|
{
|
|
bool checkedNew = activeSimIds.contains(participantId);
|
|
|
|
if (m_ui->pbMovementTrack->isChecked() != checkedNew)
|
|
{
|
|
m_ui->pbMovementTrack->setChecked(checkedNew);
|
|
}
|
|
};
|
|
if (!m_sitMapGuiIfc->setMovementTrackCallback(this, onMovementTrackChangedFunc))
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " setMovementTrackCallback failed";
|
|
}
|
|
break;
|
|
}
|
|
case ParticipantManagement::TypeClass::Unit:
|
|
case ParticipantManagement::TypeClass::SupportUnit:
|
|
case ParticipantManagement::TypeClass::Vessel:
|
|
case ParticipantManagement::TypeClass::Unknown:
|
|
return false;
|
|
}
|
|
|
|
if (bUpdateDynamicParticipantData)
|
|
{
|
|
const auto dpd = m_ppmDtc->dynamicParticipantData(participantData.id());
|
|
if (dpd.participantId() || participantData.id())
|
|
{
|
|
onDynamicParticipantDataChanged(dpd);
|
|
}
|
|
else
|
|
{
|
|
const ParticipantManagement::Party party = m_ppmDtc->party(m_participant.partyId());
|
|
const QColor color = QColor::fromRgb(QRgb(party.color()));
|
|
|
|
updateIcon(color, QString::fromStdString(m_participant.symbol()));
|
|
}
|
|
}
|
|
|
|
|
|
//other connects
|
|
connect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::typeChanged,
|
|
this, &OcParticipantInfo::onTypeChanged);
|
|
connect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::dynamicParticipantDataChanged,
|
|
this, &OcParticipantInfo::onDynamicParticipantDataChanged);
|
|
connect(m_session, &LtsSession::LtsSession::partitionTimeChanged,
|
|
this, &OcParticipantInfo::onPartitionTimeChanged);
|
|
|
|
return true;
|
|
}
|
|
|
|
void OcParticipantInfo::setChargeVisible(bool vis)
|
|
{
|
|
m_ui->twGear->setVisible(vis);
|
|
}
|
|
|
|
void OcParticipantInfo::setSpecialSensorVisible(bool vis)
|
|
{
|
|
m_ui->lblSpecialSensorState->setVisible(vis);
|
|
m_ui->lbSpecialSensorState->setVisible(vis);
|
|
}
|
|
|
|
void OcParticipantInfo::setBuildingPosVisible(bool vis)
|
|
{
|
|
m_ui->lblBuilding->setVisible(vis);
|
|
m_ui->lblRoom->setVisible(vis);
|
|
}
|
|
|
|
void OcParticipantInfo::setKindVisible(bool vis)
|
|
{
|
|
m_ui->lblKind->setVisible(vis);
|
|
m_ui->lbKind->setVisible(vis);
|
|
}
|
|
|
|
|
|
void OcParticipantInfo::onDynamicParticipantDataChanged(const ParticipantManagement::DynamicParticipantData &data)
|
|
{
|
|
if (data.participantId() != m_participant.id() && data.participantId() != 0)
|
|
return;
|
|
|
|
//Current State
|
|
if (data.stateHistory().size() > 0)
|
|
{
|
|
const ProjectDataManagement::VulnerabilityClass vc = m_typeClass == ParticipantManagement::TypeClass::Human ?
|
|
ProjectDataManagement::VulnerabilityClass_def::SoldierInjuries :
|
|
ProjectDataManagement::VulnerabilityClass_def::VehicleDamages;
|
|
|
|
const ParticipantManagement::StateInformation &lastState = m_ppmDtc->youngestStateInformation(data.stateHistory());
|
|
m_ui->lblStatus->setText(ProjectDataManagement::toString(lastState.vulnerabilityState(), vc));
|
|
|
|
// VBA
|
|
setKindVisible(lastState.vulnerabilityKindId() > 0);
|
|
m_ui->lblKind->setText(m_pdmDtc->trVulnerabilityKindName(lastState.vulnerabilityKindId(), vc));
|
|
}
|
|
else
|
|
{
|
|
m_ui->lblStatus->setText(QStringLiteral("-"));
|
|
m_ui->lblKind->setText(QStringLiteral("-"));
|
|
}
|
|
|
|
setRed(m_ui->lblEquipNr, data.manipulation().size());
|
|
|
|
// Note: This is not transmitted to O/C. If so, we need to add LEDs for Apache.
|
|
// So long: Hide, if it's an aircraft.
|
|
|
|
// Special Sensor State
|
|
if (!data.specialSensorDataState() || m_typeClass == ParticipantManagement::TypeClass_def::Aircraft)
|
|
{
|
|
m_ui->lblSpecialSensorState->hide();
|
|
m_ui->lbSpecialSensorState->hide();
|
|
}
|
|
else
|
|
{
|
|
showSpecialSensorData(data.specialSensorDataState());
|
|
m_ui->lbSpecialSensorState->show();
|
|
m_ui->lblSpecialSensorState->show();
|
|
}
|
|
|
|
//Gear
|
|
if (data.gear().size() == 0)
|
|
{
|
|
m_gearList.clear();
|
|
m_ui->twGear->clearContents();
|
|
m_ui->twGear->hide();
|
|
m_ui->pbGearRanges->hide();
|
|
}
|
|
else if (data.gear() != m_gearList)
|
|
{
|
|
m_gearList = data.gear();
|
|
std::vector<ParticipantManagement::GearInformation> tmpGearList = m_gearList;
|
|
|
|
m_ui->twGear->show();
|
|
m_ui->pbGearRanges->show();
|
|
m_ui->twGear->clearContents();
|
|
|
|
int row = 0;
|
|
int rowCount = tmpGearList.size();
|
|
m_ui->twGear->setRowCount(rowCount);
|
|
m_ui->twGear->setSortingEnabled(false);
|
|
|
|
constexpr int unknownTasId = 0x80000000;
|
|
|
|
for (const ParticipantManagement::GearInformation &gearInfo : m_gearList)
|
|
{
|
|
QTableWidgetItem *item = nullptr;
|
|
if (gearInfo.chargeTypeId() <= 0) //chargTypeId 0 is near miss code
|
|
{
|
|
rowCount--;
|
|
continue;
|
|
}
|
|
|
|
const int gearTypeId = gearInfo.gearTypeId();
|
|
if ((gearTypeId & unknownTasId) == unknownTasId)
|
|
item = new QTableWidgetItem(tr("Unknown gear id %1").arg(gearTypeId & ~unknownTasId));
|
|
else if (gearTypeId == 0)
|
|
{
|
|
// Hack for old systems which neither send gearTasCode/gearType nor gearSerialNumber/gearId
|
|
// 1 = Wanne, 2 = Turm
|
|
switch (gearInfo.gearId())
|
|
{
|
|
case 1:
|
|
item = new QTableWidgetItem(tr("Tank", "Gear Type"));
|
|
break;
|
|
case 2:
|
|
item = new QTableWidgetItem(tr("Turret", "Gear Type"));
|
|
break;
|
|
default:
|
|
item = new QTableWidgetItem(tr("N/A", "Gear Type"));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
item = new QTableWidgetItem(m_pdmDtc->trGearTypeName(gearTypeId));
|
|
m_ui->twGear->setItem(row, 0, item);
|
|
|
|
if (gearInfo.chargeTypeId() != 0 && gearInfo.chargeTypeId() != -1) // hat Charge (and ignore only chargecounts)
|
|
{
|
|
int chargeTypeId = gearInfo.chargeTypeId();
|
|
if ((chargeTypeId & unknownTasId) == unknownTasId)
|
|
item = new QTableWidgetItem(tr("Unknown charge id %1").arg(chargeTypeId & ~unknownTasId));
|
|
else if (chargeTypeId == 0)
|
|
item = new QTableWidgetItem(tr("N/A", "Charge Type"));
|
|
else
|
|
{
|
|
item = new QTableWidgetItem(m_pdmDtc->trChargeTypeShortName(chargeTypeId, true));
|
|
item->setToolTip(m_pdmDtc->trChargeTypeName(chargeTypeId, true));
|
|
}
|
|
m_ui->twGear->setItem(row, 1, item);
|
|
//ressourceCount
|
|
//: Blank in this case refers to blank ammunition used for training
|
|
item = new QTableWidgetItem((gearInfo.remain() < 0) ? tr("N/A", "Blank Ammunition") : QString::number(gearInfo.remain()));
|
|
m_ui->twGear->setItem(row, 2, item);
|
|
}
|
|
row++;
|
|
}
|
|
m_ui->twGear->setRowCount(rowCount);
|
|
m_ui->twGear->setSortingEnabled(true);
|
|
|
|
} //end Gear
|
|
|
|
m_ui->tbNbc->setVisible(data.hasNbcProtectionConfigured() && data.hasNbcProtectionActive());
|
|
|
|
updateIcon(m_participant);
|
|
}
|
|
|
|
void OcParticipantInfo::showSpecialSensorData(int specialSensorData)
|
|
{
|
|
const int specialSensorDataState = specialSensorData & 0xFF;
|
|
QString strSpecialSensorData;
|
|
switch (specialSensorDataState)
|
|
{
|
|
case ParticipantManagement::SpecialSensorStatus_def::ChemicalDetectionFunction_NotOperational:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::ChemicalDetectionFunction_NotOperational);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::ChemicalDetectionFunction_Detecting:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::ChemicalDetectionFunction_Detecting);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::NBCDetectionAccessory_NotOperational:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::NBCDetectionAccessory_NotOperational);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::NBCDetectionAccessory_Test:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::NBCDetectionAccessory_Test);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::NBCDetectionAccessory_DetectingAir:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::NBCDetectionAccessory_DetectingAir);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::AVLB_Mounted:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::AVLB_Mounted);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::AVLB_Deployed:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::AVLB_Deployed);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::AVLB_Mounting:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::AVLB_Mounting);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::AVLB_Deploying:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::AVLB_Deploying);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineLayer_Operational:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineLayer_Operational);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineLayer_Laying:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineLayer_Laying);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineClearingFunction_March:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineClearingFunction_March);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineClearingFunction_ReadyToClear:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineClearingFunction_ReadyToClear);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineClearingFunction_Clearing:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineClearingFunction_Clearing);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_NotOperational:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_NotOperational);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_ParameterInput:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_ParameterInput);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_ReadyToDeploy:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_ReadyToDeploy);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_Deploying:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_Deploying);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_Resupply:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_Resupply);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_FinishDeploying:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::MineTrowingFunction_FinishDeploying);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::ADLER_Operational:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::ADLER_Operational);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::ADLER_ConditionallyOperational:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::ADLER_ConditionallyOperational);
|
|
break;
|
|
case ParticipantManagement::SpecialSensorStatus_def::ADLER_NotOperational:
|
|
strSpecialSensorData = toString(ParticipantManagement::SpecialSensorStatus_def::ADLER_NotOperational);
|
|
break;
|
|
|
|
default:
|
|
strSpecialSensorData = tr("Unknown (%1)").arg(specialSensorDataState);
|
|
break;
|
|
}
|
|
|
|
if ((specialSensorData & (1 << 8)) != 0)
|
|
strSpecialSensorData += QStringLiteral(" L");
|
|
if ((specialSensorData & (1 << 9)) != 0)
|
|
strSpecialSensorData += QStringLiteral(" R");
|
|
if ((specialSensorData & (1 << 10)) != 0)
|
|
strSpecialSensorData += QStringLiteral(" P");
|
|
if ((specialSensorData & (1 << 11)) != 0)
|
|
strSpecialSensorData += QStringLiteral(" F");
|
|
|
|
if (specialSensorDataState == 66) // CSF Spürbetrieb
|
|
{
|
|
const int type = (specialSensorData >> 12) & 0x0F;
|
|
strSpecialSensorData += QLatin1Char(' ');
|
|
switch (type)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
strSpecialSensorData += tr("FIR");
|
|
break;
|
|
case 3:
|
|
strSpecialSensorData += tr("ZABC");
|
|
break;
|
|
case 4:
|
|
strSpecialSensorData += tr("CSF");
|
|
break;
|
|
case 5:
|
|
strSpecialSensorData += tr("PzBr");
|
|
break;
|
|
case 6:
|
|
strSpecialSensorData += tr("MV");
|
|
break;
|
|
case 7:
|
|
strSpecialSensorData += tr("MRF");
|
|
break;
|
|
case 8:
|
|
strSpecialSensorData += tr("WMV");
|
|
break;
|
|
case 0:
|
|
default:
|
|
break;
|
|
}
|
|
if (type == 4) // CSF
|
|
{
|
|
const int nbcType = (specialSensorData >> 16) & 0x03;
|
|
strSpecialSensorData += QLatin1Char(' ');
|
|
switch (nbcType)
|
|
{
|
|
case 0:
|
|
strSpecialSensorData += tr("No C-Agent");
|
|
break;
|
|
case 1:
|
|
strSpecialSensorData += tr("Sarin");
|
|
break;
|
|
case 2:
|
|
strSpecialSensorData += tr("VX");
|
|
break;
|
|
case 3:
|
|
strSpecialSensorData += tr("S-Lost");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
m_ui->lblSpecialSensorState->setText(strSpecialSensorData);
|
|
}
|
|
|
|
void OcParticipantInfo::onPositionChanged(const ParticipantManagement::ParticipantPosition &position)
|
|
{
|
|
if (position.participantId() != m_participant.id() && position.participantId() != 0)
|
|
return;
|
|
|
|
onUpdatePosition(position.participantId(), position.pos(), position.sampleTime());
|
|
|
|
if (m_ismDtc && m_roomId != position.roomId())
|
|
{
|
|
if (position.roomId() > 0)
|
|
{
|
|
const auto mse = m_ismDtc->mainStructureElement(position.buildingId());
|
|
QString roomName;
|
|
for (const auto &room : mse.elements())
|
|
{
|
|
if (room.id() == position.roomId())
|
|
{
|
|
roomName = QString::fromStdString(room.displayName());
|
|
break;
|
|
}
|
|
}
|
|
QString buildingName = m_ismDtc->getBuildingDisplayName(mse);
|
|
|
|
m_roomId = position.roomId();
|
|
m_ui->lblBuilding->setText(buildingName);
|
|
m_ui->lblRoom->setText(roomName);
|
|
}
|
|
setBuildingPosVisible(m_roomId > 0);
|
|
}
|
|
|
|
if (position.mountedOn().is_set())
|
|
{
|
|
const auto mountedOnParticipant = m_ppmDtc->participant(position.mountedOn().get());
|
|
if (mountedOnParticipant.equipmentNumber().is_set())
|
|
m_ui->pbMountedOn->setText(QString::number(mountedOnParticipant.equipmentNumber().get()));
|
|
else
|
|
m_ui->pbMountedOn->setText(QString::number(0));
|
|
m_ui->pbMountedOn->show();
|
|
}
|
|
else
|
|
m_ui->pbMountedOn->hide();
|
|
|
|
if (position.mountedParticipants().is_set())
|
|
{
|
|
m_ui->pbMountedParticipants->setText(QString::number(position.mountedParticipants().get().size()));
|
|
m_ui->pbMountedParticipants->show();
|
|
}
|
|
else
|
|
m_ui->pbMountedParticipants->hide();
|
|
}
|
|
|
|
|
|
void OcParticipantInfo::onUpdatePosition(int participantId, const Core::GeoPosition &position, qint64 sampleTime)
|
|
{
|
|
m_lastPositionMSec = sampleTime;
|
|
if ((position.lat() == 0 && position.lon() == 0) || participantId == 0 || std::isnan(position.lon()) || std::isnan(position.lat()))
|
|
{
|
|
m_ui->lblPosition->setText(tr("Invalid Position"));
|
|
}
|
|
else
|
|
{
|
|
QString mgrs = LtsCoordTrans::mgrsFromGeographic(position.lon(), position.lat());
|
|
|
|
if (!qFuzzyIsNull(position.z()))
|
|
mgrs += QStringLiteral(" | ") + QString::number(position.z(), 'f', 2);
|
|
|
|
m_ui->lblPosition->setText(mgrs);
|
|
}
|
|
}
|
|
|
|
void OcParticipantInfo::onParticipantChanged(const ParticipantManagement::Participant &participant)
|
|
{
|
|
if (participant.id() != m_participant.id())
|
|
return;
|
|
|
|
if (m_participant.typeId() != participant.typeId())
|
|
m_ui->lblType->setText(ParticipantManagement::trTypeName(m_ppmDtc->type(participant.typeId()).name()));
|
|
if (m_participant.partyId() != participant.partyId())
|
|
m_ui->lblParty->setText(ParticipantManagement::trPartyName(m_ppmDtc->party(participant.partyId()).name()));
|
|
m_ui->lblDesignator->setText(QString::fromStdString(participant.designator()));
|
|
m_ui->lblTactitcalIdentifier->setText(QString::fromStdString(participant.tacticalIdentifier()));
|
|
|
|
if (participant.equipmentNumber().is_set())
|
|
m_ui->lblEquipNr->setText(QString::number(participant.equipmentNumber().get()));
|
|
else if (participant.isSimulated())
|
|
m_ui->lblEquipNr->setText(tr("simulated"));
|
|
else
|
|
m_ui->lblEquipNr->setText(QLatin1String("-"));
|
|
|
|
#ifdef LTS_DEBUG
|
|
m_ui->lblEquipNr->setToolTip(QString::number(participant.id()));
|
|
#endif
|
|
|
|
|
|
m_participant = participant;
|
|
|
|
//hide Info if not exists
|
|
m_ui->lblInfoText->setText(QString::fromStdString(participant.info()));
|
|
m_ui->lblInfoText->setVisible(participant.info().size() > 0);
|
|
m_ui->lblInfo->setVisible(participant.info().size() > 0);
|
|
m_ui->lblInfo->setText(QString::number(participant.info().size()));
|
|
|
|
onDynamicParticipantDataChanged(m_ppmDtc->dynamicParticipantData(participant.id()));
|
|
}
|
|
|
|
void OcParticipantInfo::onTypeChanged(const ParticipantManagement::Type &type, DataModification modType)
|
|
{
|
|
Q_UNUSED(modType)
|
|
if (m_participant.typeId() != type.id())
|
|
return;
|
|
m_ui->lblType->setText(ParticipantManagement::trTypeName(type.name()));
|
|
}
|
|
|
|
void OcParticipantInfo::onPartitionTimeChanged(qint64 newPartitionTime)
|
|
{
|
|
setRed(m_ui->lblPosition, LtsUtils::isPositionTimeOutdated(newPartitionTime, m_lastPositionMSec)); //10minuten
|
|
}
|
|
|
|
|
|
void OcParticipantInfo::onFindOnMap()
|
|
{
|
|
if (m_sitMapGuiIfc)
|
|
m_sitMapGuiIfc->centerMapToParticipant(m_participant.id());
|
|
}
|
|
|
|
void OcParticipantInfo::onMovementTrack()
|
|
{
|
|
if (m_sitMapGuiIfc)
|
|
m_sitMapGuiIfc->enableMovementTrack(m_participant.id(), m_ui->pbMovementTrack->isChecked());
|
|
}
|
|
|
|
|
|
} // namespace OcSituationClient
|