Refactor config modules into core/UI/feature layers

Split Configuration into a core owner plus a registry for non-core
modules. UI modules (ui, console, visualizer, macros) now live under
ui/config/ behind UiConfigs singleton; feature modules (ai, pendant,
heightmap) move to their own directories and plug in via
registerModule() from main().

Add lazy registration: modules registered after Configuration::init()
are loaded from disk immediately. Callers updated to use the new
owners (UiConfigs::instance().ui(), ConfigurationAI::instance(), etc.).

Author: etet100

doc/config_module.md

@@ -0,0 +1,92 @@
+# Configuration module
+
+This note describes how configuration is split between core and non-core
+layers in G-Pilot.
+
+## Layout
+
+```
+src/gpilot/
+├── core/
+│   ├── config/
+│   │   ├── configuration.{h,cpp}     Registry + CORE module owner
+│   │   ├── registry.h                Custom type (de)serialisation
+│   │   ├── module/                   CORE modules only
+│   │   │   ├── abstractconfigurationmodule.{h,cpp}
+│   │   │   ├── configurationconnection.{h,cpp}
+│   │   │   ├── configurationjogging.{h,cpp}
+│   │   │   ├── configurationmachine.{h,cpp}
+│   │   │   ├── configurationparser.{h,cpp}
+│   │   │   └── configurationsender.{h,cpp}
+│   │   └── persistence/              INI / JSON / XML backends
+│   └── heightmap/
+│       └── configurationheightmap.{h,cpp}
+├── modules/
+│   ├── ai/
+│   │   └── configurationai.{h,cpp}
+│   └── pendant/
+│       └── configurationpendant.{h,cpp}
+└── ui/
+    └── config/
+        ├── uiconfigs.{h,cpp}         Holder for the four UI modules below
+        ├── configurationui.{h,cpp}
+        ├── configurationconsole.{h,cpp}
+        ├── configurationmacros.{h,cpp}
+        └── configurationvisualizer.{h,cpp}
+```
+
+## Registration model
+
+`Configuration` owns the CORE modules as member fields and also keeps a list
+of every registered module. Non-core modules live in their own directories
+and plug in via `registerModule(AbstractConfigurationModule*)`.
+
+- **Eager registration** (90% of cases): the module registers itself before
+  `Configuration::init()`. All registered modules are loaded in one pass when
+  `init()` runs.
+- **Lazy registration**: if `init()` has already run, `registerModule()` opens
+  the persistence backend and loads just that module immediately — useful
+  when a feature is created on demand and wants its config right away.
+
+Example (`main.cpp`):
+
+```cpp
+Configuration& cfg = Core::instance().configuration();
+
+// Eager — register before init():
+UiConfigs::instance().registerAll(cfg);
+ConfigurationAI::registerWith(cfg);
+ConfigurationPendant::registerWith(cfg);
+ConfigurationHeightmap::registerWith(cfg);
+
+cfg.init(appPath, configType);   // loads all registered modules at once
+```
+
+## Accessors
+
+Module → access pattern
+
+| Module | Access |
+|---|---|
+| Core (connection, machine, sender, parser, jogging) | `Core::instance().configuration().xxxModule()` |
+| UI (ui, console, visualizer, macros) | `UiConfigs::instance().xxx()` |
+| AI, Pendant, Heightmap | `ConfigurationXxx::instance()` |
+
+## File format
+
+The config file (`config.json` / `config.ini` / `config.xml`) stores each
+module in a section named after `getSectionName()`. Moving source files
+between directories does not change the file format — section names stay the
+same, and persisters already use read-modify-write, so sections of modules
+that are not currently registered are preserved on save.
+
+## Adding a new non-core config module
+
+1. Create `ConfigurationXxx` deriving from `AbstractConfigurationModule`
+   with `Q_PROPERTY` declarations and a unique `getSectionName()`.
+2. Add a `static ConfigurationXxx& instance()` and
+   `static void registerWith(Configuration&)` following the pattern in
+   `modules/ai/configurationai.h`.
+3. Call `ConfigurationXxx::registerWith(cfg)` in `main.cpp` before
+   `cfg.init(...)`, or from wherever the feature is activated for lazy
+   loading.

src/gpilot/core/config/configuration.cpp

@@ -15,29 +15,17 @@ Configuration::Configuration()
     : QObject(nullptr),
     m_sender(),
     m_connection(),
-    m_visualizer(),
-    m_console(),
     m_parser(),
-    m_ui(),
     m_machine(),
-    m_heightmap(),
-    m_jogging(),
-    m_ai(),
-    m_pendant(),
-    m_macros()
+    m_jogging()
 {
-    m_modules << &m_sender
-        << &m_connection
-        << &m_visualizer
-        << &m_console
-        << &m_parser
-        << &m_ui
-        << &m_machine
-        << &m_heightmap
-        << &m_jogging
-        << &m_ai
-        << &m_pendant
-        << &m_macros;
+    // Core modules are owned by Configuration — register them immediately so
+    // they are included in the first load/save pass.
+    registerModule(&m_sender);
+    registerModule(&m_connection);
+    registerModule(&m_parser);
+    registerModule(&m_machine);
+    registerModule(&m_jogging);
 }
 
 bool Configuration::init(const QString& appPath, const QString& configType)
