sdrangel/plugins/feature/skymap/skymapgui.cpp

///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2021-2024 Jon Beniston, M7RCE <jon@beniston.com>                //
// Copyright (C) 2021-2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com>          //
//                                                                               //
// 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 <QGeoCoordinate>

#include <QtWebEngineWidgets/QWebEngineView>
#include <QWebEngineSettings>
#include <QWebEngineProfile>

#include "feature/featureuiset.h"
#include "gui/basicfeaturesettingsdialog.h"
#include "gui/dialogpositioner.h"
#include "util/astronomy.h"
#include "util/units.h"
#include "maincore.h"

#include "ui_skymapgui.h"
#include "skymap.h"
#include "skymapgui.h"
#include "skymapsettingsdialog.h"

#include "SWGTargetAzimuthElevation.h"
#include "SWGSkyMapTarget.h"

SkyMapGUI* SkyMapGUI::create(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature)
{
    SkyMapGUI* gui = new SkyMapGUI(pluginAPI, featureUISet, feature);
    return gui;
}

void SkyMapGUI::destroy()
{
    delete this;
}

void SkyMapGUI::resetToDefaults()
{
    m_settings.resetToDefaults();
    displaySettings();
    applyAllSettings();
}

QByteArray SkyMapGUI::serialize() const
{
    return m_settings.serialize();
}

bool SkyMapGUI::deserialize(const QByteArray& data)
{
    if (m_settings.deserialize(data))
    {
        m_feature->setWorkspaceIndex(m_settings.m_workspaceIndex);
        displaySettings();
        applyAllSettings();
        return true;
    }
    else
    {
        resetToDefaults();
        return false;
    }
}

