dbmappingcomponent.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/dbmappingcomponent.h"
 
#include <QAction>
#include <QDialog>
#include <QFileDialog>
#include <QFrame>
#include <QMenu>
#include <QModelIndex>
#include <QPoint>
#include <QShortcut>
#include <QSplitter>
#include <QTabWidget>
#include <QVariant>
#include <QWidget>
#include <Qt>
#include <QtGlobal>
 
#include "ui_dbmappingcomponent.h"
 
#include "core/webdataservices.h"
#include "gui/components/dbautosimulatorstashingcomponent.h"
#include "gui/components/dbautostashingcomponent.h"
#include "gui/components/dbmodelmappingmodifydialog.h"
#include "gui/components/dbownmodelscomponent.h"
#include "gui/components/dbownmodelsetcomponent.h"
#include "gui/components/dbstashcomponent.h"
#include "gui/components/modelmatchercomponent.h"
#include "gui/editors/aircrafticaoform.h"
#include "gui/editors/distributorform.h"
#include "gui/editors/liveryform.h"
#include "gui/editors/modelmappingform.h"
#include "gui/guiapplication.h"
#include "gui/guiutility.h"
#include "gui/menus/aircraftmodelmenus.h"
#include "gui/menus/menuaction.h"
#include "gui/models/aircraftmodellistmodel.h"
#include "gui/shortcut.h"
#include "gui/views/aircraftmodelview.h"
#include "gui/views/viewbase.h"
#include "misc/aviation/aircrafticaocode.h"
#include "misc/aviation/livery.h"
#include "misc/icons.h"
#include "misc/logmessage.h"
#include "misc/network/authenticateduser.h"
#include "misc/propertyindexvariantmap.h"
#include "misc/simulation/aircraftmodelutils.h"
#include "misc/swiftdirectories.h"
 
using namespace swift::core;
using namespace swift::misc;
using namespace swift::misc::aviation;
using namespace swift::misc::network;
using namespace swift::misc::simulation;
using namespace swift::misc::simulation::fscommon;
using namespace swift::gui;
using namespace swift::gui::editors;
using namespace swift::gui::views;
using namespace swift::gui::models;
using namespace swift::gui::menus;
 
namespace swift::gui::components
{
    CDbMappingComponent::CDbMappingComponent(QWidget *parent)
        : COverlayMessagesFrame(parent), ui(new Ui::CDbMappingComponent),
          m_autoStashDialog(new CDbAutoStashingComponent(this)),
          m_autoSimulatorDialog(new CDbAutoSimulatorStashingComponent(this)),
          m_modelModifyDialog(new CDbModelMappingModifyDialog(this))
    {
        ui->setupUi(this);
        ui->comp_StashAircraft->setMappingComponent(this);
        ui->comp_OwnModelSet->setMappingComponent(this);
 
        ui->tvp_AircraftModelsForVPilot->setAircraftModelMode(CAircraftModelListModel::VPilotRuleModel);
        ui->tvp_AircraftModelsForVPilot->addFilterDialog();
 
        // model menus
        ui->comp_OwnAircraftModels->view()->setCustomMenu(
            new CShowSimulatorFileMenu(ui->comp_OwnAircraftModels->view(), this));
        ui->comp_OwnAircraftModels->view()->setCustomMenu(new CMergeWithVPilotMenu(this));
        ui->comp_OwnAircraftModels->view()->setCustomMenu(new COwnModelSetMenu(this));
        ui->comp_OwnAircraftModels->view()->setCustomMenu(new CStashToolsMenu(this));
 
        ui->comp_OwnModelSet->view()->setCustomMenu(new CShowSimulatorFileMenu(ui->comp_OwnModelSet->view(), this));
        ui->comp_OwnModelSet->view()->setCustomMenu(new CStashToolsMenu(this));
 
        ui->comp_StashAircraft->view()->setCustomMenu(new CShowSimulatorFileMenu(ui->comp_StashAircraft->view(), this));
        ui->comp_StashAircraft->view()->setCustomMenu(new CApplyDbDataMenu(this));
        ui->comp_StashAircraft->view()->setCustomMenu(new COwnModelSetMenu(this));
        ui->comp_StashAircraft->view()->setCustomMenu(new CStashToolsMenu(this));
 
        ui->comp_ModelWorkbench->view()->menuAddItems(CAircraftModelView::MenuClear |
                                                      CAircraftModelView::MenuRemoveSelectedRows);
        ui->comp_ModelWorkbench->view()->setCustomMenu(new CApplyDbDataMenu(this));
        ui->comp_ModelWorkbench->view()->setCustomMenu(new COwnModelSetMenu(this));
        ui->comp_ModelWorkbench->view()->setCustomMenu(new CStashToolsMenu(this));
        ui->comp_ModelWorkbench->view()->setCustomMenu(new CRemovedModelsMenu(this));
 
        // connects
        connect(ui->editor_ModelMapping, &CModelMappingForm::requestStash, this,
                &CDbMappingComponent::stashCurrentModel);
 
        connect(ui->comp_OwnAircraftModels, &CDbOwnModelsComponent::ownModelsSimulatorChanged, this,
                &CDbMappingComponent::onOwnModelsSimulatorChanged, Qt::QueuedConnection);
        connect(ui->comp_OwnAircraftModels->view(), &CAircraftModelView::doubleClicked, this,
                &CDbMappingComponent::onModelRowSelected);
        connect(ui->comp_OwnAircraftModels->view(), &CAircraftModelView::modelDataChangedDigest, this,
                &CDbMappingComponent::onOwnModelsChangedDigest, Qt::QueuedConnection);
        connect(ui->comp_OwnAircraftModels->view(), &CAircraftModelView::requestStash, this,
                &CDbMappingComponent::stashSelectedModels);
        connect(ui->comp_OwnAircraftModels->view(), &CAircraftModelView::toggledHighlightStashedModels, this,
                &CDbMappingComponent::onStashedModelsChangedTriggerDigest);
 
        connect(ui->comp_ModelWorkbench->view(), &CAircraftModelView::doubleClicked, this,
                &CDbMappingComponent::onModelRowSelected);
        connect(ui->comp_ModelWorkbench->view(), &CAircraftModelView::modelDataChangedDigest, this,
                &CDbMappingComponent::onWorkbenchDataChanged, Qt::QueuedConnection);
        connect(ui->comp_ModelWorkbench->view(), &CAircraftModelView::requestStash, this,
                &CDbMappingComponent::stashSelectedModels);
        connect(ui->comp_ModelWorkbench->view(), &CAircraftModelView::toggledHighlightStashedModels, this,
                &CDbMappingComponent::onStashedModelsChangedTriggerDigest);
 
        connect(ui->comp_StashAircraft->view(), &CAircraftModelView::modelDataChangedDigest, this,
                &CDbMappingComponent::onStashedModelsDataChangedDigest);
        connect(ui->comp_StashAircraft->view(), &CAircraftModelView::doubleClicked, this,
                &CDbMappingComponent::onModelRowSelected);
        connect(ui->comp_StashAircraft->view(), &CAircraftModelView::requestHandlingOfStashDrop, this,
                &CDbMappingComponent::handleStashDropRequest);
        connect(ui->comp_StashAircraft, &CDbStashComponent::stashedModelsChanged, this,
                &CDbMappingComponent::onStashedModelsChangedTriggerDigest);
        connect(ui->comp_StashAircraft, &CDbStashComponent::modelsSuccessfullyPublished, this,
                &CDbMappingComponent::onModelsSuccessfullyPublished, Qt::QueuedConnection);
 
        connect(ui->comp_OwnModelSet->view(), &CAircraftModelView::modelDataChangedDigest, this,
                &CDbMappingComponent::onModelSetChangedDigest, Qt::QueuedConnection);
        connect(ui->comp_OwnModelSet->view(), &CAircraftModelView::requestStash, this,
                &CDbMappingComponent::stashSelectedModels);
 
        connect(ui->tw_ModelsToBeMapped, &QTabWidget::currentChanged, this, &CDbMappingComponent::onTabIndexChanged);
        connect(ui->tw_ModelsToBeMapped, &QTabWidget::currentChanged, ui->comp_ModelMatcher,
                &CModelMatcherComponent::tabIndexChanged);
 
        connect(ui->comp_OwnModelSet->view(), &CAircraftModelView::doubleClicked, this,
                &CDbMappingComponent::onModelRowSelected);
 
        // initial values
        this->onModelSetChangedDigest(ui->comp_OwnModelSet->view()->rowCount(),
                                      ui->comp_OwnModelSet->view()->hasFilter());
        this->onStashedModelsDataChangedDigest(ui->comp_StashAircraft->view()->rowCount(),
                                               ui->comp_StashAircraft->view()->hasFilter());
        this->onOwnModelsChangedDigest(ui->comp_OwnAircraftModels->view()->rowCount(),
                                       ui->comp_OwnAircraftModels->view()->hasFilter());
 
        // allow to use workbench data
        ui->comp_ModelMatcher->setWorkbenchView(ui->comp_ModelWorkbench->view());
 
        // how to display forms
        ui->editor_AircraftModel->setSelectOnly();
 
        ui->tw_ModelsToBeMapped->setTabIcon(TabStash, CIcons::appDbStash16());
        ui->tw_ModelsToBeMapped->setTabIcon(TabOwnModels, CIcons::appModels16());
        ui->tw_ModelsToBeMapped->setTabIcon(TabOwnModelSet, CIcons::appModels16());
        ui->tw_ModelsToBeMapped->setTabIcon(TabWorkbench, CIcons::wrench16());
 
        // custom menu and shortcut
        this->setContextMenuPolicy(Qt::CustomContextMenu);
        connect(this, &CDbMappingComponent::customContextMenuRequested, this,
                &CDbMappingComponent::onCustomContextMenu);
        new QShortcut(CShortcut::keyAddToModelSet(), this, SLOT(ps_addToOwnModelSet()));
 
        // vPilot
        this->initVPilotLoading();
    }
 
