aircraftmodelview.cpp

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#include "aircraftmodelview.h"
 
#include <QAction>
#include <QDropEvent>
#include <QMap>
#include <QShortcut>
#include <QString>
#include <QStringBuilder>
#include <QWidget>
#include <QtGlobal>
 
#include "gui/filters/aircraftmodelfilterdialog.h"
#include "gui/guiapplication.h"
#include "gui/guiutility.h"
#include "gui/menus/menuaction.h"
#include "gui/shortcut.h"
#include "gui/views/aircraftmodelstatisticsdialog.h"
#include "gui/views/aircraftmodelvalidationdialog.h"
#include "gui/views/viewbase.h"
#include "misc/aviation/aircrafticaocode.h"
#include "misc/aviation/aircrafticaocodelist.h"
#include "misc/aviation/airlineicaocodelist.h"
#include "misc/aviation/livery.h"
#include "misc/aviation/liverylist.h"
#include "misc/directories.h"
#include "misc/icons.h"
#include "misc/simulation/aircraftmodel.h"
#include "misc/simulation/distributorlist.h"
#include "misc/simulation/simulatorinfolist.h"
#include "misc/statusmessagelist.h"
#include "misc/variant.h"
 
using namespace swift::misc;
using namespace swift::misc::simulation;
using namespace swift::misc::aviation;
using namespace swift::gui::models;
using namespace swift::gui::filters;
using namespace swift::gui::menus;
 
namespace swift::gui::views
{
    CAircraftModelView::CAircraftModelView(QWidget *parent) : COrderableViewWithDbObjects(parent)
    {
        // default
        this->standardInit(new CAircraftModelListModel(CAircraftModelListModel::OwnAircraftModelClient, this));
        this->setSettingsDirectoryIndex(CDirectories::IndexDirLastModelJsonOrDefault);
 
        // shortcut
        QShortcut *stashShortcut = new QShortcut(CShortcut::keyStash(), this);
        stashShortcut->setContext(Qt::WidgetShortcut);
        connect(stashShortcut, &QShortcut::activated, this, &CAircraftModelView::requestedStash);
 
        // default mode
        CAircraftModelListModel::AircraftModelMode mode = derivedModel()->getModelMode();
        this->setAircraftModelMode(mode);
        this->setSortIndicator();
    }
 
    void CAircraftModelView::setAircraftModelMode(CAircraftModelListModel::AircraftModelMode mode)
    {
        this->setCustomMenu(nullptr, false); // delete everything
        derivedModel()->setAircraftModelMode(mode);
        this->setSortIndicator();
        switch (mode)
        {
        case CAircraftModelListModel::StashModel: m_menus = MenuDefaultNoClear; break;
        case CAircraftModelListModel::Database: m_menus = MenuDefaultDbViews; break;
        case CAircraftModelListModel::VPilotRuleModel: m_menus = MenuDefaultNoClear | MenuStashing; break;
        case CAircraftModelListModel::OwnAircraftModelMappingTool:
            m_menus = MenuDefaultNoClear | MenuStashing | MenuLoadAndSave;
            break;
        case CAircraftModelListModel::OwnAircraftModelClient:
        default: m_menus = MenuDefaultNoClear | MenuBackend; break;
        }
    }
 
    int CAircraftModelView::applyToSelected(const CLivery &livery)
    {
        if (!hasSelection()) { return 0; }
        const int c = this->updateSelected(CVariant::from(livery), CAircraftModel::IndexLivery);
        return c;
    }
 
    int CAircraftModelView::applyToSelected(const CAircraftIcaoCode &icao)
    {
        if (!hasSelection()) { return 0; }
        const int c = this->updateSelected(CVariant::from(icao), CAircraftModel::IndexAircraftIcaoCode);
        return c;
    }
 
    int CAircraftModelView::applyToSelected(const CDistributor &distributor)
    {
        if (!hasSelection()) { return 0; }
        const int c = this->updateSelected(CVariant::from(distributor), CAircraftModel::IndexDistributor);
        return c;
    }
 