bool SkyMapGUI::handleMessage(const Message& message)
{
    if (SkyMap::MsgConfigureSkyMap::match(message))
    {
        qDebug("SkyMapGUI::handleMessage: SkyMap::MsgConfigureSkyMap");
        const SkyMap::MsgConfigureSkyMap& cfg = (SkyMap::MsgConfigureSkyMap&) 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 (SkyMap::MsgFind::match(message))
    {
        SkyMap::MsgFind& msgFind = (SkyMap::MsgFind&) message;
        find(msgFind.getTarget());
        return true;
    }
    else if (SkyMap::MsgSetDateTime::match(message))
    {
        SkyMap::MsgSetDateTime& msgSetDateTime = (SkyMap::MsgSetDateTime&) message;
        setDateTime(msgSetDateTime.getDateTime());
        return true;
    }
    else if (MainCore::MsgTargetAzimuthElevation::match(message))
    {
        MainCore::MsgTargetAzimuthElevation& msg = (MainCore::MsgTargetAzimuthElevation&) message;

        // Ignore messages from StarTracker, as we use MsgSkyMapTarget instead, as more accurate and no refraction correction
        if ((msg.getPipeSource() == m_source) && !m_settings.m_source.contains("StarTracker"))
        {
            // Convert from Az/Alt to RA/Dec
            SWGSDRangel::SWGTargetAzimuthElevation *swgTarget = msg.getSWGTargetAzimuthElevation();
            AzAlt aa;
            aa.az = swgTarget->getAzimuth();
            aa.alt = swgTarget->getElevation();

            QGeoCoordinate position = getPosition();
            RADec rd;
            QDateTime dateTime = QDateTime::currentDateTime();

            rd = Astronomy::azAltToRaDec(aa, position.latitude(), position.longitude(), dateTime);

            // Convert from JNOW to J2000
            double jd = Astronomy::julianDate(dateTime);
            rd = Astronomy::precess(rd, jd, Astronomy::jd_j2000());

            m_ra = rd.ra;
            m_dec = rd.dec;
            if (m_settings.m_track) {
                m_webInterface->setView(rd.ra, rd.dec);
            }

            m_webInterface->setAntennaFoV(m_settings.m_hpbw);
         }
        return true;
    }
    else if (MainCore::MsgSkyMapTarget::match(message))
    {
        MainCore::MsgSkyMapTarget& msg = (MainCore::MsgSkyMapTarget&) message;
        if (msg.getPipeSource() == m_source)
        {
            SWGSDRangel::SWGSkyMapTarget *swgTarget = msg.getSWGSkyMapTarget();
            m_ra = swgTarget->getRa();
            m_dec = swgTarget->getDec();
            if (m_settings.m_track) {
                m_webInterface->setView(m_ra, m_dec);
            }
            setPosition(swgTarget->getLatitude(), swgTarget->getLongitude(), swgTarget->getAltitude());
            QDateTime dateTime = QDateTime::currentDateTime();
            if (swgTarget->getDateTime())
            {
                QString dateTimeString = *swgTarget->getDateTime();
                if (!dateTimeString.isEmpty()) {
                    dateTime = QDateTime::fromString(*swgTarget->getDateTime(), Qt::ISODateWithMs);
                }
            }
            setDateTime(dateTime);

            m_webInterface->setAntennaFoV(swgTarget->getHpbw());
        }
        return true;
    }

    return false;
}

void SkyMapGUI::handleInputMessages()
{
    Message* message;

    while ((message = getInputMessageQueue()->pop()))
    {
        if (handleMessage(*message)) {
            delete message;
        }
    }
}

void SkyMapGUI::onWidgetRolled(QWidget* widget, bool rollDown)
{
    (void) widget;
    (void) rollDown;

    getRollupContents()->saveState(m_rollupState);
    applySetting("rollupState");
}

SkyMapGUI::SkyMapGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature, QWidget* parent) :
    FeatureGUI(parent),
    ui(new Ui::SkyMapGUI),
    m_pluginAPI(pluginAPI),
    m_featureUISet(featureUISet),
    m_doApplySettings(true),
    m_source(nullptr),
    m_availableChannelOrFeatureHandler(SkyMapSettings::m_pipeURIs, {"target", "skymap.target"}),
    m_ready(false)
{
    m_feature = feature;
    setAttribute(Qt::WA_DeleteOnClose, true);
    m_helpURL = "plugins/feature/skymap/readme.md";
    RollupContents *rollupContents = getRollupContents();
	ui->setupUi(rollupContents);
    setSizePolicy(rollupContents->sizePolicy());
    rollupContents->arrangeRollups();
	connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));

    m_webInterface = new WebInterface();
    connect(m_webInterface, &WebInterface::received, this, &SkyMapGUI::receivedEvent);

    // Web server to serve dynamic files from QResources
    m_webPort = 0;
    m_webServer = new WebServer(m_webPort);

    m_webServer->addSubstitution("/skymap/html/wwt.html", "$WS_PORT$", QString::number(m_webInterface->serverPort()));
    m_webServer->addSubstitution("/skymap/html/esasky.html", "$WS_PORT$", QString::number(m_webInterface->serverPort()));
    m_webServer->addSubstitution("/skymap/html/aladin.html", "$WS_PORT$", QString::number(m_webInterface->serverPort()));

    ui->tabs->tabBar()->tabButton(0, QTabBar::RightSide)->resize(0, 0); // Hide close button
    ui->web->setTabs(ui->tabs);
    ui->web->load(QUrl(QString("http://127.0.0.1:%1/skymap/html/wwt.html").arg(m_webPort)));
    ui->web->show();

    m_skymap = reinterpret_cast<SkyMap*>(feature);
    m_skymap->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()));

    QWebEngineSettings *settings = ui->web->settings();
    settings->setAttribute(QWebEngineSettings::FullScreenSupportEnabled, true);
    connect(ui->web->page(), &QWebEnginePage::fullScreenRequested, this, &SkyMapGUI::fullScreenRequested);
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
    connect(ui->web->page(), &QWebEnginePage::loadingChanged, this, &SkyMapGUI::loadingChanged);
    connect(ui->web, &QWebEngineView::renderProcessTerminated, this, &SkyMapGUI::renderProcessTerminated);
#endif

    // Default to My Position
    m_settings.m_latitude = MainCore::instance()->getSettings().getLatitude();
    m_settings.m_longitude = MainCore::instance()->getSettings().getLongitude();
    m_settings.m_altitude = MainCore::instance()->getSettings().getAltitude();

    // Get updated when position changes
    connect(&MainCore::instance()->getSettings(), &MainSettings::preferenceChanged, this, &SkyMapGUI::preferenceChanged);

    displaySettings();
    applyAllSettings();

    makeUIConnections();
    m_resizer.enableChildMouseTracking();

    QObject::connect(&m_availableChannelOrFeatureHandler, &AvailableChannelOrFeatureHandler::channelsOrFeaturesChanged, this, &SkyMapGUI::updateSourceList);
    QObject::connect(&m_availableChannelOrFeatureHandler, &AvailableChannelOrFeatureHandler::messageEnqueued, this, &SkyMapGUI::handlePipeMessageQueue);
    m_availableChannelOrFeatureHandler.scanAvailableChannelsAndFeatures();

    connect(&m_wtml, &WTML::dataUpdated, this, &SkyMapGUI::wtmlUpdated);
    m_wtml.getData();
}

SkyMapGUI::~SkyMapGUI()
{
    QObject::disconnect(&m_availableChannelOrFeatureHandler, &AvailableChannelOrFeatureHandler::channelsOrFeaturesChanged, this, &SkyMapGUI::updateSourceList);
    if (m_webServer)
    {
        m_webServer->close();
        delete m_webServer;
    }
    delete m_webInterface;
    delete ui;
}