    CDbMappingComponent::~CDbMappingComponent() { this->gracefulShutdown(); }
 
    void CDbMappingComponent::initVPilotLoading()
    {
        m_vPilotEnabled = this->vPilotSupport && m_swiftDbUser.get().hasAdminRole();
        static const QString tabName(ui->tw_ModelsToBeMapped->tabText(TabVPilot));
 
        if (m_vPilot1stInit && vPilotSupport)
        {
            m_vPilot1stInit = false;
            connect(ui->tvp_AircraftModelsForVPilot, &CAircraftModelView::doubleClicked, this,
                    &CDbMappingComponent::onModelRowSelected);
            connect(ui->tvp_AircraftModelsForVPilot, &CAircraftModelView::modelDataChanged, this,
                    &CDbMappingComponent::onVPilotDataChanged);
            connect(&m_vPilotReader, &CVPilotRulesReader::readFinished, this,
                    &CDbMappingComponent::onLoadVPilotDataFinished);
            connect(ui->tvp_AircraftModelsForVPilot, &CAircraftModelView::requestStash, this,
                    &CDbMappingComponent::stashSelectedModels);
            connect(ui->tvp_AircraftModelsForVPilot, &CAircraftModelView::toggledHighlightStashedModels, this,
                    &CDbMappingComponent::onStashedModelsChangedTriggerDigest);
            connect(ui->tvp_AircraftModelsForVPilot, &CAircraftModelView::requestUpdate, this,
                    &CDbMappingComponent::requestVPilotDataUpdate);
 
            ui->tvp_AircraftModelsForVPilot->setCustomMenu(new CMappingVPilotMenu(this));
            ui->tvp_AircraftModelsForVPilot->setCustomMenu(new CStashToolsMenu(this));
            ui->tvp_AircraftModelsForVPilot->setDisplayAutomatically(true);
 
            ui->tvp_AircraftModelsForVPilot->addFilterDialog();
            const CAircraftModelList vPilotModels(m_vPilotReader.getAsModelsFromCache());
            ui->tvp_AircraftModelsForVPilot->updateContainerMaybeAsync(vPilotModels);
            const int noModels = vPilotModels.size();
            CLogMessage(this).info(u"%1 cached vPilot models loaded") << noModels;
        }
        ui->tab_VPilot->setEnabled(m_vPilotEnabled);
        ui->tab_VPilot->setVisible(m_vPilotEnabled);
        if (m_vPilotEnabled)
        {
            // create / restore tab
            ui->tw_ModelsToBeMapped->addTab(ui->tab_VPilot, tabName);
            this->onVPilotDataChanged(ui->tvp_AircraftModelsForVPilot->rowCount(),
                                      ui->tvp_AircraftModelsForVPilot->hasFilter());
        }
        else
        {
            m_vPilotFormatted = false;
            ui->tw_ModelsToBeMapped->removeTab(TabVPilot);
        }
    }
 