    int CAircraftModelView::applyToSelected(const CPropertyIndexVariantMap &vm)
    {
        if (!hasSelection()) { return 0; }
        const int c = this->updateSelected(vm);
        return c;
    }
 
    bool CAircraftModelView::hasSelectedModelsToStash() const
    {
        return m_menus.testFlag(MenuCanStashModels) && hasSelection();
    }
 
    void CAircraftModelView::setAcceptedMetaTypeIds()
    {
        Q_ASSERT(m_model);
        m_model->setAcceptedMetaTypeIds({
            qMetaTypeId<CAirlineIcaoCode>(),
            qMetaTypeId<CAirlineIcaoCodeList>(),
            qMetaTypeId<CAircraftIcaoCode>(),
            qMetaTypeId<CAircraftIcaoCodeList>(),
            qMetaTypeId<CLivery>(),
            qMetaTypeId<CLiveryList>(),
            qMetaTypeId<CDistributor>(),
            qMetaTypeId<CDistributorList>(),
            qMetaTypeId<CAircraftModel>(),
            qMetaTypeId<CAircraftModelList>(),
        });
    }
 
    void CAircraftModelView::addFilterDialog() { this->setFilterDialog(new CAircraftModelFilterDialog(this)); }
 
    CAircraftModelFilterDialog *CAircraftModelView::getFilterDialog() const
    {
        return qobject_cast<CAircraftModelFilterDialog *>(this->getFilterWidget());
    }
 
    int CAircraftModelView::removeModelsWithModelString(const QStringList &modelStrings,
                                                        Qt::CaseSensitivity sensitivity)
    {
        if (modelStrings.isEmpty()) { return 0; }
        CAircraftModelList copy(this->container());
        const int delta = copy.removeModelsWithString(modelStrings, sensitivity);
        if (delta > 0) { this->updateContainerMaybeAsync(copy); }
        return delta;
    }
 
    int CAircraftModelView::removeModelsWithModelString(const CAircraftModelList &models,
                                                        Qt::CaseSensitivity sensitivity)
    {
        return this->removeModelsWithModelString(models.getModelStringList(), sensitivity);
    }
 
    int CAircraftModelView::replaceOrAddModelsWithString(const CAircraftModelList &models,
                                                         Qt::CaseSensitivity sensitivity)
    {
        if (models.isEmpty()) { return 0; }
        CAircraftModelList copy(this->container());
        int c = copy.replaceOrAddModelsWithString(models, sensitivity);
        if (c == 0) { return 0; }
        this->updateContainerMaybeAsync(copy);
        return c;
    }
 
    void CAircraftModelView::setHighlightModelStrings(const QStringList &highlightModels)
    {
        this->derivedModel()->setHighlightModelStrings(highlightModels);
    }
 
    void CAircraftModelView::setHighlightModelsForInvalidModels()
    {
        this->clearHighlighting();
        CAircraftModelList invaliddModels;
        invaliddModels.loadInvalidModels();
        if (!invaliddModels.isEmpty())
        {
            this->setHighlight(true);
            this->setHighlightColor(Qt::red);
            this->setHighlightModels(invaliddModels);
 
            const int r = this->rowOf(invaliddModels.front());
            const QModelIndex i = m_model->index(r, 0);
            this->scrollTo(i);
        }
    }
 
    void CAircraftModelView::setHighlightModels(const CAircraftModelList &highlightModels)
    {
        this->derivedModel()->setHighlightModels(highlightModels);
    }
 
    void CAircraftModelView::setHighlight(bool highlight) { this->derivedModel()->setHighlight(highlight); }
 
    void CAircraftModelView::setHighlightColor(const QBrush &brush) { this->derivedModel()->setHighlightColor(brush); }
 
    bool CAircraftModelView::highlightModels() const { return this->derivedModel()->highlightModels(); }
 
    void CAircraftModelView::setCorrespondingSimulator(const CSimulatorInfo &simulator, const QString &simDir)
    {
        m_correspondingSimulator = simulator;
        m_correspondingSimulatorDir = simDir;
    }
 