void SkyMapGUI::setWorkspaceIndex(int index)
{
    m_settings.m_workspaceIndex = index;
    m_feature->setWorkspaceIndex(index);
}

void SkyMapGUI::blockApplySettings(bool block)
{
    m_doApplySettings = !block;
}

void SkyMapGUI::on_map_currentIndexChanged(int index)
{
    (void) index;

    m_settings.m_map = ui->map->currentText();
    applySetting("map");

    m_ready = false;
    if (m_settings.m_map == "WWT") {
        ui->web->load(QUrl(QString("http://127.0.0.1:%1/skymap/html/wwt.html").arg(m_webPort)));
    } else if (m_settings.m_map == "ESASky") {
        ui->web->load(QUrl(QString("http://127.0.0.1:%1/skymap/html/esasky.html").arg(m_webPort)));
    } else if (m_settings.m_map == "Aladin") {
        ui->web->load(QUrl(QString("http://127.0.0.1:%1/skymap/html/aladin.html").arg(m_webPort)));
    } else if (m_settings.m_map == "Moon") {
        ui->web->load(QUrl(QString("http://quickmap.lroc.asu.edu/"))); // Jumping straight to 3D view doesn't seem to work
        setStatusText("");
        m_ready = true;
    }
    updateToolbar();
    updateBackgrounds();
}

void SkyMapGUI::on_background_currentIndexChanged(int index)
{
    if (index >= 0)
    {
        m_settings.m_background = ui->background->currentText();
        applySetting("background");
        m_webInterface->setBackground(backgroundID(m_settings.m_background));
    }
}

void SkyMapGUI::on_projection_currentIndexChanged(int index)
{
    if (index >= 0)
    {
        m_settings.m_projection = ui->projection->currentText();
        applySetting("projection");
        if (m_settings.m_map == "WWT") {
            updateBackgrounds();
        }
        m_webInterface->setProjection(m_settings.m_projection);
        if (m_settings.m_map == "WWT") {
            m_webInterface->setBackground(backgroundID(m_settings.m_background));
        }
    }
}

void SkyMapGUI::on_source_currentIndexChanged(int index)
{
    if (index >= 0)
    {
        m_settings.m_source = ui->source->currentText();
        applySetting("source");
        ui->track->setEnabled(true);
    }
    else
    {
        ui->track->setChecked(false);
        ui->track->setEnabled(false);
    }
}

void SkyMapGUI::renderProcessTerminated(QWebEnginePage::RenderProcessTerminationStatus terminationStatus, int exitCode)
{
    qDebug() << "SkyMapGUI::renderProcessTerminated: " << terminationStatus << "exitCode" << exitCode;
}

#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))

void SkyMapGUI::loadingChanged(const QWebEngineLoadingInfo &loadingInfo)
{
    if (loadingInfo.status() == QWebEngineLoadingInfo::LoadFailedStatus)
    {
        qDebug() << "SkyMapGUI::loadingChanged: Failed to load " << loadingInfo.url().toString()
            << "errorString: " << loadingInfo.errorString() << " "
            << "errorDomain:" << loadingInfo.errorDomain()
            << "errorCode:" << loadingInfo.errorCode()
            ;
    }
}
#endif

void SkyMapGUI::initSkyMap()
{
    QGeoCoordinate position = getPosition();
    updateToolbar();
    m_webInterface->setWWTSettings(m_settings.m_wwtSettings);
    m_webInterface->setPosition(position);
    m_webInterface->showNames(m_settings.m_displayNames);
    m_webInterface->showConstellations(m_settings.m_displayConstellations);
    m_webInterface->showReticle(m_settings.m_displayReticle);
    m_webInterface->showGrid(m_settings.m_displayGrid);
    m_webInterface->showAntennaFoV(m_settings.m_displayAntennaFoV);
    m_webInterface->setProjection(m_settings.m_projection);
    m_webInterface->setBackground(backgroundID(m_settings.m_background));
}

void SkyMapGUI::displaySettings()
{
    setTitleColor(m_settings.m_rgbColor);
    setWindowTitle(m_settings.m_title);
    setTitle(m_settings.m_title);
    blockApplySettings(true);
    ui->displayNames->setChecked(m_settings.m_displayNames);
    int idx = ui->map->findText(m_settings.m_map);
    if (idx >= 0) {
        ui->map->setCurrentIndex(idx);
    }
    ui->displayConstellations->setChecked(m_settings.m_displayConstellations);
    ui->displayReticle->setChecked(m_settings.m_displayReticle);
    ui->displayGrid->setChecked(m_settings.m_displayGrid);
    ui->displayAntennaFoV->setChecked(m_settings.m_displayAntennaFoV);
    idx = ui->background->findText(m_settings.m_background);
    if (idx >= 0) {
        ui->background->setCurrentIndex(idx);
    }
    ui->track->setChecked(m_settings.m_track);
    idx = ui->source->findText(m_settings.m_source);
    if (idx >= 0)
    {
        ui->source->setCurrentIndex(idx);
        ui->track->setEnabled(true);
    }
    else
    {
        ui->track->setChecked(false);
        ui->track->setEnabled(false);
    }
    initSkyMap();
    getRollupContents()->restoreState(m_rollupState);
    blockApplySettings(false);
}