    void CDbMappingComponent::formatVPilotView()
    {
        if (!m_vPilotEnabled || m_vPilotFormatted) { return; }
        m_vPilotFormatted = true;
        ui->tvp_AircraftModelsForVPilot->presizeOrFullResizeToContents();
    }
 
    CAircraftModel CDbMappingComponent::getModelFromView(const QModelIndex &index) const
    {
        if (!index.isValid()) { return CAircraftModel(); }
        const QObject *sender = QObject::sender();
 
        // check if we have an explicit sender
        if (sender == ui->tvp_AircraftModelsForVPilot) { return ui->tvp_AircraftModelsForVPilot->at(index); }
        if (sender == ui->comp_OwnAircraftModels->view()) { return ui->comp_OwnAircraftModels->view()->at(index); }
        if (sender == ui->comp_StashAircraft || sender == ui->comp_StashAircraft->view())
        {
            return ui->comp_StashAircraft->view()->at(index);
        }
        if (sender == ui->comp_OwnModelSet->view()) { return ui->comp_OwnModelSet->view()->at(index); }
 
        // no sender, use current tab
        const CAircraftModelView *mv = this->currentModelView();
        if (!mv) { return CAircraftModel(); }
        return mv->at(index);
    }
 
    void CDbMappingComponent::gracefulShutdown()
    {
        this->disconnect();
        m_vPilotReader.gracefulShutdown();
        ui->comp_OwnAircraftModels->gracefulShutdown();
    }
 
    bool CDbMappingComponent::hasSelectedModelsToStash() const
    {
        const CAircraftModelView *mv = this->currentModelView();
        if (!mv) { return false; }
        return mv->hasSelectedModelsToStash();
    }
 
    CAircraftModelView *CDbMappingComponent::currentModelView() const
    {
        const TabIndex tab = currentTabIndex();
        return this->modelView(tab);
    }
 
    CAircraftModelView *CDbMappingComponent::modelView(TabIndex tab) const
    {
        switch (tab)
        {
        case TabOwnModels: return ui->comp_OwnAircraftModels->view();
        case TabVPilot: return ui->tvp_AircraftModelsForVPilot;
        case TabWorkbench: return ui->comp_ModelWorkbench->view();
        case TabStash: return ui->comp_StashAircraft->view();
        case TabOwnModelSet: return ui->comp_OwnModelSet->view();
        default: return nullptr;
        }
    }
 
    QString CDbMappingComponent::currentTabText() const
    {
        const int i = ui->tw_ModelsToBeMapped->currentIndex();
        return ui->tw_ModelsToBeMapped->tabText(i);
    }
 
    void CDbMappingComponent::updateEditorsWhenApplicable()
    {
        const CAircraftModel currentEditorModel(ui->editor_ModelMapping->getValue());
        if (!currentEditorModel.hasModelString()) { return; } // no related model
        const QString modelString(currentEditorModel.getModelString());
        const CAircraftModel currentStashedModel(ui->comp_StashAircraft->getStashedModel(modelString));
        if (!currentStashedModel.hasModelString()) { return; }
 
        // we have found a model in the stashed models and this is the one currently displayed
        // in the editors
        bool updated = false;
        const CLivery stashedLivery(currentStashedModel.getLivery());
        if (stashedLivery.hasValidDbKey())
        {
            if (ui->editor_AircraftModel->setLivery(stashedLivery)) { updated = true; }
        }
 
        const CDistributor stashedDistributor(currentStashedModel.getDistributor());
        if (stashedDistributor.hasValidDbKey())
        {
            if (ui->editor_AircraftModel->setDistributor(stashedDistributor)) { updated = true; }
        }
 
        const CAircraftIcaoCode stashedIcaoCode(currentStashedModel.getAircraftIcaoCode());
        if (stashedIcaoCode.hasValidDbKey())
        {
            if (ui->editor_AircraftModel->setAircraftIcao(stashedIcaoCode)) { updated = true; }
        }
 
        if (updated) { CLogMessage(this).info(u"Updated editor data for '%1'") << modelString; }
    }
 
    CAircraftModelList CDbMappingComponent::getSelectedModelsToStash() const
    {
        const CAircraftModelView *mv = this->currentModelView();
        if (!mv || !mv->hasSelectedModelsToStash()) { return CAircraftModelList(); }
        return mv->selectedObjects();
    }
 
    const CAircraftModelList &CDbMappingComponent::getStashedModels() const
    {
        return ui->comp_StashAircraft->getStashedModels();
    }
 
    bool CDbMappingComponent::hasStashedModels() const { return !this->getStashedModels().isEmpty(); }
 
    QStringList CDbMappingComponent::getStashedModelStrings() const
    {
        return ui->comp_StashAircraft->getStashedModelStrings();
    }
 
    CDbMappingComponent::TabIndex CDbMappingComponent::currentTabIndex() const
    {
        if (!ui->tw_ModelsToBeMapped) { return CDbMappingComponent::NoValidTab; }
        const int t = ui->tw_ModelsToBeMapped->currentIndex();
        return static_cast<TabIndex>(t);
    }
 
    bool CDbMappingComponent::isStashTab() const { return this->currentTabIndex() == TabStash; }
 
    bool CDbMappingComponent::isWorkbenchTab() const { return this->currentTabIndex() == TabWorkbench; }
 
    bool CDbMappingComponent::canAddToModelSetTab() const
    {
        const bool allowed = this->currentTabIndex() == CDbMappingComponent::TabOwnModels ||
                             this->currentTabIndex() == CDbMappingComponent::TabStash;
        return allowed && this->currentModelView()->hasSelection();
    }
 
    CStatusMessageList CDbMappingComponent::validateCurrentModel(bool withNestedForms) const
    {
        CStatusMessageList msgs;
        if (withNestedForms)
        {
            // tests the 3 subforms and the model itself lenient
            msgs.push_back(ui->editor_ModelMapping->validate(false));
            msgs.push_back(ui->editor_AircraftModel->validate(true));
        }
        else
        {
            // model lenient
            msgs.push_back(ui->editor_ModelMapping->validate(false));
        }
        return msgs;
    }
 
