flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-08-06 17:53:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(swiftdata): Remove simulator options from context menu

Browse Source 
All required options (basically only reload) are already available from
other buttons in the UI and are more clear that they are only executed
for the currently selected simulator.
This commit is contained in:
Lars Toenning
2025-03-24 15:51:37 +01:00
parent 9a42759b8d
commit edac1efac7
2 changed files with 0 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files

402
src/gui/components/dbownmodelscomponent.cpp
View File

@@ -310,409 +310,7 @@ namespace swift::gui::components
QPointer<CDbOwnModelsComponent> ownModelsComp(qobject_cast<CDbOwnModelsComponent *>(this->parent()));
Q_ASSERT_X(ownModelsComp, Q_FUNC_INFO, "Cannot access parent");
if (m_loadActions.isEmpty()) { m_loadActions = QList<QAction *>(sims.numberSimulators(), nullptr); }
menuActions.addMenuSimulator();
if (sims.isFSX())
{
if (!m_loadActions[0])
{
m_loadActions[0] = new QAction(CIcons::appModels16(), "FSX models", this);
connect(m_loadActions[0], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->setSimulator(CSimulatorInfo::fsx(), true);
});
}
menuActions.addAction(m_loadActions[0], CMenuAction::pathSimulator());
}
if (sims.isP3D())
{
if (!m_loadActions[1])
{
m_loadActions[1] = new QAction(CIcons::appModels16(), "P3D models", this);
connect(m_loadActions[1], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->setSimulator(CSimulatorInfo::p3d(), true);
});
}
menuActions.addAction(m_loadActions[1], CMenuAction::pathSimulator());
}
if (sims.isFS9())
{
if (!m_loadActions[2])
{
m_loadActions[2] = new QAction(CIcons::appModels16(), "FS9 models", this);
connect(m_loadActions[2], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->setSimulator(CSimulatorInfo::fs9(), true);
});
}
menuActions.addAction(m_loadActions[2], CMenuAction::pathSimulator());
}
if (sims.isXPlane())
{
if (!m_loadActions[3])
{
m_loadActions[3] = new QAction(CIcons::appModels16(), "XPlane models", this);
connect(m_loadActions[3], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->setSimulator(CSimulatorInfo::xplane(), true);
});
}
menuActions.addAction(m_loadActions[3], CMenuAction::pathSimulator());
}
if (sims.isFG())
{
if (!m_loadActions[4])
{
m_loadActions[4] = new QAction(CIcons::appModels16(), "FG models", this);
connect(m_loadActions[4], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->setSimulator(CSimulatorInfo::fg(), true);
});
}
menuActions.addAction(m_loadActions[4], CMenuAction::pathSimulator());
}
if (sims.isMSFS())
{
if (!m_loadActions[5])
{
m_loadActions[5] = new QAction(CIcons::appModels16(), "MSFS models", this);
connect(m_loadActions[5], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->setSimulator(CSimulatorInfo::msfs(), true);
});
}
menuActions.addAction(m_loadActions[5], CMenuAction::pathSimulator());
}
if (sims.isMSFS2024())
{
if (!m_loadActions[6])
{
m_loadActions[6] = new QAction(CIcons::appModels16(), "MSFS2024 models", this);
connect(m_loadActions[6], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->setSimulator(CSimulatorInfo::msfs2024(), true);
});
}
menuActions.addAction(m_loadActions[6], CMenuAction::pathSimulator());
}
// with models loaded I allow a refresh reload
// I need those models because I want to merge with DB data in the loader
if (sGui && sGui->getWebDataServices() && sGui->getWebDataServices()->getModelsCount() > 0)
{
if (m_reloadActions.isEmpty())
{
// Two reload actions per simulator
m_reloadActions = QList<QAction *>(sims.numberSimulators() * 2, nullptr);
}
menuActions.addMenu(CIcons::refresh16(), "Force model reload",
CMenuAction::pathSimulatorModelsReload());
if (sims.isFSX())
{
if (!m_reloadActions[0])
{
m_reloadActions[0] = new QAction(CIcons::appModels16(), "FSX models", this);
connect(m_reloadActions[0], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->requestSimulatorModels(CSimulatorInfo::fsx(),
IAircraftModelLoader::InBackgroundNoCache);
});
m_reloadActions[1] = new QAction(CIcons::appModels16(), "FSX models from directory", this);
connect(m_reloadActions[1], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
const CSimulatorInfo sim(CSimulatorInfo::FSX);
const QString dir = ownModelsComp->directorySelector(sim);
if (!dir.isEmpty())
{
ownModelsComp->requestSimulatorModels(sim, IAircraftModelLoader::InBackgroundNoCache,
QStringList(dir));
}
});
}
menuActions.addAction(m_reloadActions[0], CMenuAction::pathSimulatorModelsReload());
menuActions.addAction(m_reloadActions[1], CMenuAction::pathSimulatorModelsReload());
}
if (sims.isP3D())
{
if (!m_reloadActions[2])
{
m_reloadActions[2] = new QAction(CIcons::appModels16(), "P3D models", this);
connect(m_reloadActions[2], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->requestSimulatorModels(CSimulatorInfo::p3d(),
IAircraftModelLoader::InBackgroundNoCache);
});
m_reloadActions[3] = new QAction(CIcons::appModels16(), "P3D models from directoy", this);
connect(m_reloadActions[3], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
const CSimulatorInfo sim(CSimulatorInfo::P3D);
const QString dir = ownModelsComp->directorySelector(sim);
if (!dir.isEmpty())
{
ownModelsComp->requestSimulatorModels(sim, IAircraftModelLoader::InBackgroundNoCache,
QStringList(dir));
}
});
}
menuActions.addAction(m_reloadActions[2], CMenuAction::pathSimulatorModelsReload());
menuActions.addAction(m_reloadActions[3], CMenuAction::pathSimulatorModelsReload());
}
if (sims.isFS9())
{
if (!m_reloadActions[4])
{
m_reloadActions[4] = new QAction(CIcons::appModels16(), "FS9 models", this);
connect(m_reloadActions[4], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->requestSimulatorModels(CSimulatorInfo::fs9(),
IAircraftModelLoader::InBackgroundNoCache);
});
m_reloadActions[5] = new QAction(CIcons::appModels16(), "FS9 models from directoy", this);
connect(m_reloadActions[5], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
const CSimulatorInfo sim(CSimulatorInfo::FS9);
const QString dir = ownModelsComp->directorySelector(sim);
if (!dir.isEmpty())
{
ownModelsComp->requestSimulatorModels(sim, IAircraftModelLoader::InBackgroundNoCache,
QStringList(dir));
}
});
}
menuActions.addAction(m_reloadActions[4], CMenuAction::pathSimulatorModelsReload());
menuActions.addAction(m_reloadActions[5], CMenuAction::pathSimulatorModelsReload());
}
if (sims.isXPlane())
{
if (!m_reloadActions[6])
{
m_reloadActions[6] = new QAction(CIcons::appModels16(), "XPlane models", this);
connect(m_reloadActions[6], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->requestSimulatorModels(CSimulatorInfo::xplane(),
IAircraftModelLoader::InBackgroundNoCache);
});
m_reloadActions[7] = new QAction(CIcons::appModels16(), "XPlane models from directoy", this);
connect(m_reloadActions[7], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
const CSimulatorInfo sim(CSimulatorInfo::XPLANE);
const QString dir = ownModelsComp->directorySelector(sim);
if (!dir.isEmpty())
{
ownModelsComp->requestSimulatorModels(sim, IAircraftModelLoader::InBackgroundNoCache,
QStringList(dir));
}
});
}
menuActions.addAction(m_reloadActions[6], CMenuAction::pathSimulatorModelsReload());
menuActions.addAction(m_reloadActions[7], CMenuAction::pathSimulatorModelsReload());
}
if (sims.isFG())
{
if (!m_reloadActions[8])
{
m_reloadActions[8] = new QAction(CIcons::appModels16(), "FG models", this);
connect(m_reloadActions[8], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->requestSimulatorModels(CSimulatorInfo::fg(),
IAircraftModelLoader::InBackgroundNoCache);
});
m_reloadActions[9] = new QAction(CIcons::appModels16(), "FG models from directoy", this);
connect(m_reloadActions[9], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
const CSimulatorInfo sim(CSimulatorInfo::FG);
const QString dir = ownModelsComp->directorySelector(sim);
if (!dir.isEmpty())
{
ownModelsComp->requestSimulatorModels(sim, IAircraftModelLoader::InBackgroundNoCache,
QStringList(dir));
}
});
}
menuActions.addAction(m_reloadActions[8], CMenuAction::pathSimulatorModelsReload());
menuActions.addAction(m_reloadActions[9], CMenuAction::pathSimulatorModelsReload());
}
if (sims.isMSFS())
{
if (!m_reloadActions[10])
{
m_reloadActions[10] = new QAction(CIcons::appModels16(), "MSFS models", this);
connect(m_reloadActions[10], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->requestSimulatorModels(CSimulatorInfo::msfs(),
IAircraftModelLoader::InBackgroundNoCache);
});
m_reloadActions[11] = new QAction(CIcons::appModels16(), "MSFS models from directoy", this);
connect(m_reloadActions[11], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
const CSimulatorInfo sim(CSimulatorInfo::MSFS);
const QString dir = ownModelsComp->directorySelector(sim);
if (!dir.isEmpty())
{
ownModelsComp->requestSimulatorModels(sim, IAircraftModelLoader::InBackgroundNoCache,
QStringList(dir));
}
});
}
menuActions.addAction(m_reloadActions[10], CMenuAction::pathSimulatorModelsReload());
menuActions.addAction(m_reloadActions[11], CMenuAction::pathSimulatorModelsReload());
}
if (sims.isMSFS2024())
{
if (!m_reloadActions[12])
{
m_reloadActions[12] = new QAction(CIcons::appModels16(), "MSFS2024 models", this);
connect(m_reloadActions[12], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->requestSimulatorModels(CSimulatorInfo::msfs2024(),
IAircraftModelLoader::InBackgroundNoCache);
});
m_reloadActions[13] = new QAction(CIcons::appModels16(), "MSFS2024 models from directoy", this);
connect(m_reloadActions[13], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
const CSimulatorInfo sim(CSimulatorInfo::MSFS2024);
const QString dir = ownModelsComp->directorySelector(sim);
if (!dir.isEmpty())
{
ownModelsComp->requestSimulatorModels(sim, IAircraftModelLoader::InBackgroundNoCache,
QStringList(dir));
}
});
}
menuActions.addAction(m_reloadActions[12], CMenuAction::pathSimulatorModelsReload());
menuActions.addAction(m_reloadActions[13], CMenuAction::pathSimulatorModelsReload());
}
}
else
{
// dummy action grayed out
CMenuAction a = menuActions.addAction(CIcons::refresh16(), "Force model reload impossible, no DB data",
CMenuAction::pathSimulator());
a.setActionEnabled(false); // gray out
}
if (m_clearCacheActions.isEmpty())
{
m_clearCacheActions = QList<QAction *>(sims.numberSimulators(), nullptr);
}
menuActions.addMenu(CIcons::delete16(), "Clear model caches", CMenuAction::pathSimulatorModelsClearCache());
if (sims.isFSX())
{
if (!m_clearCacheActions[0])
{
m_clearCacheActions[0] = new QAction(CIcons::appModels16(), "Clear FSX cache", this);
connect(m_clearCacheActions[0], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->clearSimulatorCache(CSimulatorInfo::fsx());
});
}
menuActions.addAction(m_clearCacheActions[0], CMenuAction::pathSimulatorModelsClearCache());
}
if (sims.isP3D())
{
if (!m_clearCacheActions[1])
{
m_clearCacheActions[1] = new QAction(CIcons::appModels16(), "Clear P3D cache", this);
connect(m_clearCacheActions[1], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->clearSimulatorCache(CSimulatorInfo::p3d());
});
}
menuActions.addAction(m_clearCacheActions[1], CMenuAction::pathSimulatorModelsClearCache());
}
if (sims.isFS9())
{
if (!m_clearCacheActions[2])
{
m_clearCacheActions[2] = new QAction(CIcons::appModels16(), "Clear FS9 cache", this);
connect(m_clearCacheActions[2], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->clearSimulatorCache(CSimulatorInfo::fs9());
});
}
menuActions.addAction(m_clearCacheActions[2], CMenuAction::pathSimulatorModelsClearCache());
}
if (sims.isXPlane())
{
if (!m_clearCacheActions[3])
{
m_clearCacheActions[3] = new QAction(CIcons::appModels16(), "Clear XPlane cache", this);
connect(m_clearCacheActions[3], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked);
ownModelsComp->clearSimulatorCache(CSimulatorInfo::xplane());
});
}
menuActions.addAction(m_clearCacheActions[3], CMenuAction::pathSimulatorModelsClearCache());
}
if (sims.isFG())
{
if (!m_clearCacheActions[4])
{
m_clearCacheActions[4] = new QAction(CIcons::appModels16(), "Clear FG cache", this);
connect(m_clearCacheActions[4], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->clearSimulatorCache(CSimulatorInfo::fg());
});
}
menuActions.addAction(m_clearCacheActions[4], CMenuAction::pathSimulatorModelsClearCache());
}
if (sims.isMSFS())
{
if (!m_clearCacheActions[5])
{
m_clearCacheActions[5] = new QAction(CIcons::appModels16(), "Clear MSFS cache", this);
connect(m_clearCacheActions[5], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->clearSimulatorCache(CSimulatorInfo::msfs());
});
}
menuActions.addAction(m_clearCacheActions[5], CMenuAction::pathSimulatorModelsClearCache());
}
if (sims.isMSFS2024())
{
if (!m_clearCacheActions[6])
{
m_clearCacheActions[6] = new QAction(CIcons::appModels16(), "Clear MSFS2024 cache", this);
connect(m_clearCacheActions[6], &QAction::triggered, ownModelsComp, [ownModelsComp](bool checked) {
if (!ownModelsComp) { return; }
Q_UNUSED(checked)
ownModelsComp->clearSimulatorCache(CSimulatorInfo::msfs2024());
});
}
menuActions.addAction(m_clearCacheActions[6], CMenuAction::pathSimulatorModelsClearCache());
}
if (sims.isXPlane() && CBuildConfig::isRunningOnWindowsNtPlatform() && CBuildConfig::buildWordSize() == 64)
{

3
src/gui/components/dbownmodelscomponent.h
View File

@@ -243,9 +243,6 @@ namespace swift::gui
virtual void customMenu(menus::CMenuActions &menuActions) override;
private:
QList<QAction *> m_loadActions; //!< load actions
QList<QAction *> m_reloadActions; //!< reload actions
QList<QAction *> m_clearCacheActions; //!< clear own models cahce if ever needed
QAction *m_csl2xsbAction = nullptr; //!< run csl2xsb script
};
};