void SkyMapGUI::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);

        QList<QString> settingsKeys({
            "rgbColor",
            "title",
            "useReverseAPI",
            "reverseAPIAddress",
            "reverseAPIPort",
            "reverseAPIDeviceIndex",
            "reverseAPIChannelIndex"
        });

        applySettings(settingsKeys);
    }

    resetContextMenuType();
}

void SkyMapGUI::applySetting(const QString& settingsKey)
{
    applySettings({settingsKey});
}

void SkyMapGUI::applySettings(const QStringList& settingsKeys, bool force)
{
    m_settingsKeys.append(settingsKeys);
    if (m_doApplySettings)
    {
        SkyMap::MsgConfigureSkyMap* message = SkyMap::MsgConfigureSkyMap::create(m_settings, m_settingsKeys, force);
        m_skymap->getInputMessageQueue()->push(message);
        m_settingsKeys.clear();

        m_availableChannelOrFeatureHandler.deregisterPipes(m_source, {"target", "skymap.target"});

        QObject *oldSource = m_source;
        m_source = m_availableChannelOrFeatureHandler.registerPipes(m_settings.m_source, {"target", "skymap.target"});

        // When we change plugins, default to current date and time and My Position, until we get something different
        if (oldSource && !m_source)
        {
            setDateTime(QDateTime::currentDateTime());
            setPosition(MainCore::instance()->getSettings().getLatitude(),
                MainCore::instance()->getSettings().getLongitude(),
                MainCore::instance()->getSettings().getAltitude());
        }
    }
}

void SkyMapGUI::applyAllSettings()
{
    applySettings(QStringList(), true);
}

void SkyMapGUI::find(const QString& text)
{
    if (!m_ready)
    {
        // Save for when ready
        m_find = text;
    }
    else
    {
        float ra, dec;

        // WWT's find doesn't support coordinates, so we check here
        if (Units::stringToRADec(text, ra, dec)) {
            m_webInterface->setView(ra, dec);
        } else {
            m_webInterface->track(text);
        }
    }
}

void SkyMapGUI::on_find_returnPressed()
{
    find(ui->find->text().trimmed());
}

void SkyMapGUI::on_displaySettings_clicked()
{
    SkyMapSettingsDialog dialog(&m_settings);
    new DialogPositioner(&dialog, true);
    if (dialog.exec() == QDialog::Accepted)
    {
        applySettings(dialog.m_settingsKeysChanged);

        if (dialog.m_settingsKeysChanged.contains("latitude")
            || dialog.m_settingsKeysChanged.contains("longitude")
            || dialog.m_settingsKeysChanged.contains("altitude")
            || dialog.m_settingsKeysChanged.contains("useMyPosition")) {
           m_webInterface->setPosition(getPosition());
        }
        if (dialog.m_settingsKeysChanged.contains("hpbw")) {
            m_webInterface->setAntennaFoV(m_settings.m_hpbw);
        }
        if (dialog.m_settingsKeysChanged.contains("wwtSettings")) {
            m_webInterface->setWWTSettings(m_settings.m_wwtSettings);
        }
    }
}

void SkyMapGUI::on_displayNames_clicked(bool checked)
{
    m_settings.m_displayNames = checked;
    m_webInterface->showNames(checked);
    applySetting("displayNames");
}

void SkyMapGUI::on_displayConstellations_clicked(bool checked)
{
    m_settings.m_displayConstellations = checked;
    m_webInterface->showConstellations(checked);
    applySetting("displayConstellations");
}

void SkyMapGUI::on_displayReticle_clicked(bool checked)
{
    m_settings.m_displayReticle = checked;
    m_webInterface->showReticle(checked);
    applySetting("displayReticle");
}

void SkyMapGUI::on_displayGrid_clicked(bool checked)
{
    m_settings.m_displayGrid = checked;
    m_webInterface->showGrid(checked);
    applySetting("displayGrid");
}

void SkyMapGUI::on_displayAntennaFoV_clicked(bool checked)
{
    m_settings.m_displayAntennaFoV = checked;
    m_webInterface->showAntennaFoV(checked);
    applySetting("displayAntennaFoV");
}