    void CDbMappingComponent::handleStashDropRequest(const CAirlineIcaoCode &code) const
    {
        const CLivery stdLivery(sGui->getWebDataServices()->getStdLiveryForAirlineCode(code));
        if (!stdLivery.hasValidDbKey()) { return; }
        ui->comp_StashAircraft->applyToSelected(stdLivery);
    }
 
    void CDbMappingComponent::stashCurrentModel()
    {
        const bool nested = this->isStashTab(); // on stash tab, full validation, otherwise not
        CStatusMessageList msgs(this->validateCurrentModel(nested));
        if (!msgs.hasErrorMessages())
        {
            const CAircraftModel editorModel(getEditorAircraftModel());
 
            // from stash, do not consolidate, because we want to keep data as they are from the editor
            const bool consolidate = !this->isStashTab();
            msgs.push_back(ui->comp_StashAircraft->stashModel(editorModel, true, consolidate));
        }
        if (msgs.hasErrorMessages()) { this->showOverlayMessagesOrHTMLMessage(msgs); }
    }
 
    void CDbMappingComponent::displayAutoStashingDialog() { m_autoStashDialog->exec(); }
 
    void CDbMappingComponent::displayAutoSimulatorStashingDialog() { m_autoSimulatorDialog->exec(); }
 
    void CDbMappingComponent::removeDbModelsFromView()
    {
        const QStringList modelStrings(sGui->getWebDataServices()->getModelStrings());
        if (modelStrings.isEmpty()) { return; }
        CAircraftModelView *mv = this->currentModelView();
        if (mv) { mv->removeModelsWithModelString(modelStrings); }
    }
 
    void CDbMappingComponent::showChangedAttributes()
    {
        if (!this->hasStashedModels()) { return; }
        if (this->currentTabIndex() != TabStash) { return; }
        ui->comp_StashAircraft->showChangedAttributes();
    }
 
    void CDbMappingComponent::toggleAutoFiltering() { m_autoFilterInDbViews = !m_autoFilterInDbViews; }
 
    void CDbMappingComponent::applyFormLiveryData()
    {
        if (ui->comp_StashAircraft->view()->selectedRowCount() < 1) { return; }
        const CStatusMessageList msgs = ui->editor_AircraftModel->validateLivery(true);
        if (msgs.hasErrorMessages()) { this->showOverlayMessagesOrHTMLMessage(msgs); }
        else { ui->comp_StashAircraft->applyToSelected(ui->editor_AircraftModel->getLivery()); }
    }
 
    void CDbMappingComponent::applyFormAircraftIcaoData()
    {
        if (ui->comp_StashAircraft->view()->selectedRowCount() < 1) { return; }
        const CStatusMessageList msgs = ui->editor_AircraftModel->validateAircraftIcao(true);
        if (msgs.hasErrorMessages()) { this->showOverlayMessagesOrHTMLMessage(msgs); }
        else { ui->comp_StashAircraft->applyToSelected(ui->editor_AircraftModel->getAircraftIcao()); }
    }
 
    void CDbMappingComponent::applyFormDistributorData()
    {
        if (ui->comp_StashAircraft->view()->selectedRowCount() < 1) { return; }
        const CStatusMessageList msgs = ui->editor_AircraftModel->validateDistributor(true);
        if (msgs.hasErrorMessages()) { this->showOverlayMessagesOrHTMLMessage(msgs); }
        else { ui->comp_StashAircraft->applyToSelected(ui->editor_AircraftModel->getDistributor()); }
    }
 
    void CDbMappingComponent::modifyModelDialog()
    {
        // only one model selected, use as default
        if (ui->comp_StashAircraft->view()->hasSingleSelectedRow())
        {
            m_modelModifyDialog->setValue(ui->comp_StashAircraft->view()->selectedObject());
        }
 
        const QDialog::DialogCode s = static_cast<QDialog::DialogCode>(m_modelModifyDialog->exec());
        if (s == QDialog::Rejected) { return; }
        const CPropertyIndexVariantMap vm = m_modelModifyDialog->getValues();
        ui->comp_StashAircraft->applyToSelected(vm);
    }
 
    void CDbMappingComponent::resizeForSelect() { this->maxTableView(); }
 
    void CDbMappingComponent::resizeForMapping()
    {
        const int h = this->height(); // total height
        int h2 = ui->qw_EditorsScrollArea->minimumHeight();
        h2 = qRound(h2 * 1.10); // desired height of inner widget + some space for scrollarea
        int currentSize = ui->sp_MappingComponent->sizes().last(); // current size
        if (h2 <= currentSize) { return; }
 
        int h1;
        if (h * 0.90 > h2)
        {
            // enough space to display as whole
            h1 = h - h2;
        }
        else
        {
            h1 = h / 3;
            h2 = h / 3 * 2;
        }
        const QList<int> sizes({ h1, h2 });
        ui->sp_MappingComponent->setSizes(sizes);
    }
 
    void CDbMappingComponent::maxTableView()
    {
        const int h = this->height();
        const int h1 = h;
        const int h2 = 0;
        const QList<int> sizes({ h1, h2 });
        ui->sp_MappingComponent->setSizes(sizes);
    }
 
    void CDbMappingComponent::loadVPilotData()
    {
        if (m_vPilotReader.readInBackground(true))
        {
            CLogMessage(this).info(u"Start loading vPilot rulesets");
            ui->tvp_AircraftModelsForVPilot->showLoadIndicator();
        }
        else { CLogMessage(this).warning(u"Loading vPilot rulesets already in progress"); }
    }
 
    void CDbMappingComponent::onLoadVPilotDataFinished(bool success)
    {
        if (!m_vPilotEnabled) { return; }
        if (success)
        {
            CLogMessage(this).info(u"Loading vPilot ruleset completed");
            const CAircraftModelList models(m_vPilotReader.getAsModels());
            if (ui->tvp_AircraftModelsForVPilot->displayAutomatically())
            {
                ui->tvp_AircraftModelsForVPilot->updateContainerMaybeAsync(models);
            }
        }
        else { CLogMessage(this).error(u"Loading vPilot ruleset failed"); }
        ui->tvp_AircraftModelsForVPilot->hideLoadIndicator();
    }
 
    void CDbMappingComponent::loadRemovedModels()
    {
        if (!ui->comp_ModelWorkbench->view()) { return; }
        const QString logDir = CSwiftDirectories::logDirectory();
        ui->comp_ModelWorkbench->view()->showFileLoadDialog(logDir);
    }
 