    void CAircraftModelView::dropEvent(QDropEvent *event)
    {
        // moves from myself are ignored
        // depends on isDropAllowed() / acceptDrop() if this function is called
        Qt::DropAction action = event->dropAction();
        if (action == Qt::MoveAction)
        {
            COrderableViewWithDbObjects::dropEvent(event);
            return;
        }
        if (!this->isDropAllowed()) { return; }
        if (!event) { return; }
        const QMimeData *mime = event->mimeData();
        if (!mime) { return; }
 
        if (CGuiUtility::hasSwiftVariantMimeType(mime))
        {
            const CVariant valueVariant(CGuiUtility::fromSwiftDragAndDropData(mime));
            if (valueVariant.isValid())
            {
                if (valueVariant.canConvert<CAircraftModel>())
                {
                    const CAircraftModel model = valueVariant.value<CAircraftModel>();
                    if (!model.hasModelString()) { return; }
                    const CAircraftModelList models({ model });
                    this->derivedModel()->replaceOrAddByModelString(models);
                    return;
                }
                else if (valueVariant.canConvert<CAircraftModelList>())
                {
                    const CAircraftModelList models(valueVariant.value<CAircraftModelList>());
                    if (models.isEmpty()) { return; }
                    this->derivedModel()->replaceOrAddByModelString(models);
                    return;
                }
 
                // only for selected members
                if (!this->hasSelection()) { return; }
                if (valueVariant.canConvert<CAircraftIcaoCode>())
                {
                    const CAircraftIcaoCode icao = valueVariant.value<CAircraftIcaoCode>();
                    if (icao.validate().hasErrorMessages()) { return; }
                    this->applyToSelected(icao);
                }
                else if (valueVariant.canConvert<CAircraftIcaoCodeList>())
                {
                    const CAircraftIcaoCodeList icaos(valueVariant.value<CAircraftIcaoCodeList>());
                    if (icaos.size() != 1) { return; }
                    const CAircraftIcaoCode icao = icaos.front();
                    if (icao.validate().hasErrorMessages()) { return; }
                    this->applyToSelected(icao);
                }
                else if (valueVariant.canConvert<CLivery>())
                {
                    const CLivery livery = valueVariant.value<CLivery>();
                    if (livery.validate().hasErrorMessages()) { return; }
                    this->applyToSelected(livery);
                }
                else if (valueVariant.canConvert<CLiveryList>())
                {
                    const CLiveryList liveries(valueVariant.value<CLiveryList>());
                    if (liveries.size() != 1) { return; }
                    const CLivery livery = liveries.front();
                    if (livery.validate().hasErrorMessages()) { return; }
                    this->applyToSelected(livery);
                }
                else if (valueVariant.canConvert<CDistributor>())
                {
                    const CDistributor distributor = valueVariant.value<CDistributor>();
                    if (distributor.validate().hasErrorMessages()) { return; }
                    this->applyToSelected(distributor);
                }
                else if (valueVariant.canConvert<CDistributorList>())
                {
                    const CDistributorList distributors(valueVariant.value<CDistributorList>());
                    if (distributors.size() != 1) { return; }
                    const CDistributor distributor = distributors.front();
                    if (distributor.validate().hasErrorMessages()) { return; }
                    this->applyToSelected(distributor);
                }
                else if (valueVariant.canConvert<CAirlineIcaoCode>())
                {
                    const CAirlineIcaoCode airline = valueVariant.value<CAirlineIcaoCode>();
                    if (airline.validate().hasErrorMessages()) { return; }
                    emit requestHandlingOfStashDrop(
                        airline); // I need to convert to stanard livery, which I can`t do here
                }
                else if (valueVariant.canConvert<CAirlineIcaoCodeList>())
                {
                    const CAirlineIcaoCodeList airlines(valueVariant.value<CAirlineIcaoCodeList>());
                    if (airlines.size() != 1) { return; }
                    const CAirlineIcaoCode airline = airlines.front();
                    if (airline.validate().hasErrorMessages()) { return; }
                    emit requestHandlingOfStashDrop(
                        airline); // I need to convert to stanard livery, which I can`t do here
                }
            }
        }
        else { CViewBase::dropEvent(event); }
    }
 