void SkyMapGUI::on_track_clicked(bool checked)
{
    m_settings.m_track = checked;
    applySetting("track");
    if (m_settings.m_track) {
        m_webInterface->setView(m_ra, m_dec);
    }
}

void SkyMapGUI::fullScreenRequested(QWebEngineFullScreenRequest fullScreenRequest)
{
    fullScreenRequest.accept();
    if (fullScreenRequest.toggleOn())
    {
        ui->web->setParent(nullptr);
        ui->web->showFullScreen();
    }
    else
    {
        ui->tab0->layout()->addWidget(ui->web);
    }
}

void SkyMapGUI::setDateTime(QDateTime dateTime)
{
    m_dateTime = dateTime;
    m_webInterface->setDateTime(m_dateTime);
}

QDateTime SkyMapGUI::getDateTime() const
{
    if (!m_source || !m_dateTime.isValid()) {
        return QDateTime::currentDateTime();
    } else {
        return m_dateTime;
    }
}

void SkyMapGUI::setPosition(float latitude, float longitude, float altitude)
{
    m_settings.m_latitude = latitude;
    m_settings.m_longitude = longitude;
    m_settings.m_altitude = altitude;
    m_webInterface->setPosition(getPosition());
}

QGeoCoordinate SkyMapGUI::getPosition() const
{
    float latitude, longitude, altitude;

    if (m_settings.m_useMyPosition)
    {
        latitude = MainCore::instance()->getSettings().getLatitude();
        longitude = MainCore::instance()->getSettings().getLongitude();
        altitude = MainCore::instance()->getSettings().getAltitude();
    }
    else
    {
        latitude = m_settings.m_latitude;
        longitude = m_settings.m_longitude;
        altitude = m_settings.m_altitude;
    }

    QGeoCoordinate position(latitude, longitude, altitude);
    return position;
}

void SkyMapGUI::preferenceChanged(int elementType)
{
    Preferences::ElementType pref = (Preferences::ElementType)elementType;
    if ((pref == Preferences::Latitude) || (pref == Preferences::Longitude) || (pref == Preferences::Altitude))
    {
        QGeoCoordinate position = getPosition();
        m_webInterface->setPosition(position);
    }
}

void SkyMapGUI::makeUIConnections()
{
    QObject::connect(ui->find, &QLineEdit::returnPressed, this, &SkyMapGUI::on_find_returnPressed);
    QObject::connect(ui->displaySettings, &QToolButton::clicked, this, &SkyMapGUI::on_displaySettings_clicked);
    QObject::connect(ui->displayNames, &QToolButton::clicked, this, &SkyMapGUI::on_displayNames_clicked);
    QObject::connect(ui->displayConstellations, &QToolButton::clicked, this, &SkyMapGUI::on_displayConstellations_clicked);
    QObject::connect(ui->displayReticle, &QToolButton::clicked, this, &SkyMapGUI::on_displayReticle_clicked);
    QObject::connect(ui->displayGrid, &QToolButton::clicked, this, &SkyMapGUI::on_displayGrid_clicked);
    QObject::connect(ui->displayAntennaFoV, &QToolButton::clicked, this, &SkyMapGUI::on_displayAntennaFoV_clicked);
    QObject::connect(ui->background, qOverload<int>(&QComboBox::currentIndexChanged), this, &SkyMapGUI::on_background_currentIndexChanged);
    QObject::connect(ui->map, qOverload<int>(&QComboBox::currentIndexChanged), this, &SkyMapGUI::on_map_currentIndexChanged);
    QObject::connect(ui->projection, qOverload<int>(&QComboBox::currentIndexChanged), this, &SkyMapGUI::on_projection_currentIndexChanged);
    QObject::connect(ui->source, qOverload<int>(&QComboBox::currentIndexChanged), this, &SkyMapGUI::on_source_currentIndexChanged);
    QObject::connect(ui->track, &QToolButton::clicked, this, &SkyMapGUI::on_track_clicked);
    QObject::connect(ui->tabs, &QTabWidget::tabCloseRequested, this, &SkyMapGUI::on_tabs_tabCloseRequested);
}