    void CDbMappingComponent::onVPilotCacheChanged()
    {
        if (ui->tvp_AircraftModelsForVPilot->displayAutomatically())
        {
            ui->tvp_AircraftModelsForVPilot->updateContainerMaybeAsync(m_vPilotReader.getAsModelsFromCache());
        }
        else { ui->tvp_AircraftModelsForVPilot->hideLoadIndicator(); }
    }
 
    void CDbMappingComponent::requestVPilotDataUpdate() { this->onVPilotCacheChanged(); }
 
    void CDbMappingComponent::onStashedModelsChangedTriggerDigest()
    {
        m_dsStashedModelsChanged.inputSignal(); // will call onStashedModelsChangedDigest
    }
 
    void CDbMappingComponent::onStashedModelsChangedDigest()
    {
        const bool highlightVPilot = ui->tvp_AircraftModelsForVPilot->derivedModel()->highlightModels();
        const bool highlightOwnModels = ui->comp_OwnAircraftModels->view()->derivedModel()->highlightModels();
        const bool highlightModelSet = ui->comp_OwnModelSet->view()->derivedModel()->highlightModels();
        const bool highlight = highlightOwnModels || highlightModelSet || highlightVPilot;
        if (!highlight) { return; }
        const QStringList stashedModels(ui->comp_StashAircraft->getStashedModelStrings());
        if (highlightVPilot)
        {
            ui->tvp_AircraftModelsForVPilot->derivedModel()->setHighlightModelStrings(stashedModels);
        }
        if (highlightOwnModels)
        {
            ui->comp_OwnAircraftModels->view()->derivedModel()->setHighlightModelStrings(stashedModels);
        }
        if (highlightModelSet)
        {
            ui->comp_OwnModelSet->view()->derivedModel()->setHighlightModelStrings(stashedModels);
        }
    }
 
    void CDbMappingComponent::onTabIndexChanged(int index)
    {
        const CDbMappingComponent::TabIndex ti = static_cast<CDbMappingComponent::TabIndex>(index);
        switch (ti)
        {
        case CDbMappingComponent::TabOwnModelSet:
        {
            ui->frp_Editors->setVisible(true);
            ui->editor_ModelMapping->setVisible(true);
            this->resizeForSelect();
        }
        break;
        case CDbMappingComponent::TabModelMatcher:
        {
            ui->editor_ModelMapping->setVisible(false);
            ui->frp_Editors->setVisible(false);
            this->resizeForSelect();
        }
        break;
        case CDbMappingComponent::TabVPilot:
        {
            // fall thru intended
            this->formatVPilotView();
        }
            [[fallthrough]];
        default:
        {
            ui->frp_Editors->setVisible(true);
            ui->editor_ModelMapping->setVisible(true);
        }
        break;
        }
        emit this->tabIndexChanged(index);
    }
 
    void CDbMappingComponent::onModelsSuccessfullyPublished(const CAircraftModelList &models, bool directWrite)
    {
        if (models.isEmpty()) { return; }
        if (!directWrite) { return; } // no models wwritten, but CRs
        emit this->requestUpdatedData(CEntityFlags::ModelEntity);
    }
 
    void CDbMappingComponent::onVPilotDataChanged(int count, bool withFilter)
    {
        Q_UNUSED(count)
        Q_UNUSED(withFilter)
        ui->tvp_AircraftModelsForVPilot->setTabWidgetViewText(ui->tw_ModelsToBeMapped,
                                                              ui->tw_ModelsToBeMapped->indexOf(ui->tab_VPilot));
    }
 
    void CDbMappingComponent::onWorkbenchDataChanged(int count, bool withFilter)
    {
        Q_UNUSED(count)
        Q_UNUSED(withFilter)
        ui->comp_ModelWorkbench->view()->setTabWidgetViewText(ui->tw_ModelsToBeMapped,
                                                              ui->tw_ModelsToBeMapped->indexOf(ui->tab_Workbench));
    }
 
    void CDbMappingComponent::ps_addToOwnModelSet()
    {
        if (!this->canAddToModelSetTab()) { return; }
        const CAircraftModelList models(this->currentModelView()->selectedObjects());
        const CStatusMessage m = this->addToOwnModelSet(models, this->getOwnModelsSimulator());
        CLogMessage::preformatted(m);
    }
 
    void CDbMappingComponent::mergeWithVPilotModels()
    {
        if (!ui->comp_OwnAircraftModels->modelLoader()) { return; }
        if (m_vPilotReader.getModelsCount() < 1) { return; }
        const CSimulatorInfo sim(ui->comp_OwnAircraftModels->getOwnModelsSimulator());
        if (!sim.isSingleSimulator() || !sim.isMicrosoftOrPrepare3DSimulator()) { return; }
        CAircraftModelList ownModels(getOwnModels());
        if (ownModels.isEmpty()) { return; }
        ui->comp_OwnAircraftModels->view()->showLoadIndicator();
        CAircraftModelUtilities::mergeWithVPilotData(ownModels, m_vPilotReader.getAsModelsFromCache(), true);
        ui->comp_OwnAircraftModels->updateViewAndCache(ownModels);
    }
 
    void CDbMappingComponent::mergeSelectedWithVPilotModels()
    {
        if (!ui->comp_OwnAircraftModels->modelLoader()) { return; }
        if (m_vPilotReader.getModelsCount() < 1) { return; }
        if (!ui->comp_OwnAircraftModels->view()->hasSelection()) { return; }
        const CSimulatorInfo sim(ui->comp_OwnAircraftModels->getOwnModelsSimulator());
        if (!sim.isSingleSimulator() || !sim.isMicrosoftOrPrepare3DSimulator()) { return; }
        CAircraftModelList ownModels(this->getOwnSelectedModels()); // subset
        if (ownModels.isEmpty()) { return; }
        ui->comp_OwnAircraftModels->view()->showLoadIndicator();
        CAircraftModelUtilities::mergeWithVPilotData(ownModels, m_vPilotReader.getAsModelsFromCache(), true);
 
        // full models
        CAircraftModelList allModels = m_vPilotReader.getAsModelsFromCache();
        allModels.replaceOrAddModelsWithString(ownModels, Qt::CaseInsensitive);
        ui->comp_OwnAircraftModels->updateViewAndCache(allModels);
    }
 