@@ -59,11 +47,41 @@ bool Configuration::init(const QString& appPath, const QString& configType)
         return false;
     }
 
+    m_initialized = true;
     load();
 
     return true;
 }
 
+bool Configuration::registerModule(AbstractConfigurationModule* module)
+{
+    if (module == nullptr) {
+        qWarning() << "[Configuration] registerModule called with nullptr";
+        return false;
+    }
+    if (m_modules.contains(module)) {
+        qWarning() << "[Configuration] Module already registered:" << module->getSectionName();
+        return false;
+    }
+
+    m_modules.append(module);
+
+    // Lazy registration: persistence is already open, load this module now.
+    if (m_initialized && m_provider != nullptr) {
+        qDebug() << "[Configuration] Lazy-registering module" << module->getSectionName();
+        m_provider->open();
+        loadModule(module);
+        m_provider->close();
+    }
+
+    return true;
+}
+
+void Configuration::unregisterModule(AbstractConfigurationModule* module)
+{
+    m_modules.removeOne(module);
+}
+
 QString Configuration::language()
 {
     return this->m_language;
@@ -78,6 +96,11 @@ void Configuration::save()
 {
     qDebug() << "[Configuration] Save configurations";
 
+    if (!m_persister) {
+        qWarning() << "[Configuration] save() called before init()";
+        return;
+    }
+
     m_persister->open();
     for (AbstractConfigurationModule* module : std::as_const(m_modules)) {
         saveModule(module);
@@ -202,6 +225,11 @@ void Configuration::load()
 {
     qInfo() << "Load configurations";
 
+    if (!m_provider) {
+        qWarning() << "[Configuration] load() called before init()";
+        return;
+    }
+
     m_provider->open();
     for (AbstractConfigurationModule* module : std::as_const(m_modules)) {
         loadModule(module);
@@ -326,4 +354,3 @@ void Configuration::loadModule(AbstractConfigurationModule *module)
         }
     }
 }
-

src/gpilot/core/config/configuration.h

@@ -3,21 +3,19 @@
 
 #include "module/abstractconfigurationmodule.h"
 #include "module/configurationconnection.h"
-#include "module/configurationvisualizer.h"
 #include "module/configurationsender.h"
-#include "module/configurationconsole.h"
 #include "module/configurationparser.h"
-#include "module/configurationui.h"
 #include "module/configurationmachine.h"
-#include "module/configurationheightmap.h"
 #include "module/configurationjogging.h"
-#include "module/configurationpendant.h"
-#include "module/configurationai.h"
-#include "module/configurationmacros.h"
 #include "persistence/abstractpersister.h"
 #include "persistence/abstractprovider.h"
 #include <QObject>
 
+// Configuration is both an owner of CORE modules and a registry for modules
+// coming from other layers (UI, optional features). Non-core modules live in
+// their own directories and plug themselves in via registerModule() before
+// init() is called (eager) or after init() (lazy — the new module is loaded
+// from the config file immediately on register).
 class Configuration : public QObject
 {
     Q_OBJECT;
@@ -26,43 +24,43 @@ class Configuration : public QObject
         Configuration();
         QString language();
         void setLanguage(QString);
-        // Call this before loading/saving to set the config type (json, ini, xml)
+
+        // Opens the persistence backend and loads every already-registered
+        // module. Call AFTER every eager module has registered itself.
         bool init(const QString& appPath, const QString& configType);
+
+        // Adds the module to the registry. If init() already ran, the module
+        // is loaded from disk immediately. Returns false on duplicate or when
+        // the load step fails.
+        bool registerModule(AbstractConfigurationModule* module);
+
+        // Removes the module from the registry. No-op if not present.
+        // Does NOT save — call save() before unregistering if you need to.
+        void unregisterModule(AbstractConfigurationModule* module);
+
         void save();
         void load();
         void setDefaults();
+
+        // Core-only accessors. Non-core modules live behind their own owner
+        // classes (UiConfigs, ConfigurationAI::instance() etc.).
         ConfigurationConnection& connectionModule() { return m_connection; };
-        ConfigurationVisualizer& visualizerModule() { return m_visualizer; };
         ConfigurationSender& senderModule() { return m_sender; };
-        ConfigurationConsole& consoleModule() { return m_console; };
         ConfigurationParser& parserModule() { return m_parser; };
-        ConfigurationUI& uiModule() { return m_ui; };
         ConfigurationMachine& machineModule() { return m_machine; };
-        ConfigurationHeightmap& heightmapModule() { return m_heightmap; };
         ConfigurationJogging& joggingModule() { return m_jogging; };
-        ConfigurationAI& aiModule() { return m_ai; };
-        ConfigurationPendant& pendantModule() { return m_pendant; };
-        ConfigurationMacros& macrosModule() { return m_macros; };
 
     private:
         QString m_language;
+        bool m_initialized = false;
         QList<AbstractConfigurationModule*> m_modules;
 
-        // Modules
         ConfigurationSender m_sender;
         ConfigurationConnection m_connection;
-        ConfigurationVisualizer m_visualizer;
-        ConfigurationConsole m_console;
         ConfigurationParser m_parser;
-        ConfigurationUI m_ui;
         ConfigurationMachine m_machine;
-        ConfigurationHeightmap m_heightmap;
         ConfigurationJogging m_jogging;
-        ConfigurationAI m_ai;
-        ConfigurationPendant m_pendant;
-        ConfigurationMacros m_macros;
 
-        // Read/Write
         AbstractPersister* m_persister = nullptr;
         AbstractProvider* m_provider = nullptr;
 

src/gpilot/core/config/module/configurationai.cpp

@@ -6,6 +6,8 @@
 #include "io/connection/connectionmanager.h"
 #include "io/connection/abstractconnection.h"
 #include "modules/ai/openaimanager.h"
+#include "modules/ai/configurationai.h"
+#include "ui/config/uiconfigs.h"
 #include <QCoreApplication>
 #include <QDebug>
 
@@ -105,7 +107,7 @@ Core::ConsoleCommandResult Core::tryHandleInternalCommand(const QString& command
             return ConsoleCommandResult::stop();
         }
         OpenAIManager& ai = OpenAIManager::instance();
-        ai.setApiKey(m_configuration.aiModule().openAIKey());
+        ai.setApiKey(ConfigurationAI::instance().openAIKey());
         ai.sendRequest(args,
             [this](const QString& response) { emit log("[AI] " + response); },
             [this](const QString& error) { emit log("[AI][Error] " + error); },
@@ -166,24 +168,24 @@ Core::ConsoleCommandResult Core::tryHandleScanned(const QString& command)
 
 void Core::addRecentFile(QString fileName)
 {
-    m_configuration.uiModule().addRecentFile(fileName);
+    UiConfigs::instance().ui().addRecentFile(fileName);
     m_configuration.save();
     emit recentFilesChanged();
 }
 
 void Core::addRecentHeightmap(QString fileName)
 {
-    m_configuration.uiModule().addRecentHeightmap(fileName);
+    UiConfigs::instance().ui().addRecentHeightmap(fileName);
     m_configuration.save();
     emit recentFilesChanged();
 }
 
 void Core::clearRecentFiles(bool heightmapMode)
 {
     if (heightmapMode) {
-        m_configuration.uiModule().clearRecentHeightmaps();
+        UiConfigs::instance().ui().clearRecentHeightmaps();
     } else {
-        m_configuration.uiModule().clearRecentFiles();
+        UiConfigs::instance().ui().clearRecentFiles();
     }
     m_configuration.save();
     emit recentFilesChanged();

src/gpilot/core/core.cpp

@@ -3,7 +3,8 @@
 // Copyright 2024 BTS
 
 #include "configurationheightmap.h"
-\
+#include "core/config/configuration.h"
+
 const QMap<QString,QVariant> DEFAULTS = {
     {"heightmapAreaX1", 0},
     {"heightmapAreaY1", 0},
@@ -25,3 +26,14 @@ const QMap<QString,QVariant> DEFAULTS = {
 ConfigurationHeightmap::ConfigurationHeightmap(QObject *parent) : AbstractConfigurationModule(parent, DEFAULTS)
 {
 }
+
+ConfigurationHeightmap& ConfigurationHeightmap::instance()
+{
+    static ConfigurationHeightmap inst;
+    return inst;
+}
+
+void ConfigurationHeightmap::registerWith(Configuration& cfg)
+{
+    cfg.registerModule(&instance());
+}

…config/module/configurationheightmap.cpp …ore/heightmap/configurationheightmap.cppsrc/gpilot/core/config/module/configurationheightmap.cpp renamed to src/gpilot/core/heightmap/configurationheightmap.cpp src/gpilot/core/config/module/configurationheightmap.cpp renamed to src/gpilot/core/heightmap/configurationheightmap.cpp

@@ -5,7 +5,9 @@
 #ifndef CONFIGURATIONHEIGHTMAP_H
 #define CONFIGURATIONHEIGHTMAP_H
 
-#include "abstractconfigurationmodule.h"
+#include "core/config/module/abstractconfigurationmodule.h"
+
+class Configuration;
 
 class ConfigurationHeightmap : public AbstractConfigurationModule
 {
@@ -49,6 +51,9 @@ class ConfigurationHeightmap : public AbstractConfigurationModule
         int interpolationType() const { return m_interpolationType; }
         bool interpolationShow() const { return m_interpolationShow; }
 
+        static ConfigurationHeightmap& instance();
+        static void registerWith(Configuration& cfg);
+
     private:
         double m_areaX1;
         double m_areaY1;