You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1712 lines
61 KiB
1712 lines
61 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2021-2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Copyright (C) 2021-2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2021 DreamNik <dreamnik@mail.ru> // |
|
// // |
|
// This program 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 as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program 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 V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <cmath> |
|
#include <QMessageBox> |
|
#include <QLineEdit> |
|
#include <QRegExp> |
|
|
|
#include <QtCharts/QChartView> |
|
#include <QtCharts/QLineSeries> |
|
#include <QtCharts/QDateTimeAxis> |
|
#include <QtCharts/QValueAxis> |
|
|
|
#include "channel/channelwebapiutils.h" |
|
#include "feature/featureset.h" |
|
#include "feature/featureuiset.h" |
|
#include "feature/featureutils.h" |
|
#include "feature/featurewebapiutils.h" |
|
#include "gui/basicfeaturesettingsdialog.h" |
|
#include "gui/dialogpositioner.h" |
|
#include "util/units.h" |
|
#include "device/deviceapi.h" |
|
#include "device/deviceset.h" |
|
#include "maincore.h" |
|
|
|
#include "ui_satellitetrackergui.h" |
|
#include "satellitetracker.h" |
|
#include "satellitetrackergui.h" |
|
#include "satellitetrackerreport.h" |
|
#include "satellitetrackersettingsdialog.h" |
|
#include "satelliteselectiondialog.h" |
|
#include "satelliteradiocontroldialog.h" |
|
#include "satellitetrackersgp4.h" |
|
|
|
SatelliteTrackerGUI* SatelliteTrackerGUI::create(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature) |
|
{ |
|
SatelliteTrackerGUI* gui = new SatelliteTrackerGUI(pluginAPI, featureUISet, feature); |
|
return gui; |
|
} |
|
|
|
void SatelliteTrackerGUI::destroy() |
|
{ |
|
delete this; |
|
} |
|
|
|
void SatelliteTrackerGUI::resetToDefaults() |
|
{ |
|
m_settings.resetToDefaults(); |
|
displaySettings(); |
|
applySettings(true); |
|
} |
|
|
|
QByteArray SatelliteTrackerGUI::serialize() const |
|
{ |
|
return m_settings.serialize(); |
|
} |
|
|
|
bool SatelliteTrackerGUI::deserialize(const QByteArray& data) |
|
{ |
|
if (m_settings.deserialize(data)) |
|
{ |
|
m_feature->setWorkspaceIndex(m_settings.m_workspaceIndex); |
|
updateSelectedSats(); |
|
displaySettings(); |
|
applySettings(true); |
|
return true; |
|
} |
|
else |
|
{ |
|
resetToDefaults(); |
|
return false; |
|
} |
|
} |
|
|
|
QString SatelliteTrackerGUI::convertDegreesToText(double degrees) |
|
{ |
|
if (m_settings.m_azElUnits == SatelliteTrackerSettings::DMS) |
|
return Units::decimalDegreesToDegreeMinutesAndSeconds(degrees); |
|
else if (m_settings.m_azElUnits == SatelliteTrackerSettings::DM) |
|
return Units::decimalDegreesToDegreesAndMinutes(degrees); |
|
else if (m_settings.m_azElUnits == SatelliteTrackerSettings::D) |
|
return Units::decimalDegreesToDegrees(degrees); |
|
else |
|
return QString("%1").arg(degrees, 0, 'f', 2); |
|
} |
|
|
|
bool SatelliteTrackerGUI::handleMessage(const Message& message) |
|
{ |
|
if (SatelliteTracker::MsgConfigureSatelliteTracker::match(message)) |
|
{ |
|
qDebug("SatelliteTrackerGUI::handleMessage: SatelliteTracker::MsgConfigureSatelliteTracker"); |
|
const SatelliteTracker::MsgConfigureSatelliteTracker& cfg = (SatelliteTracker::MsgConfigureSatelliteTracker&) message; |
|
|
|
if (cfg.getForce()) { |
|
m_settings = cfg.getSettings(); |
|
} else { |
|
m_settings.applySettings(cfg.getSettingsKeys(), cfg.getSettings()); |
|
} |
|
|
|
blockApplySettings(true); |
|
displaySettings(); |
|
blockApplySettings(false); |
|
|
|
return true; |
|
} |
|
else if (SatelliteTrackerReport::MsgReportSat::match(message)) |
|
{ |
|
SatelliteTrackerReport::MsgReportSat& satReport = (SatelliteTrackerReport::MsgReportSat&) message; |
|
SatelliteState *satState = satReport.getSatelliteState(); |
|
|
|
if (satState->m_name == m_settings.m_target) |
|
{ |
|
delete m_targetSatState; |
|
m_targetSatState = satState; |
|
|
|
ui->azimuth->setText(convertDegreesToText(satState->m_azimuth)); |
|
ui->elevation->setText(convertDegreesToText(satState->m_elevation)); |
|
plotChart(); |
|
|
|
if (satState->m_passes.size() > 0) |
|
{ |
|
const SatellitePass &pass = satState->m_passes[0]; |
|
bool geostationary = !pass.m_aos.isValid() && !pass.m_los.isValid(); |
|
|
|
if ((m_nextTargetAOS != pass.m_aos) || (m_nextTargetLOS != pass.m_los) || (geostationary != m_geostationarySatVisible)) |
|
{ |
|
m_nextTargetAOS = pass.m_aos; |
|
m_nextTargetLOS = pass.m_los; |
|
m_geostationarySatVisible = geostationary; |
|
updateTimeToAOS(); |
|
} |
|
} |
|
} |
|
|
|
updateTable(satState); |
|
|
|
if (satState->m_name != m_settings.m_target) { |
|
delete satState; |
|
} |
|
|
|
return true; |
|
} |
|
else if (SatelliteTrackerReport::MsgReportAOS::match(message)) |
|
{ |
|
SatelliteTrackerReport::MsgReportAOS& aosReport = (SatelliteTrackerReport::MsgReportAOS&) message; |
|
aos(aosReport.getSpeech()); |
|
return true; |
|
} |
|
else if (SatelliteTrackerReport::MsgReportTarget::match(message)) |
|
{ |
|
SatelliteTrackerReport::MsgReportTarget& targetReport = (SatelliteTrackerReport::MsgReportTarget&) message; |
|
setTarget(targetReport.getName()); |
|
return true; |
|
} |
|
else if (SatelliteTrackerReport::MsgReportLOS::match(message)) |
|
{ |
|
SatelliteTrackerReport::MsgReportLOS& losReport = (SatelliteTrackerReport::MsgReportLOS&) message; |
|
los(losReport.getSpeech()); |
|
return true; |
|
} |
|
else if (SatelliteTracker::MsgSatData::match(message)) |
|
{ |
|
SatelliteTracker::MsgSatData& satData = (SatelliteTracker::MsgSatData&) message; |
|
m_satellites = satData.getSatellites(); |
|
// Remove satellites that no longer exist |
|
QMutableListIterator<QString> itr(m_settings.m_satellites); |
|
|
|
while (itr.hasNext()) |
|
{ |
|
QString satellite = itr.next(); |
|
if (!m_satellites.contains(satellite)) |
|
itr.remove(); |
|
} |
|
|
|
if (!m_satellites.contains(m_settings.m_target)) { |
|
setTarget(""); |
|
} |
|
|
|
// Update GUI |
|
updateSelectedSats(); |
|
|
|
return true; |
|
} |
|
else if (SatelliteTracker::MsgError::match(message)) |
|
{ |
|
SatelliteTracker::MsgError& errorMsg = (SatelliteTracker::MsgError&) message; |
|
QString error = errorMsg.getError(); |
|
QMessageBox::critical(this, "Satellite Tracker", error); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
// Call when m_settings.m_satellites changes |
|
void SatelliteTrackerGUI::updateSelectedSats() |
|
{ |
|
// Remove unselects sats from target combo and table |
|
for (int i = 0; i < ui->target->count(); ) |
|
{ |
|
QString name = ui->target->itemText(i); |
|
int idx = m_settings.m_satellites.indexOf(name); |
|
|
|
if (idx == -1) |
|
{ |
|
ui->target->removeItem(i); |
|
QList<QTableWidgetItem *> matches = ui->satTable->findItems(name, Qt::MatchExactly); |
|
|
|
for (int j = 0; j < matches.length(); j++) { |
|
ui->satTable->removeRow(ui->satTable->row(matches[j])); |
|
} |
|
} |
|
else |
|
{ |
|
i++; |
|
} |
|
} |
|
|
|
// Add new satellites to target combo |
|
for (int i = 0; i < m_settings.m_satellites.size(); i++) |
|
{ |
|
if (ui->target->findText(m_settings.m_satellites[i], Qt::MatchExactly) == -1) { |
|
ui->target->addItem(m_settings.m_satellites[i]); |
|
} |
|
} |
|
// Select current target, if it still exists |
|
int idx = ui->target->findText(m_settings.m_target); |
|
|
|
if (idx != -1) { |
|
ui->target->setCurrentIndex(idx); |
|
} else { |
|
setTarget(""); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::handleInputMessages() |
|
{ |
|
Message* message; |
|
|
|
while ((message = getInputMessageQueue()->pop())) |
|
{ |
|
if (handleMessage(*message)) { |
|
delete message; |
|
} |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::onWidgetRolled(QWidget* widget, bool rollDown) |
|
{ |
|
(void) widget; |
|
(void) rollDown; |
|
|
|
RollupContents *rollupContents = getRollupContents(); |
|
rollupContents->saveState(m_rollupState); |
|
} |
|
|
|
SatelliteTrackerGUI::SatelliteTrackerGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature, QWidget* parent) : |
|
FeatureGUI(parent), |
|
ui(new Ui::SatelliteTrackerGUI), |
|
m_pluginAPI(pluginAPI), |
|
m_featureUISet(featureUISet), |
|
m_doApplySettings(true), |
|
m_lastFeatureState(0), |
|
m_lastUpdatingSatData(false), |
|
m_targetSatState(nullptr), |
|
m_plotPass(0), |
|
m_lineChart(nullptr), |
|
m_polarChart(nullptr), |
|
m_geostationarySatVisible(false) |
|
{ |
|
m_feature = feature; |
|
setAttribute(Qt::WA_DeleteOnClose, true); |
|
m_helpURL = "plugins/feature/satellitetracker/readme.md"; |
|
RollupContents *rollupContents = getRollupContents(); |
|
ui->setupUi(rollupContents); |
|
rollupContents->arrangeRollups(); |
|
connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool))); |
|
|
|
m_satelliteTracker = reinterpret_cast<SatelliteTracker*>(feature); |
|
m_satelliteTracker->setMessageQueueToGUI(&m_inputMessageQueue); |
|
|
|
m_settings.setRollupState(&m_rollupState); |
|
|
|
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &))); |
|
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages())); |
|
|
|
connect(&m_statusTimer, SIGNAL(timeout()), this, SLOT(updateStatus())); |
|
m_statusTimer.start(1000); |
|
|
|
connect(&m_redrawTimer, &QTimer::timeout, this, &SatelliteTrackerGUI::plotChart); |
|
|
|
// Initialise charts |
|
m_emptyChart.layout()->setContentsMargins(0, 0, 0, 0); |
|
m_emptyChart.setMargins(QMargins(1, 1, 1, 1)); |
|
ui->passChart->setChart(&m_emptyChart); |
|
ui->passChart->setRenderHint(QPainter::Antialiasing); |
|
|
|
ui->dateTime->setDateTime(m_satelliteTracker->currentDateTime()); |
|
ui->deviceFeatureSelect->setVisible(false); |
|
|
|
resizeTable(); |
|
// Allow user to reorder columns |
|
ui->satTable->horizontalHeader()->setSectionsMovable(true); |
|
// Allow user to sort table by clicking on headers |
|
ui->satTable->setSortingEnabled(true); |
|
// Add context menu to allow hiding/showing of columns |
|
menu = new QMenu(ui->satTable); |
|
|
|
for (int i = 0; i < ui->satTable->horizontalHeader()->count(); i++) |
|
{ |
|
QString text = ui->satTable->horizontalHeaderItem(i)->text(); |
|
menu->addAction(createCheckableItem(text, i, true)); |
|
} |
|
|
|
ui->satTable->horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu); |
|
connect(ui->satTable->horizontalHeader(), SIGNAL(customContextMenuRequested(QPoint)), SLOT(columnSelectMenu(QPoint))); |
|
// Get signals when columns change |
|
connect(ui->satTable->horizontalHeader(), SIGNAL(sectionMoved(int, int, int)), SLOT(satTable_sectionMoved(int, int, int))); |
|
connect(ui->satTable->horizontalHeader(), SIGNAL(sectionResized(int, int, int)), SLOT(satTable_sectionResized(int, int, int))); |
|
|
|
m_speech = new QTextToSpeech(this); |
|
|
|
displaySettings(); |
|
applySettings(true); |
|
makeUIConnections(); |
|
m_resizer.enableChildMouseTracking(); |
|
|
|
// Get initial list of satellites |
|
on_updateSatData_clicked(); |
|
|
|
// Use My Position from preferences, if none set |
|
if ((m_settings.m_latitude == 0.0) && (m_settings.m_longitude == 0.0)) { |
|
on_useMyPosition_clicked(); |
|
} |
|
} |
|
|
|
SatelliteTrackerGUI::~SatelliteTrackerGUI() |
|
{ |
|
delete ui; |
|
} |
|
|
|
void SatelliteTrackerGUI::setWorkspaceIndex(int index) |
|
{ |
|
m_settings.m_workspaceIndex = index; |
|
m_settingsKeys.append("workspaceIndex"); |
|
m_feature->setWorkspaceIndex(index); |
|
} |
|
|
|
void SatelliteTrackerGUI::blockApplySettings(bool block) |
|
{ |
|
m_doApplySettings = !block; |
|
} |
|
|
|
void SatelliteTrackerGUI::displaySettings() |
|
{ |
|
setTitleColor(m_settings.m_rgbColor); |
|
setWindowTitle(m_settings.m_title); |
|
setTitle(m_settings.m_title); |
|
blockApplySettings(true); |
|
ui->latitude->setValue(m_settings.m_latitude); |
|
ui->longitude->setValue(m_settings.m_longitude); |
|
|
|
ui->target->blockSignals(true); |
|
ui->target->clear(); |
|
for (const QString& s : m_settings.m_satellites) { |
|
ui->target->addItem(s); |
|
} |
|
ui->target->blockSignals(false); |
|
ui->target->setCurrentIndex(ui->target->findText(m_settings.m_target)); |
|
|
|
ui->dateTime->setDateTime(QDateTime::fromString(m_settings.m_dateTime, Qt::ISODateWithMs)); |
|
ui->dateTimeSelect->setCurrentIndex((int)m_settings.m_dateTimeSelect); |
|
ui->dateTime->setVisible(m_settings.m_dateTimeSelect == SatelliteTrackerSettings::CUSTOM); |
|
ui->autoTarget->setChecked(m_settings.m_autoTarget); |
|
ui->darkTheme->setChecked(m_settings.m_chartsDarkTheme); |
|
ui->satTable->horizontalHeader()->setSortIndicator(m_settings.m_columnSort, m_settings.m_columnSortOrder); |
|
getRollupContents()->restoreState(m_rollupState); |
|
plotChart(); |
|
blockApplySettings(false); |
|
} |
|
|
|
void SatelliteTrackerGUI::onMenuDialogCalled(const QPoint &p) |
|
{ |
|
if (m_contextMenuType == ContextMenuChannelSettings) |
|
{ |
|
BasicFeatureSettingsDialog dialog(this); |
|
dialog.setTitle(m_settings.m_title); |
|
dialog.setUseReverseAPI(m_settings.m_useReverseAPI); |
|
dialog.setReverseAPIAddress(m_settings.m_reverseAPIAddress); |
|
dialog.setReverseAPIPort(m_settings.m_reverseAPIPort); |
|
dialog.setReverseAPIFeatureSetIndex(m_settings.m_reverseAPIFeatureSetIndex); |
|
dialog.setReverseAPIFeatureIndex(m_settings.m_reverseAPIFeatureIndex); |
|
dialog.setDefaultTitle(m_displayedName); |
|
|
|
dialog.move(p); |
|
new DialogPositioner(&dialog, false); |
|
dialog.exec(); |
|
|
|
m_settings.m_title = dialog.getTitle(); |
|
m_settings.m_useReverseAPI = dialog.useReverseAPI(); |
|
m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress(); |
|
m_settings.m_reverseAPIPort = dialog.getReverseAPIPort(); |
|
m_settings.m_reverseAPIFeatureSetIndex = dialog.getReverseAPIFeatureSetIndex(); |
|
m_settings.m_reverseAPIFeatureIndex = dialog.getReverseAPIFeatureIndex(); |
|
|
|
setTitle(m_settings.m_title); |
|
setTitleColor(m_settings.m_rgbColor); |
|
|
|
m_settingsKeys.append("title"); |
|
m_settingsKeys.append("rgbColor"); |
|
m_settingsKeys.append("useReverseAPI"); |
|
m_settingsKeys.append("reverseAPIAddress"); |
|
m_settingsKeys.append("reverseAPIPort"); |
|
m_settingsKeys.append("reverseAPIFeatureSetIndex"); |
|
m_settingsKeys.append("reverseAPIFeatureIndex"); |
|
|
|
applySettings(); |
|
} |
|
|
|
resetContextMenuType(); |
|
} |
|
|
|
void SatelliteTrackerGUI::aos(const QString &speech) |
|
{ |
|
// Call plotChart() to start the periodic updates with sat position in polar chart |
|
plotChart(); |
|
// Give speech notification of pass |
|
if (!speech.isEmpty()) { |
|
m_speech->say(speech); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::los(const QString &speech) |
|
{ |
|
// Give speech notification of end of pass |
|
if (!speech.isEmpty()) { |
|
m_speech->say(speech); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_startStop_toggled(bool checked) |
|
{ |
|
if (m_doApplySettings) |
|
{ |
|
SatelliteTracker::MsgStartStop *message = SatelliteTracker::MsgStartStop::create(checked); |
|
m_satelliteTracker->getInputMessageQueue()->push(message); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_latitude_valueChanged(double value) |
|
{ |
|
m_settings.m_latitude = value; |
|
m_settingsKeys.append("latitude"); |
|
applySettings(); |
|
plotChart(); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_longitude_valueChanged(double value) |
|
{ |
|
m_settings.m_longitude = value; |
|
m_settingsKeys.append("longitude"); |
|
applySettings(); |
|
plotChart(); |
|
} |
|
|
|
void SatelliteTrackerGUI::setTarget(const QString& target) |
|
{ |
|
if (target != m_settings.m_target) |
|
{ |
|
m_settings.m_target = target; |
|
m_settingsKeys.append("target"); |
|
ui->azimuth->setText(""); |
|
ui->elevation->setText(""); |
|
ui->aos->setText(""); |
|
ui->target->setCurrentIndex(ui->target->findText(m_settings.m_target)); |
|
m_nextTargetAOS = QDateTime(); |
|
m_nextTargetLOS = QDateTime(); |
|
m_geostationarySatVisible = false; |
|
applySettings(); |
|
delete m_targetSatState; |
|
m_targetSatState = nullptr; |
|
m_plotPass = 0; |
|
ui->passLabel->setText(QString("%1").arg(m_plotPass)); |
|
plotChart(); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_target_currentTextChanged(const QString &text) |
|
{ |
|
setTarget(text); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_useMyPosition_clicked(bool checked) |
|
{ |
|
(void) checked; |
|
double stationLatitude = MainCore::instance()->getSettings().getLatitude(); |
|
double stationLongitude = MainCore::instance()->getSettings().getLongitude(); |
|
double stationAltitude = MainCore::instance()->getSettings().getAltitude(); |
|
|
|
ui->latitude->setValue(stationLatitude); |
|
ui->longitude->setValue(stationLongitude); |
|
m_settings.m_heightAboveSeaLevel = stationAltitude; |
|
m_settingsKeys.append("heightAboveSeaLevel"); |
|
applySettings(); |
|
plotChart(); |
|
} |
|
|
|
// Show settings dialog |
|
void SatelliteTrackerGUI::on_displaySettings_clicked() |
|
{ |
|
SatelliteTrackerSettingsDialog dialog(&m_settings); |
|
new DialogPositioner(&dialog, true); |
|
if (dialog.exec() == QDialog::Accepted) |
|
{ |
|
m_settingsKeys.append("heightAboveSeaLevel"); |
|
m_settingsKeys.append("predictionPeriod"); |
|
m_settingsKeys.append("passStartTime"); |
|
m_settingsKeys.append("passFinishTime"); |
|
m_settingsKeys.append("minAOSElevation"); |
|
m_settingsKeys.append("minPassElevation"); |
|
m_settingsKeys.append("rotatorMaxAzimuth"); |
|
m_settingsKeys.append("rotatorMaxElevation"); |
|
m_settingsKeys.append("aosSpeech"); |
|
m_settingsKeys.append("losSpeech"); |
|
m_settingsKeys.append("aosCommand"); |
|
m_settingsKeys.append("losCommand"); |
|
m_settingsKeys.append("updatePeriod"); |
|
m_settingsKeys.append("dopplerPeriod"); |
|
m_settingsKeys.append("defaultFrequency"); |
|
m_settingsKeys.append("azElUnits"); |
|
m_settingsKeys.append("groundTrackPoints"); |
|
m_settingsKeys.append("drawRotators"); |
|
m_settingsKeys.append("dateFormat"); |
|
m_settingsKeys.append("utc"); |
|
m_settingsKeys.append("tles"); |
|
m_settingsKeys.append("replayEnabled"); |
|
m_settingsKeys.append("replayStartDateTime"); |
|
m_settingsKeys.append("sendTimeToMap"); |
|
applySettings(); |
|
plotChart(); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_dateTimeSelect_currentIndexChanged(int index) |
|
{ |
|
m_settings.m_dateTimeSelect = (SatelliteTrackerSettings::DateTimeSelect)index; |
|
|
|
if (m_settings.m_dateTimeSelect != SatelliteTrackerSettings::CUSTOM) |
|
{ |
|
m_settings.m_dateTime = ""; |
|
ui->dateTime->setVisible(false); |
|
} |
|
else |
|
{ |
|
m_settings.m_dateTime = ui->dateTime->dateTime().toString(Qt::ISODateWithMs); |
|
ui->dateTime->setVisible(true); |
|
} |
|
|
|
ui->deviceFeatureSelect->setVisible(m_settings.m_dateTimeSelect >= SatelliteTrackerSettings::FROM_MAP); |
|
updateDeviceFeatureCombo(); |
|
|
|
m_settingsKeys.append("dateTimeSelect"); |
|
m_settingsKeys.append("dateTime"); |
|
|
|
applySettings(); |
|
plotChart(); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_dateTime_dateTimeChanged(const QDateTime &datetime) |
|
{ |
|
(void) datetime; |
|
|
|
if (ui->dateTimeSelect->currentIndex() == 1) |
|
{ |
|
m_settings.m_dateTime = ui->dateTime->dateTime().toString(Qt::ISODateWithMs); |
|
m_settingsKeys.append("dateTime"); |
|
applySettings(); |
|
plotChart(); |
|
} |
|
} |
|
|
|
// Find target on the Map |
|
void SatelliteTrackerGUI::on_viewOnMap_clicked() |
|
{ |
|
if (!m_settings.m_target.isEmpty()) { |
|
FeatureWebAPIUtils::mapFind(m_settings.m_target); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_updateSatData_clicked() |
|
{ |
|
m_satelliteTracker->getInputMessageQueue()->push(SatelliteTracker::MsgUpdateSatData::create()); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_selectSats_clicked() |
|
{ |
|
SatelliteSelectionDialog dialog(&m_settings, m_satellites); |
|
new DialogPositioner(&dialog, true); |
|
if (dialog.exec() == QDialog::Accepted) |
|
{ |
|
updateSelectedSats(); |
|
m_settingsKeys.append("satellites"); |
|
applySettings(); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_radioControl_clicked() |
|
{ |
|
SatelliteRadioControlDialog dialog(&m_settings, m_satellites); |
|
new DialogPositioner(&dialog, true); |
|
if (dialog.exec() == QDialog::Accepted) |
|
{ |
|
m_settingsKeys.append("deviceSettings"); |
|
applySettings(); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_autoTarget_clicked(bool checked) |
|
{ |
|
m_settings.m_autoTarget = checked; |
|
m_settingsKeys.append("autoTarget"); |
|
applySettings(); |
|
} |
|
|
|
void SatelliteTrackerGUI::updateStatus() |
|
{ |
|
int state = m_satelliteTracker->getState(); |
|
|
|
if (m_lastFeatureState != state) |
|
{ |
|
// We set checked state of start/stop button, in case it was changed via API |
|
bool oldState; |
|
switch (state) |
|
{ |
|
case Feature::StNotStarted: |
|
ui->startStop->setStyleSheet("QToolButton { background:rgb(79,79,79); }"); |
|
break; |
|
case Feature::StIdle: |
|
oldState = ui->startStop->blockSignals(true); |
|
ui->startStop->setChecked(false); |
|
ui->startStop->blockSignals(oldState); |
|
ui->startStop->setStyleSheet("QToolButton { background-color : blue; }"); |
|
break; |
|
case Feature::StRunning: |
|
oldState = ui->startStop->blockSignals(true); |
|
ui->startStop->setChecked(true); |
|
ui->startStop->blockSignals(oldState); |
|
ui->startStop->setStyleSheet("QToolButton { background-color : green; }"); |
|
break; |
|
case Feature::StError: |
|
ui->startStop->setStyleSheet("QToolButton { background-color : red; }"); |
|
QMessageBox::information(this, tr("Message"), m_satelliteTracker->getErrorMessage()); |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
m_lastFeatureState = state; |
|
} |
|
|
|
// Indicate if satellite data is being updated |
|
bool updatingSatData = m_satelliteTracker->isUpdatingSatData(); |
|
|
|
if (updatingSatData != m_lastUpdatingSatData) |
|
{ |
|
if (updatingSatData) { |
|
ui->updateSatData->setStyleSheet("QToolButton { background-color : green; }"); |
|
} else { |
|
ui->updateSatData->setStyleSheet("QToolButton { background: none; }"); |
|
} |
|
|
|
m_lastUpdatingSatData = updatingSatData; |
|
} |
|
|
|
updateTimeToAOS(); |
|
updateDeviceFeatureCombo(); |
|
} |
|
|
|
// Update time to AOS |
|
void SatelliteTrackerGUI::updateTimeToAOS() |
|
{ |
|
if (m_geostationarySatVisible) |
|
{ |
|
ui->aos->setText("Now"); |
|
} |
|
else if (m_nextTargetAOS.isValid()) |
|
{ |
|
QDateTime currentTime = m_satelliteTracker->currentDateTime(); // FIXME: UTC |
|
int secondsToAOS = m_nextTargetAOS.toSecsSinceEpoch() - currentTime.toSecsSinceEpoch(); |
|
|
|
if (secondsToAOS > 0) |
|
{ |
|
int seconds = secondsToAOS % 60; |
|
int minutes = (secondsToAOS / 60) % 60; |
|
int hours = (secondsToAOS / (60 * 60)) % 24; |
|
int days = secondsToAOS / (60 * 60 * 24); |
|
|
|
if (days == 1) |
|
{ |
|
ui->aos->setText(QString("1 day")); |
|
} |
|
else if (days > 0) |
|
{ |
|
ui->aos->setText(QString("%1 days").arg(days)); |
|
} |
|
else |
|
{ |
|
ui->aos->setText(QString("%1:%2:%3") |
|
.arg(hours, 2, 10, QLatin1Char('0')) |
|
.arg(minutes, 2, 10, QLatin1Char('0')) |
|
.arg(seconds, 2, 10, QLatin1Char('0'))); |
|
} |
|
} |
|
else if (m_nextTargetLOS < currentTime) |
|
{ |
|
ui->aos->setText(""); |
|
} |
|
else |
|
{ |
|
ui->aos->setText("Now"); |
|
} |
|
} |
|
else |
|
ui->aos->setText(""); |
|
} |
|
|
|
void SatelliteTrackerGUI::applySettings(bool force) |
|
{ |
|
if (m_doApplySettings) |
|
{ |
|
SatelliteTracker::MsgConfigureSatelliteTracker* message = SatelliteTracker::MsgConfigureSatelliteTracker::create( |
|
m_settings, m_settingsKeys, force); |
|
m_satelliteTracker->getInputMessageQueue()->push(message); |
|
} |
|
|
|
m_settingsKeys.clear(); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_nextPass_clicked() |
|
{ |
|
if (m_targetSatState != nullptr) |
|
{ |
|
if (m_plotPass < m_targetSatState->m_passes.size() - 1) |
|
{ |
|
m_plotPass++; |
|
ui->passLabel->setText(QString("%1").arg(m_plotPass)); |
|
plotChart(); |
|
} |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_prevPass_clicked() |
|
{ |
|
if (m_plotPass > 0) |
|
{ |
|
m_plotPass--; |
|
ui->passLabel->setText(QString("%1").arg(m_plotPass)); |
|
plotChart(); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::on_darkTheme_clicked(bool checked) |
|
{ |
|
m_settings.m_chartsDarkTheme = checked; |
|
plotChart(); |
|
m_settingsKeys.append("chartsDarkTheme"); |
|
applySettings(); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_chartSelect_currentIndexChanged(int index) |
|
{ |
|
(void) index; |
|
plotChart(); |
|
} |
|
|
|
void SatelliteTrackerGUI::plotChart() |
|
{ |
|
if (ui->chartSelect->currentIndex() == 0) { |
|
plotPolarChart(); |
|
} else { |
|
plotAzElChart(); |
|
} |
|
} |
|
|
|
// Linear interpolation |
|
static double interpolate(double x0, double y0, double x1, double y1, double x) |
|
{ |
|
return (y0*(x1-x) + y1*(x-x0)) / (x1-x0); |
|
} |
|
|
|
// Reduce az/el range from 450,180 to 360,90 |
|
void SatelliteTrackerGUI::limitAzElRange(double& azimuth, double& elevation) const |
|
{ |
|
if (elevation > 90.0) |
|
{ |
|
elevation = 180.0 - elevation; |
|
if (azimuth < 180.0) { |
|
azimuth += 180.0; |
|
} else { |
|
azimuth -= 180.0; |
|
} |
|
} |
|
if (azimuth > 360.0) { |
|
azimuth -= 360.0f; |
|
} |
|
if (azimuth == 0) { |
|
azimuth = 360.0; |
|
} |
|
} |
|
|
|
// Plot pass in polar coords |
|
void SatelliteTrackerGUI::plotPolarChart() |
|
{ |
|
if ((m_targetSatState == nullptr) || !m_satellites.contains(m_settings.m_target) || (m_targetSatState->m_passes.size() == 0)) |
|
{ |
|
ui->passChart->setChart(&m_emptyChart); |
|
return; |
|
} |
|
|
|
QChart *oldChart = m_polarChart; |
|
|
|
if (m_plotPass >= m_targetSatState->m_passes.size() - 1) |
|
{ |
|
m_plotPass = m_targetSatState->m_passes.size() - 1; |
|
ui->passLabel->setText(QString("%1").arg(m_plotPass)); |
|
} |
|
|
|
const SatellitePass &pass = m_targetSatState->m_passes[m_plotPass]; |
|
|
|
// Always create a new chart, otherwise sometimes they aren't drawn properly |
|
m_polarChart = new QPolarChart(); |
|
m_polarChart->setTheme(m_settings.m_chartsDarkTheme ? QChart::ChartThemeDark : QChart::ChartThemeLight); |
|
QValueAxis *angularAxis = new QValueAxis(); |
|
QCategoryAxis *radialAxis = new QCategoryAxis(); |
|
|
|
angularAxis->setTickCount(9); |
|
angularAxis->setMinorTickCount(1); |
|
angularAxis->setLabelFormat("%d"); |
|
angularAxis->setRange(0, 360); |
|
|
|
radialAxis->setMin(0); |
|
radialAxis->setMax(90); |
|
radialAxis->append("90", 0); |
|
radialAxis->append("60", 30); |
|
radialAxis->append("30", 60); |
|
radialAxis->append("0", 90); |
|
radialAxis->setLabelsPosition(QCategoryAxis::AxisLabelsPositionOnValue); |
|
|
|
m_polarChart->addAxis(angularAxis, QPolarChart::PolarOrientationAngular); |
|
m_polarChart->addAxis(radialAxis, QPolarChart::PolarOrientationRadial); |
|
m_polarChart->legend()->hide(); |
|
m_polarChart->layout()->setContentsMargins(0, 0, 0, 0); |
|
m_polarChart->setMargins(QMargins(1, 1, 1, 1)); |
|
|
|
SatNogsSatellite *sat = m_satellites.value(m_settings.m_target); |
|
|
|
if (pass.m_aos.isValid() && pass.m_los.isValid()) |
|
{ |
|
QString title; |
|
|
|
if (m_settings.m_utc) { |
|
title = pass.m_aos.date().toString(m_settings.m_dateFormat); |
|
} else { |
|
title = pass.m_aos.toLocalTime().date().toString(m_settings.m_dateFormat); |
|
} |
|
|
|
m_polarChart->setTitle(QString("%1").arg(title)); |
|
QLineSeries *polarSeries = new QLineSeries(); |
|
|
|
getPassAzEl( |
|
nullptr, |
|
nullptr, |
|
polarSeries, |
|
sat->m_tle->m_tle0, |
|
sat->m_tle->m_tle1, |
|
sat->m_tle->m_tle2, |
|
m_settings.m_latitude, |
|
m_settings.m_longitude, |
|
m_settings.m_heightAboveSeaLevel/1000.0, |
|
pass.m_aos, pass.m_los |
|
); |
|
|
|
// Polar charts can't handle points that are more than 180 degrees apart, so |
|
// we need to split passes that cross from 359 -> 0 degrees (or the reverse) |
|
QList<QLineSeries *> series; |
|
series.append(new QLineSeries()); |
|
QLineSeries *s = series.first(); |
|
QPen pen(QColor(32, 159, 223), 2, Qt::SolidLine); |
|
s->setPen(pen); |
|
|
|
qreal prevAz = polarSeries->at(0).x(); |
|
qreal prevEl = polarSeries->at(0).y(); |
|
|
|
for (int i = 1; i < polarSeries->count(); i++) |
|
{ |
|
qreal az = polarSeries->at(i).x(); |
|
qreal el = polarSeries->at(i).y(); |
|
|
|
if ((prevAz > 270.0) && (az <= 90.0)) |
|
{ |
|
double elMid = interpolate(prevAz, prevEl, az+360.0, el, 360.0); |
|
s->append(360.0, elMid); |
|
series.append(new QLineSeries()); |
|
s = series.last(); |
|
s->setPen(pen); |
|
s->append(0.0, elMid); |
|
s->append(az, el); |
|
} |
|
else if ((prevAz <= 90.0) && (az > 270.0)) |
|
{ |
|
double elMid = interpolate(prevAz, prevEl, az-360.0, el, 0.0); |
|
s->append(0.0, elMid); |
|
series.append(new QLineSeries()); |
|
s = series.last(); |
|
s->setPen(pen); |
|
s->append(360.0, elMid); |
|
s->append(az, el); |
|
} |
|
else |
|
{ |
|
s->append(polarSeries->at(i)); |
|
} |
|
|
|
prevAz = az; |
|
prevEl = el; |
|
} |
|
|
|
for (int i = 0; i < series.length(); i++) |
|
{ |
|
m_polarChart->addSeries(series[i]); |
|
series[i]->attachAxis(angularAxis); |
|
series[i]->attachAxis(radialAxis); |
|
} |
|
|
|
int redrawTime = 0; |
|
|
|
if (m_settings.m_drawRotators != SatelliteTrackerSettings::NO_ROTATORS) |
|
{ |
|
// Plot rotator position |
|
QString ourSourceName = QString("F:%1 %2").arg(m_satelliteTracker->getIndexInFeatureSet()).arg(m_satelliteTracker->getIdentifier()); |
|
std::vector<FeatureSet*>& featureSets = MainCore::instance()->getFeatureeSets(); |
|
for (int featureSetIndex = 0; featureSetIndex < (int)featureSets.size(); featureSetIndex++) |
|
{ |
|
FeatureSet *featureSet = featureSets[featureSetIndex]; |
|
for (int featureIndex = 0; featureIndex < featureSet->getNumberOfFeatures(); featureIndex++) |
|
{ |
|
Feature *feature = featureSet->getFeatureAt(featureIndex); |
|
if (FeatureUtils::compareFeatureURIs(feature->getURI(), "sdrangel.feature.gs232controller")) |
|
{ |
|
QString source; |
|
ChannelWebAPIUtils::getFeatureSetting(featureSetIndex, featureIndex, "source", source); // Will return false if source isn't set in Controller |
|
int track = 0; |
|
ChannelWebAPIUtils::getFeatureSetting(featureSetIndex, featureIndex, "track", track); |
|
if ((m_settings.m_drawRotators == SatelliteTrackerSettings::ALL_ROTATORS) || ((source == ourSourceName) && track)) |
|
{ |
|
int onTarget = 0; |
|
ChannelWebAPIUtils::getFeatureReportValue(featureSetIndex, featureIndex, "onTarget", onTarget); |
|
|
|
if (!onTarget) |
|
{ |
|
// Target azimuth red dotted line |
|
double targetAzimuth, targetElevation; |
|
bool targetAzimuthOk = ChannelWebAPIUtils::getFeatureReportValue(featureSetIndex, featureIndex, "targetAzimuth", targetAzimuth); |
|
bool targetElevationOk = ChannelWebAPIUtils::getFeatureReportValue(featureSetIndex, featureIndex, "targetElevation", targetElevation); |
|
if (targetAzimuthOk && targetElevationOk) |
|
{ |
|
limitAzElRange(targetAzimuth, targetElevation); |
|
|
|
QScatterSeries *rotatorSeries = new QScatterSeries(); |
|
QColor color(255, 0, 0, 150); |
|
QPen pen(color); |
|
rotatorSeries->setPen(pen); |
|
rotatorSeries->setColor(color.darker()); |
|
rotatorSeries->setMarkerSize(20); |
|
rotatorSeries->append(targetAzimuth, 90-targetElevation); |
|
m_polarChart->addSeries(rotatorSeries); |
|
rotatorSeries->attachAxis(angularAxis); |
|
rotatorSeries->attachAxis(radialAxis); |
|
|
|
redrawTime = 333; |
|
} |
|
} |
|
|
|
// Current azimuth line. Yellow while off target, green on target. |
|
double currentAzimuth, currentElevation; |
|
bool currentAzimuthOk = ChannelWebAPIUtils::getFeatureReportValue(featureSetIndex, featureIndex, "currentAzimuth", currentAzimuth); |
|
bool currentElevationOk = ChannelWebAPIUtils::getFeatureReportValue(featureSetIndex, featureIndex, "currentElevation", currentElevation); |
|
if (currentAzimuthOk && currentElevationOk) |
|
{ |
|
limitAzElRange(currentAzimuth, currentElevation); |
|
|
|
QScatterSeries *rotatorSeries = new QScatterSeries(); |
|
QColor color; |
|
if (onTarget) { |
|
color = QColor(0, 255, 0, 150); |
|
} else { |
|
color = QColor(255, 255, 0, 150); |
|
} |
|
rotatorSeries->setPen(QPen(color)); |
|
rotatorSeries->setColor(color.darker()); |
|
rotatorSeries->setMarkerSize(20); |
|
rotatorSeries->append(currentAzimuth, 90-currentElevation); |
|
m_polarChart->addSeries(rotatorSeries); |
|
rotatorSeries->attachAxis(angularAxis); |
|
rotatorSeries->attachAxis(radialAxis); |
|
|
|
redrawTime = 333; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Create series with single point, so we can plot time of AOS |
|
QLineSeries *aosSeries = new QLineSeries(); |
|
aosSeries->append(polarSeries->at(0)); |
|
QTime time; |
|
|
|
if (m_settings.m_utc) { |
|
time = pass.m_aos.time(); |
|
} else { |
|
time = pass.m_aos.toLocalTime().time(); |
|
} |
|
|
|
if (m_settings.m_utc) { |
|
aosSeries->setPointLabelsFormat(QString("AOS %1").arg(time.toString("hh:mm"))); |
|
} else { |
|
aosSeries->setPointLabelsFormat(QString("AOS %1").arg(time.toString("hh:mm"))); |
|
} |
|
|
|
aosSeries->setPointLabelsVisible(true); |
|
aosSeries->setPointLabelsClipping(false); |
|
m_polarChart->addSeries(aosSeries); |
|
aosSeries->attachAxis(angularAxis); |
|
aosSeries->attachAxis(radialAxis); |
|
// Create series with single point, so we can plot time of LOS |
|
QLineSeries *losSeries = new QLineSeries(); |
|
losSeries->append(polarSeries->at(polarSeries->count()-1)); |
|
|
|
if (m_settings.m_utc) { |
|
time = pass.m_los.time(); |
|
} else { |
|
time = pass.m_los.toLocalTime().time(); |
|
} |
|
|
|
losSeries->setPointLabelsFormat(QString("LOS %1").arg(time.toString("hh:mm"))); |
|
losSeries->setPointLabelsVisible(true); |
|
losSeries->setPointLabelsClipping(false); |
|
m_polarChart->addSeries(losSeries); |
|
losSeries->attachAxis(angularAxis); |
|
losSeries->attachAxis(radialAxis); |
|
QDateTime currentTime; |
|
|
|
if (m_settings.m_dateTime == "") { |
|
currentTime = m_satelliteTracker->currentDateTimeUtc(); |
|
} else if (m_settings.m_utc) { |
|
currentTime = QDateTime::fromString(m_settings.m_dateTime, Qt::ISODateWithMs); |
|
} else { |
|
currentTime = QDateTime::fromString(m_settings.m_dateTime, Qt::ISODateWithMs).toUTC(); |
|
} |
|
|
|
if ((currentTime >= pass.m_aos) && (currentTime <= pass.m_los)) |
|
{ |
|
// Create series with single point, so we can plot current time |
|
QScatterSeries *nowSeries = new QScatterSeries(); |
|
nowSeries->setMarkerSize(3); |
|
// Find closest point to current time |
|
int idx = std::round(polarSeries->count() * (currentTime.toMSecsSinceEpoch() - pass.m_aos.toMSecsSinceEpoch()) |
|
/ (pass.m_los.toMSecsSinceEpoch() - pass.m_aos.toMSecsSinceEpoch())); |
|
nowSeries->append(polarSeries->at(idx)); |
|
nowSeries->setPointLabelsFormat(m_settings.m_target); |
|
nowSeries->setPointLabelsVisible(true); |
|
nowSeries->setPointLabelsClipping(false); |
|
m_polarChart->addSeries(nowSeries); |
|
nowSeries->attachAxis(angularAxis); |
|
nowSeries->attachAxis(radialAxis); |
|
} |
|
|
|
if (redrawTime > 0) |
|
{ |
|
// Redraw to show updated rotator position |
|
m_redrawTimer.setSingleShot(true); |
|
m_redrawTimer.start(redrawTime); |
|
} |
|
|
|
delete polarSeries; |
|
} |
|
else |
|
{ |
|
// Possibly geostationary, just plot current position |
|
QDateTime currentTime; |
|
|
|
if (m_settings.m_dateTime == "") { |
|
currentTime = m_satelliteTracker->currentDateTimeUtc(); |
|
} else if (m_settings.m_utc) { |
|
currentTime = QDateTime::fromString(m_settings.m_dateTime, Qt::ISODateWithMs); |
|
} else { |
|
currentTime = QDateTime::fromString(m_settings.m_dateTime, Qt::ISODateWithMs).toUTC(); |
|
} |
|
|
|
QString title; |
|
|
|
if (m_settings.m_utc) { |
|
title = currentTime.date().toString(m_settings.m_dateFormat); |
|
} else { |
|
title = currentTime.toLocalTime().date().toString(m_settings.m_dateFormat); |
|
} |
|
|
|
m_polarChart->setTitle(QString("%1").arg(title)); |
|
QLineSeries *nowSeries = new QLineSeries(); |
|
QDateTime endTime = currentTime.addSecs(1); |
|
|
|
getPassAzEl( |
|
nullptr, |
|
nullptr, |
|
nowSeries, |
|
sat->m_tle->m_tle0, |
|
sat->m_tle->m_tle1, |
|
sat->m_tle->m_tle2, |
|
m_settings.m_latitude, |
|
m_settings.m_longitude, |
|
m_settings.m_heightAboveSeaLevel/1000.0, |
|
currentTime, endTime |
|
); |
|
|
|
nowSeries->setPointLabelsFormat(m_settings.m_target); |
|
nowSeries->setPointLabelsVisible(true); |
|
nowSeries->setPointLabelsClipping(false); |
|
m_polarChart->addSeries(nowSeries); |
|
nowSeries->attachAxis(angularAxis); |
|
nowSeries->attachAxis(radialAxis); |
|
} |
|
|
|
ui->passChart->setChart(m_polarChart); |
|
delete oldChart; |
|
} |
|
|
|
// Plot target elevation/azimuth for the next pass |
|
void SatelliteTrackerGUI::plotAzElChart() |
|
{ |
|
if ((m_targetSatState == nullptr) || !m_satellites.contains(m_settings.m_target) || (m_targetSatState->m_passes.size() == 0)) |
|
{ |
|
ui->passChart->setChart(&m_emptyChart); |
|
return; |
|
} |
|
|
|
QChart *oldChart = m_lineChart; |
|
|
|
if (m_plotPass >= m_targetSatState->m_passes.size() - 1) |
|
{ |
|
m_plotPass = m_targetSatState->m_passes.size() - 1; |
|
ui->passLabel->setText(QString("%1").arg(m_plotPass)); |
|
} |
|
|
|
const SatellitePass &pass = m_targetSatState->m_passes[m_plotPass]; |
|
// Always create a new chart, otherwise sometimes they aren't drawn properly |
|
m_lineChart = new QChart(); |
|
m_lineChart->setTheme(m_settings.m_chartsDarkTheme ? QChart::ChartThemeDark : QChart::ChartThemeLight); |
|
QDateTimeAxis *xAxis = new QDateTimeAxis(); |
|
QValueAxis *yLeftAxis = new QValueAxis(); |
|
QValueAxis *yRightAxis = new QValueAxis(); |
|
QString title; |
|
|
|
if (m_settings.m_utc) { |
|
title = pass.m_aos.date().toString(m_settings.m_dateFormat); |
|
} else { |
|
title = pass.m_aos.toLocalTime().date().toString(m_settings.m_dateFormat); |
|
} |
|
|
|
m_lineChart->setTitle(QString("%1").arg(title)); |
|
m_lineChart->legend()->hide(); |
|
m_lineChart->addAxis(xAxis, Qt::AlignBottom); |
|
m_lineChart->addAxis(yLeftAxis, Qt::AlignLeft); |
|
m_lineChart->addAxis(yRightAxis, Qt::AlignRight); |
|
m_lineChart->layout()->setContentsMargins(0, 0, 0, 0); |
|
m_lineChart->setMargins(QMargins(1, 1, 1, 1)); |
|
SatNogsSatellite *sat = m_satellites.value(m_settings.m_target); |
|
QLineSeries *azSeries = new QLineSeries(); |
|
QLineSeries *elSeries = new QLineSeries(); |
|
|
|
getPassAzEl( |
|
azSeries, |
|
elSeries, |
|
nullptr, |
|
sat->m_tle->m_tle0, |
|
sat->m_tle->m_tle1, |
|
sat->m_tle->m_tle2, |
|
m_settings.m_latitude, |
|
m_settings.m_longitude, |
|
m_settings.m_heightAboveSeaLevel/1000.0, |
|
pass.m_aos, |
|
pass.m_los |
|
); |
|
|
|
// Split crossing of 360/0 degrees in to multiple series in the same colour |
|
QList<QLineSeries *> azSeriesList; |
|
QPen pen(QColor(153, 202, 83), 2, Qt::SolidLine); |
|
QLineSeries *s = new QLineSeries(); |
|
azSeriesList.append(s); |
|
s->setPen(pen); |
|
qreal prevAz = azSeries->at(0).y(); |
|
|
|
for (int i = 0; i < azSeries->count(); i++) |
|
{ |
|
qreal az = azSeries->at(i).y(); |
|
|
|
if (((prevAz >= 270) && (az < 90)) || ((prevAz < 90) && (az >= 270))) |
|
{ |
|
s = new QLineSeries(); |
|
azSeriesList.append(s); |
|
s->setPen(pen); |
|
} |
|
|
|
s->append(azSeries->at(i).x(), az); |
|
prevAz = az; |
|
} |
|
|
|
m_lineChart->addSeries(elSeries); |
|
elSeries->attachAxis(xAxis); |
|
elSeries->attachAxis(yLeftAxis); |
|
|
|
for (int i = 0; i < azSeriesList.size(); i++) |
|
{ |
|
m_lineChart->addSeries(azSeriesList[i]); |
|
azSeriesList[i]->attachAxis(xAxis); |
|
azSeriesList[i]->attachAxis(yRightAxis); |
|
} |
|
|
|
// Plot current target on elevation series |
|
if (m_targetSatState && (m_targetSatState->m_elevation > 0.0)) |
|
{ |
|
QDateTime currentTime; |
|
|
|
if (m_settings.m_dateTime == "") { |
|
currentTime = m_satelliteTracker->currentDateTimeUtc(); |
|
} else if (m_settings.m_utc) { |
|
currentTime = QDateTime::fromString(m_settings.m_dateTime, Qt::ISODateWithMs); |
|
} else { |
|
currentTime = QDateTime::fromString(m_settings.m_dateTime, Qt::ISODateWithMs).toUTC(); |
|
} |
|
|
|
QScatterSeries *posSeries = new QScatterSeries(); |
|
posSeries->setMarkerSize(3); |
|
posSeries->append(currentTime.toMSecsSinceEpoch(), m_targetSatState->m_elevation); |
|
posSeries->setPointLabelsVisible(true); |
|
posSeries->setPointLabelsFormat(m_settings.m_target); |
|
posSeries->setPointLabelsClipping(false); |
|
m_lineChart->addSeries(posSeries); |
|
posSeries->attachAxis(xAxis); |
|
posSeries->attachAxis(yLeftAxis); |
|
} |
|
|
|
xAxis->setRange(pass.m_aos, pass.m_los); |
|
xAxis->setFormat("hh:mm"); |
|
yLeftAxis->setRange(0.0, 90.0); |
|
yLeftAxis->setTickCount(7); |
|
yLeftAxis->setLabelFormat("%d"); |
|
yLeftAxis->setTitleText(QString("Elevation (%1)").arg(QChar(0xb0))); |
|
yRightAxis->setRange(0.0, 360.0); |
|
yRightAxis->setTickCount(7); |
|
yRightAxis->setLabelFormat("%d"); |
|
yRightAxis->setTitleText(QString("Azimuth (%1)").arg(QChar(0xb0))); |
|
|
|
ui->passChart->setChart(m_lineChart); |
|
|
|
delete azSeries; |
|
delete oldChart; |
|
} |
|
|
|
void SatelliteTrackerGUI::resizeTable() |
|
{ |
|
// Fill table with a row of dummy data that will size the columns nicely |
|
int row = ui->satTable->rowCount(); |
|
ui->satTable->setRowCount(row + 1); |
|
ui->satTable->setItem(row, SAT_COL_NAME, new QTableWidgetItem("Satellite123")); |
|
ui->satTable->setItem(row, SAT_COL_AZ, new QTableWidgetItem("360")); |
|
ui->satTable->setItem(row, SAT_COL_EL, new QTableWidgetItem("-90")); |
|
ui->satTable->setItem(row, SAT_COL_TNE, new QTableWidgetItem("99:99:99 AOS")); |
|
ui->satTable->setItem(row, SAT_COL_DUR, new QTableWidgetItem("9:99:99")); |
|
ui->satTable->setItem(row, SAT_COL_AOS, new QTableWidgetItem("+1 10:17")); |
|
ui->satTable->setItem(row, SAT_COL_LOS, new QTableWidgetItem("+1 10:17")); |
|
ui->satTable->setItem(row, SAT_COL_MAX_EL, new QTableWidgetItem("90")); |
|
ui->satTable->setItem(row, SAT_COL_DIR, new QTableWidgetItem("^")); |
|
ui->satTable->setItem(row, SAT_COL_LATITUDE, new QTableWidgetItem("-90.0")); |
|
ui->satTable->setItem(row, SAT_COL_LONGITUDE, new QTableWidgetItem("-180.0")); |
|
ui->satTable->setItem(row, SAT_COL_ALT, new QTableWidgetItem("50000")); |
|
ui->satTable->setItem(row, SAT_COL_RANGE, new QTableWidgetItem("50000")); |
|
ui->satTable->setItem(row, SAT_COL_RANGE_RATE, new QTableWidgetItem("10.0")); |
|
ui->satTable->setItem(row, SAT_COL_DOPPLER, new QTableWidgetItem("10000")); |
|
ui->satTable->setItem(row, SAT_COL_PATH_LOSS, new QTableWidgetItem("100")); |
|
ui->satTable->setItem(row, SAT_COL_NORAD_ID, new QTableWidgetItem("123456")); |
|
ui->satTable->resizeColumnsToContents(); |
|
ui->satTable->setRowCount(row); |
|
} |
|
|
|
// As we only have limited space in table, display time plus number of days to AOS/LOS |
|
// unless it's greater than 10 days, in which case just display the date |
|
QString SatelliteTrackerGUI::formatDaysTime(qint64 days, QDateTime dateTime) |
|
{ |
|
QDateTime dt; |
|
|
|
if (m_settings.m_utc) { |
|
dt = dateTime.toUTC(); |
|
} else { |
|
dt = dateTime.toLocalTime(); |
|
} |
|
|
|
if (abs(days) > 10) { |
|
return dt.date().toString(m_settings.m_dateFormat); |
|
} else if (days == 0) { |
|
return dt.time().toString("hh:mm"); |
|
} else if (days > 0) { |
|
return dt.time().toString(QString("hh:mm +%1").arg(days)); |
|
} else { |
|
return dt.time().toString(QString("hh:mm %1").arg(days)); |
|
} |
|
} |
|
|
|
QString SatelliteTrackerGUI::formatSecondsAsHHMMSS(qint64 seconds) |
|
{ |
|
char const* sign = ""; |
|
|
|
if (seconds < 0) |
|
{ |
|
sign = "-"; |
|
seconds = -seconds; |
|
} |
|
|
|
int minutes = seconds / 60; |
|
seconds = seconds % 60; |
|
int hours = minutes / 60; |
|
minutes = minutes % 60; |
|
|
|
if (hours > 0) { |
|
return QString("%1%2:%3:%4").arg(sign).arg(hours).arg(minutes, 2, 10, QChar('0')).arg(seconds, 2, 10, QChar('0')); |
|
} else { |
|
return QString("%1%2:%3").arg(sign).arg(minutes).arg(seconds, 2, 10, QChar('0')); |
|
} |
|
} |
|
|
|
// Table item showing some text, but sorted by datetime set as user data |
|
class DateTimeSortedTableWidgetItem : public QTableWidgetItem { |
|
public: |
|
bool operator<(const QTableWidgetItem& other) const |
|
{ |
|
QVariant v1 = data(Qt::UserRole); |
|
QVariant v2 = other.data(Qt::UserRole); |
|
|
|
if (v1.isValid() && v2.isValid()) { |
|
return v1.toDateTime() < v2.toDateTime(); |
|
} else { |
|
return false; |
|
} |
|
} |
|
}; |
|
|
|
// Handle sorting for next column, which can have times as HH:MM:SS or MM:SS |
|
class NextEventTableWidgetItem : public QTableWidgetItem |
|
{ |
|
public: |
|
bool operator<(const QTableWidgetItem &other) const override |
|
{ |
|
QString t1 = text(); |
|
QString t2 = other.text(); |
|
int t1Colons = t1.count(":"); |
|
int t2Colons = t2.count(":"); |
|
|
|
if (t1Colons == t2Colons) |
|
{ |
|
QCollator coll; |
|
coll.setNumericMode(true); |
|
return coll.compare(t1, t2) < 0; |
|
} |
|
else |
|
{ |
|
return t1Colons < t2Colons; |
|
} |
|
} |
|
}; |
|
|
|
class NaturallySortedTableWidgetItem : public QTableWidgetItem |
|
{ |
|
public: |
|
bool operator<(const QTableWidgetItem &other) const override |
|
{ |
|
QCollator coll; |
|
coll.setNumericMode(true); |
|
return coll.compare(text() , other.text()) < 0; |
|
} |
|
}; |
|
|
|
#define SPEED_OF_LIGHT 299792458.0 |
|
|
|
// Frequency in Hz, speed in m/s |
|
static double doppler(double frequency, double speed) |
|
{ |
|
return frequency * speed / SPEED_OF_LIGHT; |
|
} |
|
|
|
// Frequency in Hz, speed in m/s |
|
static double freeSpaceLoss(double frequency, double distance) |
|
{ |
|
return 20.0 * log10(distance) + 20 * log10(frequency) + 20 * log10(4*M_PI/SPEED_OF_LIGHT); |
|
} |
|
|
|
// Distance in m, delay in s |
|
static double propagationDelay(double distance) |
|
{ |
|
return distance / SPEED_OF_LIGHT; |
|
} |
|
|
|
// Update satellite data table with latest data for the satellite |
|
void SatelliteTrackerGUI::updateTable(SatelliteState *satState) |
|
{ |
|
// Does the table already contain this satellite? |
|
QList<QTableWidgetItem *> matches = ui->satTable->findItems(satState->m_name, Qt::MatchExactly); |
|
QTableWidgetItem *items[SAT_COL_COLUMNS]; |
|
|
|
if (matches.size() == 0) |
|
{ |
|
// Add a new row |
|
ui->satTable->setSortingEnabled(false); |
|
int row = ui->satTable->rowCount(); |
|
ui->satTable->setRowCount(row + 1); |
|
|
|
for (int i = 0; i < SAT_COL_COLUMNS; i++) |
|
{ |
|
if ((i == SAT_COL_AOS) || (i == SAT_COL_LOS)) { |
|
items[i] = new DateTimeSortedTableWidgetItem(); |
|
} else if ((i == SAT_COL_NAME) || (i == SAT_COL_NORAD_ID)) { |
|
items[i] = new QTableWidgetItem(); |
|
} else if (i == SAT_COL_TNE) { |
|
items[i] = new NextEventTableWidgetItem(); |
|
} else { |
|
items[i] = new NaturallySortedTableWidgetItem(); |
|
} |
|
|
|
items[i]->setToolTip(ui->satTable->horizontalHeaderItem(i)->toolTip()); |
|
ui->satTable->setItem(row, i, items[i]); |
|
} |
|
|
|
ui->satTable->setSortingEnabled(true); |
|
// Static columns |
|
items[SAT_COL_NAME]->setText(satState->m_name); |
|
|
|
if (m_satellites.contains(satState->m_name)) |
|
{ |
|
SatNogsSatellite *sat = m_satellites.value(satState->m_name); |
|
items[SAT_COL_NORAD_ID]->setData(Qt::DisplayRole, sat->m_noradCatId); |
|
} |
|
|
|
// Text alignment |
|
for (int col : {SAT_COL_AZ, SAT_COL_EL, SAT_COL_TNE, SAT_COL_DUR, SAT_COL_MAX_EL, |
|
SAT_COL_LATITUDE, SAT_COL_LONGITUDE, |
|
SAT_COL_ALT, SAT_COL_RANGE, SAT_COL_RANGE_RATE, SAT_COL_DOPPLER, |
|
SAT_COL_PATH_LOSS, SAT_COL_DELAY}) |
|
{ |
|
items[col]->setTextAlignment(Qt::AlignRight|Qt::AlignVCenter); |
|
} |
|
} |
|
else |
|
{ |
|
// Update existing row |
|
int row = ui->satTable->row(matches[0]); |
|
|
|
for (int i = 0; i < SAT_COL_COLUMNS; i++) { |
|
items[i] = ui->satTable->item(row, i); |
|
} |
|
} |
|
|
|
items[SAT_COL_AZ]->setData(Qt::DisplayRole, (int)round(satState->m_azimuth)); |
|
items[SAT_COL_EL]->setData(Qt::DisplayRole, (int)round(satState->m_elevation)); |
|
|
|
if (satState->m_passes.size() > 0) |
|
{ |
|
// Get number of days to AOS/LOS |
|
QDateTime currentDateTime = m_satelliteTracker->currentDateTime(); |
|
int daysToAOS = currentDateTime.daysTo(satState->m_passes[0].m_aos); |
|
int daysToLOS = currentDateTime.daysTo(satState->m_passes[0].m_los); |
|
|
|
if (satState->m_passes[0].m_aos > currentDateTime) { |
|
items[SAT_COL_TNE]->setText(formatSecondsAsHHMMSS(currentDateTime.secsTo(satState->m_passes[0].m_aos))+" AOS"); |
|
} else { |
|
items[SAT_COL_TNE]->setText(formatSecondsAsHHMMSS(currentDateTime.secsTo(satState->m_passes[0].m_los))+" LOS"); |
|
} |
|
|
|
items[SAT_COL_DUR]->setText(formatSecondsAsHHMMSS(satState->m_passes[0].m_aos.secsTo(satState->m_passes[0].m_los))); |
|
items[SAT_COL_AOS]->setText(formatDaysTime(daysToAOS, satState->m_passes[0].m_aos)); |
|
items[SAT_COL_AOS]->setData(Qt::UserRole, satState->m_passes[0].m_aos); |
|
items[SAT_COL_LOS]->setText(formatDaysTime(daysToLOS, satState->m_passes[0].m_los)); |
|
items[SAT_COL_LOS]->setData(Qt::UserRole, satState->m_passes[0].m_los); |
|
items[SAT_COL_MAX_EL]->setData(Qt::DisplayRole, (int)round(satState->m_passes[0].m_maxElevation)); |
|
|
|
if (satState->m_passes[0].m_northToSouth) { |
|
items[SAT_COL_DIR]->setText(QString("%1").arg(QChar(0x2193))); // Down arrow |
|
} else { |
|
items[SAT_COL_DIR]->setText(QString("%1").arg(QChar(0x2191))); // Up arrow |
|
} |
|
} |
|
else |
|
{ |
|
items[SAT_COL_TNE]->setText(""); |
|
items[SAT_COL_DUR]->setText(""); |
|
items[SAT_COL_AOS]->setText(""); |
|
items[SAT_COL_LOS]->setText(""); |
|
items[SAT_COL_MAX_EL]->setData(Qt::DisplayRole, QVariant()); |
|
items[SAT_COL_DIR]->setText(""); |
|
} |
|
|
|
items[SAT_COL_LATITUDE]->setData(Qt::DisplayRole, satState->m_latitude); |
|
items[SAT_COL_LONGITUDE]->setData(Qt::DisplayRole, satState->m_longitude); |
|
items[SAT_COL_ALT]->setData(Qt::DisplayRole, (int)round(satState->m_altitude)); |
|
items[SAT_COL_RANGE]->setData(Qt::DisplayRole, (int)round(satState->m_range)); |
|
items[SAT_COL_RANGE_RATE]->setData(Qt::DisplayRole, QString::number(satState->m_rangeRate, 'f', 3)); |
|
items[SAT_COL_DOPPLER]->setData(Qt::DisplayRole, (int)round(-doppler(m_settings.m_defaultFrequency, satState->m_rangeRate*1000.0))); |
|
items[SAT_COL_PATH_LOSS]->setData(Qt::DisplayRole, QString::number(freeSpaceLoss(m_settings.m_defaultFrequency, satState->m_range*1000.0), 'f', 1)); |
|
items[SAT_COL_DELAY]->setData(Qt::DisplayRole, QString::number(propagationDelay(satState->m_range*1000.0)*1000.0, 'f', 1)); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_satTable_cellDoubleClicked(int row, int column) |
|
{ |
|
(void) column; |
|
|
|
QString sat = ui->satTable->item(row, SAT_COL_NAME)->text(); |
|
FeatureWebAPIUtils::mapFind(sat); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_satTableHeader_sortIndicatorChanged(int logicalIndex, Qt::SortOrder order) |
|
{ |
|
m_settings.m_columnSort = logicalIndex; |
|
m_settings.m_columnSortOrder = order; |
|
m_settingsKeys.append("columnSort"); |
|
m_settingsKeys.append("columnSortOrder"); |
|
|
|
applySettings(); |
|
} |
|
|
|
// Columns in table reordered |
|
void SatelliteTrackerGUI::satTable_sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex) |
|
{ |
|
(void) oldVisualIndex; |
|
m_settings.m_columnIndexes[logicalIndex] = newVisualIndex; |
|
} |
|
|
|
// Column in table resized (when hidden size is 0) |
|
void SatelliteTrackerGUI::satTable_sectionResized(int logicalIndex, int oldSize, int newSize) |
|
{ |
|
(void) oldSize; |
|
m_settings.m_columnSizes[logicalIndex] = newSize; |
|
} |
|
|
|
// Right click in table header - show column select menu |
|
void SatelliteTrackerGUI::columnSelectMenu(QPoint pos) |
|
{ |
|
menu->popup(ui->satTable->horizontalHeader()->viewport()->mapToGlobal(pos)); |
|
} |
|
|
|
// Hide/show column when menu selected |
|
void SatelliteTrackerGUI::columnSelectMenuChecked(bool checked) |
|
{ |
|
(void) checked; |
|
QAction* action = qobject_cast<QAction*>(sender()); |
|
|
|
if (action != nullptr) |
|
{ |
|
int idx = action->data().toInt(nullptr); |
|
ui->satTable->setColumnHidden(idx, !action->isChecked()); |
|
} |
|
} |
|
|
|
// Create column select menu item |
|
QAction *SatelliteTrackerGUI::createCheckableItem(QString &text, int idx, bool checked) |
|
{ |
|
QAction *action = new QAction(text, this); |
|
action->setCheckable(true); |
|
action->setChecked(checked); |
|
action->setData(QVariant(idx)); |
|
connect(action, SIGNAL(triggered()), this, SLOT(columnSelectMenuChecked())); |
|
return action; |
|
} |
|
|
|
void SatelliteTrackerGUI::updateDeviceFeatureCombo() |
|
{ |
|
if (m_settings.m_dateTimeSelect == SatelliteTrackerSettings::FROM_MAP) { |
|
updateMapList(); |
|
} else if (m_settings.m_dateTimeSelect == SatelliteTrackerSettings::FROM_FILE) { |
|
updateFileInputList(); |
|
} |
|
} |
|
|
|
void SatelliteTrackerGUI::updateDeviceFeatureCombo(const QStringList &items, const QString &selected) |
|
{ |
|
// Remove items no longer in list |
|
int i = 0; |
|
while (i < ui->deviceFeatureSelect->count()) |
|
{ |
|
if (!items.contains(ui->deviceFeatureSelect->itemText(i))) { |
|
ui->deviceFeatureSelect->removeItem(i); |
|
} else { |
|
i++; |
|
} |
|
} |
|
// Add new items to list |
|
for (auto item : items) |
|
{ |
|
int idx = ui->deviceFeatureSelect->findText(item); |
|
|
|
if (idx == -1) { |
|
ui->deviceFeatureSelect->addItem(item); |
|
} |
|
} |
|
|
|
ui->deviceFeatureSelect->setCurrentIndex(ui->deviceFeatureSelect->findText(selected)); |
|
} |
|
|
|
void SatelliteTrackerGUI::updateFileInputList() |
|
{ |
|
// Create list of File Input devices |
|
std::vector<DeviceSet*>& deviceSets = MainCore::instance()->getDeviceSets(); |
|
int deviceIndex = 0; |
|
QStringList items; |
|
|
|
for (std::vector<DeviceSet*>::const_iterator it = deviceSets.begin(); it != deviceSets.end(); ++it, deviceIndex++) |
|
{ |
|
if ((*it)->m_deviceAPI && (*it)->m_deviceAPI->getHardwareId() == "FileInput") { |
|
items.append(QString("R%1").arg(deviceIndex)); |
|
} |
|
} |
|
|
|
updateDeviceFeatureCombo(items, m_settings.m_fileInputDevice); |
|
} |
|
|
|
void SatelliteTrackerGUI::updateMapList() |
|
{ |
|
// Create list of Map features |
|
std::vector<FeatureSet*>& featureSets = MainCore::instance()->getFeatureeSets(); |
|
int featureIndex = 0; |
|
QStringList items; |
|
|
|
for (std::vector<FeatureSet*>::const_iterator it = featureSets.begin(); it != featureSets.end(); ++it, featureIndex++) |
|
{ |
|
for (int fi = 0; fi < (*it)->getNumberOfFeatures(); fi++) |
|
{ |
|
Feature *feature = (*it)->getFeatureAt(fi); |
|
|
|
if (feature->getURI() == "sdrangel.feature.map") { |
|
items.append(QString("F%1:%2").arg(featureIndex).arg(fi)); |
|
} |
|
} |
|
} |
|
|
|
updateDeviceFeatureCombo(items, m_settings.m_mapFeature); |
|
} |
|
|
|
void SatelliteTrackerGUI::on_deviceFeatureSelect_currentIndexChanged(int index) |
|
{ |
|
(void) index; |
|
|
|
if (m_settings.m_dateTimeSelect == SatelliteTrackerSettings::FROM_MAP) |
|
{ |
|
m_settings.m_mapFeature = ui->deviceFeatureSelect->currentText(); |
|
m_settingsKeys.append("mapFeature"); |
|
} else |
|
{ |
|
m_settings.m_fileInputDevice = ui->deviceFeatureSelect->currentText(); |
|
m_settingsKeys.append("fileInputDevice"); |
|
} |
|
|
|
applySettings(); |
|
} |
|
|
|
void SatelliteTrackerGUI::makeUIConnections() |
|
{ |
|
QObject::connect(ui->startStop, &ButtonSwitch::toggled, this, &SatelliteTrackerGUI::on_startStop_toggled); |
|
QObject::connect(ui->useMyPosition, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_useMyPosition_clicked); |
|
QObject::connect(ui->latitude, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &SatelliteTrackerGUI::on_latitude_valueChanged); |
|
QObject::connect(ui->longitude, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &SatelliteTrackerGUI::on_longitude_valueChanged); |
|
QObject::connect(ui->target, &QComboBox::currentTextChanged, this, &SatelliteTrackerGUI::on_target_currentTextChanged); |
|
QObject::connect(ui->displaySettings, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_displaySettings_clicked); |
|
QObject::connect(ui->radioControl, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_radioControl_clicked); |
|
QObject::connect(ui->dateTimeSelect, qOverload<int>(&QComboBox::currentIndexChanged), this, &SatelliteTrackerGUI::on_dateTimeSelect_currentIndexChanged); |
|
QObject::connect(ui->dateTime, &WrappingDateTimeEdit::dateTimeChanged, this, &SatelliteTrackerGUI::on_dateTime_dateTimeChanged); |
|
QObject::connect(ui->viewOnMap, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_viewOnMap_clicked); |
|
QObject::connect(ui->updateSatData, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_updateSatData_clicked); |
|
QObject::connect(ui->selectSats, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_selectSats_clicked); |
|
QObject::connect(ui->autoTarget, &ButtonSwitch::clicked, this, &SatelliteTrackerGUI::on_autoTarget_clicked); |
|
QObject::connect(ui->chartSelect, qOverload<int>(&QComboBox::currentIndexChanged), this, &SatelliteTrackerGUI::on_chartSelect_currentIndexChanged); |
|
QObject::connect(ui->nextPass, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_nextPass_clicked); |
|
QObject::connect(ui->prevPass, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_prevPass_clicked); |
|
QObject::connect(ui->darkTheme, &QToolButton::clicked, this, &SatelliteTrackerGUI::on_darkTheme_clicked); |
|
QObject::connect(ui->satTable, &QTableWidget::cellDoubleClicked, this, &SatelliteTrackerGUI::on_satTable_cellDoubleClicked); |
|
QObject::connect(ui->satTable->horizontalHeader(), &QHeaderView::sortIndicatorChanged, this, &SatelliteTrackerGUI::on_satTableHeader_sortIndicatorChanged); |
|
QObject::connect(ui->deviceFeatureSelect, qOverload<int>(&QComboBox::currentIndexChanged), this, &SatelliteTrackerGUI::on_deviceFeatureSelect_currentIndexChanged); |
|
} |
|
|
|
|