void SkyMapGUI::receivedEvent(const QJsonObject &obj)
{
    if (obj.contains("event"))
    {
        QString event = obj.value("event").toString();
        if (event == "view")
        {
            QStringList status;

            double ra = 0.0, dec = 0.0;
            double latitude = 0.0, longitude = 0.0;
            double fov = 0.0;
            AzAlt aa = {0.0, 0.0};
            QDateTime dateTime;

            if (obj.contains("dateTime"))
            {
                dateTime = QDateTime::fromString(obj.value("dateTime").toString(), Qt::ISODateWithMs).toLocalTime();
            }
            else
            {
                dateTime = getDateTime();
            }

            if (obj.contains("ra") && obj.contains("dec"))
            {
                ra = obj.value("ra").toDouble();
                dec = obj.value("dec").toDouble();

                // Convert from decimal to DMS
                QString raDMS = Units::decimalHoursToHoursMinutesAndSeconds(ra);
                QString decDMS = Units::decimalDegreesToDegreeMinutesAndSeconds(dec);

                status.append(QString("J2000  RA: %1  Dec: %2")
                    .arg(raDMS).arg(decDMS));
            }

            if (obj.contains("fov"))
            {
                fov = obj.value("fov").toDouble();

                status.append(QString("FoV: %1%2").arg(fov, 0, 'f', 2).arg(QChar(0xb0)));
            }

            if (obj.contains("latitude") && obj.contains("longitude"))
            {
                latitude = obj.value("latitude").toDouble();
                longitude = obj.value("longitude").toDouble();

                status.append(QString("Lat: %1%3 Long: %2%3")
                    .arg(latitude).arg(longitude)
                    .arg(QChar(0xb0)));
            }

            if (obj.contains("dateTime"))
            {
                status.append(QString("Date: %1").arg(dateTime.date().toString()));
                status.append(QString("Time: %1").arg(dateTime.time().toString()));
            }

            if (obj.contains("ra") && obj.contains("dec") && obj.contains("latitude") && obj.contains("longitude") && obj.contains("dateTime"))
            {
                // Convert from RA/Dec to Az/Alt
                RADec rd = {ra, dec};
                aa = Astronomy::raDecToAzAlt(rd, latitude, longitude, dateTime);
                QString az = QString::number(aa.az, 'f', 3);
                QString alt = QString::number(aa.alt, 'f', 3);

                status.insert(1, QString("Az: %1%3  Alt: %2%3")
                    .arg(az).arg(alt)
                    .arg(QChar(0xb0)));

                sendToRotator(status[0], aa.az, aa.alt);
            }
            else if (obj.contains("ra") && obj.contains("dec"))
            {
                RADec rd = {ra, dec};
                QGeoCoordinate position = getPosition();

                AzAlt aa = Astronomy::raDecToAzAlt(rd, position.latitude(), position.longitude(), dateTime);
                sendToRotator(status[0], aa.az, aa.alt);
            }

            setStatusText(status.join(" - "));

            // Send details to SkyMap for use in Web report
            SkyMap::ViewDetails viewDetails;
            viewDetails.m_ra = ra;
            viewDetails.m_dec = dec;
            viewDetails.m_azimuth = aa.az;
            viewDetails.m_elevation = aa.alt;
            viewDetails.m_latitude = latitude;
            viewDetails.m_longitude = longitude;
            viewDetails.m_fov = fov;
            viewDetails.m_dateTime = dateTime;
            SkyMap::MsgReportViewDetails* message = SkyMap::MsgReportViewDetails::create(viewDetails);
            m_skymap->getInputMessageQueue()->push(message);

        }
        else if (event == "ready")
        {
            m_ready = true;
            initSkyMap();

            // Run find that was requested while map was initialising
            if (!m_find.isEmpty())
            {
                find(m_find);
                m_find = "";
            }
        }
    }
    else
    {
        qDebug() << "SkyMapGUI::receivedEvent - Unexpected event: " << obj;
    }
}

static const QStringList wwtPlanets = {
    QStringLiteral("Sun"),
    QStringLiteral("Mercury"),
    QStringLiteral("Venus"),
    QStringLiteral("Earth"),
    QStringLiteral("Moon"),
    QStringLiteral("Mars"),
    QStringLiteral("Jupiter"),
    QStringLiteral("Saturn"),
    QStringLiteral("Uranus"),
    QStringLiteral("Neptune"),
    QStringLiteral("Pluto"),
    QStringLiteral("Io"),
    QStringLiteral("Europa"),
    QStringLiteral("Ganymede"),
    QStringLiteral("Callisto")
};

static const QStringList wwtPlanetIDs = {
    QStringLiteral("Sun"),
    QStringLiteral("Mercury"),
    QStringLiteral("Venus"),
    QStringLiteral("Bing Maps Aerial"), //"Earth",
    QStringLiteral("Moon"),
    QStringLiteral("Visible Imagery"), // Mars
    QStringLiteral("Jupiter"),
    QStringLiteral("Saturn"),
    QStringLiteral("Uranus"),
    QStringLiteral("Neptune"),
    QStringLiteral("Pluto (New Horizons)"),
    QStringLiteral("Io"),
    QStringLiteral("Europa"),
    QStringLiteral("Ganymede"),
    QStringLiteral("Callisto")
};

