dbairlineicaoselectorbase.cpp

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#include "gui/components/dbairlineicaoselectorbase.h"
 
#include <QCompleter>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QMetaType>
#include <QPalette>
#include <QPointer>
#include <QtGlobal>
 
#include "core/webdataservices.h"
#include "gui/guiapplication.h"
#include "misc/aviation/airlineicaocodelist.h"
#include "misc/db/datastoreutility.h"
#include "misc/mixin/mixincompare.h"
#include "misc/variant.h"
 
using namespace swift::gui;
using namespace swift::core;
using namespace swift::misc;
using namespace swift::misc::db;
using namespace swift::misc::network;
using namespace swift::misc::aviation;
using namespace swift::misc::network;
 
namespace swift::gui::components
{
    CDbAirlineIcaoSelectorBase::CDbAirlineIcaoSelectorBase(QWidget *parent) : QFrame(parent)
    {
        this->setAcceptDrops(true);
        this->setAcceptedMetaTypeIds({ qMetaTypeId<CAirlineIcaoCode>(), qMetaTypeId<CAirlineIcaoCodeList>() });
 
        connect(sGui->getWebDataServices(), &CWebDataServices::dataRead, this, &CDbAirlineIcaoSelectorBase::onCodesRead,
                Qt::QueuedConnection);
 
        // when we already have data, init completers. This can not be done directly in the
        // constructor due to virtual functions
        const int c = sGui->getWebDataServices()->getAirlineIcaoCodesCount();
        if (c > 0)
        {
            QPointer<CDbAirlineIcaoSelectorBase> myself(this);
            QTimer::singleShot(500, [=]() {
                if (!sGui || sGui->isShuttingDown()) { return; }
                if (!myself) { return; }
                this->onCodesRead(CEntityFlags::AirlineIcaoEntity, CEntityFlags::ReadFinished, c, {});
            });
        }
    }
 
    CDbAirlineIcaoSelectorBase::~CDbAirlineIcaoSelectorBase() {}
 
    bool CDbAirlineIcaoSelectorBase::setAirlineIcao(const CAirlineIcaoCode &icao)
    {
        if (icao == m_currentIcao) { return false; }
        if (icao.isLoadedFromDb()) { m_currentIcao = icao; }
        else { m_currentIcao = sGui->getWebDataServices()->smartAirlineIcaoSelector(icao); }
        emit changedAirlineIcao(m_currentIcao);
        return true;
    }
 
    bool CDbAirlineIcaoSelectorBase::setAirlineIcao(int key)
    {
        CAirlineIcaoCode icao(sGui->getWebDataServices()->getAirlineIcaoCodeForDbKey(key));
        if (!icao.hasCompleteData()) { return false; }
        this->setAirlineIcao(icao);
        return true;
    }
 
    bool CDbAirlineIcaoSelectorBase::isSet() const
    {
        const CAirlineIcaoCode icao(this->getAirlineIcao());
        return icao.isLoadedFromDb() || icao.hasCompleteData();
    }
 
    void CDbAirlineIcaoSelectorBase::dragEnterEvent(QDragEnterEvent *event)
    {
        if (!event || !acceptDrop(event->mimeData())) { return; }
        this->setBackgroundRole(QPalette::Highlight);
        event->acceptProposedAction();
    }
 
    void CDbAirlineIcaoSelectorBase::dragMoveEvent(QDragMoveEvent *event)
    {
        if (!event || !acceptDrop(event->mimeData())) { return; }
        event->acceptProposedAction();
    }
 
    void CDbAirlineIcaoSelectorBase::dragLeaveEvent(QDragLeaveEvent *event)
    {
        if (!event) { return; }
        event->accept();
    }
 
    void CDbAirlineIcaoSelectorBase::dropEvent(QDropEvent *event)
    {
        if (!event || !acceptDrop(event->mimeData())) { return; }
        const CVariant valueVariant(toCVariant(event->mimeData()));
        if (valueVariant.isValid())
        {
            if (valueVariant.canConvert<CAirlineIcaoCode>())
            {
                const CAirlineIcaoCode icao(valueVariant.value<CAirlineIcaoCode>());
                if (!icao.hasValidDbKey()) { return; }
                this->setAirlineIcao(icao);
            }
            else if (valueVariant.canConvert<CAirlineIcaoCodeList>())
            {
                const CAirlineIcaoCodeList icaos(valueVariant.value<CAirlineIcaoCodeList>());
                if (icaos.isEmpty()) { return; }
                this->setAirlineIcao(icaos.front());
            }
        }
    }
 
    void CDbAirlineIcaoSelectorBase::onCodesRead(CEntityFlags::Entity entity, CEntityFlags::ReadState readState,
                                                 int count, const QUrl &url)
    {
        Q_UNUSED(url)
 
        if (!sGui) { return; }
        if (entity.testFlag(CEntityFlags::AirlineIcaoEntity) && CEntityFlags::isFinishedReadState(readState))
        {
            if (count > 0)
            {
                QCompleter *c = this->createCompleter();
                Q_ASSERT_X(c, Q_FUNC_INFO, "missing converter");
                connect(c, qOverload<const QString &>(&QCompleter::activated), this,
                        &CDbAirlineIcaoSelectorBase::onCompleterActivated);
                m_completer.reset(c); // deletes any old completer
            }
            else { m_completer.reset(nullptr); }
        }
    }
 
    void CDbAirlineIcaoSelectorBase::onCompleterActivated(const QString &icaoString)
    {
        const int dbKey = CDatastoreUtility::extractIntegerKey(icaoString);
        if (dbKey < 0) { return; }
        this->setAirlineIcao(dbKey);
    }
} // namespace swift::gui::components