    void CAircraftModelView::customMenu(CMenuActions &menuActions)
    {
        // Statistics and validation
        if (!this->isEmpty())
        {
            menuActions.addAction(CIcons::appAircraft16(), "Model statistics", CMenuAction::pathModel(),
                                  { this, &CAircraftModelView::displayModelStatisticsDialog });
            if (m_withValidationContextMenu)
            {
                QDialog *parentDialog = CGuiUtility::findParentDialog(this);
                if (!(parentDialog && (qobject_cast<CAircraftModelValidationDialog *>(parentDialog))))
                {
                    menuActions.addAction(CIcons::disk16(), "Model validation (selected)", CMenuAction::pathModel(),
                                          { this, &CAircraftModelView::displayModelValidationDialog });
                }
            }
            if (CAircraftModelList::hasInvalidModelFile())
            {
                menuActions.addAction(CIcons::disk16(), "Highlight invalid models (from file)",
                                      CMenuAction::pathModel(),
                                      { this, &CAircraftModelView::setHighlightModelsForInvalidModels });
            }
        }
 
        // Stash menus
        bool addStashMenu = false;
        if (m_menus.testFlag(MenuCanStashModels))
        {
            if (!m_menuFlagActions.contains(MenuCanStashModels))
            {
                CMenuActions ma;
                ma.addAction(CIcons::appDbStash16(), "Stash selected", CMenuAction::pathModelStash(),
                             { this, &CAircraftModelView::requestedStash });
                QAction *added =
                    ma.addAction(CIcons::appDbStash16(), "Stashing clears selection (on/off)",
                                 CMenuAction::pathModelStash(), { this, &CAircraftModelView::stashingClearsSelection });
                added->setCheckable(true);
                m_menuFlagActions.insert(MenuCanStashModels, ma);
            }
 
            // modify menu items
            const int selected = this->selectedRowCount();
            const bool tooMany = selected > 500;
            const bool canStash = selected > 0 && !tooMany;
            QAction *a = menuActions.addActions(initMenuActions(MenuCanStashModels)).first();
            a->setEnabled(canStash);
            a = menuActions.addActions(initMenuActions(MenuCanStashModels)).last();
            a->setChecked(m_stashingClearsSelection);
            addStashMenu = true;
        }
        if (m_menus.testFlag(MenuHighlightStashed))
        {
            // this function requires that someone provides the model strings to be highlighted
            if (!m_menuFlagActions.contains(MenuHighlightStashed))
            {
                CMenuActions ma;
                QAction *added =
                    ma.addAction(CIcons::appDbStash16(), "Highlight stashed (on/off)", CMenuAction::pathModelStash(),
                                 { this, &CAircraftModelView::toggleHighlightStashedModels });
                added->setCheckable(true);
                m_menuFlagActions.insert(MenuHighlightStashed, ma);
            }
            QAction *a = menuActions.addActions(initMenuActions(CViewBaseNonTemplate::MenuHighlightStashed)).first();
            a->setChecked(this->derivedModel()->highlightModels());
            addStashMenu = true;
        }
 
        // client specific
        if (m_menus.testFlag(MenuDisableModelsTemp) && this->hasSelection())
        {
            if (!m_menuFlagActions.contains(MenuDisableModelsTemp))
            {
                CMenuActions ma;
                ma.addAction(CIcons::delete16(), "Temp.disable model", CMenuAction::pathModel(),
                             { this, &CAircraftModelView::requestTempDisable });
                m_menuFlagActions.insert(MenuDisableModelsTemp, ma);
            }
            menuActions.addActions(initMenuActions(CViewBaseNonTemplate::MenuDisableModelsTemp));
        }
 
        if (addStashMenu) { menuActions.addMenuStash(); }
 
        // base class menus
        COrderableViewWithDbObjects::customMenu(menuActions);
    }
 