    void CDbMappingComponent::onCustomContextMenu(const QPoint &point)
    {
        QPoint globalPos = this->mapToGlobal(point);
        QScopedPointer<QMenu> contextMenu(new QMenu(this));
 
        contextMenu->addAction("Max.data area", this, &CDbMappingComponent::resizeForSelect,
                               QKeySequence(static_cast<Qt::Key>(Qt::CTRL) + Qt::Key_M, Qt::Key_D));
        contextMenu->addAction("Max.mapping area", this, &CDbMappingComponent::resizeForMapping,
                               QKeySequence(static_cast<Qt::Key>(Qt::CTRL) + Qt::Key_M, Qt::Key_M));
        QAction *selectedItem = contextMenu.data()->exec(globalPos);
        Q_UNUSED(selectedItem)
    }
 
    void CDbMappingComponent::onStashedModelsDataChangedDigest(int count, bool withFilter)
    {
        Q_UNUSED(count)
        Q_UNUSED(withFilter)
        ui->comp_StashAircraft->view()->setTabWidgetViewText(
            ui->tw_ModelsToBeMapped, ui->tw_ModelsToBeMapped->indexOf(ui->tab_StashAircraftModels));
 
        // update editors
        this->updateEditorsWhenApplicable();
    }
 
    void CDbMappingComponent::onModelSetChangedDigest(int count, bool withFilter)
    {
        Q_UNUSED(count)
        Q_UNUSED(withFilter)
 
        // none standard with simulator
        int i = ui->tw_ModelsToBeMapped->indexOf(ui->tab_OwnModelSet);
        QString o = "Active model set " + ui->comp_OwnModelSet->getModelSetSimulator().toQString(true);
        const QString f = ui->comp_OwnModelSet->view()->hasFilter() ? "F" : "";
        o = CGuiUtility::replaceTabCountValue(o, ui->comp_OwnModelSet->view()->rowCount()) + f;
        ui->tw_ModelsToBeMapped->setTabText(i, o);
    }
 
    void CDbMappingComponent::onOwnModelsChangedDigest(int count, bool withFilter)
    {
        Q_UNUSED(count)
        Q_UNUSED(withFilter)
 
        // non standard with sim
        const int i = ui->tw_ModelsToBeMapped->indexOf(ui->tab_OwnModels);
        static const QString ot("Stored own models");
        QString o(ot);
        const QString sim(ui->comp_OwnAircraftModels->getOwnModelsSimulator().toQString(true));
        if (!sim.isEmpty()) { o = o.append(" ").append(sim); }
        const QString f = ui->comp_OwnAircraftModels->view()->hasFilter() ? "F" : "";
        o = CGuiUtility::replaceTabCountValue(o, ui->comp_OwnAircraftModels->view()->rowCount()) + f;
        ui->tw_ModelsToBeMapped->setTabText(i, o);
    }
 
    void CDbMappingComponent::onUserChanged() { this->initVPilotLoading(); }
 
    void CDbMappingComponent::stashSelectedModels()
    {
        if (!this->hasSelectedModelsToStash()) { return; }
        CStatusMessageList msgs = ui->comp_StashAircraft->stashModels(this->getSelectedModelsToStash());
        if (msgs.hasWarningOrErrorMessages()) { this->showOverlayMessagesOrHTMLMessage(msgs); }
    }
 
    void CDbMappingComponent::onModelRowSelected(const QModelIndex &index)
    {
        CAircraftModel model(this->getModelFromView(index)); // data from view
        if (!model.hasModelString()) { return; }
 
        // we either use the model, or try to resolve the data to DB data
        bool dbModel = model.hasValidDbKey();
        const CLivery livery(dbModel ? model.getLivery() :
                                       sGui->getWebDataServices()->smartLiverySelector(model.getLivery()));
        const CAircraftIcaoCode aircraftIcao(
            dbModel ? model.getAircraftIcaoCode() :
                      sGui->getWebDataServices()->smartAircraftIcaoSelector(model.getAircraftIcaoCode()));
        const CDistributor distributor(
            dbModel ? model.getDistributor() :
                      sGui->getWebDataServices()->smartDistributorSelector(model.getDistributor()));
 
        // set model part
        ui->editor_ModelMapping->setValue(model);
 
        // if found, then set in editor
        if (livery.hasValidDbKey()) { ui->editor_AircraftModel->setLivery(livery); }
        else { ui->editor_AircraftModel->clearLivery(); }
        if (aircraftIcao.hasValidDbKey()) { ui->editor_AircraftModel->setAircraftIcao(aircraftIcao); }
        else { ui->editor_AircraftModel->clearAircraftIcao(); }
        if (distributor.hasValidDbKey()) { ui->editor_AircraftModel->setDistributor(distributor); }
        else { ui->editor_AircraftModel->clearDistributor(); }
 
        // request filtering
        if (m_autoFilterInDbViews)
        {
            emit filterByLivery(model.getLivery());
            emit filterByAircraftIcao(model.getAircraftIcaoCode());
            emit filterByDistributor(model.getDistributor());
        }
    }
 
    void CDbMappingComponent::onOwnModelsSimulatorChanged(const CSimulatorInfo simulator)
    {
        // loading of models can fail, so we clean the tab text
        Q_UNUSED(simulator)
 
        ui->comp_OwnAircraftModels->clearView();
        this->onOwnModelsChangedDigest(0, false);
    }
 
    CAircraftModel CDbMappingComponent::getEditorAircraftModel() const
    {
        CAircraftModel model(ui->editor_ModelMapping->getValue());
        model.setDistributor(ui->editor_AircraftModel->getDistributor());
        model.setAircraftIcaoCode(ui->editor_AircraftModel->getAircraftIcao());
        model.setLivery(ui->editor_AircraftModel->getLivery());
        return model;
    }
 
    CAircraftModelList CDbMappingComponent::getOwnModels() const { return ui->comp_OwnAircraftModels->getOwnModels(); }
 
    CAircraftModelList CDbMappingComponent::getOwnCachedModels(const CSimulatorInfo &simulator) const
    {
        return ui->comp_OwnAircraftModels->getOwnCachedModels(simulator);
    }
 
    CAircraftModelList CDbMappingComponent::getOwnSelectedModels() const
    {
        return ui->comp_OwnAircraftModels->getOwnSelectedModels();
    }
 
