How hdps/core works
Project type and purpose
• Type: Desktop application framework built in C++ using Qt6 and CMake.
• Purpose: Provide a core “host” application with a plugin architecture for visual analytics of high-dimensional data.
File structure
• Top-level CMakeLists.txt, conanfile.py and cmake/ folder show it’s built with CMake + CPM for dependency management.
• ManiVault/src contains:
– core entry points (Main.cpp, Application.cpp)
– abstract interfaces (Abstract*Manager, Abstract*Plugin)
– private implementations (src/private)
– modular subsystems (event, managers, renderers, models, widgets, util).
• ManiVault/src/plugins contains many per-plugin directories, each with its own CMakeLists, JSON metadata, and source implementing plugin interfaces.
README for insights
• “Core” hosts fully self-encapsulated plugins communicating via the core.
• Plugins types: Loader, Writer, Analysis, Transformation, View, Task.
• Core subsystems manage data, events, tasks, UI, settings, scripting, error logging.
Main components & interactions
a. Application Layer (Frontend/UI):
– MainWindow / CentralDockWidget / various Widget classes (in src/private & src/widgets)
– Actions (src/actions) implement UI commands
– Models (src/models) back MVC views in Qt
b. Core Framework Layer:
– Managers (src private & src): PluginManager, DataManager, TaskManager, EventManager, SettingsManager, ScriptingManager, ErrorManager, WorkspaceManager, HelpManager, ThemeManager
– CoreInterface façade exposing manager services to plugins
– Event system (src/event) for pub/sub
– Abstract interfaces (Abstract*Manager, Abstract*Plugin)
c. Plugin Layer:
– Each plugin folder under src/plugins implements one or more plugin types via JSON metadata + C++ classes
– They register with PluginManager at startup
– They use CoreInterface to request data, dispatch events, spawn tasks, update UI
d. Utility Layer:
– src/util: JSON handling, logging, file I/O, network, serialization, mathematical & rendering helpers
– external dependencies: Qt6, FontAwesome (downloaded via cmake), Googletest for plugin tests
e. Resource Layer:
– cmake scripts to install dependencies and embed resources
Architectural patterns & design principles
• Plugin architecture (inversion of control): Core loads/discovers plugins at runtime, each plugin implements a well-defined interface.
• MVC/MVVM for UI: Models ⇄ Views via Qt Model classes + Actions as controllers.
• Event bus for loose coupling: Plugins and core subsystems communicate via the EventManager.
• Task handling strategy: tasks (modal, background, foreground) are executed via TaskManager and TaskHandler abstractions.
• Resource bundling: Qt QRC for cross-platform asset management.