Adds initial intermediate qt6 porting state
This commit is contained in:
11247 files changed
+1891537
No files matched your search
@@ -0,0 +1,17 @@
|
||||
#
|
||||
# $Id$
|
||||
# $HeadURL$
|
||||
# $Author$
|
||||
# Created by Jörg Turla, SPDG, 2017-06-29
|
||||
#
|
||||
|
||||
ADD_SUBDIRECTORY(Gui)
|
||||
|
||||
#
|
||||
# Gui Plugin Interface
|
||||
#
|
||||
ADD_INTERFACE_LIBRARY(PlanOverlaysGuiPluginInterface
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/plan_overlays_plugin_interface.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/..
|
||||
GuiPluginInterface
|
||||
)
|
||||
@@ -0,0 +1,54 @@
|
||||
#
|
||||
# $Id$
|
||||
# $HeadURL$
|
||||
# $Author$
|
||||
# Created by Jörg Turla, SPDG, 2017-06-29
|
||||
#
|
||||
|
||||
ADD_SUBDIRECTORY(Test)
|
||||
|
||||
SET (PlanOverlaysGuiPlugin_SRCS
|
||||
flm_reply_handler.cpp
|
||||
flm_reply_handler.h
|
||||
plan_overlay_dialog.cpp
|
||||
plan_overlay_dialog.h
|
||||
plan_overlay_model.cpp
|
||||
plan_overlay_model.h
|
||||
plan_overlay_view.cpp
|
||||
plan_overlay_view.h
|
||||
plan_overlays_gui_plugin.cpp
|
||||
plan_overlays_gui_plugin.h
|
||||
|
||||
TopicEditor/topic_editor.h
|
||||
TopicEditor/topic_editor.cpp
|
||||
)
|
||||
|
||||
SET(EXE_UICS
|
||||
TopicEditor/topic_editor.ui
|
||||
)
|
||||
|
||||
QT5_WRAP_UI(EXE_SRCS ${EXE_UICS})
|
||||
|
||||
SOURCE_GROUP(PlanOverlaysPlugin FILES ${PlanOverlaysGuiPlugin_SRCS})
|
||||
|
||||
NGL_ADD_LIBRARY(WS PlanOverlaysGuiPlugin MODULE ${PlanOverlaysGuiPlugin_SRCS} ${EXE_SRCS})
|
||||
NGL_TARGET_LINK_LIBRARIES( PlanOverlaysGuiPlugin
|
||||
LtsSession
|
||||
LtsSessionData
|
||||
PlanOverlaysGuiPluginInterface
|
||||
situationMap
|
||||
situationMapObjects
|
||||
GuiPluginInterface
|
||||
FlmDataPluginInterface
|
||||
OpmDataPluginInterface
|
||||
ExmDataPluginInterface
|
||||
LtsFileDialog
|
||||
LtsUtilsGuiDds
|
||||
LtsWidgets
|
||||
NGLLogger
|
||||
Qt5::Widgets
|
||||
TopicEditorBase
|
||||
LtsScriptTimeline
|
||||
)
|
||||
|
||||
NGL_INSTALL_TARGET(PlanOverlaysGuiPlugin)
|
||||
+68
@@ -0,0 +1,68 @@
|
||||
#
|
||||
# $Id$
|
||||
# $HeadURL$
|
||||
# $Author$
|
||||
#
|
||||
|
||||
# PlanOverlays Test Application
|
||||
|
||||
SET(EXE_SRCS
|
||||
main.cpp
|
||||
../plan_overlay_dialog.cpp
|
||||
../plan_overlay_dialog.h
|
||||
../plan_overlay_view.cpp
|
||||
../plan_overlay_view.h
|
||||
../plan_overlay_model.cpp
|
||||
../plan_overlay_model.h
|
||||
log4cxx_planOverlaysTest.props
|
||||
)
|
||||
|
||||
SET(EXE_HDRS
|
||||
)
|
||||
|
||||
SET(EXE_UICS
|
||||
)
|
||||
|
||||
NGL_WRAP_UI(EXE_SRCS ${EXE_UICS})
|
||||
|
||||
|
||||
SET(LOG4CXX_PROPS_FILE log4cxx_planOverlaysTest.props)
|
||||
|
||||
NGL_ADD_EXECUTABLE(WS NO_TRANSLATION planOverlaysTest ${EXE_SRCS} ${EXE_HDRS} ${EXE_UICS})
|
||||
NGL_TARGET_LINK_LIBRARIES(
|
||||
planOverlaysTest
|
||||
NGLLogger
|
||||
LtsSession
|
||||
LtsSessionData
|
||||
LtsWidgets
|
||||
nglapplication
|
||||
LtsPluginManager
|
||||
GuiPluginInterface
|
||||
FlmDataPluginInterface
|
||||
OpmDataPluginInterface
|
||||
ExmDataPluginInterface
|
||||
LtsFileDialog
|
||||
# ArcGIS::ArcGIS
|
||||
LtsPluginLoader
|
||||
LtsUtilsGuiDds
|
||||
Qt5::Gui
|
||||
)
|
||||
|
||||
IF(TARGET planOverlaysTest)
|
||||
|
||||
if(BUILD_PlanEditorCopyConfig)
|
||||
ADD_CUSTOM_COMMAND( TARGET planOverlaysTest POST_BUILD
|
||||
COMMAND ${CMAKE_COMMAND}
|
||||
ARGS -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/${LOG4CXX_PROPS_FILE} $<TARGET_FILE_DIR:planOverlaysTest>/${LOG4CXX_PROPS_FILE}
|
||||
)
|
||||
ENDIF()
|
||||
ENDIF()
|
||||
|
||||
IF(MSVC)
|
||||
# Configure the template file
|
||||
SET(VS_USER_FILE planOverlaysTest.vcxproj.user)
|
||||
configure_file( PlanOverlaysTest.vcxproj.user.in ${CMAKE_CURRENT_BINARY_DIR}/${VS_USER_FILE} @ONLY)
|
||||
ENDIF(MSVC)
|
||||
|
||||
NGL_INSTALL_TARGET_DEVEL(planOverlaysTest)
|
||||
NGL_INSTALL(FILES WS ${CMAKE_CURRENT_SOURCE_DIR}/${LOG4CXX_PROPS_FILE} DESTINATION "bin" COMPONENT Devel)
|
||||
Executable
+39
@@ -0,0 +1,39 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
<LocalDebuggerCommandArguments>
|
||||
</LocalDebuggerCommandArguments>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
<LocalDebuggerCommandArguments>
|
||||
</LocalDebuggerCommandArguments>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|x64'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|x64'">
|
||||
<LocalDebuggerEnvironment>PATH=C:\ExtFW\bin;%PATH%</LocalDebuggerEnvironment>
|
||||
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
||||
</PropertyGroup>
|
||||
</Project>
|
||||
Executable
+138
@@ -0,0 +1,138 @@
|
||||
log4j.reset=true
|
||||
log4j.rootLogger=WARN, file
|
||||
|
||||
# SituationMap
|
||||
###########################################################
|
||||
|
||||
log4j.logger.PlanEditor=DEBUG
|
||||
log4j.logger.PlanEditor.SymbolAdjustDialog=TRACE
|
||||
|
||||
|
||||
|
||||
|
||||
log4j.logger.SituationMap.SitMapTestApp=ERROR
|
||||
log4j.logger.SituationMap.SitMap=ERROR
|
||||
|
||||
log4j.logger.SituationMap.MapImpl=ERROR
|
||||
log4j.logger.SituationMap.MapSettings=WARN
|
||||
log4j.logger.SituationMap.MapInitializer=WARN
|
||||
log4j.logger.SituationMap.LayerFactoryImpl=ERROR
|
||||
log4j.logger.SituationMap.CoordTranslationFunctorImpl=ERROR
|
||||
log4j.logger.SituationMap.GridImpl=ERROR
|
||||
log4j.logger.SituationMap.ObjectFactory=ERROR
|
||||
log4j.logger.SituationMap.IdGenerator=ERROR
|
||||
log4j.logger.SituationMap.ObjectContainer=ERROR
|
||||
log4j.logger.SituationMap.ObjectContainerCTC=ERROR
|
||||
log4j.logger.SituationMap.SymbolDictionary=ERROR
|
||||
log4j.logger.SituationMap.SymbolDictionaryImpl=ERROR
|
||||
log4j.logger.SituationMap.SymbolDictionaryExtendedImpl=ERROR
|
||||
log4j.logger.SituationMap.Sidc2525Delta=ERROR
|
||||
|
||||
log4j.logger.SituationMap.AbstractMapObjectImpl=ERROR
|
||||
log4j.logger.SituationMap.AbstractEffectSimulationImpl=ERROR
|
||||
log4j.logger.SituationMap.OriginTranslated=ERROR
|
||||
log4j.logger.SituationMap.PositionsTranslated=ERROR
|
||||
log4j.logger.SituationMap.AbstractMultiPointMapObjectImpl=ERROR
|
||||
log4j.logger.SituationMap.AbstractSinglePointMapObjectImpl=ERROR
|
||||
log4j.logger.SituationMap.BasicPathObjectImpl=ERROR
|
||||
|
||||
log4j.logger.SituationMap.PolygonImpl=ERROR
|
||||
log4j.logger.SituationMap.PolylineImpl=ERROR
|
||||
log4j.logger.SituationMap.TextImpl=ERROR
|
||||
|
||||
log4j.logger.SituationMap.AreaFireImpl=ERROR
|
||||
log4j.logger.SituationMap.BiologicalAgentImpl=ERROR
|
||||
log4j.logger.SituationMap.BuildingOutlineImpl=ERROR
|
||||
log4j.logger.SituationMap.ChemicalAgentImpl=ERROR
|
||||
log4j.logger.SituationMap.DangerAreaImpl=ERROR
|
||||
log4j.logger.SituationMap.FunctionalAreaImpl=ERROR
|
||||
log4j.logger.SituationMap.HitLineImpl=ERROR
|
||||
log4j.logger.SituationMap.MineImpl=ERROR
|
||||
log4j.logger.SituationMap.ParticipantImpl=ERROR
|
||||
log4j.logger.SituationMap.SingleFireImpl=ERROR
|
||||
log4j.logger.SituationMap.IndicationContainer=ERROR
|
||||
|
||||
log4j.logger.SituationMap.AbstractGraphicalObject=ERROR
|
||||
log4j.logger.SituationMap.GraphicalObjectEllipse=ERROR
|
||||
log4j.logger.SituationMap.GraphicalObjectPath=ERROR
|
||||
log4j.logger.SituationMap.GraphicalObjectMultiPath=ERROR
|
||||
log4j.logger.SituationMap.GraphicalObjectPictureMarker=ERROR
|
||||
log4j.logger.SituationMap.GraphicalObjectRange=ERROR
|
||||
log4j.logger.SituationMap.GraphicalObjectText=ERROR
|
||||
log4j.logger.SituationMap.TacticalAppearance=ERROR
|
||||
log4j.logger.SituationMap.MessageBase=ERROR
|
||||
|
||||
log4j.logger.SituationMap.EventDispatcher=ERROR
|
||||
log4j.logger.SituationMap.RubberbandFactory=DEBUG
|
||||
|
||||
# Appnd_File
|
||||
###########################################################
|
||||
log4j.appender.file=org.apache.log4j.RollingFileAppender
|
||||
log4j.appender.file.MaxFileSize=1MB
|
||||
log4j.appender.file.MaxBackupIndex=9
|
||||
log4j.appender.file.file=${LOG4QT_LOGDIR}/${LOG4QT_USER}_SituationMapTestApp.log
|
||||
log4j.appender.file.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.file.layout.ConversionPattern=%d %-5p %c |#| %m (%.50F:%L) %n
|
||||
|
||||
|
||||
# Appnd_Console
|
||||
###########################################################
|
||||
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
|
||||
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.stdout.layout.ConversionPattern= %d %-5p %c{1} |#| %m (%-.30F:%L) %n
|
||||
|
||||
#log4j.appender.stdout.layout.ConversionPattern= %d %-5p %-30c |#| %m (%-.30F:%L) %n
|
||||
|
||||
|
||||
# Appnd_Syslog
|
||||
###########################################################
|
||||
log4j.appender.syslog=org.apache.log4j.SyslogAppender
|
||||
log4j.appender.syslog.Threshold=ERROR
|
||||
log4j.appender.syslog.SysLogHost=localhost
|
||||
log4j.appender.syslog.Facility=LOCAL7
|
||||
log4j.appender.syslog.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.syslog.layout.ConversionPattern= %-4r %-5p %c %x - %m
|
||||
log4j.appender.syslog.LevelRangeFilter.AcceptOnMatch=true
|
||||
log4j.appender.syslog.LevelRangeFilter.LevelMin=FATAL
|
||||
log4j.appender.syslog.LevelRangeFilter.LevelMax=FATAL
|
||||
|
||||
###########################################################
|
||||
###########################################################
|
||||
###########################################################
|
||||
# 1) Available Levels in LOG4CXX Version 0.10.0:
|
||||
# TRACE,
|
||||
# DEBUG,
|
||||
# INFO,
|
||||
# WARN,
|
||||
# ERROR
|
||||
# FATAL
|
||||
#
|
||||
# d = date/time
|
||||
# p = priority (Level)
|
||||
# c = category/channel
|
||||
# m = message
|
||||
# F = file
|
||||
# L = line
|
||||
# n = platform dependent line separator character or characters.
|
||||
# ....
|
||||
#
|
||||
# Examples for console:
|
||||
# a)
|
||||
# %d %p %c #%m# (%.50F:%L)%n
|
||||
# date/time
|
||||
# priority
|
||||
# category/channel
|
||||
# #message#
|
||||
# (Maximal 50Character des Filename von rechts:Line)
|
||||
# line separator
|
||||
#
|
||||
# b)
|
||||
# %d (%.15F:%L) %-5p %c |#| %m%n
|
||||
# date/time
|
||||
# (Maximal 15Character des Filename von rechts:Line)
|
||||
# priority, Right pad with spaces if the priority name is less than 5 characters long.
|
||||
# category/channel
|
||||
# message
|
||||
# line separator
|
||||
#
|
||||
|
||||
@@ -0,0 +1,177 @@
|
||||
|
||||
|
||||
|
||||
#include <nglapplication/nglapplication.h>
|
||||
#include <NGLLogger/INGLLogger.h>
|
||||
|
||||
#include "../plan_overlay_dialog.h"
|
||||
|
||||
#include "../plan_overlay_model.h"
|
||||
#include "../plan_overlay_view.h"
|
||||
|
||||
#include <LtsWidgets/lts_base_layout_widget.h>
|
||||
#include <LtsPluginManager/lts_plugin_loader.h>
|
||||
#include <PluginInterfaces/style_plugin_interface.h>
|
||||
#include <PluginInterfaces/project_plugin_interface.h>
|
||||
|
||||
#include <Plugins/SituationMapPlugin/situation_map_gui_plugin_interface.h>
|
||||
|
||||
|
||||
#include <QtCore/QDir>
|
||||
#include <QtCore/QPointer>
|
||||
#include <QtCore/QStandardPaths>
|
||||
|
||||
#include <QtGui/QSurface>
|
||||
|
||||
#include <QtWidgets/QMainWindow>
|
||||
#include <QtWidgets/QDesktopWidget>
|
||||
#include <QtWidgets/QDialog>
|
||||
#include <QtWidgets/QHBoxLayout>
|
||||
#include <QtWidgets/QMessageBox>
|
||||
#include <QtWidgets/QLabel>
|
||||
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
int main (int argc, char* argv[])
|
||||
{
|
||||
|
||||
#ifdef Q_OS_WIN
|
||||
|
||||
QCoreApplication::setAttribute(Qt::AA_UseOpenGLES);
|
||||
#endif
|
||||
|
||||
|
||||
NGLApplication app ( argc, argv );
|
||||
|
||||
|
||||
app.createLogger("planOverlayTest", "log4cxx_planOverlayTest.props");
|
||||
TRACE_LOG(app.baseLogger()) << LOGFUNCTION << " START";
|
||||
|
||||
STARTUP_LOG(app.baseLogger());
|
||||
|
||||
app.setOrganizationName(QLatin1String("RME"));
|
||||
app.setApplicationName(QLatin1String("Plan Overlay Test Application"));
|
||||
|
||||
|
||||
LtsPluginManager::LtsPluginLoader *pluginLoader = LtsPluginManager::LtsPluginLoader::getInstance();
|
||||
|
||||
pluginLoader->loadPlugins( LtsPluginManager::PluginType::STYLE , nullptr, QStringList() << QStringLiteral("rme.light") );
|
||||
pluginLoader->loadPlugins( LtsPluginManager::PluginType::PROJECT, nullptr, QStringList() << QStringLiteral("legatus") );
|
||||
|
||||
|
||||
|
||||
QDir::setSearchPaths( QLatin1String( "icon" ), QStringList( QLatin1String( ":/style/icons/" ) ) );
|
||||
QDir::setSearchPaths( QLatin1String( "icon" ), QStringList( QLatin1String( ":/style/" ) ) );
|
||||
|
||||
|
||||
|
||||
#ifdef BUILD_STATIC_LIBRARIES
|
||||
|
||||
Q_INIT_RESOURCE(lts_resources);
|
||||
#endif
|
||||
|
||||
#define USE_QDIALOG
|
||||
|
||||
|
||||
|
||||
PlanOverlaysPlugin::PlanOverlayModel * planOverlayModel = new PlanOverlaysPlugin::PlanOverlayModel();
|
||||
|
||||
#ifdef USE_QDIALOG
|
||||
PlanOverlaysPlugin::PlanOverlayDialog<QDialog> * dialog = new PlanOverlaysPlugin::PlanOverlayDialog<QDialog>( nullptr, planOverlayModel, nullptr, nullptr );
|
||||
#endif
|
||||
|
||||
#ifdef USE_LTSFRAMELESS
|
||||
PlanOverlaysPlugin::PlanOverlayDialog<LtsWidgets::LtsFramelessDialog> * dialog = new PlanOverlaysPlugin::PlanOverlayDialog<LtsWidgets::LtsFramelessDialog>( nullptr, planOverlayModel, nullptr );
|
||||
#endif
|
||||
|
||||
#ifdef CHECK_ERROR
|
||||
PlanOverlaysPlugin::PlanOverlayDialog<QWidget> * dialog = new PlanOverlaysPlugin::PlanOverlayDialog<QWidget>( nullptr, planOverlayModel, nullptr );
|
||||
#endif
|
||||
|
||||
unsigned int counter = 1;
|
||||
|
||||
auto doReadFile = [dialog,&counter]( int )
|
||||
{
|
||||
PlanOverlaysPlugin::PlanOverlayModel::PlanItem planItem = dialog->dialogWidget()->planOverlayModel()->planItem(counter++);
|
||||
|
||||
planItem.m_folderId = 6;
|
||||
planItem.m_fileId = 42;
|
||||
planItem.m_dirPath = QString();
|
||||
planItem.m_fileName = QStringLiteral("Hugo_%1").arg(planItem.m_fileId);
|
||||
planItem.m_minScale = 250000;
|
||||
planItem.m_maxScale = 12000;
|
||||
planItem.m_opacity = 1;
|
||||
planItem.m_visibility = true;
|
||||
|
||||
dialog->dialogWidget()->planOverlayModel()->updatePlanItem( planItem );
|
||||
};
|
||||
|
||||
auto doReloadPlan = [](unsigned int planId)
|
||||
{
|
||||
Q_UNUSED(planId);
|
||||
QMessageBox::information(nullptr,QObject::tr("Reload Plan"),QObject::tr("doReloadPlan has been called"),QMessageBox::StandardButton::Ok);
|
||||
};
|
||||
|
||||
auto doUnloadPlan = [dialog](unsigned int planId)
|
||||
{
|
||||
dialog->dialogWidget()->planOverlayModel()->removeOverlay(planId);
|
||||
};
|
||||
|
||||
|
||||
dialog->dialogWidget()->initFileManagement( nullptr, nullptr, nullptr, doReadFile, doReloadPlan, doUnloadPlan );
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
dialog->show();
|
||||
|
||||
app.setQuitOnLastWindowClosed(true);
|
||||
|
||||
int retval = app.exec();
|
||||
|
||||
SHUTDOWN_LOG(app.baseLogger());
|
||||
|
||||
return retval;
|
||||
}
|
||||
+171
@@ -0,0 +1,171 @@
|
||||
|
||||
|
||||
|
||||
#include "topic_editor.h"
|
||||
#include "ui_topic_editor.h"
|
||||
#include "../plan_overlays_gui_plugin.h"
|
||||
|
||||
#include <LtsSession/lts_session_data.h>
|
||||
#include <NGLLogger/NGLLoggerBootstrap.h>
|
||||
#include <TopicEditorBase/topic_previewer.h>
|
||||
|
||||
#include <QInputDialog>
|
||||
#include <QJsonObject>
|
||||
#include <QJsonArray>
|
||||
#include <QMessageBox>
|
||||
#include <QPushButton>
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
PlanTopicEditor::PlanTopicEditor(
|
||||
ForeignGuiInterface **ifc, const std::shared_ptr<FileManagement::Interface::Dtc> &flmDtc, QWidget *parent
|
||||
)
|
||||
: TopicEditorBase::TopicEditor(parent)
|
||||
, m_ifc(ifc)
|
||||
, m_flmDtc(flmDtc)
|
||||
, m_model(nullptr)
|
||||
, m_ui(new Ui::PlanTopicEditor)
|
||||
, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("PlanTopicEditor"))
|
||||
{
|
||||
|
||||
m_ui->setupUi(this);
|
||||
init(m_ui->widget);
|
||||
|
||||
m_buttonBox->setText(LtsWidgets::DialogButton::Edit, tr("Manage Plan Overlays"));
|
||||
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &PlanTopicEditor::onOpenPlanOverlayDialog);
|
||||
if ((*m_ifc) == nullptr)
|
||||
{
|
||||
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, false);
|
||||
return;
|
||||
}
|
||||
else
|
||||
m_ui->lblReadOnly->hide();
|
||||
|
||||
m_model = (*m_ifc)->planOverlayModel();
|
||||
|
||||
#ifndef LTS_DEBUG
|
||||
if (LtsSessionData::LtsSessionData::getInstance()->debugFlagValue(QStringLiteral("PlanOverlays.TopicEditor.ShowFakeButton")) == QVariant(true))
|
||||
#endif
|
||||
{
|
||||
QPushButton *pb = new QPushButton(QStringLiteral("[fake compatibility mode data]"));
|
||||
layout()->addWidget(pb);
|
||||
connect(pb, &QPushButton::clicked,
|
||||
this, [this]()
|
||||
{
|
||||
|
||||
m_topicData.properties = QJsonObject();
|
||||
bool k = true;
|
||||
int fileId = QInputDialog::getInt(this, QStringLiteral("fileId"), QStringLiteral("Enter the file id of an existing plan overlay"), 1003, 0, 999999, 1, &k);
|
||||
if (!k)
|
||||
{
|
||||
QMessageBox::critical(this, QStringLiteral("nan"), QStringLiteral("nan!"));
|
||||
return;
|
||||
}
|
||||
m_topicData.properties[QStringLiteral("FileId")] = fileId;
|
||||
updateInternalData();
|
||||
});
|
||||
}
|
||||
|
||||
setOnlineHelpFilename(QStringLiteral("Script_Editor-Add_Tactical_Plan_Topic"));
|
||||
}
|
||||
|
||||
PlanTopicEditor::~PlanTopicEditor()
|
||||
{
|
||||
delete m_ui;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void PlanTopicEditor::updateInternalData()
|
||||
{
|
||||
if (!hasTopicDataProperties())
|
||||
return;
|
||||
|
||||
m_planItems = QJsonArray();
|
||||
|
||||
|
||||
int fileId = getTopicDataValue(QStringLiteral("FileId")).toInt(-1);
|
||||
|
||||
if (fileId != -1)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "topic compatibility mode - converting..";
|
||||
|
||||
QJsonObject fakePlanItem;
|
||||
fakePlanItem[QStringLiteral("keyId")] = 0;
|
||||
fakePlanItem[QStringLiteral("fileId")] = fileId;
|
||||
QString fileName;
|
||||
if (m_flmDtc)
|
||||
fileName = QString::fromStdString(m_flmDtc->fileContent(fileId).name());
|
||||
if (fileName.isEmpty())
|
||||
fileName = tr("Plan file id %1").arg(fileId);
|
||||
fakePlanItem[QStringLiteral("fileName")] = fileName;
|
||||
fakePlanItem[QStringLiteral("opacity")] = 1.0;
|
||||
m_planItems += fakePlanItem;
|
||||
}
|
||||
else
|
||||
m_planItems = getTopicDataValue(QStringLiteral("PlanItems")).toArray();
|
||||
|
||||
|
||||
if (m_planItems.isEmpty())
|
||||
{
|
||||
WARNING_LOG(m_logger) << "topic empty";
|
||||
return;
|
||||
}
|
||||
|
||||
retable();
|
||||
}
|
||||
|
||||
void PlanTopicEditor::retranslate()
|
||||
{
|
||||
translate(m_ui, tr("Plan Topic Editor"));
|
||||
}
|
||||
|
||||
|
||||
void PlanTopicEditor::retable()
|
||||
{
|
||||
while (m_ui->plans->rowCount())
|
||||
m_ui->plans->removeRow(m_ui->plans->rowCount() - 1);
|
||||
|
||||
for (auto i = m_planItems.constBegin(); i != m_planItems.constEnd(); ++i)
|
||||
{
|
||||
m_ui->plans->insertRow(0);
|
||||
m_ui->plans->setItem(0, 0, new QTableWidgetItem((*i).toObject()[QStringLiteral("fileName")].toString(tr("(unknown)"))));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
bool PlanTopicEditor::apply2()
|
||||
{
|
||||
m_topicData.properties.remove(QStringLiteral("FileId"));
|
||||
setTopicDataProperty(QStringLiteral("PlanItems"), m_planItems);
|
||||
setDescription(m_ui->widget->description());
|
||||
m_ui->widget->previewer()->setTopicData(m_topicData);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void PlanTopicEditor::onOpenPlanOverlayDialog()
|
||||
{
|
||||
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, false);
|
||||
|
||||
if ((*m_ifc) == nullptr)
|
||||
{
|
||||
new LtsWidgets::LtsMessageDialogNew(this, tr("Plans can't be edited because essentials view was closed"));
|
||||
return;
|
||||
}
|
||||
|
||||
connect((*m_ifc)->openPlanOverlayDialog(m_planItems, true), &QWidget::destroyed, this, [this]()
|
||||
{
|
||||
m_planItems = m_model->toJson();
|
||||
retable();
|
||||
slotChangesMade();
|
||||
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit);
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <FileManagement/logger.h>
|
||||
#include <FileManagement/Data/flm_data_plugin.h>
|
||||
#include <LtsSession/lts_session.h>
|
||||
#include <TopicEditorBase/topic_editor_base.h>
|
||||
|
||||
#include <QJsonArray>
|
||||
|
||||
|
||||
namespace Ui { class PlanTopicEditor; }
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
class ForeignGuiInterface;
|
||||
class PlanOverlayModel;
|
||||
|
||||
|
||||
class PlanTopicEditor : public TopicEditorBase::TopicEditor
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
explicit PlanTopicEditor(
|
||||
ForeignGuiInterface **ifc, const std::shared_ptr<FileManagement::Interface::Dtc> &flmDtc, QWidget *parent = nullptr
|
||||
);
|
||||
~PlanTopicEditor();
|
||||
|
||||
|
||||
|
||||
private:
|
||||
void updateInternalData() override final;
|
||||
void retranslate() override final;
|
||||
|
||||
void retable();
|
||||
void enaDisa();
|
||||
|
||||
private slots:
|
||||
bool apply2() override final;
|
||||
|
||||
void onOpenPlanOverlayDialog();
|
||||
|
||||
private:
|
||||
ForeignGuiInterface **m_ifc { nullptr };
|
||||
std::shared_ptr<FileManagement::Interface::Dtc> m_flmDtc { nullptr };
|
||||
|
||||
QJsonArray m_planItems;
|
||||
PlanOverlayModel *m_model { nullptr };
|
||||
|
||||
Ui::PlanTopicEditor *m_ui { nullptr };
|
||||
NGL::INGLLogger &m_logger;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<ui version="4.0">
|
||||
<class>PlanTopicEditor</class>
|
||||
<widget class="QWidget" name="PlanTopicEditor">
|
||||
<property name="geometry">
|
||||
<rect>
|
||||
<x>0</x>
|
||||
<y>0</y>
|
||||
<width>623</width>
|
||||
<height>357</height>
|
||||
</rect>
|
||||
</property>
|
||||
<property name="sizePolicy">
|
||||
<sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
|
||||
<horstretch>0</horstretch>
|
||||
<verstretch>0</verstretch>
|
||||
</sizepolicy>
|
||||
</property>
|
||||
<property name="windowTitle">
|
||||
<string notr="true">File Topic Editor</string>
|
||||
</property>
|
||||
<layout class="QGridLayout" name="gridLayout">
|
||||
<item row="3" column="0">
|
||||
<widget class="TopicEditorBase::TopicPreviewWidget" name="widget" native="true"/>
|
||||
</item>
|
||||
<item row="3" column="1">
|
||||
<spacer name="horizontalSpacer">
|
||||
<property name="orientation">
|
||||
<enum>Qt::Horizontal</enum>
|
||||
</property>
|
||||
<property name="sizeHint" stdset="0">
|
||||
<size>
|
||||
<width>40</width>
|
||||
<height>20</height>
|
||||
</size>
|
||||
</property>
|
||||
</spacer>
|
||||
</item>
|
||||
<item row="2" column="0" colspan="2">
|
||||
<widget class="QTableWidget" name="plans">
|
||||
<property name="editTriggers">
|
||||
<set>QAbstractItemView::NoEditTriggers</set>
|
||||
</property>
|
||||
<property name="alternatingRowColors">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
<property name="selectionBehavior">
|
||||
<enum>QAbstractItemView::SelectRows</enum>
|
||||
</property>
|
||||
<attribute name="horizontalHeaderVisible">
|
||||
<bool>false</bool>
|
||||
</attribute>
|
||||
<attribute name="horizontalHeaderStretchLastSection">
|
||||
<bool>true</bool>
|
||||
</attribute>
|
||||
<attribute name="verticalHeaderVisible">
|
||||
<bool>false</bool>
|
||||
</attribute>
|
||||
<column>
|
||||
<property name="text">
|
||||
<string>Plan name</string>
|
||||
</property>
|
||||
</column>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="1" column="0" colspan="2">
|
||||
<widget class="QLabel" name="label">
|
||||
<property name="text">
|
||||
<string>Selected Plans:</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="0" column="0" colspan="2">
|
||||
<widget class="QLabel" name="lblReadOnly">
|
||||
<property name="text">
|
||||
<string><html><head/><body><p><span style=" color:#d69545;">Start the essentials view before opening this topic editor to be able to edit plans.</span></p></body></html></string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
</widget>
|
||||
<customwidgets>
|
||||
<customwidget>
|
||||
<class>TopicEditorBase::TopicPreviewWidget</class>
|
||||
<extends>QWidget</extends>
|
||||
<header>TopicEditorBase/topic_preview_widget.h</header>
|
||||
<container>1</container>
|
||||
</customwidget>
|
||||
</customwidgets>
|
||||
<resources/>
|
||||
<connections/>
|
||||
</ui>
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
|
||||
|
||||
|
||||
|
||||
#include "flm_reply_handler.h"
|
||||
|
||||
#include <LtsUtilsGuiDds/request_helper.h>
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
FileManagementReplyHandler::FileManagementReplyHandler( LtsUtils::RequestHelper * requestHelper )
|
||||
: m_requestHelper(requestHelper)
|
||||
{
|
||||
qRegisterMetaType<Core::FunctionReply>("Core::FunctionReply");
|
||||
}
|
||||
|
||||
|
||||
void FileManagementReplyHandler::requestReply( const Core::FunctionReplyObject & replyObject )
|
||||
{
|
||||
m_requestHelper->requestReply(replyObject);
|
||||
}
|
||||
|
||||
|
||||
void FileManagementReplyHandler::onGetFileContentDataReply( const FileManagement::GetFileContentDataReply & replyObject )
|
||||
{
|
||||
m_content = replyObject.content();
|
||||
m_requestHelper->requestReply(replyObject);
|
||||
}
|
||||
|
||||
}
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <FileManagement/flm_ftc.h>
|
||||
#include <FileManagement/flm_ftc_types.h>
|
||||
|
||||
#include <DDS/DDSConnector/dds_connector.h>
|
||||
|
||||
#include <QtCore/QObject>
|
||||
|
||||
|
||||
namespace LtsUtils
|
||||
{
|
||||
class RequestHelper;
|
||||
}
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
class FileManagementReplyHandler
|
||||
: public QObject
|
||||
, public FileManagement::Interface::Ftc::FileContentModifyReplyHandler
|
||||
, public FileManagement::Interface::Ftc::FileContentChangeStatusReplyHandler
|
||||
, public FileManagement::Interface::Ftc::FileContentRemoveReplyHandler
|
||||
, public FileManagement::Interface::Ftc::GetFileContentDataReplyHandler
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
|
||||
explicit FileManagementReplyHandler( LtsUtils::RequestHelper * );
|
||||
~FileManagementReplyHandler() = default;
|
||||
|
||||
const std::vector<uint8_t> &getContent() const { return m_content; }
|
||||
|
||||
protected:
|
||||
|
||||
|
||||
void onFileContentModifyReply ( const Core::FunctionReplyObject & replyObject) override final { requestReply(replyObject); }
|
||||
void onFileContentRemoveReply ( const Core::FunctionReplyObject & replyObject) override final { requestReply(replyObject); }
|
||||
void onFileContentChangeStatusReply ( const Core::FunctionReplyObject & replyObject) override final { requestReply(replyObject); }
|
||||
|
||||
void onGetFileContentDataReply( const FileManagement::GetFileContentDataReply & replyObject) override final;
|
||||
|
||||
private:
|
||||
|
||||
void requestReply(const Core::FunctionReplyObject &replyObject);
|
||||
|
||||
LtsUtils::RequestHelper *m_requestHelper;
|
||||
std::vector<uint8_t> m_content;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
+311
@@ -0,0 +1,311 @@
|
||||
|
||||
|
||||
|
||||
#include "plan_overlay_dialog.h"
|
||||
|
||||
#include "plan_overlay_model.h"
|
||||
#include "plan_overlay_view.h"
|
||||
|
||||
#include <LtsSession/lts_session.h>
|
||||
#include <LtsWidgets/lts_base_layout_widget.h>
|
||||
|
||||
#include <LtsWidgets/lts_drag_icon.h>
|
||||
#include <LtsWidgets/lts_dialog_button_box.h>
|
||||
|
||||
#include <Viewer/LtsFileDialog/lts_file_dialog_widget.h>
|
||||
|
||||
#include <QDebug>
|
||||
#include <QtWidgets/QApplication>
|
||||
#include <QtWidgets/QDesktopWidget>
|
||||
#include <QtWidgets/QDialog>
|
||||
#include <QtWidgets/QLabel>
|
||||
#include <QtWidgets/QPushButton>
|
||||
#include <QtWidgets/QSplitter>
|
||||
|
||||
#include <QtWidgets/QVBoxLayout>
|
||||
#include <QtWidgets/QHBoxLayout>
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
|
||||
struct PlanOverlayDialogWidget::InternalData
|
||||
{
|
||||
LtsSession::LtsSession *m_session = nullptr;
|
||||
LtsWidgets::LtsFileDialogWidget *m_fileDialogWidget = nullptr;
|
||||
PlanOverlaysPlugin::PlanOverlayModel *m_planOverlayModel = nullptr;
|
||||
PlanOverlaysPlugin::PlanOverlayView *m_planOverlayView = nullptr;
|
||||
SituationMap::ForeignGuiInterface *m_situationMapGui = nullptr;
|
||||
QWidget *m_overlaySection = nullptr;
|
||||
bool m_isInModalDialog = false;
|
||||
|
||||
};
|
||||
|
||||
|
||||
PlanOverlayDialogWidget::PlanOverlayDialogWidget(LtsSession::LtsSession *session,
|
||||
SituationMap::ForeignGuiInterface *situationMapGui,
|
||||
PlanOverlayModel *planOverlayModel,
|
||||
QWidget *parent)
|
||||
: QWidget(parent), m_internal(new InternalData())
|
||||
{
|
||||
m_internal->m_session = session;
|
||||
m_internal->m_situationMapGui = situationMapGui;
|
||||
m_internal->m_planOverlayModel = planOverlayModel;
|
||||
|
||||
const QString &title = tr("Managing Plan Overlays");
|
||||
|
||||
setObjectName(QLatin1String("PlanOverlaysPlugin::PlanOverlayDialog"));
|
||||
|
||||
QSplitter *splitter = new QSplitter(this);
|
||||
QWidget *overlays = new QWidget(this);
|
||||
QWidget *ctrlArea = new QWidget(overlays);
|
||||
QVBoxLayout *layout = new QVBoxLayout(this);
|
||||
QLabel *titleWidget = new QLabel(title, this);
|
||||
|
||||
m_internal->m_fileDialogWidget = new LtsWidgets::LtsFileDialogWidget(this);
|
||||
m_internal->m_planOverlayView = new PlanOverlayView(m_internal->m_planOverlayModel, overlays);
|
||||
|
||||
m_internal->m_planOverlayModel->setFileDialogMimeType(m_internal->m_fileDialogWidget->dragMimeType());
|
||||
|
||||
connect(m_internal->m_planOverlayView, &PlanOverlayView::requestMinScale, this, &PlanOverlayDialogWidget::onRequestMinScaleFromUser);
|
||||
connect(m_internal->m_planOverlayView, &PlanOverlayView::requestMaxScale, this, &PlanOverlayDialogWidget::onRequestMaxScaleFromUser);
|
||||
|
||||
titleWidget->setAlignment(Qt::AlignCenter);
|
||||
|
||||
QFont boldFont;
|
||||
boldFont.setBold(true);
|
||||
boldFont.setPointSize(18);
|
||||
titleWidget->setFont(boldFont);
|
||||
layout->addWidget(titleWidget);
|
||||
#ifdef LTS_DEBUG
|
||||
if ((session) && (session->exerciseId() > 0))
|
||||
{
|
||||
const QString &subtitle = tr("Exercise: %1 / Phase: %2").arg(session->exerciseId()).arg(session->exerciseData()->phId);
|
||||
QLabel *subtitleWidget = new QLabel(subtitle, this);
|
||||
subtitleWidget->setAlignment(Qt::AlignCenter);
|
||||
layout->addWidget(subtitleWidget);
|
||||
}
|
||||
#endif
|
||||
layout->addWidget(splitter, 2);
|
||||
layout->setMargin(0);
|
||||
|
||||
splitter->setOrientation(Qt::Orientation::Vertical);
|
||||
|
||||
splitter->addWidget(m_internal->m_fileDialogWidget);
|
||||
splitter->addWidget(overlays);
|
||||
splitter->setStretchFactor(0, 2);
|
||||
splitter->setStretchFactor(1, 4);
|
||||
|
||||
QPixmap icon(QLatin1String("icon:overlay_load_plan.svg"));
|
||||
|
||||
LtsWidgets::LtsDragIcon *pbAddOverlay = new LtsWidgets::LtsDragIcon(ctrlArea);
|
||||
|
||||
pbAddOverlay->setIcon(QIcon(icon));
|
||||
pbAddOverlay->setText(QString());
|
||||
pbAddOverlay->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
||||
pbAddOverlay->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
||||
pbAddOverlay->setToolTip(tr("Load selected plan file and create new plan overlayer at end of display order"));
|
||||
|
||||
connect(pbAddOverlay, &LtsWidgets::LtsDragIcon::clicked, this, &PlanOverlayDialogWidget::onLoadPlan);
|
||||
|
||||
#ifdef DISABLE_ADD_OVERLAY
|
||||
pbAddOverlay->setDisabled(true);
|
||||
connect(m_internal->m_fileDialogWidget, &LtsWidgets::LtsFileDialogWidget::readyToAccept, pbAddOverlay, [pbAddOverlay]()
|
||||
{
|
||||
pbAddOverlay->setDisabled(false);
|
||||
});
|
||||
#endif
|
||||
|
||||
QVBoxLayout *layoutOverlays = new QVBoxLayout(overlays);
|
||||
|
||||
QHBoxLayout *layoutCtrl = new QHBoxLayout();
|
||||
|
||||
layoutOverlays->addSpacing(5);
|
||||
layoutOverlays->addLayout(layoutCtrl, 0);
|
||||
layoutOverlays->addSpacing(5);
|
||||
layoutOverlays->addWidget(m_internal->m_planOverlayView, 2);
|
||||
|
||||
layoutCtrl->addStretch(2);
|
||||
layoutCtrl->addSpacing(20);
|
||||
layoutCtrl->addWidget(pbAddOverlay);
|
||||
layoutCtrl->addSpacing(20);
|
||||
layoutCtrl->addStretch(2);
|
||||
|
||||
m_internal->m_overlaySection = overlays;
|
||||
|
||||
if (m_internal->m_situationMapGui)
|
||||
{
|
||||
auto mapIsReady = [this]() { onEnableOverlaySection(true); };
|
||||
if (!m_internal->m_situationMapGui->setMapReadyCallback(this, mapIsReady))
|
||||
qCritical() << " setMapReadyCallback failed";
|
||||
|
||||
}
|
||||
|
||||
onEnableOverlaySection(true);
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayDialogWidget::~PlanOverlayDialogWidget()
|
||||
{
|
||||
delete m_internal;
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool PlanOverlayDialogWidget::isInModalDialog() const { return m_internal->m_isInModalDialog; }
|
||||
|
||||
|
||||
void PlanOverlayDialogWidget::setIsInModalDialog(bool on) { m_internal->m_isInModalDialog = on; }
|
||||
|
||||
|
||||
bool PlanOverlayDialogWidget::initFileManagement(const std::shared_ptr<FileManagement::Interface::Dtc> &dtc
|
||||
, const std::shared_ptr<OperatorManagement::Interface::Dtc> &opmDtc
|
||||
, const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc
|
||||
, const std::function<void(int selectedFileId)> &doRead
|
||||
, const std::function<void(int planId)> &doReload
|
||||
, const std::function<void(int planId)> &doUnload
|
||||
, bool isOc)
|
||||
{
|
||||
int parentFolderId = 0;
|
||||
if (isOc)
|
||||
{
|
||||
|
||||
parentFolderId = dtc->getExerciseFolderId(m_internal->m_session->exerciseId());
|
||||
}
|
||||
|
||||
int planFolderId = dtc->findFolder(parentFolderId, QStringLiteral("Tactical Plans"));
|
||||
|
||||
connect(m_internal->m_fileDialogWidget, &LtsWidgets::LtsFileDialogWidget::readSelectedFile, m_internal->m_fileDialogWidget, [doRead](int fileId)
|
||||
{
|
||||
doRead(fileId);
|
||||
});
|
||||
|
||||
connect(m_internal->m_planOverlayView, &PlanOverlayView::requestUnloadPlan, this, [doUnload](int planId)
|
||||
{
|
||||
doUnload(planId);
|
||||
});
|
||||
|
||||
connect(m_internal->m_planOverlayView, &PlanOverlayView::requestReloadPlanById, this, [doReload](int planId)
|
||||
{
|
||||
doReload(planId);
|
||||
});
|
||||
|
||||
|
||||
QVector<FileManagement::MainFolder> mainFolders;
|
||||
|
||||
if (!isOc)
|
||||
mainFolders.append(FileManagement::MainFolder::GlobalDocuments);
|
||||
mainFolders.append(FileManagement::MainFolder::ExerciseDocuments);
|
||||
mainFolders.append(FileManagement::MainFolder::UserDocuments);
|
||||
|
||||
if (!m_internal->m_fileDialogWidget->init(m_internal->m_session, dtc, opmDtc, exmDtc, LtsWidgets::FileDialogMode::modeOpenFile,
|
||||
mainFolders,{FileManagement::FileType::TacticalPlan}, planFolderId))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayDialogWidget::onEnableOverlaySection(bool on)
|
||||
{
|
||||
m_internal->m_overlaySection->setEnabled(((m_internal->m_situationMapGui) ? m_internal->m_situationMapGui->isMapReady() : true) && on);
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayDialogWidget::onLoadPlan()
|
||||
{
|
||||
m_internal->m_fileDialogWidget->requestReadingSelectedFile();
|
||||
}
|
||||
|
||||
void PlanOverlayDialogWidget::onRequestMinScaleFromUser(int planId, const QString &planName)
|
||||
{
|
||||
if (isInModalDialog()) return;
|
||||
|
||||
QHash<LtsWidgets::Button, QString> btnTxt;
|
||||
btnTxt[LtsWidgets::Button::Yes] = tr("Set to current");
|
||||
btnTxt[LtsWidgets::Button::No] = tr("Clear");
|
||||
btnTxt[LtsWidgets::Button::Cancel] = tr("Cancel");
|
||||
|
||||
const LtsWidgets::Button resultBNtn = LtsWidgets::LtsMessageDialog::showMessage(this
|
||||
, tr("Set current scale of map as minimum scale of plan overlay %1?").arg(planName)
|
||||
, tr("Redefine maximum scale of plan overlay")
|
||||
, LtsWidgets::Behaviour::Modal
|
||||
, LtsWidgets::Button::Yes | LtsWidgets::Button::No | LtsWidgets::Button::Cancel
|
||||
, btnTxt);
|
||||
if (resultBNtn == LtsWidgets::Button::Yes)
|
||||
{
|
||||
double minScale = m_internal->m_situationMapGui->getCurrentMapScale();
|
||||
if (minScale > 0.0)
|
||||
{
|
||||
const auto maxScale = m_internal->m_situationMapGui->planOverlayMaxScale(planId);
|
||||
if (minScale < maxScale || qFuzzyIsNull(maxScale))
|
||||
{
|
||||
int row = m_internal->m_planOverlayModel->getRowOfId(planId);
|
||||
m_internal->m_planOverlayModel->setMinScale(row, minScale);
|
||||
}
|
||||
else
|
||||
{
|
||||
QString msg = tr("The value of %1 is not allowed as minimum scale").arg(minScale);
|
||||
LtsWidgets::LtsMessageDialog::showMessage(this, msg, tr("Illegal value of minimum scale"));
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (resultBNtn == LtsWidgets::Button::No)
|
||||
{
|
||||
|
||||
int row = m_internal->m_planOverlayModel->getRowOfId(planId);
|
||||
m_internal->m_planOverlayModel->setMinScale(row, 0);
|
||||
}
|
||||
emit requestDialogShow();
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayDialogWidget::onRequestMaxScaleFromUser(int planId, const QString &planName)
|
||||
{
|
||||
if (isInModalDialog()) return;
|
||||
|
||||
QHash<LtsWidgets::Button, QString> btnTxt;
|
||||
btnTxt[LtsWidgets::Button::Yes] = tr("Set to current");
|
||||
btnTxt[LtsWidgets::Button::No] = tr("Clear");
|
||||
btnTxt[LtsWidgets::Button::Cancel] = tr("Cancel");
|
||||
|
||||
const LtsWidgets::Button resultBNtn = LtsWidgets::LtsMessageDialog::showMessage(this
|
||||
, tr("Set current scale of map as maximum scale of plan overlay %1?").arg(planName)
|
||||
, tr("Redefine maximum scale of plan overlay")
|
||||
, LtsWidgets::Behaviour::Modal
|
||||
, LtsWidgets::Button::Yes | LtsWidgets::Button::No | LtsWidgets::Button::Cancel
|
||||
, btnTxt);
|
||||
if (resultBNtn == LtsWidgets::Button::Yes)
|
||||
{
|
||||
double maxScale = m_internal->m_situationMapGui->getCurrentMapScale();
|
||||
if (maxScale > 0)
|
||||
{
|
||||
if (maxScale > m_internal->m_situationMapGui->planOverlayMinScale(planId))
|
||||
{
|
||||
int row = m_internal->m_planOverlayModel->getRowOfId(planId);
|
||||
m_internal->m_planOverlayModel->setMaxScale(row, maxScale);
|
||||
}
|
||||
else
|
||||
{
|
||||
QString msg = tr("The value of %1 is not allowed as maximum scale").arg(maxScale);
|
||||
LtsWidgets::LtsMessageDialog::showMessage(this, msg, tr("Illegal Value of Maximum Scale"));
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (resultBNtn == LtsWidgets::Button::No)
|
||||
{
|
||||
|
||||
int row = m_internal->m_planOverlayModel->getRowOfId(planId);
|
||||
m_internal->m_planOverlayModel->setMaxScale(row, 0);
|
||||
}
|
||||
emit requestDialogShow();
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayModel *PlanOverlayDialogWidget::planOverlayModel() const { return m_internal->m_planOverlayModel; }
|
||||
|
||||
}
|
||||
|
||||
+210
@@ -0,0 +1,210 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <LtsSession/lts_session.h>
|
||||
|
||||
#include <LtsWidgets/lts_dialog.h>
|
||||
#include <LtsWidgets/lts_frameless_dialog.h>
|
||||
|
||||
#include <Services/FileManagement/flm_dtc.h>
|
||||
#include <Services/OperatorManagement/opm_dtc.h>
|
||||
#include <Services/ExerciseManagement/exm_dtc.h>
|
||||
|
||||
#include <QtWidgets/QVBoxLayout>
|
||||
#include <QtWidgets/QApplication>
|
||||
#include <QtWidgets/QDesktopWidget>
|
||||
#include <QtWidgets/QDialog>
|
||||
#include <QtWidgets/QPushButton>
|
||||
|
||||
|
||||
namespace SituationMap
|
||||
{
|
||||
class ForeignGuiInterface;
|
||||
}
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
class PlanOverlayModel;
|
||||
|
||||
|
||||
|
||||
|
||||
class PlanOverlayDialogWidget : public QWidget
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
|
||||
explicit PlanOverlayDialogWidget(LtsSession::LtsSession *session, SituationMap::ForeignGuiInterface *situationMapGui, PlanOverlayModel *planOverlayModel, QWidget *parent);
|
||||
virtual ~PlanOverlayDialogWidget();
|
||||
|
||||
bool initFileManagement(const std::shared_ptr<FileManagement::Interface::Dtc> &dtc
|
||||
, const std::shared_ptr<OperatorManagement::Interface::Dtc> &opmDtc
|
||||
, const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc
|
||||
, const std::function<void(int selectedFileId)> &doRead
|
||||
, const std::function<void(int planId)> &doReload
|
||||
, const std::function<void(int planId)> &doUnload
|
||||
, bool isOc = false);
|
||||
|
||||
PlanOverlayModel *planOverlayModel() const;
|
||||
|
||||
bool isInModalDialog() const;
|
||||
void setIsInModalDialog(bool on = true);
|
||||
|
||||
|
||||
private slots:
|
||||
|
||||
void onLoadPlan();
|
||||
|
||||
void onRequestMinScaleFromUser(int planId, const QString &planName);
|
||||
void onRequestMaxScaleFromUser(int planId, const QString &planName);
|
||||
|
||||
void onEnableOverlaySection(bool on);
|
||||
|
||||
signals:
|
||||
|
||||
void requestDialogShow();
|
||||
|
||||
private:
|
||||
|
||||
struct InternalData;
|
||||
|
||||
InternalData *m_internal;
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class Dialog : public LtsWidgets::LtsDialog
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
|
||||
explicit Dialog(QWidget *parent, LtsWidgets::ButtonCombination buttonCombination = LtsWidgets::ButtonCombination::CloseOnly, bool closeable = true)
|
||||
: LtsWidgets::LtsDialog(parent, buttonCombination, closeable)
|
||||
{
|
||||
setUnchangeable();
|
||||
}
|
||||
|
||||
virtual ~Dialog() = default;
|
||||
|
||||
void retranslate() {;}
|
||||
|
||||
};
|
||||
|
||||
|
||||
template<class DialogClass> void createPlanOverlayDialog(DialogClass *&dlgPtr, QWidget *parent);
|
||||
|
||||
template<> inline void createPlanOverlayDialog<QDialog>(QDialog *&dlgPtr, QWidget *parent)
|
||||
{
|
||||
dlgPtr = new QDialog(parent);
|
||||
dlgPtr -> setWindowFlags(Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::WindowStaysOnTopHint | Qt::Dialog);
|
||||
dlgPtr -> setWindowTitle(QObject::tr("Plan Overlays"));
|
||||
}
|
||||
|
||||
|
||||
template<> inline void createPlanOverlayDialog<LtsWidgets::LtsFramelessDialog>(LtsWidgets::LtsFramelessDialog *&dlgPtr, QWidget *parent)
|
||||
{
|
||||
dlgPtr = new LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<class DialogClass> class PlanOverlayDialog
|
||||
{
|
||||
DialogClass *m_dialog;
|
||||
PlanOverlayDialogWidget *m_dialogWidget;
|
||||
LtsSession::LtsSession *m_session;
|
||||
|
||||
public:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
explicit PlanOverlayDialog(SituationMap::ForeignGuiInterface *situationMapGui, PlanOverlayModel *planOverlayModel, QWidget *parent, LtsSession::LtsSession *session)
|
||||
: m_dialog(nullptr), m_dialogWidget(nullptr), m_session(session)
|
||||
{
|
||||
static_assert(std::is_same<DialogClass, LtsWidgets::LtsFramelessDialog>::value || std::is_same<DialogClass, QDialog>::value
|
||||
, "This ctor of template class PlanOverlayDialog can only be used with QDialog and LtsWidgets::LtsFramelessDialog");
|
||||
|
||||
createPlanOverlayDialog(m_dialog, parent);
|
||||
|
||||
m_dialogWidget = new PlanOverlayDialogWidget(m_session, situationMapGui, planOverlayModel, m_dialog);
|
||||
|
||||
|
||||
|
||||
QVBoxLayout *layout = new QVBoxLayout(m_dialog);
|
||||
LtsWidgets::LtsDialogButtonBox *buttonBox = new LtsWidgets::LtsDialogButtonBox(parent);
|
||||
|
||||
QPushButton *btn = buttonBox->getButton(LtsWidgets::DialogButton::Help);
|
||||
if (btn && m_session)
|
||||
{
|
||||
QObject::connect(btn, &QPushButton::clicked, m_dialog, [this]()
|
||||
{
|
||||
if (m_session)
|
||||
m_session->slotShowOnlineHelp(QStringLiteral("Situation-Plan_Overlays"));
|
||||
});
|
||||
|
||||
btn->setVisible(true);
|
||||
}
|
||||
|
||||
layout->addWidget(m_dialogWidget, 2);
|
||||
layout->addWidget(buttonBox);
|
||||
|
||||
buttonBox->setButtonVisible(LtsWidgets::DialogButton::Apply, false);
|
||||
buttonBox->setButtonVisible(LtsWidgets::DialogButton::Ok, false);
|
||||
|
||||
QObject::connect(buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, m_dialog, &DialogClass::close);
|
||||
|
||||
m_dialog->setMinimumHeight(int(QApplication::desktop()->availableGeometry(m_dialogWidget).height() * 0.9));
|
||||
|
||||
QObject::connect(m_dialogWidget, &PlanOverlayDialogWidget::requestDialogShow, m_dialog, &DialogClass::show);
|
||||
|
||||
|
||||
m_dialogWidget->setIsInModalDialog(std::is_same<DialogClass, LtsWidgets::LtsFramelessDialog>::value);
|
||||
|
||||
m_dialog->setAttribute(Qt::WA_DeleteOnClose, true);
|
||||
}
|
||||
|
||||
|
||||
virtual ~PlanOverlayDialog() = default;
|
||||
PlanOverlayDialog(const PlanOverlayDialog &) = delete;
|
||||
PlanOverlayDialog &operator = (const PlanOverlayDialog &) = delete;
|
||||
|
||||
PlanOverlayDialogWidget *dialogWidget() const { return m_dialogWidget; }
|
||||
void show() { if (m_dialog) m_dialog->show(); }
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
}
|
||||
+591
@@ -0,0 +1,591 @@
|
||||
|
||||
|
||||
|
||||
#include "plan_overlay_model.h"
|
||||
|
||||
#include <QByteArray>
|
||||
#include <QDataStream>
|
||||
#include <QMimeData>
|
||||
#include <QJsonArray>
|
||||
|
||||
#include <FileManagement/flm_dtc.h>
|
||||
#include <NGLLogger/NGLLoggerBootstrap.h>
|
||||
|
||||
template<class _Ty, class _Other = _Ty> inline _Ty doExchange(_Ty &_Val, _Other && _New_val)
|
||||
{
|
||||
|
||||
_Ty _Old_val = std::move(_Val);
|
||||
_Val = std::forward<_Other>(_New_val);
|
||||
return (_Old_val);
|
||||
}
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
const QLatin1String REORDER_MIMETYPE("application/LtsPlanOverlayItemData/Reorder");
|
||||
|
||||
class PlanOverlayModel::InternalData
|
||||
{
|
||||
public:
|
||||
|
||||
QMap<unsigned int, PlanOverlayModel::PlanItem> m_planStore;
|
||||
QVector<int> m_planOrder;
|
||||
QString m_fileDialogMimeType;
|
||||
|
||||
InternalData()
|
||||
: m_planStore(), m_planOrder(), m_fileDialogMimeType()
|
||||
{
|
||||
}
|
||||
|
||||
~InternalData() = default;
|
||||
|
||||
};
|
||||
|
||||
|
||||
PlanOverlayModel::PlanOverlayModel() : QAbstractItemModel(), m_internal(new InternalData())
|
||||
, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("PlanOverlayModel"))
|
||||
{;}
|
||||
|
||||
PlanOverlayModel::~PlanOverlayModel()
|
||||
{
|
||||
delete m_internal;
|
||||
}
|
||||
|
||||
#ifdef LTS_DEBUG
|
||||
|
||||
int PlanOverlayModel::columnCount(const QModelIndex &) const { return int(ColumnSection::CustomSection) + 3; }
|
||||
#else
|
||||
int PlanOverlayModel::columnCount(const QModelIndex &) const { return int(ColumnSection::CustomSection) + 1; }
|
||||
#endif
|
||||
int PlanOverlayModel::rowCount(const QModelIndex &) const { return m_internal->m_planStore.size(); }
|
||||
int PlanOverlayModel::size() const { return m_internal->m_planStore.size(); }
|
||||
QMap<unsigned int, PlanOverlayModel::PlanItem> PlanOverlayModel::planStore() const { return m_internal->m_planStore; }
|
||||
|
||||
bool PlanOverlayModel::isEmpty() const { return m_internal->m_planStore.isEmpty(); }
|
||||
|
||||
|
||||
QVariant PlanOverlayModel::headerData(int section, Qt::Orientation orientation, int role) const
|
||||
{
|
||||
if (role != Qt::DisplayRole ||
|
||||
orientation == Qt::Orientation::Vertical)
|
||||
return QVariant();
|
||||
|
||||
switch (static_cast<ColumnSection>(section))
|
||||
{
|
||||
case ColumnSection::OrderButtons:
|
||||
return QVariant();
|
||||
case ColumnSection::PlanName:
|
||||
return tr("Plan");
|
||||
case ColumnSection::MinScale:
|
||||
return tr("Min. Scale");
|
||||
case ColumnSection::MaxScale:
|
||||
return tr("Max. Scale");
|
||||
case ColumnSection::Opacity:
|
||||
return tr("Opacity");
|
||||
case ColumnSection::CustomSection:
|
||||
return QVariant();
|
||||
case ColumnSection::ExerciseId:
|
||||
return tr("Exercise");
|
||||
case ColumnSection::PhaseId:
|
||||
return tr("Phase");
|
||||
}
|
||||
return QVariant();
|
||||
}
|
||||
|
||||
|
||||
QVariant PlanOverlayModel::data(const QModelIndex &index, int role) const
|
||||
{
|
||||
if (index.row() < 0 || index.row() >= m_internal->m_planOrder.size())
|
||||
return QVariant();
|
||||
|
||||
if (Qt::ItemDataRole::TextAlignmentRole == role)
|
||||
{
|
||||
switch (static_cast<ColumnSection>(index.column()))
|
||||
{
|
||||
case ColumnSection::PlanName:
|
||||
return QVariant(Qt::Alignment::enum_type::AlignCenter);
|
||||
case ColumnSection::MinScale:
|
||||
return QVariant(Qt::Alignment::enum_type::AlignRight | Qt::Alignment::enum_type::AlignHCenter);
|
||||
case ColumnSection::MaxScale:
|
||||
return QVariant(Qt::Alignment::enum_type::AlignRight | Qt::Alignment::enum_type::AlignHCenter);
|
||||
case ColumnSection::OrderButtons:
|
||||
case ColumnSection::Opacity:
|
||||
case ColumnSection::CustomSection:
|
||||
case ColumnSection::ExerciseId:
|
||||
case ColumnSection::PhaseId:
|
||||
return QVariant();
|
||||
}
|
||||
}
|
||||
|
||||
if (Qt::ItemDataRole::DisplayRole == role)
|
||||
{
|
||||
const PlanItem &planItem = m_internal->m_planStore[m_internal->m_planOrder.at(index.row())];
|
||||
switch (static_cast<ColumnSection>(index.column()))
|
||||
{
|
||||
case ColumnSection::OrderButtons:
|
||||
return QString();
|
||||
case ColumnSection::PlanName:
|
||||
return planItem.m_fileName;
|
||||
case ColumnSection::MinScale:
|
||||
return (planItem.m_minScale > 0) ? QStringLiteral("1:%1").arg(planItem.m_minScale) : tr("undefined");
|
||||
case ColumnSection::MaxScale:
|
||||
return (planItem.m_maxScale > 0) ? QStringLiteral("1:%1").arg(planItem.m_maxScale) : tr("undefined");
|
||||
case ColumnSection::Opacity:
|
||||
return planItem.m_opacity;
|
||||
case ColumnSection::CustomSection:
|
||||
return QString();
|
||||
case ColumnSection::ExerciseId:
|
||||
return planItem.m_exerciseId > 0 ? QVariant(planItem.m_exerciseId) : QVariant();
|
||||
case ColumnSection::PhaseId:
|
||||
return planItem.m_phaseId > 0 ? QVariant(planItem.m_phaseId) : QVariant();
|
||||
}
|
||||
}
|
||||
|
||||
return QVariant();
|
||||
|
||||
}
|
||||
|
||||
|
||||
QStringList PlanOverlayModel::mimeTypes() const
|
||||
{
|
||||
QStringList typeList;
|
||||
typeList << REORDER_MIMETYPE;
|
||||
if (!m_internal->m_fileDialogMimeType.isEmpty())
|
||||
typeList << m_internal->m_fileDialogMimeType;
|
||||
return typeList;
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::setFileDialogMimeType(const QString &mimeType)
|
||||
{
|
||||
m_internal->m_fileDialogMimeType = mimeType;
|
||||
}
|
||||
|
||||
|
||||
QMimeData *PlanOverlayModel::mimeData(const QModelIndexList &indexes) const
|
||||
{
|
||||
if (indexes.isEmpty()) return nullptr;
|
||||
|
||||
int row = indexes.first().row();
|
||||
unsigned int keyId = m_internal->m_planOrder.at(row);
|
||||
QMimeData *mimeData = new QMimeData();
|
||||
QByteArray encodedData;
|
||||
|
||||
mimeData->setData(REORDER_MIMETYPE, encodedData.setNum(keyId));
|
||||
|
||||
return mimeData;
|
||||
}
|
||||
|
||||
|
||||
bool PlanOverlayModel::canDropMimeData(const QMimeData *data, Qt::DropAction, int row, int, const QModelIndex &) const
|
||||
{
|
||||
if ((row >= 0) && (row < m_internal->m_planOrder.size()))
|
||||
{
|
||||
if (data->hasFormat(REORDER_MIMETYPE))
|
||||
{
|
||||
QByteArray encodedData = data->data(REORDER_MIMETYPE);
|
||||
bool ok = false;
|
||||
unsigned int keyId = encodedData.toUInt(&ok);
|
||||
|
||||
if (ok) return (m_internal->m_planOrder.indexOf(keyId) != row);
|
||||
}
|
||||
|
||||
if ((!m_internal->m_fileDialogMimeType.isEmpty()) && (data->hasFormat(m_internal->m_fileDialogMimeType)))
|
||||
{
|
||||
QByteArray encodedData = data->data(m_internal->m_fileDialogMimeType);
|
||||
bool ok = false;
|
||||
int keyId = encodedData.toUInt(&ok);
|
||||
|
||||
if (ok) return (keyId > 0);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool PlanOverlayModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
|
||||
{
|
||||
if (!canDropMimeData(data, action, row, column, parent)) return false;
|
||||
|
||||
if (action == Qt::IgnoreAction) return true;
|
||||
|
||||
emit dropPlanAccepted();
|
||||
|
||||
if (data->hasFormat(REORDER_MIMETYPE))
|
||||
{
|
||||
QByteArray encodedData = data->data(REORDER_MIMETYPE);
|
||||
bool ok = false;
|
||||
int keyId = encodedData.toInt(&ok);
|
||||
|
||||
if (!ok) return false;
|
||||
|
||||
int rowToMove = m_internal->m_planOrder.indexOf(keyId);
|
||||
|
||||
if (row != rowToMove)
|
||||
{
|
||||
if (row < rowToMove)
|
||||
{
|
||||
for (; row <= rowToMove; ++row)
|
||||
{
|
||||
unsigned int idSwap = m_internal->m_planOrder[row];
|
||||
m_internal->m_planOrder[row] = keyId;
|
||||
keyId = idSwap;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (--row; row >= rowToMove; --row)
|
||||
{
|
||||
unsigned int idSwap = m_internal->m_planOrder[row];
|
||||
m_internal->m_planOrder[row] = keyId;
|
||||
keyId = idSwap;
|
||||
}
|
||||
}
|
||||
emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
|
||||
emit layoutChanged();
|
||||
emit planOrderChanged(m_internal->m_planOrder);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((!m_internal->m_fileDialogMimeType.isEmpty()) && (data->hasFormat(m_internal->m_fileDialogMimeType)))
|
||||
{
|
||||
QByteArray encodedData = data->data(m_internal->m_fileDialogMimeType);
|
||||
bool ok = false;
|
||||
int fileId = encodedData.toInt(&ok);
|
||||
|
||||
if ((ok) && (fileId > 0))
|
||||
{
|
||||
emit requestLoadPlan(fileId);
|
||||
|
||||
|
||||
|
||||
int rowToMove = m_internal->m_planOrder.size() - 1;
|
||||
int keyId = m_internal->m_planOrder[rowToMove];
|
||||
|
||||
if (row != rowToMove)
|
||||
{
|
||||
for (; row <= rowToMove; ++row)
|
||||
keyId = doExchange(m_internal->m_planOrder[row], keyId);
|
||||
emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
|
||||
emit layoutChanged();
|
||||
emit planOrderChanged(m_internal->m_planOrder);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
QJsonArray PlanOverlayModel::toJson() const
|
||||
{
|
||||
QJsonArray result;
|
||||
|
||||
if (m_internal->m_planStore.count() != m_internal->m_planOrder.count())
|
||||
{
|
||||
Q_ASSERT(m_internal->m_planStore.count() == m_internal->m_planOrder.count());
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
for (int i = m_internal->m_planStore.count() - 1; i >= 0; i--)
|
||||
{
|
||||
PlanItem planItem = m_internal->m_planStore[m_internal->m_planOrder.at(i)];
|
||||
result += planItem.toJson();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayModel::PlanItem PlanOverlayModel::planItem(int keyId)
|
||||
{
|
||||
if (keyId < 1)
|
||||
{
|
||||
static int nextKey = 1;
|
||||
|
||||
keyId = nextKey++;
|
||||
}
|
||||
|
||||
PlanItem &planItem = m_internal->m_planStore[keyId];
|
||||
planItem.m_keyId = keyId;
|
||||
return planItem;
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayModel::PlanItem &PlanOverlayModel::planItemRef(int keyId)
|
||||
{
|
||||
return m_internal->m_planStore[keyId];
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayModel::PlanItem PlanOverlayModel::planItemValue(int keyId)
|
||||
{
|
||||
QMap<unsigned int, PlanOverlayModel::PlanItem>::Iterator found = m_internal->m_planStore.find(keyId);
|
||||
|
||||
return (found == m_internal->m_planStore.end()) ? PlanItem() : found.value();
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayModel::PlanItem PlanOverlayModel::planItemAtRow(int row)
|
||||
{
|
||||
if ((row < 0) || (row >= m_internal->m_planOrder.size())) return PlanItem();
|
||||
unsigned int planKeyId = m_internal->m_planOrder.at(row);
|
||||
return m_internal->m_planStore[planKeyId];
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayModel::PlanItem PlanOverlayModel::findPlanItemByFileId(int fileId)
|
||||
{
|
||||
if (fileId < 1)
|
||||
return PlanItem();
|
||||
|
||||
QMap<unsigned int, PlanOverlayModel::PlanItem>::const_iterator it;
|
||||
for (it = m_internal->m_planStore.constBegin(); it != m_internal->m_planStore.constEnd(); ++it)
|
||||
{
|
||||
if (it.value().m_fileId == fileId)
|
||||
return it.value();
|
||||
}
|
||||
|
||||
return PlanItem();
|
||||
}
|
||||
|
||||
|
||||
Qt::ItemFlags PlanOverlayModel::flags(const QModelIndex &modelIndex) const
|
||||
{
|
||||
Qt::ItemFlags flags = QAbstractItemModel::flags(modelIndex) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
|
||||
|
||||
switch (static_cast<ColumnSection>(modelIndex.column()))
|
||||
{
|
||||
case ColumnSection::OrderButtons:
|
||||
case ColumnSection::PlanName:
|
||||
case ColumnSection::MinScale:
|
||||
case ColumnSection::MaxScale:
|
||||
case ColumnSection::Opacity:
|
||||
flags |= Qt::ItemIsEditable;
|
||||
break;
|
||||
case ColumnSection::CustomSection:
|
||||
case ColumnSection::ExerciseId:
|
||||
case ColumnSection::PhaseId:
|
||||
break;
|
||||
}
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::updatePlanItem(const PlanItem &planItem)
|
||||
{
|
||||
if (!planItem.isValid())
|
||||
{
|
||||
ERROR_LOG(m_logger) << "planItem has invalid key";
|
||||
return;
|
||||
}
|
||||
|
||||
m_internal->m_planStore[planItem.m_keyId] = planItem;
|
||||
|
||||
beginResetModel();
|
||||
{
|
||||
if (!m_internal->m_planOrder.contains(planItem.m_keyId))
|
||||
m_internal->m_planOrder.prepend(planItem.m_keyId);
|
||||
}
|
||||
endResetModel();
|
||||
|
||||
int row = m_internal->m_planOrder.size() - 1;
|
||||
emit dataChanged(index(row, 0, QModelIndex()), index(row, columnCount(QModelIndex()) - 1, QModelIndex()));
|
||||
emit layoutChanged();
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::swapRow(int row1, int row2)
|
||||
{
|
||||
if (row1 < 0) return;
|
||||
if (row2 < 0) return;
|
||||
if (row1 >= m_internal->m_planOrder.size()) return;
|
||||
if (row2 >= m_internal->m_planOrder.size()) return;
|
||||
|
||||
m_internal->m_planOrder[row2] = doExchange(m_internal->m_planOrder[row1], m_internal->m_planOrder[row2]);
|
||||
|
||||
QModelIndex topLeftIndex;
|
||||
QModelIndex bottomRightIndex;
|
||||
|
||||
if (row1 < row2)
|
||||
{
|
||||
topLeftIndex = createIndex(row1, 0);
|
||||
bottomRightIndex = createIndex(row2, columnCount(QModelIndex()) - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
topLeftIndex = createIndex(row2, 0);
|
||||
bottomRightIndex = createIndex(row1, columnCount(QModelIndex()) - 1);
|
||||
}
|
||||
|
||||
emit dataChanged(topLeftIndex, bottomRightIndex);
|
||||
emit planOrderChanged(m_internal->m_planOrder);
|
||||
|
||||
}
|
||||
|
||||
|
||||
int PlanOverlayModel::getRowOfId(int keyId) const
|
||||
{
|
||||
return m_internal->m_planOrder.indexOf(keyId);
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::setMinScale(int row, double scale)
|
||||
{
|
||||
if (row < 0) return;
|
||||
if (row >= m_internal->m_planOrder.size()) return;
|
||||
|
||||
const int id = m_internal->m_planOrder[row];
|
||||
|
||||
planItemRef(id).m_minScale = scale;
|
||||
|
||||
emit planMinScaleChanged(id, scale);
|
||||
|
||||
const QModelIndex &modelIndex = createIndex(row, int(ColumnSection::MinScale));
|
||||
emit dataChanged(modelIndex, modelIndex);
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::setMaxScale(int row, double scale)
|
||||
{
|
||||
if (row < 0) return;
|
||||
if (row >= m_internal->m_planOrder.size()) return;
|
||||
|
||||
const int id = m_internal->m_planOrder[row];
|
||||
|
||||
planItemRef(id).m_maxScale = scale;
|
||||
|
||||
emit planMaxScaleChanged(id, scale);
|
||||
|
||||
const QModelIndex &modelIndex = createIndex(row, int(ColumnSection::MaxScale));
|
||||
emit dataChanged(modelIndex, modelIndex);
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::setOpacity(int row, double opacity)
|
||||
{
|
||||
if (row < 0) return;
|
||||
if (row >= m_internal->m_planOrder.size()) return;
|
||||
|
||||
if (opacity < 0) opacity = 0.0;
|
||||
if (opacity > 1) opacity = 1.0;
|
||||
|
||||
const int id = m_internal->m_planOrder[row];
|
||||
|
||||
planItemRef(id).m_opacity = opacity;
|
||||
|
||||
emit planOpacityChanged(id, opacity);
|
||||
|
||||
const QModelIndex &modelIndex = createIndex(row, int(ColumnSection::Opacity));
|
||||
emit dataChanged(modelIndex, modelIndex);
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::updateOverlay(int keyId)
|
||||
{
|
||||
|
||||
int row = m_internal->m_planOrder.indexOf(keyId);
|
||||
|
||||
if (row < 0) return;
|
||||
if (row >= m_internal->m_planOrder.size()) return;
|
||||
|
||||
emit dataChanged(createIndex(row, 0), createIndex(row, columnCount(QModelIndex()) - 1));
|
||||
emit requestUpdatePlan(keyId);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::renewPlanItem(const PlanItem &planItem)
|
||||
{
|
||||
int row = m_internal->m_planOrder.indexOf(planItem.m_keyId);
|
||||
|
||||
if (row < 0) return;
|
||||
if (row >= m_internal->m_planOrder.size()) return;
|
||||
|
||||
m_internal->m_planStore[planItem.m_keyId] = planItem;
|
||||
emit dataChanged(createIndex(row, 0), createIndex(row, columnCount(QModelIndex()) - 1));
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::removeOverlay(int keyId)
|
||||
{
|
||||
int row = m_internal->m_planOrder.indexOf(keyId);
|
||||
|
||||
if (row < 0) return;
|
||||
if (row >= m_internal->m_planOrder.size()) return;
|
||||
|
||||
emit requestRemovePlan(keyId);
|
||||
|
||||
beginResetModel();
|
||||
{
|
||||
m_internal->m_planStore.remove(keyId);
|
||||
m_internal->m_planOrder.remove(row);
|
||||
}
|
||||
endResetModel();
|
||||
|
||||
|
||||
|
||||
emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
|
||||
emit layoutChanged();
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool PlanOverlayModel::reInitModel(int exerciseId, int phaseId)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "ReInit Model for exerciseId = " << exerciseId << ", phaseId = " << phaseId;
|
||||
|
||||
if ((exerciseId < 1) || (phaseId < 1))
|
||||
{
|
||||
|
||||
WARNING_LOG(m_logger) << LOGFUNCTION << " has been called with undefined exercise and/or phaseId";
|
||||
return false;
|
||||
}
|
||||
|
||||
QVector<int> removeList;
|
||||
|
||||
removeList.reserve(m_internal->m_planOrder.size());
|
||||
|
||||
QMap<unsigned int, PlanOverlayModel::PlanItem>::const_iterator it;
|
||||
for (it = m_internal->m_planStore.constBegin(); it != m_internal->m_planStore.constEnd(); ++it)
|
||||
{
|
||||
int planExId = it.value().m_exerciseId;
|
||||
int planPhId = it.value().m_phaseId;
|
||||
|
||||
DEBUG_LOG(m_logger) << "Plan name = " << it.value().m_fileName << " exercise = " << planExId << " phase = " << planPhId;
|
||||
|
||||
if ((planExId < 1) || (planPhId < 1) || ((planExId == exerciseId) && (planPhId == phaseId)))
|
||||
{
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
bool removeFromModel(false);
|
||||
|
||||
emit requestReloadPlanByName(it.value(), exerciseId, phaseId, &removeFromModel);
|
||||
|
||||
if (removeFromModel) removeList << it.value().m_keyId;
|
||||
}
|
||||
|
||||
|
||||
for (auto id : qAsConst(removeList)) removeOverlay(id);
|
||||
|
||||
emit dataChanged(createIndex(0, 0), createIndex(m_internal->m_planOrder.size() - 1, columnCount(QModelIndex()) - 1));
|
||||
emit layoutChanged();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayModel::updateOrderOfPlans() const
|
||||
{
|
||||
emit const_cast<PlanOverlayModel *>(this)->planOrderChanged(m_internal->m_planOrder);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
+187
@@ -0,0 +1,187 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <Plugins/SituationMapPlugin/situation_map_gui_plugin_interface.h>
|
||||
#include <NGLLogger/INGLLogger.h>
|
||||
|
||||
#include <QAbstractItemModel>
|
||||
#include <QJsonObject>
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
class PlanOverlayModel final : public QAbstractItemModel
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
|
||||
enum class ColumnSection
|
||||
{
|
||||
OrderButtons = 0,
|
||||
PlanName,
|
||||
MinScale,
|
||||
MaxScale,
|
||||
Opacity,
|
||||
CustomSection,
|
||||
ExerciseId,
|
||||
PhaseId
|
||||
};
|
||||
|
||||
PlanOverlayModel();
|
||||
~PlanOverlayModel();
|
||||
|
||||
|
||||
|
||||
int columnCount(const QModelIndex &) const override;
|
||||
int rowCount(const QModelIndex &) const override;
|
||||
int size() const;
|
||||
|
||||
bool isEmpty() const;
|
||||
|
||||
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::ItemDataRole::DisplayRole) const override;
|
||||
|
||||
QVariant data(const QModelIndex &index, int role = Qt::ItemDataRole::DisplayRole) const override;
|
||||
|
||||
QModelIndex index(int row, int column, const QModelIndex &) const override { return createIndex(row, column); }
|
||||
QModelIndex parent(const QModelIndex &) const override { return QModelIndex(); }
|
||||
Qt::ItemFlags flags(const QModelIndex &modelIndex) const override;
|
||||
QModelIndex index(int row, int column) const { return index(row, column, QModelIndex()); }
|
||||
|
||||
QStringList mimeTypes() const override;
|
||||
|
||||
QMimeData *mimeData(const QModelIndexList &indexes) const override;
|
||||
|
||||
Qt::DropActions supportedDragActions() const override { return Qt::CopyAction | Qt::MoveAction; }
|
||||
Qt::DropActions supportedDropActions() const override { return Qt::CopyAction | Qt::MoveAction; }
|
||||
|
||||
bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &) const override;
|
||||
|
||||
bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &) override;
|
||||
|
||||
|
||||
|
||||
struct PlanItem
|
||||
{
|
||||
int m_keyId = -1;
|
||||
int m_folderId = -1;
|
||||
int m_fileId = -1;
|
||||
int m_exerciseId = -1;
|
||||
int m_phaseId = -1;
|
||||
QString m_dirPath;
|
||||
QString m_fileName;
|
||||
double m_minScale = 0.0;
|
||||
double m_maxScale = 0.0;
|
||||
double m_opacity = 0.0;
|
||||
bool m_visibility = true;
|
||||
|
||||
bool isValid() const { return m_keyId > 0; }
|
||||
QJsonObject toJson() const
|
||||
{
|
||||
QJsonObject obj;
|
||||
|
||||
obj[QStringLiteral("keyId")] = m_keyId;
|
||||
obj[QStringLiteral("folderId")] = m_folderId;
|
||||
obj[QStringLiteral("fileId")] = m_fileId;
|
||||
obj[QStringLiteral("fileName")] = m_fileName;
|
||||
|
||||
obj[QStringLiteral("exerciseId")] = m_exerciseId;
|
||||
obj[QStringLiteral("phaseId")] = m_phaseId;
|
||||
|
||||
obj[QStringLiteral("opacity")] = m_opacity;
|
||||
obj[QStringLiteral("maxScale")] = m_maxScale;
|
||||
obj[QStringLiteral("minScale")] = m_minScale;
|
||||
obj[QStringLiteral("visibility")] = m_visibility;
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
static PlanItem fromJson(const QJsonObject &obj)
|
||||
{
|
||||
PlanItem pi;
|
||||
|
||||
pi.m_keyId = obj[QStringLiteral("keyId")].toInt();
|
||||
pi.m_folderId = obj[QStringLiteral("folderId")].toInt();
|
||||
pi.m_fileId = obj[QStringLiteral("fileId")].toInt();
|
||||
pi.m_fileName = obj[QStringLiteral("fileName")].toInt();
|
||||
|
||||
pi.m_exerciseId = obj[QStringLiteral("exerciseId")].toInt();
|
||||
pi.m_phaseId = obj[QStringLiteral("phaseId")].toInt();
|
||||
|
||||
pi.m_opacity = obj[QStringLiteral("opacity")].toDouble();
|
||||
pi.m_maxScale = obj[QStringLiteral("maxScale")].toDouble();
|
||||
pi.m_minScale = obj[QStringLiteral("minScale")].toDouble();
|
||||
pi.m_visibility = obj[QStringLiteral("visibility")].toBool();
|
||||
|
||||
return pi;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
QMap<unsigned int, PlanItem> planStore() const;
|
||||
|
||||
PlanItem planItem(int keyId);
|
||||
|
||||
PlanItem planItemValue(int keyId);
|
||||
|
||||
PlanItem planItemAtRow(int row);
|
||||
|
||||
PlanItem findPlanItemByFileId(int fileId);
|
||||
|
||||
int getRowOfId(int keyId) const;
|
||||
|
||||
void updatePlanItem(const PlanItem &planItem);
|
||||
|
||||
void renewPlanItem(const PlanItem &planItem);
|
||||
|
||||
void setMinScale(int row, double scale);
|
||||
void setMaxScale(int row, double scale);
|
||||
void setOpacity(int row, double opacity);
|
||||
|
||||
void swapRow(int row1, int row2);
|
||||
|
||||
void removeOverlay(int keyId);
|
||||
|
||||
void setFileDialogMimeType(const QString &mimeType);
|
||||
|
||||
void updateOverlay(int keyId);
|
||||
|
||||
bool reInitModel(int exerciseId, int phaseId);
|
||||
|
||||
void updateOrderOfPlans() const;
|
||||
|
||||
QJsonArray toJson() const;
|
||||
|
||||
signals:
|
||||
|
||||
void requestLoadPlan(int keyId);
|
||||
void requestReloadPlan(int keyId);
|
||||
void requestUpdatePlan(int keyId);
|
||||
void requestRemovePlan(int keyId);
|
||||
|
||||
void requestReloadPlanByName(const PlanOverlaysPlugin::PlanOverlayModel::PlanItem &planItem, int exerciseId, int phaseId, bool *removeFromModel);
|
||||
|
||||
void planMinScaleChanged(int keyId, double minScale);
|
||||
void planMaxScaleChanged(int keyId, double maxScale);
|
||||
void planOpacityChanged(int keyId, double opacity);
|
||||
|
||||
void planOrderChanged(const QVector<int> &newIdOrder);
|
||||
|
||||
void dropPlanAccepted();
|
||||
|
||||
private:
|
||||
|
||||
PlanItem &planItemRef(int keyId);
|
||||
|
||||
class InternalData;
|
||||
|
||||
InternalData *m_internal;
|
||||
|
||||
NGL::INGLLogger &m_logger;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
+596
@@ -0,0 +1,596 @@
|
||||
|
||||
|
||||
|
||||
#include "plan_overlay_view.h"
|
||||
#include "plan_overlay_model.h"
|
||||
|
||||
#include <LtsWidgets/lts_drag_icon.h>
|
||||
|
||||
#include <QtCore/QByteArray>
|
||||
|
||||
#include <QtGui/QGuiApplication>
|
||||
#include <QtGui/QPainter>
|
||||
#include <QtGui/QTransform>
|
||||
|
||||
#include <QtWidgets/QHeaderView>
|
||||
#include <QtWidgets/QLabel>
|
||||
#include <QtWidgets/QPushButton>
|
||||
#include <QtWidgets/QSlider>
|
||||
#include <QtWidgets/QStyledItemDelegate>
|
||||
#include <QtWidgets/QVBoxLayout>
|
||||
#include <QtWidgets/QWidget>
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
class WidgetItemDelegate : public QStyledItemDelegate
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
private:
|
||||
|
||||
PlanOverlayView *m_planOverlayView;
|
||||
|
||||
mutable QMap<QByteArray, QWidget *> m_widgetMap;
|
||||
mutable QMap<QByteArray, QSize> m_sizeHints;
|
||||
|
||||
QByteArray buildKey(const QModelIndex &index) const
|
||||
{
|
||||
return QByteArray::number(index.row()) + ',' + QByteArray::number(index.column());
|
||||
}
|
||||
|
||||
|
||||
void removeKey(const QByteArray &indexKey, QObject *qobj) const
|
||||
{
|
||||
QWidget *widget = qobject_cast<QWidget *>(qobj);
|
||||
|
||||
if (nullptr == widget) return;
|
||||
if (!m_widgetMap.contains(indexKey)) return;
|
||||
if (widget != m_widgetMap[indexKey]) return;
|
||||
|
||||
|
||||
|
||||
m_sizeHints.remove(indexKey);
|
||||
m_widgetMap.remove(indexKey);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
explicit WidgetItemDelegate(PlanOverlayView *planOverlayView) : QStyledItemDelegate(planOverlayView), m_planOverlayView(planOverlayView) {;}
|
||||
~WidgetItemDelegate() = default;
|
||||
|
||||
|
||||
void destroyEditor(QWidget *editor, const QModelIndex &index) const override
|
||||
{
|
||||
if (!index.isValid()) return;
|
||||
if (m_planOverlayView->model()->rowCount() <= index.row()) return;
|
||||
|
||||
const QByteArray &indexKey = buildKey(index);
|
||||
removeKey(indexKey, editor);
|
||||
if (editor) editor-> deleteLater();
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override
|
||||
{
|
||||
const QByteArray &indexKey = buildKey(index);
|
||||
|
||||
const QVariant &modelData = index.model()->data(index, Qt::DisplayRole);
|
||||
|
||||
if (m_widgetMap.contains(indexKey))
|
||||
{
|
||||
QWidget *w = m_widgetMap[indexKey];
|
||||
removeKey(indexKey, w);
|
||||
if (w) w->deleteLater();
|
||||
}
|
||||
|
||||
const QString &backgroundStyle = QStringLiteral("background-color: %1; color: %2; border:none;").arg(QGuiApplication::palette().color(QPalette::ColorRole::Base).name(),
|
||||
m_planOverlayView->palette().text().color().name());
|
||||
const QString &backgroundDisabledStyle = QStringLiteral("background-color: %1; color: %2; border:none;").arg(QGuiApplication::palette().color(QPalette::ColorGroup::Disabled, QPalette::ColorRole::Base).name(),
|
||||
m_planOverlayView->palette().text().color().name());
|
||||
const QString &buttonStyleSheet = QStringLiteral("QPushButton:!disabled {%1}\nQPushButton:disabled {%2}").arg(backgroundStyle, backgroundDisabledStyle);
|
||||
|
||||
switch (static_cast<PlanOverlayModel::ColumnSection>(index.column()))
|
||||
{
|
||||
case PlanOverlayModel::ColumnSection::OrderButtons:
|
||||
{
|
||||
if (index.model()->rowCount() > 1)
|
||||
{
|
||||
QWidget *orderButtons = new QWidget(parent);
|
||||
QVBoxLayout *orderLayout = new QVBoxLayout(orderButtons);
|
||||
|
||||
QPixmap icon(QStringLiteral("icon:media-vcr-normal.svg"));
|
||||
|
||||
LtsWidgets::LtsDragIcon *up = nullptr;
|
||||
|
||||
if (index.row() > 0)
|
||||
{
|
||||
up = new LtsWidgets::LtsDragIcon(orderButtons);
|
||||
|
||||
|
||||
up->setIcon(QIcon(icon.transformed(QTransform().rotate(-90).scale(0.5, 0.5))));
|
||||
up->setText(QString());
|
||||
up->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
||||
up->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
||||
up->setProperty("row", index.row());
|
||||
up->setToolTip(tr("Move layer up in display order"));
|
||||
|
||||
connect(up, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onChangeLayerOrderUp);
|
||||
}
|
||||
|
||||
LtsWidgets::LtsDragIcon *down = nullptr;
|
||||
|
||||
if ((index.row() + 1) < index.model()->rowCount())
|
||||
{
|
||||
down = new LtsWidgets::LtsDragIcon(orderButtons);
|
||||
|
||||
|
||||
down->setIcon(QIcon(icon.transformed(QTransform().rotate(90).scale(0.5, 0.5))));
|
||||
down->setText(QString());
|
||||
down->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
||||
down->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
||||
down->setProperty("row", index.row());
|
||||
down->setToolTip(tr("Move layer down in display order"));
|
||||
connect(down, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onChangeLayerOrderDown);
|
||||
}
|
||||
|
||||
orderLayout->addStretch();
|
||||
orderLayout->addSpacing(5);
|
||||
if (up) orderLayout->addWidget(up);
|
||||
if (down) orderLayout->addWidget(down);
|
||||
orderLayout->addSpacing(5);
|
||||
orderLayout->addStretch();
|
||||
|
||||
orderButtons->setAutoFillBackground(true);
|
||||
|
||||
connect(orderButtons, &QObject::destroyed, orderButtons, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
||||
|
||||
m_sizeHints[indexKey] = orderButtons->sizeHint();
|
||||
m_widgetMap[indexKey] = orderButtons;
|
||||
|
||||
|
||||
|
||||
return orderButtons;
|
||||
}
|
||||
break;
|
||||
};
|
||||
|
||||
case PlanOverlayModel::ColumnSection::PlanName:
|
||||
{
|
||||
QLabel *laName = new QLabel(modelData.toString(), parent);
|
||||
|
||||
laName->setAlignment(Qt::AlignCenter);
|
||||
laName->setStyleSheet(QStringLiteral("QLabel:!disabled {%1}\nQLabel:disabled {%2}").arg(backgroundStyle, backgroundDisabledStyle));
|
||||
|
||||
m_sizeHints[indexKey] = laName->sizeHint();
|
||||
m_widgetMap[indexKey] = laName;
|
||||
|
||||
return laName;
|
||||
|
||||
};
|
||||
|
||||
case PlanOverlayModel::ColumnSection::MinScale:
|
||||
{
|
||||
QPushButton *pbScaleMin = new QPushButton(parent);
|
||||
pbScaleMin->setStyleSheet(buttonStyleSheet);
|
||||
pbScaleMin->setPalette(m_planOverlayView->palette());
|
||||
pbScaleMin->setAutoFillBackground(true);
|
||||
pbScaleMin->setProperty("row", index.row());
|
||||
pbScaleMin->setText(modelData.toString());
|
||||
pbScaleMin->setToolTip(tr("Get minimum scale from current map settings to limit zoom out"));
|
||||
|
||||
connect(pbScaleMin, &QPushButton::clicked, m_planOverlayView, &PlanOverlayView::onSetMinScale);
|
||||
connect(pbScaleMin, &QObject::destroyed, pbScaleMin, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
||||
|
||||
m_sizeHints[indexKey] = pbScaleMin->sizeHint();
|
||||
m_widgetMap[indexKey] = pbScaleMin;
|
||||
|
||||
|
||||
|
||||
return pbScaleMin;
|
||||
};
|
||||
|
||||
case PlanOverlayModel::ColumnSection::MaxScale:
|
||||
{
|
||||
QPushButton *pbScaleMax = new QPushButton(parent);
|
||||
pbScaleMax->setStyleSheet(buttonStyleSheet);
|
||||
pbScaleMax->setAutoFillBackground(true);
|
||||
pbScaleMax->setProperty("row", index.row());
|
||||
pbScaleMax->setText(modelData.toString());
|
||||
pbScaleMax->setToolTip(tr("Get maximum scale from current map settings to limit zoom in"));
|
||||
|
||||
connect(pbScaleMax, &QPushButton::clicked, m_planOverlayView, &PlanOverlayView::onSetMaxScale);
|
||||
connect(pbScaleMax, &QObject::destroyed, pbScaleMax, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
||||
|
||||
m_sizeHints[indexKey] = pbScaleMax->sizeHint();
|
||||
m_widgetMap[indexKey] = pbScaleMax;
|
||||
|
||||
|
||||
|
||||
return pbScaleMax;
|
||||
};
|
||||
|
||||
case PlanOverlayModel::ColumnSection::Opacity:
|
||||
{
|
||||
QSlider *slOpacity = new QSlider(parent);
|
||||
|
||||
slOpacity->setAutoFillBackground(true);
|
||||
slOpacity->setOrientation(Qt::Horizontal);
|
||||
slOpacity->setRange(0, 100);
|
||||
slOpacity->setValue(int(modelData.toDouble() * 100));
|
||||
slOpacity->setProperty("row", index.row());
|
||||
slOpacity->setToolTip(tr("Adjust overlays opacity"));
|
||||
|
||||
connect(slOpacity, &QSlider::sliderMoved, m_planOverlayView, &PlanOverlayView::onChangeLayerOpacity);
|
||||
connect(slOpacity, &QObject::destroyed, slOpacity, [this, indexKey](QObject * qobj) { removeKey(indexKey, qobj); });
|
||||
|
||||
m_sizeHints[indexKey] = slOpacity->sizeHint();
|
||||
m_widgetMap[indexKey] = slOpacity;
|
||||
|
||||
return slOpacity;
|
||||
};
|
||||
|
||||
case PlanOverlayModel::ColumnSection::CustomSection:
|
||||
{
|
||||
QWidget *containerWidget = new QWidget(parent);
|
||||
QVBoxLayout *layout = new QVBoxLayout(containerWidget);
|
||||
QHBoxLayout *layoutBtnRow = new QHBoxLayout();
|
||||
|
||||
LtsWidgets::LtsDragIcon *pbReload = new LtsWidgets::LtsDragIcon(containerWidget);
|
||||
|
||||
pbReload->setIcon(QPixmap(QStringLiteral("icon:overlay_reload_plan.svg")));
|
||||
pbReload->setText(QString());
|
||||
pbReload->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
||||
pbReload->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
||||
pbReload->setProperty("row", index.row());
|
||||
pbReload->setAutoFillBackground(true);
|
||||
pbReload->setToolTip(tr("Reload plan"));
|
||||
|
||||
LtsWidgets::LtsDragIcon *pbUnload = new LtsWidgets::LtsDragIcon(containerWidget);
|
||||
|
||||
pbUnload->setIcon(QPixmap(QStringLiteral("icon:overlay_unload_plan.svg")));
|
||||
pbUnload->setText(QString());
|
||||
pbUnload->setIconSize(LtsWidgets::ButtonSize::eDefault);
|
||||
pbUnload->setButtonStyle(LtsWidgets::ButtonStyle::eIconOnly);
|
||||
pbUnload->setProperty("row", index.row());
|
||||
pbUnload->setAutoFillBackground(true);
|
||||
pbUnload->setToolTip(tr("Unload plan and remove overlayer"));
|
||||
|
||||
layoutBtnRow->addWidget(pbReload);
|
||||
layoutBtnRow->addWidget(pbUnload);
|
||||
|
||||
layout->addStretch(2);
|
||||
layout->addLayout(layoutBtnRow);
|
||||
layout->addStretch(2);
|
||||
|
||||
containerWidget->setAutoFillBackground(true);
|
||||
|
||||
connect(pbReload, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onReloadOverlayById);
|
||||
connect(pbUnload, &LtsWidgets::LtsDragIcon::clicked, m_planOverlayView, &PlanOverlayView::onUnloadOverlay);
|
||||
|
||||
m_sizeHints[indexKey] = containerWidget->sizeHint();
|
||||
m_widgetMap[indexKey] = containerWidget;
|
||||
|
||||
return containerWidget;
|
||||
};
|
||||
case PlanOverlayModel::ColumnSection::ExerciseId:
|
||||
case PlanOverlayModel::ColumnSection::PhaseId:
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
const QString &labelText = m_planOverlayView->model()->data(index, Qt::ItemDataRole::DisplayRole).toString();
|
||||
#if QT_VERSION < QT_VERSION_CHECK(5, 11, 0)
|
||||
int labelWidth = option.fontMetrics.width(labelText);
|
||||
#else
|
||||
int labelWidth = option.fontMetrics.horizontalAdvance(labelText);
|
||||
#endif
|
||||
labelWidth = (option.rect.width() > labelWidth) ? option.rect.width() : labelWidth + labelWidth / 5;
|
||||
|
||||
m_sizeHints[indexKey] = QSize(labelWidth, option.rect.height());
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
|
||||
{
|
||||
const QByteArray &indexKey = buildKey(index);
|
||||
|
||||
if (m_widgetMap.contains(indexKey))
|
||||
{
|
||||
QWidget *w = m_widgetMap[indexKey];
|
||||
if (w)
|
||||
{
|
||||
w->setGeometry(option.rect);
|
||||
painter->drawPixmap(option.rect.x(), option.rect.y(), w->grab());
|
||||
return;
|
||||
}
|
||||
}
|
||||
QStyledItemDelegate::paint(painter, option, index);
|
||||
}
|
||||
|
||||
|
||||
QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override
|
||||
{
|
||||
Q_UNUSED(option);
|
||||
const QByteArray &indexKey = buildKey(index);
|
||||
return (m_sizeHints.contains(indexKey)) ? m_sizeHints[indexKey] : QSize();
|
||||
}
|
||||
|
||||
|
||||
void setEditorData(QWidget *editor, const QModelIndex &index) const override
|
||||
{
|
||||
const QVariant &modelData = index.model()->data(index, Qt::ItemDataRole::DisplayRole);
|
||||
switch (static_cast<PlanOverlayModel::ColumnSection>(index.column()))
|
||||
{
|
||||
case PlanOverlayModel::ColumnSection::PlanName:
|
||||
{
|
||||
QLabel *laName = qobject_cast<QLabel *>(editor);
|
||||
if (laName) laName->setText(modelData.toString());
|
||||
break;
|
||||
}
|
||||
|
||||
case PlanOverlayModel::ColumnSection::MinScale:
|
||||
{
|
||||
QPushButton *pbMinScale = qobject_cast<QPushButton *>(editor);
|
||||
if (pbMinScale) pbMinScale->setText(modelData.toString());
|
||||
break;
|
||||
}
|
||||
|
||||
case PlanOverlayModel::ColumnSection::MaxScale:
|
||||
{
|
||||
QPushButton *pbMaxScale = qobject_cast<QPushButton *>(editor);
|
||||
if (pbMaxScale) pbMaxScale->setText(modelData.toString());
|
||||
break;
|
||||
}
|
||||
|
||||
case PlanOverlayModel::ColumnSection::Opacity:
|
||||
{
|
||||
QSlider *slOpacity = qobject_cast<QSlider *>(editor);
|
||||
if (slOpacity) slOpacity->setValue(int(modelData.toDouble() * 100));
|
||||
break;
|
||||
}
|
||||
case PlanOverlayModel::ColumnSection::ExerciseId:
|
||||
case PlanOverlayModel::ColumnSection::PhaseId:
|
||||
case PlanOverlayModel::ColumnSection::OrderButtons:
|
||||
case PlanOverlayModel::ColumnSection::CustomSection:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override
|
||||
{
|
||||
Q_UNUSED(editor);
|
||||
Q_UNUSED(model);
|
||||
Q_UNUSED(index);
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
PlanOverlayView::PlanOverlayView(PlanOverlayModel *model, QWidget *parent)
|
||||
: QTableView(parent)
|
||||
{
|
||||
setModel(model);
|
||||
connect(model, &PlanOverlayModel::dropPlanAccepted, this, [this]()
|
||||
{
|
||||
setCurrentIndex(QModelIndex());
|
||||
PlanOverlayView::clearSelection();
|
||||
});
|
||||
connect (model, &PlanOverlayModel::layoutChanged, this, &PlanOverlayView::onLayoutChanged);
|
||||
|
||||
setSelectionMode(SelectionMode::SingleSelection);
|
||||
setSelectionBehavior(SelectionBehavior::SelectRows);
|
||||
|
||||
setItemDelegate(new WidgetItemDelegate(this));
|
||||
setEditTriggers(QAbstractItemView::AllEditTriggers);
|
||||
|
||||
setDragEnabled(true);
|
||||
setAcceptDrops(true);
|
||||
setDragDropMode(QAbstractItemView::DragDrop);
|
||||
setDragDropOverwriteMode(false);
|
||||
setDropIndicatorShown(true);
|
||||
setSortingEnabled(false);
|
||||
setShowGrid(false);
|
||||
|
||||
horizontalHeader()->setSectionResizeMode(int(PlanOverlayModel::ColumnSection::PlanName), QHeaderView::ResizeMode::Stretch);
|
||||
resizeColumnsToContents();
|
||||
resizeRowsToContents();
|
||||
horizontalHeader()->reset();
|
||||
|
||||
onLayoutChanged();
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayView::~PlanOverlayView()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onLayoutChanged()
|
||||
{
|
||||
clearSelection();
|
||||
if (model() != nullptr)
|
||||
{
|
||||
for (int row = 0; row < model()->rowCount(); ++row)
|
||||
{
|
||||
for (int col = 0; col < model()->columnCount(); ++col)
|
||||
openPersistentEditor(model()->index(row, col, QModelIndex()));
|
||||
}
|
||||
}
|
||||
|
||||
resizeRowsToContents();
|
||||
resizeColumnsToContents();
|
||||
horizontalHeader()->setSectionResizeMode(int(PlanOverlayModel::ColumnSection::PlanName), QHeaderView::ResizeMode::Stretch);
|
||||
}
|
||||
|
||||
|
||||
int PlanOverlayView::getPlanKeyIdOfRow(int row) const
|
||||
{
|
||||
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
||||
|
||||
if (nullptr == poModel) return -1;
|
||||
|
||||
if (row < 0) return -1;
|
||||
if (row >= poModel->rowCount(QModelIndex())) return -1;
|
||||
|
||||
const PlanOverlayModel::PlanItem &planItem = poModel->planItemAtRow(row);
|
||||
|
||||
return (planItem.isValid()) ? planItem.m_keyId : -1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
QString PlanOverlayView::getPlanNameOfRow(int row) const
|
||||
{
|
||||
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
||||
|
||||
if (nullptr == poModel) return QString();
|
||||
|
||||
if (row < 0) return QString();
|
||||
if (row >= poModel->rowCount(QModelIndex())) return QString();
|
||||
|
||||
const PlanOverlayModel::PlanItem &planItem = poModel->planItemAtRow(row);
|
||||
|
||||
return (planItem.isValid()) ? planItem.m_fileName : QString();
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onSetMinScale()
|
||||
{
|
||||
QPushButton *senderButton = qobject_cast<QPushButton *>(sender());
|
||||
if (nullptr == senderButton) return;
|
||||
|
||||
int row = senderButton->property("row").toInt();
|
||||
int keyId = getPlanKeyIdOfRow(row);
|
||||
|
||||
if (keyId < 0) return;
|
||||
|
||||
emit requestMinScale(keyId, model()->data(model()->index(row, int(PlanOverlayModel::ColumnSection::PlanName), QModelIndex()), Qt::ItemDataRole::DisplayRole).toString());
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onSetMaxScale()
|
||||
{
|
||||
QPushButton *senderButton = qobject_cast<QPushButton *>(sender());
|
||||
if (nullptr == senderButton) return;
|
||||
|
||||
int row = senderButton->property("row").toInt();
|
||||
int keyId = getPlanKeyIdOfRow(row);
|
||||
|
||||
if (keyId < 0) return;
|
||||
|
||||
emit requestMaxScale(keyId, model()->data(model()->index(row, int(PlanOverlayModel::ColumnSection::PlanName), QModelIndex()), Qt::ItemDataRole::DisplayRole).toString());
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onReloadOverlayById()
|
||||
{
|
||||
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
||||
if (nullptr == senderButton) return;
|
||||
|
||||
int row = senderButton->property("row").toInt();
|
||||
int keyId = getPlanKeyIdOfRow(row);
|
||||
|
||||
if (keyId < 0) return;
|
||||
|
||||
emit requestReloadPlanById(keyId);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onReloadOverlayByName()
|
||||
{
|
||||
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
||||
if (nullptr == senderButton) return;
|
||||
|
||||
int row = senderButton->property("row").toInt();
|
||||
QString planName = getPlanNameOfRow(row);
|
||||
|
||||
if (planName.isEmpty()) return;
|
||||
|
||||
emit requestReloadPlanByName(planName);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void PlanOverlayView::onUnloadOverlay()
|
||||
{
|
||||
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
||||
if (nullptr == senderButton) return;
|
||||
|
||||
int keyId = getPlanKeyIdOfRow(senderButton->property("row").toInt());
|
||||
|
||||
if (keyId >= 0)
|
||||
emit requestUnloadPlan(keyId);
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onChangeLayerOpacity(int sliderValue)
|
||||
{
|
||||
QSlider *senderSlider = qobject_cast<QSlider *>(sender());
|
||||
if (nullptr == senderSlider) return;
|
||||
|
||||
int row = senderSlider->property("row").toInt();
|
||||
|
||||
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
||||
|
||||
if (nullptr == poModel) return;
|
||||
if (row < 0) return;
|
||||
if (row >= poModel->rowCount(QModelIndex())) return;
|
||||
|
||||
poModel->setOpacity(row, double(sliderValue) / 100.0);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onChangeLayerOrderUp()
|
||||
{
|
||||
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
||||
if (nullptr == senderButton) return;
|
||||
|
||||
int row = senderButton->property("row").toInt();
|
||||
|
||||
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
||||
|
||||
if (nullptr == poModel) return;
|
||||
if (row < 1) return;
|
||||
if (row >= poModel->rowCount(QModelIndex())) return;
|
||||
|
||||
poModel->swapRow(row, row - 1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void PlanOverlayView::onChangeLayerOrderDown()
|
||||
{
|
||||
LtsWidgets::LtsDragIcon *senderButton = qobject_cast<LtsWidgets::LtsDragIcon *>(sender());
|
||||
if (nullptr == senderButton) return;
|
||||
|
||||
int row = senderButton->property("row").toInt();
|
||||
|
||||
PlanOverlayModel *poModel = dynamic_cast<PlanOverlayModel *>(model());
|
||||
|
||||
if (nullptr == poModel) return;
|
||||
if (row < 0) return;
|
||||
if (row + 1 >= poModel->rowCount(QModelIndex())) return;
|
||||
|
||||
poModel->swapRow(row, row + 1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
#include <plan_overlay_view.moc>
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <QtWidgets/QTableView>
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
class PlanOverlayModel;
|
||||
|
||||
class PlanOverlayView final : public QTableView
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
|
||||
explicit PlanOverlayView(PlanOverlayModel *model, QWidget *parent = nullptr);
|
||||
~PlanOverlayView();
|
||||
|
||||
signals:
|
||||
|
||||
void requestReloadPlanById(int planId);
|
||||
void requestReloadPlanByName(const QString &planName);
|
||||
void requestUnloadPlan(int planId);
|
||||
|
||||
void requestMinScale(int planId, const QString &planName);
|
||||
void requestMaxScale(int planId, const QString &planName);
|
||||
|
||||
public slots:
|
||||
|
||||
void onSetMinScale();
|
||||
void onSetMaxScale();
|
||||
void onChangeLayerOrderUp();
|
||||
void onChangeLayerOrderDown();
|
||||
void onChangeLayerOpacity(int);
|
||||
|
||||
void onReloadOverlayById();
|
||||
void onReloadOverlayByName();
|
||||
void onUnloadOverlay();
|
||||
|
||||
protected:
|
||||
|
||||
void onLayoutChanged();
|
||||
|
||||
int getPlanKeyIdOfRow(int row) const;
|
||||
QString getPlanNameOfRow(int row) const;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
+928
@@ -0,0 +1,928 @@
|
||||
|
||||
|
||||
|
||||
#include "plan_overlays_gui_plugin.h"
|
||||
#include "plan_overlay_model.h"
|
||||
#include "plan_overlay_dialog.h"
|
||||
#include "TopicEditor/topic_editor.h"
|
||||
#include "flm_reply_handler.h"
|
||||
|
||||
#include <LtsUtilsCore/pgarray.h>
|
||||
#include <LtsUtilsCore/dds_vector.h>
|
||||
#include <NGLLogger/INGLLogger.h>
|
||||
#include <NGLLogger/NGLLoggerBootstrap.h>
|
||||
#include <LtsWidgets/lts_base_layout_widget.h>
|
||||
#include <LtsWidgets/lts_message_dialog.h>
|
||||
#include <LtsSession/lts_session.h>
|
||||
#include <LtsSession/lts_session_data.h>
|
||||
#include <LtsUtilsGuiDds/request_helper.h>
|
||||
#include <PluginInterfaces/style_plugin_interface.h>
|
||||
#include <PluginInterfaces/project_plugin_interface.h>
|
||||
#include <Services/OperatorManagement/opm_dtc.h>
|
||||
#include <Services/ExerciseManagement/exm_dtc.h>
|
||||
#include <Services/PlanEditor/ped_operator_rights.h>
|
||||
#include <Plugins/OperatorManagement/opm_data_plugin_interface.h>
|
||||
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
|
||||
#include <Plugins/FileManagement/flm_data_plugin_interface.h>
|
||||
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
|
||||
#include <Plugins/FileManagement/Gui/Explorer/TopicEditor/topic_editor.h>
|
||||
#include <Plugins/SituationMapPlugin/situation_map_gui_plugin_interface.h>
|
||||
#include <Viewer/SituationMap/Map/map.h>
|
||||
#include <Viewer/SituationMap/GeometryModel/geometry_model_factory.h>
|
||||
|
||||
#include <QCoreApplication>
|
||||
#include <QDateTime>
|
||||
#include <QFile>
|
||||
#include <QPointer>
|
||||
#include <QStandardPaths>
|
||||
#include <QHBoxLayout>
|
||||
#include <QMainWindow>
|
||||
#include <QtGlobal>
|
||||
|
||||
#include <QDebug>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
std::shared_ptr<GuiPluginBase::Interface> PlanOverlaysGuiPlugin::createGuiInterface(LtsSession::LtsSession * session)
|
||||
{
|
||||
return std::make_shared<InterfaceImpl>(session);
|
||||
}
|
||||
|
||||
|
||||
static NGL::INGLLogger &getLogger()
|
||||
{
|
||||
try
|
||||
{
|
||||
return NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("PlanOverLaysPlugin");
|
||||
}
|
||||
catch (const std::exception &ex)
|
||||
{
|
||||
fprintf(stderr, "Error retrieving logger: %s", ex.what());
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class InterfaceImpl::InternalData
|
||||
{
|
||||
public:
|
||||
|
||||
FileManagement::FileContent m_planContent;
|
||||
|
||||
std::shared_ptr<FileManagement::Interface::Dtc> m_dtc;
|
||||
std::shared_ptr<FileManagement::Interface::Ftc> m_ftc;
|
||||
|
||||
std::shared_ptr<OperatorManagement::Interface::Dtc> m_opmDtc;
|
||||
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
|
||||
|
||||
LtsUtils::RequestHelper * m_requestHelper;
|
||||
FileManagementReplyHandler * m_flmReplyHandler;
|
||||
|
||||
PlanOverlayModel * m_overlayModel;
|
||||
|
||||
std::shared_ptr<SituationMap::ForeignGuiInterface> m_situationMapGui;
|
||||
|
||||
SituationMap::ForeignGuiInterface * m_foreignSitmapIfc;
|
||||
|
||||
QString m_messageBoxTitle;
|
||||
|
||||
InternalData()
|
||||
: m_requestHelper(nullptr)
|
||||
, m_flmReplyHandler(nullptr)
|
||||
, m_overlayModel(nullptr)
|
||||
, m_foreignSitmapIfc(nullptr)
|
||||
{}
|
||||
|
||||
~InternalData() = default;
|
||||
|
||||
};
|
||||
|
||||
|
||||
InterfaceImpl::InterfaceImpl(LtsSession::LtsSession * session)
|
||||
: QObject()
|
||||
, GuiPluginBase::Interface(session, getLogger())
|
||||
, m_internal(new InternalData())
|
||||
, m_foreignIfc(nullptr)
|
||||
|
||||
{
|
||||
m_internal->m_requestHelper = new LtsUtils::RequestHelper(this);
|
||||
m_internal->m_flmReplyHandler = new FileManagementReplyHandler(m_internal->m_requestHelper);
|
||||
|
||||
m_internal->m_messageBoxTitle = tr("Plan Overlays");
|
||||
}
|
||||
|
||||
|
||||
bool InterfaceImpl::fetchInterfaces()
|
||||
{
|
||||
|
||||
if (!m_session->getDtc<FileManagement::DataInterface>(m_internal->m_dtc))
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "getDtc for FileManagement::DataInterface failed.";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!m_session->getDtc<OperatorManagement::DataInterface>(m_internal->m_opmDtc))
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "getDtc for OperatorManagement::DataInterface failed.";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!m_session->getDtc<ExerciseManagement::DataInterface>(m_internal->m_exmDtc))
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "getDtc for ExerciseManagement::DataInterface failed.";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!m_session->getFtc<FileManagement::DataInterface>(m_internal->m_ftc))
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "getFtc for FileManagement::DataInterface failed.";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!m_session->getForeignGuiInterface(m_internal->m_situationMapGui))
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "getForeignGuiInterface for SituationMap::ForeignGuiInterface failed.";
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
m_internal->m_foreignSitmapIfc = m_internal->m_situationMapGui.get();
|
||||
|
||||
|
||||
delete m_internal->m_overlayModel;
|
||||
m_internal->m_overlayModel = new PlanOverlayModel();
|
||||
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::requestLoadPlan , this, &InterfaceImpl::loadPlanByUser, Qt::ConnectionType::DirectConnection);
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::requestUpdatePlan , this, &InterfaceImpl::onUpdatePlan , Qt::ConnectionType::DirectConnection);
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::requestRemovePlan , this, QOverload<int>::of(&InterfaceImpl::removePlan) , Qt::ConnectionType::DirectConnection);
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::planMinScaleChanged , this, &InterfaceImpl::onChangePlanMinScaleOnMap , Qt::ConnectionType::DirectConnection);
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::planMaxScaleChanged , this, &InterfaceImpl::onChangePlanMaxScaleOnMap , Qt::ConnectionType::DirectConnection);
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::planOpacityChanged , this, &InterfaceImpl::onChangePlanOpacityOnMap , Qt::ConnectionType::DirectConnection);
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::planOrderChanged , this, &InterfaceImpl::onChangePlanOrderOnMap , Qt::ConnectionType::DirectConnection);
|
||||
|
||||
connect(m_internal->m_overlayModel, &PlanOverlayModel::requestReloadPlanByName, this, &InterfaceImpl::onReloadPlanByName, static_cast<Qt::ConnectionType>(Qt::DirectConnection|Qt::UniqueConnection));
|
||||
|
||||
m_internal->m_ftc->enableFileContentModify();
|
||||
m_internal->m_ftc->enableGetFileContentData();
|
||||
|
||||
connect(m_internal->m_dtc.get(), &FileManagement::Interface::Dtc::fileContentChanged, this, &InterfaceImpl::onPlanContentChanged, Qt::UniqueConnection);
|
||||
connect(m_internal->m_exmDtc.get(), &ExerciseManagement::Interface::Dtc::exerciseChanged, this, &InterfaceImpl::onExerciseChanged, Qt::UniqueConnection);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::setForeignSitMapGuiIfc(SituationMap::ForeignGuiInterface *foreignSitmapIfc)
|
||||
{
|
||||
|
||||
m_internal->m_foreignSitmapIfc = foreignSitmapIfc;
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::setForeignPlanOverlaysGuiIfc(ForeignGuiInterface *ifc)
|
||||
{
|
||||
m_foreignIfc = ifc;
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::clearInterfaces()
|
||||
{
|
||||
if (!m_internal)
|
||||
return;
|
||||
|
||||
m_internal->m_dtc.reset();
|
||||
m_internal->m_opmDtc.reset();
|
||||
m_internal->m_exmDtc.reset();
|
||||
m_internal->m_ftc.reset();
|
||||
m_internal->m_situationMapGui.reset();
|
||||
m_internal->m_foreignSitmapIfc = nullptr;
|
||||
}
|
||||
|
||||
|
||||
PlanOverlayModel *InterfaceImpl::planOverlayModel()
|
||||
{
|
||||
return m_internal->m_overlayModel;
|
||||
}
|
||||
|
||||
bool InterfaceImpl::loadPlanByUser(int planFileId)
|
||||
{
|
||||
return loadPlan(planFileId, true, nullptr);
|
||||
}
|
||||
|
||||
|
||||
bool InterfaceImpl::loadPlan(int planFileId)
|
||||
{
|
||||
return loadPlan(planFileId, QJsonObject());
|
||||
}
|
||||
|
||||
bool InterfaceImpl::loadPlan(int planFileId, const QJsonObject &planItemObject)
|
||||
{
|
||||
return loadPlan(planFileId, false, nullptr, planItemObject);
|
||||
}
|
||||
|
||||
|
||||
bool InterfaceImpl::loadPlan(int planFileId,
|
||||
bool applyMinMaxScaleOfMetadata,
|
||||
SituationMap::ForeignGuiInterface* overrideSitMapIfc,
|
||||
const QJsonObject &planItemObject)
|
||||
{
|
||||
|
||||
|
||||
if (overrideSitMapIfc == nullptr)
|
||||
overrideSitMapIfc = m_internal->m_foreignSitmapIfc;
|
||||
|
||||
if (overrideSitMapIfc == nullptr)
|
||||
{
|
||||
ERROR_LOG(m_logger) << "no sit map ifc to load a plan on!";
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
m_internal->m_dtc->waitForHistoricalDataFileContent(5000);
|
||||
FileManagement::FileContent fileContent = m_internal->m_dtc->fileContent(planFileId);
|
||||
|
||||
|
||||
if (fileContent.id() <= 0)
|
||||
{
|
||||
ERROR_LOG(m_logger) << "Could not find plan with id " << planFileId << " in filemanagement - removing";
|
||||
return false;
|
||||
}
|
||||
|
||||
QString nameOfPlan = QString::fromStdString(fileContent.name());
|
||||
|
||||
std::function<void(const Core::FunctionReply &baseReply)> handleContent = [this, fileContent, applyMinMaxScaleOfMetadata, nameOfPlan, overrideSitMapIfc, planItemObject](const Core::FunctionReply &)
|
||||
{
|
||||
const QByteArray &planXMLContent = LtsUtils::toQByteArray(m_internal->m_flmReplyHandler->getContent());
|
||||
|
||||
int planFileId = fileContent.id();
|
||||
|
||||
|
||||
if (!overrideSitMapIfc->planOverlaySetContent(planFileId, nameOfPlan, planXMLContent))
|
||||
{
|
||||
ERROR_LOG(m_logger) << "no sit map ifc to load a plan on!";
|
||||
return false;
|
||||
}
|
||||
|
||||
PlanOverlaysPlugin::PlanOverlayModel::PlanItem planItem = m_internal->m_overlayModel->findPlanItemByFileId(planFileId);
|
||||
|
||||
if (!planItem.isValid())
|
||||
planItem = m_internal->m_overlayModel->planItem(-1);
|
||||
|
||||
planItem.m_folderId = fileContent.folderId();
|
||||
if (fileContent.exerciseId().is_set())
|
||||
{
|
||||
planItem.m_exerciseId = fileContent.exerciseId().get();
|
||||
if (fileContent.phaseId().is_set())
|
||||
planItem.m_phaseId = fileContent.phaseId().get();
|
||||
}
|
||||
planItem.m_fileId = planFileId;
|
||||
planItem.m_fileName = nameOfPlan;
|
||||
|
||||
|
||||
if (applyMinMaxScaleOfMetadata)
|
||||
{
|
||||
|
||||
QScopedPointer<SituationMap::GeometryModel> geoModel(SituationMap::GeometryModelFactory::singleton()->create());
|
||||
if (geoModel->fromByteArray(planXMLContent))
|
||||
{
|
||||
const QString &minScaleStr = geoModel->getModelAttribute(SituationMap::GeometryModel::Attribute::MetaDataMinScale).toString();
|
||||
const QString &maxScaleStr = geoModel->getModelAttribute(SituationMap::GeometryModel::Attribute::MetaDataMaxScale).toString();
|
||||
|
||||
bool ok = false;
|
||||
double minScale = minScaleStr.toDouble(&ok);
|
||||
if (ok)
|
||||
planItem.m_minScale = minScale;
|
||||
else
|
||||
planItem.m_minScale = 0.0;
|
||||
|
||||
double maxScale = maxScaleStr.toDouble(&ok);
|
||||
if (ok)
|
||||
planItem.m_maxScale = maxScale;
|
||||
else
|
||||
planItem.m_maxScale = 0.0;
|
||||
|
||||
DEBUG_LOG(m_logger) << " load plan and set minMaxScale:"
|
||||
<< " minScaleStr = " << minScaleStr
|
||||
<< " maxScaleStr = " << maxScaleStr
|
||||
<< " planItem.m_minScale = " << planItem.m_minScale
|
||||
<< " planItem.m_maxScale = " << planItem.m_maxScale;
|
||||
|
||||
overrideSitMapIfc->setPlanOverlayMinScale(planFileId, planItem.m_minScale);
|
||||
overrideSitMapIfc->setPlanOverlayMaxScale(planFileId, planItem.m_maxScale);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
if (planItemObject.isEmpty())
|
||||
{
|
||||
|
||||
|
||||
planItem.m_opacity = overrideSitMapIfc->planOverlayOpacity(planFileId);
|
||||
planItem.m_maxScale = overrideSitMapIfc->planOverlayMaxScale(planFileId);
|
||||
planItem.m_minScale = overrideSitMapIfc->planOverlayMinScale(planFileId);
|
||||
planItem.m_visibility = overrideSitMapIfc->planOverlayVisibility(planFileId);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
planItem.m_opacity = planItemObject[QStringLiteral("opacity")].toDouble(0.);
|
||||
planItem.m_maxScale = planItemObject[QStringLiteral("maxScale")].toDouble(0.);
|
||||
planItem.m_minScale = planItemObject[QStringLiteral("minScale")].toDouble(0.);
|
||||
planItem.m_visibility = planItemObject[QStringLiteral("visibility")].toBool(true);
|
||||
|
||||
overrideSitMapIfc->setPlanOverlayOpacity(planFileId, planItem.m_opacity);
|
||||
overrideSitMapIfc->setPlanOverlayMaxScale(planFileId, planItem.m_maxScale);
|
||||
overrideSitMapIfc->setPlanOverlayMinScale(planFileId, planItem.m_minScale);
|
||||
overrideSitMapIfc->setPlanOverlayVisibility(planFileId, planItem.m_visibility);
|
||||
}
|
||||
|
||||
m_internal->m_overlayModel->updatePlanItem(planItem);
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
|
||||
bool ok = m_internal->m_requestHelper->startSingleRequest([this, planFileId]()
|
||||
{
|
||||
FileManagement::GetFileContentDataRequest req;
|
||||
req.fileContentId(planFileId);
|
||||
return m_internal->m_ftc->getFileContentDataRequest(req, m_internal->m_flmReplyHandler);
|
||||
}, handleContent);
|
||||
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool InterfaceImpl::unloadAllPlans()
|
||||
{
|
||||
DEBUG_LOG(m_logger) << LOGFUNCTION << " START";
|
||||
|
||||
const QMap<unsigned int, PlanOverlayModel::PlanItem> &planStore = m_internal->m_overlayModel->planStore();
|
||||
|
||||
QMapIterator<unsigned int, PlanOverlayModel::PlanItem> mapIt(planStore);
|
||||
while (mapIt.hasNext())
|
||||
{
|
||||
mapIt.next();
|
||||
unsigned int planId = mapIt.key();
|
||||
DEBUG_LOG(m_logger) << LOGFUNCTION << " removeOverlay, planId=" << planId;
|
||||
|
||||
|
||||
m_internal->m_overlayModel->removeOverlay(planId);
|
||||
}
|
||||
DEBUG_LOG(m_logger) << LOGFUNCTION << " END";
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::onUpdatePlan(int planId)
|
||||
{
|
||||
PlanOverlaysPlugin::PlanOverlayModel::PlanItem planItem = m_internal->m_overlayModel->planItemValue(planId);
|
||||
if (!planItem.isValid())
|
||||
{
|
||||
ERROR_LOG(m_logger) << "plan item with id " << planId << " not found in model";
|
||||
return;
|
||||
}
|
||||
|
||||
int planFileId = planItem.m_fileId;
|
||||
FileManagement::FileContent fileContent = m_internal->m_dtc->fileContent(planFileId);
|
||||
|
||||
planItem.m_fileName = QString::fromStdString(fileContent.name());
|
||||
|
||||
std::function<void(const Core::FunctionReply &baseReply)> handleContent = [this,planFileId,planItem](const Core::FunctionReply &baseReply)
|
||||
{
|
||||
const FileManagement::GetFileContentDataReply &reply = static_cast<const FileManagement::GetFileContentDataReply &>(baseReply);
|
||||
|
||||
const QByteArray &planXMLContent = LtsUtils::toQByteArray(reply.content());
|
||||
|
||||
|
||||
if (!m_internal->m_foreignSitmapIfc->planOverlaySetContent(planFileId, planItem.m_fileName, planXMLContent))
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error rendering planContent [" << planItem.m_fileName << "]";
|
||||
return false;
|
||||
}
|
||||
|
||||
m_internal->m_overlayModel->renewPlanItem(planItem);
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
bool ok = m_internal->m_requestHelper->startSingleRequest([this, planFileId]()
|
||||
{
|
||||
FileManagement::GetFileContentDataRequest req;
|
||||
req.fileContentId(planFileId);
|
||||
return m_internal->m_ftc->getFileContentDataRequest(req, m_internal->m_flmReplyHandler);
|
||||
}, handleContent);
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error reading planContent [" << planItem.m_fileName << "]";
|
||||
LtsWidgets::LtsMessageDialog::showMessage(m_session->baseLayout(), tr("Reading plan '%1' from database failed").arg(planItem.m_fileName), m_internal->m_messageBoxTitle);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
InterfaceImpl::~InterfaceImpl()
|
||||
{
|
||||
delete m_internal->m_requestHelper;
|
||||
delete m_internal->m_flmReplyHandler;
|
||||
delete m_internal->m_overlayModel;
|
||||
delete m_internal; m_internal = nullptr;
|
||||
}
|
||||
|
||||
|
||||
QString InterfaceImpl::menuGroup() const { return tr("Situation Map"); }
|
||||
|
||||
|
||||
QVector<LtsWidgets::PluginData> InterfaceImpl::getActions()
|
||||
{
|
||||
QVector<LtsWidgets::PluginData> actionVector;
|
||||
|
||||
{
|
||||
LtsWidgets::PluginData pluginAction;
|
||||
|
||||
pluginAction.menuGroup = menuGroup();
|
||||
|
||||
pluginAction.menuText = tr("Managing Plan Overlays");
|
||||
pluginAction.menuIcon = QIcon(QStringLiteral("icon:overlay_plans.svg"));
|
||||
pluginAction.identifier = QStringLiteral("manage_plan_overlay");
|
||||
pluginAction.tooltip = tr("Loading plan overlays, changing order of plan overlays and modifying overlay settings");
|
||||
pluginAction.operatorRight = OperatorRights::PlanEditor::TacticalPlansShow;
|
||||
pluginAction.exercisePart = LtsWidgets::ExercisePart::eSpecial;
|
||||
pluginAction.directFunc = [this](const LtsWidgets::PluginData &)
|
||||
{
|
||||
if (m_planOverlayDialog)
|
||||
{
|
||||
m_planOverlayDialog->show();
|
||||
m_planOverlayDialog->raise();
|
||||
} else {
|
||||
m_planOverlayDialog = openPlanOverlayDialog();
|
||||
}
|
||||
};
|
||||
|
||||
actionVector << pluginAction;
|
||||
}
|
||||
return actionVector;
|
||||
}
|
||||
|
||||
|
||||
QWidget *InterfaceImpl::openPlanOverlayDialog(const QJsonArray &planItems, bool removePlansOnClose)
|
||||
{
|
||||
auto doReadFile = [this](int selectedFileId)
|
||||
{
|
||||
if (selectedFileId > 0)
|
||||
loadPlanByUser(selectedFileId);
|
||||
};
|
||||
|
||||
auto doUnloadPlan = [this](int planId)
|
||||
{
|
||||
if (planId > 0)
|
||||
m_internal->m_overlayModel->removeOverlay(planId);
|
||||
};
|
||||
|
||||
auto doReloadPlan = [this](int planId)
|
||||
{
|
||||
if (planId > 0)
|
||||
onReloadPlanById(planId);
|
||||
};
|
||||
|
||||
|
||||
for (const QJsonValue &planItemValue : qAsConst(planItems))
|
||||
{
|
||||
if (!planItemValue.isObject())
|
||||
{
|
||||
WARNING_LOG(m_logger) << "planItem from json array is not an object! " << planItemValue.type();
|
||||
continue;
|
||||
}
|
||||
|
||||
QJsonObject planItemObj(planItemValue.toObject());
|
||||
int planFileId = planItemObj[QStringLiteral("fileId")].toInt(-1);
|
||||
|
||||
if (!loadPlan(planFileId, planItemObj))
|
||||
ERROR_LOG(m_logger) << "could not load plan with file id " << planFileId;
|
||||
}
|
||||
|
||||
|
||||
#define USE_QDIALOG 1
|
||||
|
||||
#ifdef USE_QDIALOG
|
||||
PlanOverlayDialog<QDialog> * overlayDialog = new PlanOverlayDialog<QDialog>(m_internal->m_foreignSitmapIfc, m_internal->m_overlayModel, m_session->baseLayout(), m_session);
|
||||
#else
|
||||
PlanOverlayDialog<LtsWidgets::LtsDialog> * overlayDialog = new PlanOverlayDialog<LtsWidgets::LtsDialog>(m_session, sitMapIfc, m_internal->m_overlayModel, m_session->baseLayout());
|
||||
#endif
|
||||
|
||||
overlayDialog->dialogWidget()->initFileManagement(m_internal->m_dtc, m_internal->m_opmDtc, m_internal->m_exmDtc, doReadFile, doReloadPlan, doUnloadPlan, appId() == LtsAppDescriptor::App::OC );
|
||||
overlayDialog->show();
|
||||
|
||||
|
||||
if (removePlansOnClose)
|
||||
{
|
||||
connect(overlayDialog->dialogWidget(), &QObject::destroyed,
|
||||
this, [this]()
|
||||
{
|
||||
auto planStore = m_internal->m_overlayModel->planStore();
|
||||
for (auto i = planStore.constBegin(); i != planStore.constEnd(); ++i)
|
||||
{
|
||||
|
||||
removePlan(i.key());
|
||||
}
|
||||
});
|
||||
}
|
||||
connect(overlayDialog->dialogWidget(), &QObject::destroyed,
|
||||
this, [overlayDialog]() { delete overlayDialog; });
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
return overlayDialog->dialogWidget();
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::onReloadPlanById(int planId)
|
||||
{
|
||||
const PlanOverlaysPlugin::PlanOverlayModel::PlanItem & planItem = m_internal->m_overlayModel->planItem(planId);
|
||||
if (planItem.isValid())
|
||||
{
|
||||
int fileId = planItem.m_fileId;
|
||||
FileManagement::FileContent fileContent = m_internal->m_dtc->fileContent(fileId);
|
||||
QString nameOfPlan = QString::fromStdString(fileContent.name());
|
||||
|
||||
std::function<void(const Core::FunctionReply &baseReply)> handleContent = [this,planId,nameOfPlan](const Core::FunctionReply &baseReply)
|
||||
{
|
||||
const FileManagement::GetFileContentDataReply &reply = static_cast<const FileManagement::GetFileContentDataReply &>(baseReply);
|
||||
|
||||
const QByteArray &planXMLContent = LtsUtils::toQByteArray(reply.content());
|
||||
if (planXMLContent.isEmpty())
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error plan [" << nameOfPlan << "] is empty";
|
||||
return false;
|
||||
}
|
||||
|
||||
PlanOverlaysPlugin::PlanOverlayModel::PlanItem planItem = m_internal->m_overlayModel->planItem(planId);
|
||||
|
||||
if (!m_internal->m_foreignSitmapIfc->planOverlaySetContent(planItem.m_fileId, planItem.m_fileName, planXMLContent))
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error rendering planContent [" << nameOfPlan << "]";
|
||||
return false;
|
||||
}
|
||||
|
||||
planItem.m_fileName = nameOfPlan;
|
||||
|
||||
planItem.m_opacity = m_internal->m_foreignSitmapIfc->planOverlayOpacity(planItem.m_fileId);
|
||||
planItem.m_maxScale = m_internal->m_foreignSitmapIfc->planOverlayMaxScale(planItem.m_fileId);
|
||||
planItem.m_minScale = m_internal->m_foreignSitmapIfc->planOverlayMinScale(planItem.m_fileId);
|
||||
planItem.m_visibility = m_internal->m_foreignSitmapIfc->planOverlayVisibility(planItem.m_fileId);
|
||||
|
||||
m_internal->m_overlayModel->updatePlanItem(planItem);
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
bool ok = m_internal->m_requestHelper->startSingleRequest([this,fileId]() -> bool
|
||||
{
|
||||
FileManagement::GetFileContentDataRequest req;
|
||||
req.fileContentId(fileId);
|
||||
return m_internal->m_ftc->getFileContentDataRequest(req, m_internal->m_flmReplyHandler);
|
||||
}, handleContent);
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error reading planContent [" << nameOfPlan << "]";
|
||||
const QString & msg = tr("Reading plan '%1' from database failed").arg(nameOfPlan);
|
||||
LtsWidgets::LtsMessageDialog::showMessage(m_session->baseLayout(), msg, m_internal->m_messageBoxTitle);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool InterfaceImpl::removePlan(int planId)
|
||||
{
|
||||
return removePlan(planId, nullptr);
|
||||
}
|
||||
|
||||
|
||||
bool InterfaceImpl::removePlan(int planId, SituationMap::ForeignGuiInterface* overrideSitMapIfc)
|
||||
{
|
||||
if (overrideSitMapIfc == nullptr)
|
||||
overrideSitMapIfc = m_internal->m_foreignSitmapIfc;
|
||||
|
||||
if (overrideSitMapIfc == nullptr)
|
||||
{
|
||||
ERROR_LOG(m_logger) << "no sit map ifc to remove a plan from for planId " << planId;
|
||||
return false;
|
||||
}
|
||||
|
||||
const PlanOverlaysPlugin::PlanOverlayModel::PlanItem & planItem = m_internal->m_overlayModel->planItem(planId);
|
||||
if (!planItem.isValid())
|
||||
{
|
||||
ERROR_LOG(m_logger) << "plan item invalid for planId " << planId;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!overrideSitMapIfc->planOverlayRemove(planItem.m_fileId))
|
||||
{
|
||||
|
||||
if (!overrideSitMapIfc->planOverlayRemove(planId))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void InterfaceImpl::onChangePlanMinScaleOnMap(int planId, double minScale)
|
||||
{
|
||||
const PlanOverlaysPlugin::PlanOverlayModel::PlanItem & planItem = m_internal->m_overlayModel->planItem(planId);
|
||||
if (planItem.isValid())
|
||||
m_internal->m_foreignSitmapIfc->setPlanOverlayMinScale(planItem.m_fileId, minScale);
|
||||
}
|
||||
|
||||
void InterfaceImpl::onChangePlanMaxScaleOnMap(int planId, double maxScale)
|
||||
{
|
||||
const PlanOverlaysPlugin::PlanOverlayModel::PlanItem & planItem = m_internal->m_overlayModel->planItem(planId);
|
||||
if (planItem.isValid())
|
||||
m_internal->m_foreignSitmapIfc->setPlanOverlayMaxScale(planItem.m_fileId, maxScale);
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::onChangePlanOpacityOnMap(int planId, double opacity)
|
||||
{
|
||||
const PlanOverlaysPlugin::PlanOverlayModel::PlanItem & planItem = m_internal->m_overlayModel->planItem(planId);
|
||||
if (planItem.isValid())
|
||||
m_internal->m_foreignSitmapIfc->setPlanOverlayOpacity(planItem.m_fileId, opacity);
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::onChangePlanOrderOnMap(const QVector<int> &newIdOrder)
|
||||
{
|
||||
QVector<int> layerOrder;
|
||||
|
||||
|
||||
|
||||
|
||||
layerOrder.reserve(newIdOrder.size());
|
||||
for (int planId : newIdOrder)
|
||||
{
|
||||
const PlanOverlaysPlugin::PlanOverlayModel::PlanItem & planItem = m_internal->m_overlayModel->planItem(planId);
|
||||
if (planItem.isValid())
|
||||
{
|
||||
layerOrder.push_front(planItem.m_fileId);
|
||||
}
|
||||
}
|
||||
|
||||
m_internal->m_foreignSitmapIfc->planOverlayChangeOrder(layerOrder);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::onPlanContentChanged(const FileManagement::FileContent &data, DataModification modType)
|
||||
{
|
||||
if (data.fileType() != FileManagement::FileType::TacticalPlan) return;
|
||||
|
||||
const PlanOverlaysPlugin::PlanOverlayModel::PlanItem &planItem = m_internal->m_overlayModel->findPlanItemByFileId(data.id());
|
||||
|
||||
if (planItem.isValid())
|
||||
{
|
||||
switch (modType)
|
||||
{
|
||||
case DataModification::eModified : m_internal->m_overlayModel->updateOverlay(planItem.m_keyId); break;
|
||||
case DataModification::eRemoved : m_internal->m_overlayModel->removeOverlay(planItem.m_keyId); break;
|
||||
|
||||
default: return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::onExerciseChanged(const ExerciseManagement::Exercise &data, DataModification modType)
|
||||
{
|
||||
switch (modType)
|
||||
{
|
||||
case DataModification::eModified:
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onExerciseChanged - Modified";
|
||||
m_internal->m_overlayModel->reInitModel(data.id(), data.activePhaseId());
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void InterfaceImpl::onReloadPlanByName(const PlanOverlaysPlugin::PlanOverlayModel::PlanItem &planItem, int exerciseId, int phaseId, bool *removeFromModel)
|
||||
{
|
||||
if (removeFromModel)
|
||||
*removeFromModel = false;
|
||||
|
||||
if (planItem.isValid())
|
||||
{
|
||||
int planFileId = m_internal->m_dtc->getFileId(FileManagement::FileType::TacticalPlan, planItem.m_fileName, exerciseId, phaseId);
|
||||
|
||||
DEBUG_LOG(m_logger) << "Plan File Id = " << planFileId;
|
||||
|
||||
if (planFileId < 1)
|
||||
{
|
||||
if (removeFromModel) *removeFromModel = true;
|
||||
INFO_LOG(m_logger) << "Plan overlay will be removed: name = " << planItem.m_fileName;
|
||||
return;
|
||||
}
|
||||
|
||||
FileManagement::FileContent fileContent = m_internal->m_dtc->fileContent(planFileId);
|
||||
QString nameOfPlan = QString::fromStdString(fileContent.name());
|
||||
int planId = planItem.m_keyId;
|
||||
|
||||
std::function<void(const Core::FunctionReply &baseReply)> handleContent = [this, planId, nameOfPlan, fileContent](const Core::FunctionReply &baseReply)
|
||||
{
|
||||
const FileManagement::GetFileContentDataReply &reply = static_cast<const FileManagement::GetFileContentDataReply &>(baseReply);
|
||||
|
||||
const QByteArray &planXMLContent = LtsUtils::toQByteArray(reply.content());
|
||||
if (planXMLContent.isEmpty())
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error plan [" << nameOfPlan << "] is empty";
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
PlanOverlaysPlugin::PlanOverlayModel::PlanItem pi = m_internal->m_overlayModel->planItem(planId);
|
||||
|
||||
|
||||
if (!m_internal->m_foreignSitmapIfc->planOverlayRemove(pi.m_fileId))
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error removing plan overlay from map failed [" << nameOfPlan << "]";
|
||||
}
|
||||
|
||||
|
||||
if (!m_internal->m_foreignSitmapIfc->planOverlaySetContent(fileContent.id(), nameOfPlan, planXMLContent))
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error rendering planContent [" << nameOfPlan << "]";
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
pi.m_fileName = nameOfPlan;
|
||||
pi.m_fileId = fileContent.id();
|
||||
pi.m_folderId = fileContent.folderId();
|
||||
if (fileContent.exerciseId().is_set())
|
||||
{
|
||||
pi.m_exerciseId = fileContent.exerciseId().get();
|
||||
if (fileContent.phaseId().is_set())
|
||||
pi.m_phaseId = fileContent.phaseId().get();
|
||||
}
|
||||
|
||||
|
||||
m_internal->m_overlayModel->updatePlanItem(pi);
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
||||
|
||||
bool ok = m_internal->m_requestHelper->startSingleRequest([this,planFileId]() -> bool
|
||||
{
|
||||
FileManagement::GetFileContentDataRequest req;
|
||||
req.fileContentId(planFileId);
|
||||
return m_internal->m_ftc->getFileContentDataRequest(req, m_internal->m_flmReplyHandler);
|
||||
}, handleContent);
|
||||
|
||||
m_internal->m_overlayModel->updateOrderOfPlans();
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Error reading planContent [" << nameOfPlan << "]";
|
||||
const QString & msg = tr("Reading plan '%1' from database failed").arg(nameOfPlan);
|
||||
LtsWidgets::LtsMessageDialog::showMessage(m_session->baseLayout(), msg, m_internal->m_messageBoxTitle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TopicEditorBase::TopicEditor *InterfaceImpl::createTopicEditor(const TopicEditorBase::TopicData &data)
|
||||
{
|
||||
std::shared_ptr<FileManagement::Interface::Dtc> flmDtc;
|
||||
if (!m_session->getDtc<FileManagement::DataInterface>(flmDtc))
|
||||
WARNING_LOG(m_logger) << "flm dtc missing - plan topic compatibility mode file name resolution not available";
|
||||
|
||||
PlanTopicEditor *editor = new PlanTopicEditor(&m_foreignIfc, flmDtc);
|
||||
editor->setTopicData(data);
|
||||
return editor;
|
||||
}
|
||||
|
||||
|
||||
TopicReplay::Interface *InterfaceImpl::createInterface(TopicEditorBase::TopicType)
|
||||
{
|
||||
return new TopicReplayInterface(m_internal->m_foreignSitmapIfc, this);
|
||||
}
|
||||
|
||||
|
||||
InterfaceImpl::TopicReplayInterface::TopicReplayInterface(SituationMap::ForeignGuiInterface *foreignSitmapIfc, InterfaceImpl *ovr)
|
||||
: m_ovr(ovr)
|
||||
, m_foreignSitmapIfc(foreignSitmapIfc)
|
||||
, m_logger(getLogger())
|
||||
{}
|
||||
|
||||
InterfaceImpl::TopicReplayInterface::~TopicReplayInterface()
|
||||
{
|
||||
playbackStop();
|
||||
}
|
||||
|
||||
|
||||
bool InterfaceImpl::TopicReplayInterface::playbackInit(const QJsonObject &attributes)
|
||||
{
|
||||
if (!m_foreignSitmapIfc)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "No foreign sitMapIfc, use PlanOverlaysPlugin::ForeignGuiInterface::setForeignSitMapGuiIfc() to define SituationMapGuiPlugin interface. Can't load tactical plan for playback ...";
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int planFileId = attributes[QStringLiteral("fileId")].toInt(-1);
|
||||
|
||||
if (planFileId != -1)
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Plan Overlays topic in compatibility mode!";
|
||||
DEBUG_LOG(m_logger) << "Loading plan id = " << planFileId;
|
||||
|
||||
if (!m_ovr->loadPlan(planFileId, false, m_foreignSitmapIfc))
|
||||
return false;
|
||||
|
||||
m_loadedPlanFileIds += planFileId;
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto plans = attributes[QStringLiteral("PlanItems")].toArray();
|
||||
for (const QJsonValue &planItemValue : plans)
|
||||
{
|
||||
if (!planItemValue.isObject())
|
||||
{
|
||||
ERROR_LOG(m_logger) << "PlanItem from json array is not an object! " << planItemValue.type();
|
||||
continue;
|
||||
}
|
||||
|
||||
const QJsonObject planItemObj(planItemValue.toObject());
|
||||
planFileId = planItemObj[QStringLiteral("fileId")].toInt(-1);
|
||||
|
||||
if (!m_ovr->loadPlan(planFileId, planItemObj))
|
||||
{
|
||||
ERROR_LOG(m_logger) << "could not load plan with file id " << planFileId;
|
||||
continue;
|
||||
}
|
||||
|
||||
m_loadedPlanFileIds += planFileId;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool InterfaceImpl::TopicReplayInterface::playbackStop()
|
||||
{
|
||||
if (nullptr == m_foreignSitmapIfc)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Use PlanOverlaysPlugin::ForeignGuiInterface::setForeignSitMapGuiIfc() to define SituationMapGuiPlugin interface ...";
|
||||
return false;
|
||||
}
|
||||
|
||||
while (!m_loadedPlanFileIds.isEmpty())
|
||||
{
|
||||
int planFileId = m_loadedPlanFileIds.takeFirst();
|
||||
DEBUG_LOG(m_logger) << " removePlan with file id " << planFileId;
|
||||
if (!m_ovr->removePlan(planFileId, m_foreignSitmapIfc))
|
||||
ERROR_LOG(m_logger) << "could not unload plan with file id " << planFileId;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
QVector<TopicEditorBase::TopicData> InterfaceImpl::TopicReplayInterface::additionalTrackEntries(const QJsonObject &attributes, bool &keepOriginalTopic) const
|
||||
{
|
||||
keepOriginalTopic = false;
|
||||
const auto plans = attributes[QStringLiteral("PlanItems")].toArray();
|
||||
QVector<TopicEditorBase::TopicData> ret;
|
||||
ret.reserve(plans.size());
|
||||
for (const QJsonValue &ele : plans)
|
||||
{
|
||||
const auto pi = PlanOverlayModel::PlanItem::fromJson(ele.toObject());
|
||||
if (!pi.isValid())
|
||||
continue;
|
||||
|
||||
TopicEditorBase::TopicData data;
|
||||
data.topicType = TopicEditorBase::TopicType::TacticalPlan;
|
||||
data.properties = QJsonObject({{QStringLiteral("FileId"), pi.m_fileId}});
|
||||
ret += data;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
+188
@@ -0,0 +1,188 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "plan_overlay_model.h"
|
||||
|
||||
#include <PluginInterfaces/gui_plugin_interface.h>
|
||||
#include <TopicEditorBase/topic_editor_interface.h>
|
||||
#include <Common/ProjectConfig/project_defines.h>
|
||||
#include <Plugins/PlanOverlays/plan_overlays_plugin_interface.h>
|
||||
#include <Plugins/FileManagement/flm_data_plugin_interface.h>
|
||||
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
|
||||
|
||||
#include <QObject>
|
||||
|
||||
|
||||
namespace Core
|
||||
{
|
||||
class FunctionReplyObject;
|
||||
}
|
||||
|
||||
namespace SituationMap
|
||||
{
|
||||
class ScriptFilterForeignGuiInterface;
|
||||
}
|
||||
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class PlanOverlaysGuiPlugin final : public QObject, public GuiPluginBase::Plugin
|
||||
{
|
||||
Q_PLUGIN_METADATA(IID "gui:3:planoverlays")
|
||||
Q_INTERFACES(GuiPluginBase::Plugin)
|
||||
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
explicit PlanOverlaysGuiPlugin() = default;
|
||||
~PlanOverlaysGuiPlugin() = default;
|
||||
|
||||
QString pluginName() override { return QStringLiteral("PlanOverlaysPlugin"); }
|
||||
std::shared_ptr<GuiPluginBase::Interface> createGuiInterface(LtsSession::LtsSession *session) override;
|
||||
bool availableInPartition(IDL::PartitionType partition) const override
|
||||
{
|
||||
return (partition == IDL::PartitionType::Global ||
|
||||
partition == IDL::PartitionType::Exercise ||
|
||||
partition == IDL::PartitionType::Replay);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class InterfaceImpl final : public QObject, public ForeignGuiInterface, public GuiPluginBase::Interface
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
class InternalData;
|
||||
InternalData *m_internal;
|
||||
|
||||
public:
|
||||
explicit InterfaceImpl(LtsSession::LtsSession *session);
|
||||
~InterfaceImpl();
|
||||
|
||||
QVector<LtsWidgets::PluginData> getActions() override;
|
||||
|
||||
QString menuGroup() const override;
|
||||
bool fetchInterfaces() override;
|
||||
void clearInterfaces() override;
|
||||
|
||||
|
||||
|
||||
void setForeignSitMapGuiIfc(SituationMap::ForeignGuiInterface *foreignSitmapIfc) override;
|
||||
void setForeignPlanOverlaysGuiIfc(ForeignGuiInterface *ifc) override;
|
||||
|
||||
|
||||
|
||||
bool loadPlanByUser(int planFileId);
|
||||
|
||||
|
||||
|
||||
bool loadPlan(int planFileId) override;
|
||||
|
||||
|
||||
|
||||
bool loadPlan(int planFileId, const QJsonObject &planItemObject) override;
|
||||
|
||||
|
||||
|
||||
bool loadPlan(int planFileId, bool applyMinMaxScaleOfMetadata, SituationMap::ForeignGuiInterface *overrideSitMapIfc, const QJsonObject &planItemObject = QJsonObject());
|
||||
|
||||
|
||||
|
||||
bool unloadAllPlans() override;
|
||||
|
||||
|
||||
TopicEditorBase::TopicEditor *createTopicEditor(const TopicEditorBase::TopicData &data) override;
|
||||
|
||||
QWidget *openPlanOverlayDialog(const QJsonArray &planItems = QJsonArray(), bool removePlansOnClose = false) override;
|
||||
|
||||
PlanOverlayModel *planOverlayModel() override;
|
||||
|
||||
|
||||
private:
|
||||
|
||||
|
||||
void onReloadPlanById(int planId);
|
||||
|
||||
|
||||
|
||||
void onUpdatePlan(int planId);
|
||||
|
||||
|
||||
|
||||
bool removePlan(int planId);
|
||||
|
||||
|
||||
|
||||
bool removePlan(int planId, SituationMap::ForeignGuiInterface *overrideSitMapIfc);
|
||||
|
||||
void onChangePlanMinScaleOnMap(int planId, double minScale);
|
||||
void onChangePlanMaxScaleOnMap(int planId, double maxScale);
|
||||
|
||||
|
||||
|
||||
void onChangePlanOpacityOnMap(int planId, double opacity);
|
||||
|
||||
|
||||
|
||||
void onChangePlanOrderOnMap(const QVector<int> & newIdOrder);
|
||||
|
||||
void onPlanContentChanged(const FileManagement::FileContent &data, DataModification modType);
|
||||
void onExerciseChanged(const ExerciseManagement::Exercise &data, DataModification modType);
|
||||
|
||||
void onReloadPlanByName(const PlanOverlayModel::PlanItem &planItem, int exerciseId, int phaseId, bool *removeFromModel);
|
||||
|
||||
|
||||
|
||||
class TopicReplayInterface : public TopicReplay::Interface
|
||||
{
|
||||
public:
|
||||
TopicReplayInterface(SituationMap::ForeignGuiInterface* overrideSitmapIfc,
|
||||
InterfaceImpl *ovr);
|
||||
|
||||
~TopicReplayInterface();
|
||||
|
||||
bool playbackInit(const QJsonObject &attributes) override;
|
||||
bool playbackStop() override;
|
||||
|
||||
|
||||
bool exportTopic(const QJsonObject &,
|
||||
const QString &,
|
||||
TopicEditorBase::ExportNotifier *) override
|
||||
{
|
||||
Q_ASSERT(false);
|
||||
return false;
|
||||
}
|
||||
QVector<TopicEditorBase::TopicData> additionalTrackEntries(const QJsonObject &attributes, bool &keepOriginalTopic) const override;
|
||||
|
||||
private:
|
||||
InterfaceImpl *m_ovr;
|
||||
SituationMap::ForeignGuiInterface *m_foreignSitmapIfc;
|
||||
|
||||
QVector<int> m_loadedPlanFileIds;
|
||||
NGL::INGLLogger &m_logger;
|
||||
};
|
||||
|
||||
|
||||
TopicReplay::Interface *createInterface(TopicEditorBase::TopicType) override;
|
||||
ForeignGuiInterface *m_foreignIfc;
|
||||
QPointer<QWidget> m_planOverlayDialog;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <PluginInterfaces/topic_replay_interface.h>
|
||||
#include <TopicEditorBase/topic_editor_interface.h>
|
||||
|
||||
#include <QJsonArray>
|
||||
#include <QJsonObject>
|
||||
|
||||
|
||||
namespace SituationMap
|
||||
{
|
||||
class ForeignGuiInterface;
|
||||
}
|
||||
|
||||
namespace PlanOverlaysPlugin
|
||||
{
|
||||
class PlanOverlayModel;
|
||||
|
||||
class ForeignGuiInterface : public TopicReplay::Factory, public TopicEditorBase::Interface
|
||||
{
|
||||
public:
|
||||
|
||||
ForeignGuiInterface() = default;
|
||||
virtual ~ForeignGuiInterface() = default;
|
||||
|
||||
static QString pluginName() { return QStringLiteral("PlanOverlaysGuiPlugin"); }
|
||||
|
||||
|
||||
|
||||
virtual void setForeignSitMapGuiIfc(SituationMap::ForeignGuiInterface *foreignSitMapIfc) = 0;
|
||||
|
||||
virtual void setForeignPlanOverlaysGuiIfc(ForeignGuiInterface *ifc) = 0;
|
||||
|
||||
virtual QWidget *openPlanOverlayDialog(const QJsonArray &planItems = QJsonArray(), bool removePlansOnClose = false) = 0;
|
||||
|
||||
|
||||
|
||||
virtual bool loadPlan(int planFileId, const QJsonObject &planItemObject) = 0;
|
||||
virtual bool loadPlan(int planFileId) = 0;
|
||||
|
||||
|
||||
|
||||
virtual bool unloadAllPlans() = 0;
|
||||
|
||||
virtual PlanOverlayModel *planOverlayModel() = 0;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user