// From https://github.com/cds-astro/aladin-lite/blob/master/src/js/ImageLayer.js
static const QStringList aladinBackgrounds = {
    QStringLiteral("DSS colored"),
    QStringLiteral("DSS2 Red (F+R)"),
    QStringLiteral("2MASS colored"),
    QStringLiteral("Density map for Gaia EDR3 (I/350/gaiaedr3)"),
    QStringLiteral("PanSTARRS DR1 g"),
    QStringLiteral("PanSTARRS DR1 color"),
    QStringLiteral("DECaPS DR1 color"),
    QStringLiteral("Fermi color"),
    QStringLiteral("Halpha"),
    QStringLiteral("GALEXGR6_7 NUV"),
    QStringLiteral("IRIS colored"),
    QStringLiteral("Mellinger colored"),
    QStringLiteral("SDSS9 colored"),
    QStringLiteral("SDSS9 band-g"),
    QStringLiteral("IRAC color I1,I2,I4 - (GLIMPSE, SAGE, SAGE-SMC, SINGS)"),
    QStringLiteral("VTSS-Ha"),
    QStringLiteral("XMM PN colored"),
    QStringLiteral("AllWISE color"),
    QStringLiteral("GLIMPSE360")
};

static const QStringList aladinBackgroundIDs = {
    QStringLiteral("P/DSS2/color"),
    QStringLiteral("P/DSS2/red"),
    QStringLiteral("P/2MASS/color"),
    QStringLiteral("P/DM/I/350/gaiaedr3"),
    QStringLiteral("P/PanSTARRS/DR1/g"),
    QStringLiteral("P/PanSTARRS/DR1/color-z-zg-g"),
    QStringLiteral("P/DECaPS/DR1/color"),
    QStringLiteral("P/Fermi/color"),
    QStringLiteral("P/Finkbeiner"),
    QStringLiteral("P/GALEXGR6_7/NUV"),
    QStringLiteral("P/IRIS/color"),
    QStringLiteral("P/Mellinger/color"),
    QStringLiteral("P/SDSS9/color"),
    QStringLiteral("P/SDSS9/g"),
    QStringLiteral("P/SPITZER/color"),
    QStringLiteral("P/VTSS/Ha"),
    QStringLiteral("xcatdb/P/XMM/PN/color"),
    QStringLiteral("P/allWISE/color"),
    QStringLiteral("P/GLIMPSE360")
};

QString SkyMapGUI::backgroundID(const QString& name)
{
    QString id = name;

    if (m_settings.m_map == "Aladin")
    {
        int idx = aladinBackgrounds.indexOf(name);
        if (idx >= 0) {
            id = aladinBackgroundIDs[idx];
        }
    }
    else if (m_settings.m_map == "WWT")
    {
         if (m_settings.m_projection == "Solar system")
         {
             m_webInterface->track(m_settings.m_background);
             id = "Solar system";
         }
         else
         {
             int idx = wwtPlanets.indexOf(name);
             if (idx >= 0) {
                 id = wwtPlanetIDs[idx];
             }
         }
    }
    return id;
}

void SkyMapGUI::updateBackgrounds()
{
    QStringList backgrounds;

    if (m_settings.m_map == "WWT") {
        if (m_settings.m_projection == "Sky") {
            backgrounds = m_wwtBackgrounds;
        } else if (m_settings.m_projection == "Solar system") {
            backgrounds = wwtPlanets;
        } else {
            backgrounds = wwtPlanets;
        }
    } else if (m_settings.m_map == "ESASky") {
        backgrounds = QStringList();
    } else if (m_settings.m_map == "Aladin") {
        backgrounds = aladinBackgrounds;
    }

    ui->background->blockSignals(true);
    ui->background->clear();
    for (int i = 0; i < backgrounds.size(); i++) {
        ui->background->addItem(backgrounds[i]);
    }
    ui->background->blockSignals(false);
    int idx = ui->background->findText(m_settings.m_background);
    if (idx >= 0) {
        ui->background->setCurrentIndex(idx);
    } else {
        ui->background->setCurrentIndex(0);
    }

    on_background_currentIndexChanged(ui->projection->currentIndex());
}

void SkyMapGUI::wtmlUpdated(const QList<WTML::ImageSet>& dataSets)
{
    m_wwtBackgrounds.clear();
    for (int i = 0; i < dataSets.size(); i++)
    {
        if (dataSets[i].m_dataSetType == "Sky") {
            m_wwtBackgrounds.append(dataSets[i].m_name);
        }
    }
    updateBackgrounds();
}