    CAircraftModel CDbMappingComponent::getOwnModelForModelString(const QString &modelString) const
    {
        return ui->comp_OwnAircraftModels->getOwnModelForModelString(modelString);
    }
 
    CSimulatorInfo CDbMappingComponent::getOwnModelsSimulator() const
    {
        return ui->comp_OwnAircraftModels->getOwnModelsSimulator();
    }
 
    void CDbMappingComponent::setOwnModelsSimulator(const CSimulatorInfo &simulator)
    {
        ui->comp_OwnAircraftModels->setSimulator(simulator);
    }
 
    int CDbMappingComponent::getOwnModelsCount() const { return ui->comp_OwnAircraftModels->getOwnModelsCount(); }
 
    QString CDbMappingComponent::getOwnModelsInfoString() const { return ui->comp_OwnAircraftModels->getInfoString(); }
 
    QString CDbMappingComponent::getOwnModelsInfoStringFsFamily() const
    {
        return ui->comp_OwnAircraftModels->getInfoStringFsFamily();
    }
 
    void CDbMappingComponent::setOwnModelSetSimulator(const CSimulatorInfo &simulator)
    {
        Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "Need single simulator");
        ui->comp_OwnModelSet->setSimulator(simulator);
    }
 
    CAircraftModelList CDbMappingComponent::getOwnModelSet() const
    {
        return ui->comp_OwnModelSet->getModelSetFromView();
    }
 
    CStatusMessage CDbMappingComponent::stashModel(const CAircraftModel &model, bool replace)
    {
        return ui->comp_StashAircraft->stashModel(model, replace);
    }
 
    CStatusMessageList CDbMappingComponent::stashModels(const CAircraftModelList &models)
    {
        return ui->comp_StashAircraft->stashModels(models);
    }
 
    CStatusMessage CDbMappingComponent::addToOwnModelSet(const CAircraftModelList &models,
                                                         const CSimulatorInfo &simulator)
    {
        return ui->comp_OwnModelSet->addToModelSet(models, simulator);
    }
 
    CAircraftModel CDbMappingComponent::consolidateModel(const CAircraftModel &model) const
    {
        return ui->comp_StashAircraft->consolidateModel(model);
    }
 
    void CDbMappingComponent::replaceStashedModelsUnvalidated(const CAircraftModelList &models) const
    {
        ui->comp_StashAircraft->replaceModelsUnvalidated(models);
    }
 
    void CDbMappingComponent::CMappingVPilotMenu::customMenu(CMenuActions &menuActions)
    {
        CDbMappingComponent *mapComp = qobject_cast<CDbMappingComponent *>(this->parent());
        Q_ASSERT_X(mapComp, Q_FUNC_INFO, "Cannot access mapping component");
 
        const bool canUseVPilot = mappingComponent()->withVPilot();
        if (canUseVPilot)
        {
            m_menuAction = menuActions.addAction(m_menuAction, CIcons::appMappings16(), "Load vPilot Rules",
                                                 CMenuAction::pathVPilot(), this,
                                                 { mapComp, &CDbMappingComponent::loadVPilotData });
        }
        this->nestedCustomMenu(menuActions);
    }
 
    CDbMappingComponent *CDbMappingComponent::CMappingVPilotMenu::mappingComponent() const
    {
        return qobject_cast<CDbMappingComponent *>(this->parent());
    }
 
    CDbMappingComponent::CStashToolsMenu::CStashToolsMenu(CDbMappingComponent *mappingComponent)
        : menus::IMenuDelegate(mappingComponent)
    {}
 
    void CDbMappingComponent::CStashToolsMenu::customMenu(CMenuActions &menuActions)
    {
        CDbMappingComponent *mapComp = mappingComponent();
        Q_ASSERT_X(mapComp, Q_FUNC_INFO, "no mapping component");
        if (!mapComp->currentModelView()->isEmpty() &&
            mapComp->currentModelView()->getMenu().testFlag(CViewBaseNonTemplate::MenuCanStashModels))
        {
            menuActions.addMenuStash();
 
            // auto filter in DB views
            m_stashFiltering = menuActions.addAction(
                m_stashFiltering, CIcons::filter16(), "Auto filtering in DB views (on/off)",
                CMenuAction::pathModelStash(), this, { mapComp, &CDbMappingComponent::toggleAutoFiltering });
            m_stashFiltering->setCheckable(true);
            m_stashFiltering->setChecked(mapComp->m_autoFilterInDbViews);
 
            m_autoStashing = menuActions.addAction(m_autoStashing, CIcons::appDbStash16(), "Auto stashing",
                                                   CMenuAction::pathModelStash(), this,
                                                   { mapComp, &CDbMappingComponent::displayAutoStashingDialog });
            m_autoSimulatorStashing =
                menuActions.addAction(m_autoSimulatorStashing, CIcons::appDbStash16(),
                                      "Cross simulator updating (FSX-P3D-FS9)", CMenuAction::pathModelStash(), this,
                                      { mapComp, &CDbMappingComponent::displayAutoSimulatorStashingDialog });
            if (mapComp->m_autoStashDialog && mapComp->m_autoStashDialog->isCompleted())
            {
                menuActions.addAction(
                    CIcons::appDbStash16(), "Last auto stash run", CMenuAction::pathModelStash(), nullptr,
                    { mapComp->m_autoStashDialog.data(), &CDbAutoStashingComponent::showLastResults });
            }
        }
        else if (mapComp->currentTabIndex() == CDbMappingComponent::TabStash)
        {
            this->addStashViewSpecificMenus(menuActions);
        }
        this->nestedCustomMenu(menuActions);
    }
 
    void CDbMappingComponent::CStashToolsMenu::addStashViewSpecificMenus(CMenuActions &menuActions)
    {
        CDbMappingComponent *mapComp = mappingComponent();
        Q_ASSERT_X(mapComp, Q_FUNC_INFO, "no mapping component");
 
        const int dbModels = sGui->getWebDataServices()->getModelsCount();
        if (dbModels > 0 && mapComp->hasStashedModels())
        {
            menuActions.addMenu(CIcons::appDbStash16(), "Stash", CMenuAction::pathModelStash());
 
            // we have keys and data by which we could delete them from view
            const QString msgDelete("Delete " + QString::number(dbModels) + " DB model(s) from '" +
                                    mapComp->currentTabText() + "'");
            menuActions.addAction(CIcons::delete16(), msgDelete, CMenuAction::pathModelStash(), nullptr,
                                  { mapComp, &CDbMappingComponent::removeDbModelsFromView });
 
            // attribute info
            menuActions.addAction(CIcons::info16(), "Show changed attributes", CMenuAction::pathModelStash(), nullptr,
                                  { mapComp, &CDbMappingComponent::showChangedAttributes });
        }
    }
 
    CDbMappingComponent *CDbMappingComponent::CStashToolsMenu::mappingComponent() const
    {
        return qobject_cast<CDbMappingComponent *>(this->parent());
    }
 
    void CDbMappingComponent::COwnModelSetMenu::customMenu(CMenuActions &menuActions)
    {
        CDbMappingComponent *mapComp = mappingComponent();
        Q_ASSERT_X(mapComp, Q_FUNC_INFO, "no mapping component");
        if (mapComp->canAddToModelSetTab())
        {
            menuActions.addMenuModelSet();
            m_menuAction = menuActions.addAction(
                m_menuAction, CIcons::appModels16(),
                "Add to own model set " + CShortcut::toParenthesisString(CShortcut::keyAddToModelSet()),
                CMenuAction::pathModelSet(), this, { mapComp, &CDbMappingComponent::ps_addToOwnModelSet },
                CShortcut::keyAddToModelSet());
        }
        this->nestedCustomMenu(menuActions);
    }
 
    CDbMappingComponent *CDbMappingComponent::COwnModelSetMenu::mappingComponent() const
    {
        return qobject_cast<CDbMappingComponent *>(this->parent());
    }
 
    void CDbMappingComponent::CApplyDbDataMenu::customMenu(CMenuActions &menuActions)
    {
        CDbMappingComponent *mapComp = mappingComponent();
        Q_ASSERT_X(mapComp, Q_FUNC_INFO, "no mapping component");
 
        if (mapComp->currentTabIndex() == CDbMappingComponent::TabStash && mapComp->currentModelView()->hasSelection())
        {
            if (m_menuActions.isEmpty()) { m_menuActions = QList<QAction *>({ nullptr, nullptr, nullptr, nullptr }); }
 
            // stash view and selection
            menuActions.addMenuStashEditor();
 
            m_menuActions[0] = menuActions.addAction(m_menuActions[0], CIcons::appAircraftIcao16(),
                                                     "Current aircraft ICAO", CMenuAction::pathModelStashEditor(), this,
                                                     { mapComp, &CDbMappingComponent::applyFormAircraftIcaoData });
            m_menuActions[1] = menuActions.addAction(m_menuActions[1], CIcons::appDistributors16(),
                                                     "Current distributor", CMenuAction::pathModelStashEditor(), this,
                                                     { mapComp, &CDbMappingComponent::applyFormDistributorData });
            m_menuActions[2] = menuActions.addAction(m_menuActions[2], CIcons::appLiveries16(), "Current livery",
                                                     CMenuAction::pathModelStashEditor(), this,
                                                     { mapComp, &CDbMappingComponent::applyFormLiveryData });
            m_menuActions[3] = menuActions.addAction(m_menuActions[3], CIcons::databaseTable16(),
                                                     "Modify DB model data", CMenuAction::pathModelStashEditor(), this,
                                                     { mapComp, &CDbMappingComponent::modifyModelDialog });
        }
        this->nestedCustomMenu(menuActions);
    }
 
    CDbMappingComponent *CDbMappingComponent::CApplyDbDataMenu::mappingComponent() const
    {
        return qobject_cast<CDbMappingComponent *>(this->parent());
    }
 
    CDbMappingComponent::CMergeWithVPilotMenu::CMergeWithVPilotMenu(CDbMappingComponent *mappingComponent)
        : IMenuDelegate(mappingComponent)
    {
        Q_ASSERT_X(mappingComponent, Q_FUNC_INFO, "Missing vPilot reader");
    }
 
    void CDbMappingComponent::CMergeWithVPilotMenu::customMenu(CMenuActions &menuActions)
    {
        const CAircraftModelView *mv = mappingComponent()->ui->comp_OwnAircraftModels->view();
        const CSimulatorInfo sim = mappingComponent()->ui->comp_OwnAircraftModels->getOwnModelsSimulator();
        if (!mappingComponent()->withVPilot() || mv->isEmpty() || !sim.isSingleSimulator() ||
            !sim.isMicrosoftOrPrepare3DSimulator())
        {
            this->nestedCustomMenu(menuActions);
            return;
        }
 
        if (m_menuActions.isEmpty()) { m_menuActions = QList<QAction *>({ nullptr, nullptr }); }
        menuActions.addMenu("Merge with vPilot data", CMenuAction::pathVPilot());
        m_menuActions[0] = menuActions.addAction(m_menuActions[0], "All", CMenuAction::pathVPilot(), this,
                                                 { mappingComponent(), &CDbMappingComponent::mergeWithVPilotModels });
        if (mv->hasSelection())
        {
            m_menuActions[1] =
                menuActions.addAction(m_menuActions[1], "Selected only", CMenuAction::pathVPilot(), this,
                                      { mappingComponent(), &CDbMappingComponent::mergeSelectedWithVPilotModels });
        }
        this->nestedCustomMenu(menuActions);
    }
 
    void CDbMappingComponent::CRemovedModelsMenu::customMenu(CMenuActions &menuActions)
    {
        CDbMappingComponent *mapComp = mappingComponent();
        Q_ASSERT_X(mapComp, Q_FUNC_INFO, "no mapping component");
        if (mapComp->isWorkbenchTab())
        {
            menuActions.addMenuModelSet();
            m_menuAction =
                menuActions.addAction(m_menuAction, CIcons::appModels16(), "Removed models", CMenuAction::pathModel(),
                                      this, { mapComp, &CDbMappingComponent::loadRemovedModels });
        }
        this->nestedCustomMenu(menuActions);
    }
 
    CDbMappingComponent *CDbMappingComponent::CRemovedModelsMenu::mappingComponent() const
    {
        return qobject_cast<CDbMappingComponent *>(this->parent());
    }
 
    CDbMappingComponent *CDbMappingComponent::CMergeWithVPilotMenu::mappingComponent() const
    {
        return qobject_cast<CDbMappingComponent *>(this->parent());
    }
} // namespace swift::gui::components