    CStatusMessage CAircraftModelView::modifyLoadedJsonData(CAircraftModelList &models) const
    {
        if (m_correspondingSimulator.isNoSimulator()) { return {}; }
        if (models.isEmpty()) { return CStatusMessage(this, CStatusMessage::SeverityDebug, u"Empty models", true); }
 
        // multiple sims with same count
        const int removed = models.removeIfNotMatchingSimulator(m_correspondingSimulator);
        if (removed < 1) { return {}; }
        return CStatusMessage(this, CStatusMessage::SeverityWarning, u"Reduced by %1 model(s) to only use %2 models",
                              true)
               << removed << m_correspondingSimulator.toQString(true);
    }
 
    CStatusMessage CAircraftModelView::validateLoadedJsonData(const CAircraftModelList &models) const
    {
        if (models.isEmpty()) { return COrderableViewWithDbObjects::validateLoadedJsonData(models); }
        if (m_correspondingSimulator.isNoSimulator())
        {
            return COrderableViewWithDbObjects::validateLoadedJsonData(models);
        }
        if (models.containsNotMatchingSimulator(m_correspondingSimulator))
        {
            return CStatusMessage(this, CStatusMessage::SeverityError, u"Found entry not matching %1 in model data",
                                  true)
                   << m_correspondingSimulator.toQString();
        }
        return COrderableViewWithDbObjects::validateLoadedJsonData(models);
    }
 
    void CAircraftModelView::jsonLoadedAndModelUpdated(const CAircraftModelList &models)
    {
        if (models.isEmpty()) { emit this->jsonModelsForSimulatorLoaded(CSimulatorInfo()); }
        else { emit this->jsonModelsForSimulatorLoaded(models.simulatorsWithMaxEntries()); }
    }
 
    void CAircraftModelView::toggleHighlightStashedModels()
    {
        const bool h = derivedModel()->highlightModels();
        derivedModel()->setHighlight(!h);
        emit toggledHighlightStashedModels();
    }
 
    void CAircraftModelView::toggleHighlightInvalidModels()
    {
        const bool h = this->highlightModels();
        this->setHighlight(!h);
    }
 
    void CAircraftModelView::stashingClearsSelection() { m_stashingClearsSelection = !m_stashingClearsSelection; }
 
    void CAircraftModelView::requestedStash()
    {
        if (!m_menus.testFlag(MenuCanStashModels)) { return; }
        if (!this->hasSelection()) { return; }
        const CAircraftModelList models(this->selectedObjects());
        emit this->requestStash(models);
        if (m_stashingClearsSelection) { this->clearSelection(); }
        sGui->displayInStatusBar(
            CStatusMessage(CStatusMessage::SeverityInfo, u"Stashed " % models.getModelStringList(true).join(" ")));
    }
 
    void CAircraftModelView::requestTempDisable()
    {
        if (!m_menus.testFlag(MenuDisableModelsTemp)) { return; }
        if (!sGui || sGui->isShuttingDown()) { return; }
        if (!this->hasSelection()) { return; }
 
        const CAircraftModelList selectedModels(this->selectedObjects());
        sGui->displayInStatusBar(CStatusMessage(CStatusMessage::SeverityInfo,
                                                u"Temp.disabled " % selectedModels.getModelStringList(true).join(" ")));
        emit this->requestTempDisableModelsForMatching(selectedModels);
    }
 
    void CAircraftModelView::displayModelStatisticsDialog()
    {
        if (!m_statisticsDialog) { m_statisticsDialog = new CAircraftModelStatisticsDialog(this); }
        m_statisticsDialog->analyzeModels(this->container());
        m_statisticsDialog->exec();
    }
 
    void CAircraftModelView::displayModelValidationDialog()
    {
        if (!m_fileValidationDialog) { m_fileValidationDialog = new CAircraftModelValidationDialog(this); }
        m_fileValidationDialog->setModels(this->selectedObjects(), m_correspondingSimulator,
                                          m_correspondingSimulatorDir);
        m_fileValidationDialog->triggerValidation(1000);
        m_fileValidationDialog->exec();
    }
} // namespace swift::gui::views