void SkyMapGUI::updateProjection()
{
    QStringList projections;

    if (m_settings.m_map == "WWT") {
        projections = QStringList{"Sky", "Solar system", "Planet"};
    } else if (m_settings.m_map == "ESASky") {
        projections = QStringList();
    } else if (m_settings.m_map == "Aladin") {
        projections = QStringList{"SIN", "TAN", "STG", "ZEA", "FEYE", "AIR", "ARC", "NCP", "MER", "CAR", "CEA", "CYP", "AIT", "MOL", "PAR", "SFL", "COD", "HPX"};
    }

    ui->projection->blockSignals(true);
    ui->projection->clear();
    for (int i = 0; i < projections.size(); i++){
        ui->projection->addItem(projections[i]);
    }
    ui->projection->blockSignals(false);
    int idx = ui->projection->findText(m_settings.m_projection);
    if (idx >= 0) {
        ui->projection->setCurrentIndex(idx);
    } else {
        ui->projection->setCurrentIndex(0);
    }

    on_projection_currentIndexChanged(ui->projection->currentIndex());
}

void SkyMapGUI::updateToolbar()
{
    bool constellationsVisible = false;
    bool reticleVisible = true;
    bool namesVisible = false;
    bool projectionVisible = true;
    bool backgroundVisible = true;
    bool basicVisible = true;

    if (m_settings.m_map == "WWT")
    {
        constellationsVisible = true;
        namesVisible = true;
    }
    else if (m_settings.m_map == "ESASky")
    {
        projectionVisible = false;
        backgroundVisible = false;
        reticleVisible = false;
    }
    else if (m_settings.m_map == "Moon")
    {
        projectionVisible = false;
        backgroundVisible = false;
        reticleVisible = false;
        basicVisible = false;
    }

    ui->background->setVisible(backgroundVisible);
    ui->projection->setVisible(projectionVisible);

    ui->displayNames->setVisible(namesVisible);
    ui->displayConstellations->setVisible(constellationsVisible);
    ui->displayReticle->setVisible(reticleVisible);

    ui->find->setVisible(basicVisible);
    ui->findLabel->setVisible(basicVisible);
    ui->displayGrid->setVisible(basicVisible);
    ui->displayReticle->setVisible(basicVisible);
    ui->displayAntennaFoV->setVisible(basicVisible);
    ui->track->setVisible(basicVisible);
    ui->source->setVisible(basicVisible);

    updateProjection();
}

void SkyMapGUI::on_tabs_tabCloseRequested(int index)
{
    QWidget *widget = ui->tabs->widget(index);
    ui->tabs->removeTab(index);
    delete widget;
}

void SkyMapGUI::sendToRotator(const QString& name, double az, double alt)
{
    QList<ObjectPipe*> rotatorPipes;
    MainCore::instance()->getMessagePipes().getMessagePipes(m_skymap, "target", rotatorPipes);

    for (const auto& pipe : rotatorPipes)
    {
        MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
        SWGSDRangel::SWGTargetAzimuthElevation *swgTarget = new SWGSDRangel::SWGTargetAzimuthElevation();
        swgTarget->setName(new QString(name));
        swgTarget->setAzimuth(az);
        swgTarget->setElevation(alt);
        messageQueue->push(MainCore::MsgTargetAzimuthElevation::create(m_skymap, swgTarget));
    }
}

void SkyMapGUI::updateSourceList(const QStringList& renameFrom, const QStringList& renameTo)
{
    m_availableChannelOrFeatures = m_availableChannelOrFeatureHandler.getAvailableChannelOrFeatureList();

    // Update source settting if it has been renamed
    if (renameFrom.contains(m_settings.m_source))
    {
        m_settings.m_source = renameTo[renameFrom.indexOf(m_settings.m_source)];
        applySetting("source"); // Only call after m_availableChannelOrFeatures has been updated
    }

    int prevIdx = ui->source->currentIndex();
    ui->source->blockSignals(true);
    ui->source->clear();

    for (const auto& item : m_availableChannelOrFeatures) {
        ui->source->addItem(item.getLongId());
    }

    // Select current setting, if it exists
    // If not, and no prior setting, make sure nothing selected, as channel/feature may be created later on
    // If not found and something was previously selected, clear the setting, as probably deleted
    int idx = ui->source->findText(m_settings.m_source);
    if (idx >= 0)
    {
        ui->source->setCurrentIndex(idx);
        ui->track->setEnabled(true);
    }
    else if (prevIdx == -1)
    {
        ui->source->setCurrentIndex(-1);
        ui->track->setChecked(false);
        ui->track->setEnabled(false);
    }
    else
    {
        m_settings.m_source = "";
        applySetting("source");
    }

    ui->source->blockSignals(false);

    // If no current settting, select first available
    if (m_settings.m_source.isEmpty() && (ui->source->count() > 0))
    {
        ui->source->setCurrentIndex(0);
        on_source_currentIndexChanged(0);
    }
}

void SkyMapGUI::handlePipeMessageQueue(MessageQueue* messageQueue)
{
    Message* message;

    while ((message = messageQueue->pop()) != nullptr)
    {
        if (handleMessage(*message)) {
            delete message;
        }
    }
}