refactor: decouple SmartPointer reference counting

Geant4's G4EXPATShim creates EXPAT::EXPAT (uppercase) with
IMPORTED_LOCATION set to ${EXPAT_LIBRARY}, which is empty when EXPAT
is found via conda's config-mode package (expat::expat, lowercase).

After find_package(Geant4), patch EXPAT::EXPAT with the real library
path taken from expat::expat IMPORTED_LOCATION_NOCONFIG, falling back
to find_library if needed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.agents/rules/context_exclude_vtk.md

@@ -0,0 +1,9 @@
+---
+trigger: manual
+---
+# Context Restriction: No VTK
+When this rule is active, restrict the operational context to libraries excluding the VTK layer.
+- **Exclude Path**: `src/Vtk`
+- **Include Paths**: `src/Core`, `src/Math`, `src/HEP`, `src/Root`, `src/Python`, `src/utils`
+- **Focus**: Tomographic reconstruction algorithms, data structures in `Core`, and physical modeling in `HEP`. 
+- **Constraint**: Avoid referencing `Prop3D`, `Viewport`, or any VTK-specific headers unless the user overrides this restriction.

.agents/rules/context_gcompose.md

@@ -0,0 +1,9 @@
+---
+trigger: manual
+---
+# Context Focus: gcompose Application
+When this rule is active, prioritize the `gcompose` GUI application.
+- **Primary Path**: `app/gcompose`
+- **Focus**: `MainPanel`, `ContextPanel`, `PropertiesPanel`, and `ViewportPane`.
+- **Integration**: Wiring of Qt signals/slots between the `uLib` core model and the GUI widgets.
+- **Dependency**: Reference `src/Vtk` and `src/Core` as the underlying framework for the application.

.agents/rules/context_vtk.md

@@ -0,0 +1,9 @@
+---
+trigger: always_on
+---
+# Context Inclusion: VTK
+When this rule is active, include the VTK visualization layer in the operational context.
+- **Priority Path**: `src/Vtk`
+- **Focus**: `Prop3D` hierarchy, `Viewport` management, and the synchronization between domain objects and VTK props.
+- **Key Classes**: `vtkViewport`, `vtkQViewport`, `vtkObjectsContext`, and all classes in `src/Vtk/HEP/Geant`.
+- **Logic**: Ensure transformations (TRS) applied to domain objects are correctly mirrored in the visualization layer and vice versa.

.agents/rules/micromamba_build.md

@@ -0,0 +1,44 @@
+---
+trigger: always_on
+---
+
+# Rule: Build uLib with Micromamba
+
+This rule provides instructions for building the uLib project using the micromamba environment.
+
+## Context
+- **Environment**: micromamba `uLib`
+- **Output Directory**: `build`
+- **CPU Usage**: All available cores
+
+## Instructions
+
+1. **Environment Setup**:
+   Ensure micromamba is properly initialized and the `uLib` environment is active.
+   ```bash
+   export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
+   export MAMBA_ROOT_PREFIX="/home/share/micromamba"
+   export PRESET="clang-debug"
+   eval "$(${MAMBA_EXE} shell hook --shell bash)"
+   micromamba activate uLib
+   ```
+
+2. **Full Rebuild (if needed)**:
+   If the `build` directory does not exist or a full reconfiguration is required:
+   ```bash
+   conan install . --output-folder=build/${PRESET} --build=missing --profile=fast
+   cmake --preset ${PRESET}
+   cmake --build build/${PRESET} -j$(nproc)
+   ```
+
+3. **Incremental Build**:
+   Run the build command from the root directory, pointing to the `build` folder and using all cores.
+   ```bash
+   cmake --build build/${PRESET} -j$(nproc)
+   ```
+
+4. **Specific Target Build - gcompose**:
+   To build a specific target (e.g., gcompose):
+   ```bash
+   cmake --build build/${PRESET} --target gcompose -j$(nproc)
+   ```

.agents/skills/core_system.md

@@ -0,0 +1,49 @@
+# Skill: Core Object & Property System
+
+This skill defines the patterns for implementing and working with the `uLib` core object model.
+
+## Context
+- **Base Class**: `uLib::Object`
+- **Property System**: `uLib::Property<T>`
+- **Registration**: All objects must register their properties for UI visibility and serialization.
+
+## Implementation Patterns
+
+### 1. Defining an Object
+Inherit from `uLib::Object` and use the `ULIB_PROPERTY` macro for members.
+```cpp
+class MyObject : public uLib::Object {
+public:
+    ULIB_PROPERTY(double, Speed, 0.0)
+    ULIB_PROPERTY(std::string, Description, "None")
+    
+    MyObject() {
+        // Required for property visibility in PropertyEditor
+        ULIB_ACTIVATE_PROPERTIES(*this)
+    }
+};
+```
+
+### 2. Property Access
+Properties can be treated like their underlying types or accessed via `.Get()`/`.Set()`.
+```cpp
+obj.Speed = 10.5;                // Triggers Updated() signal
+double s = obj.Speed;            // Implicit conversion
+obj.Speed.SetRange(0.0, 100.0);  // Setting metadata
+```
+
+### 3. Serialization
+Implement `serialize` overloads for different archive types. Use `hrp` (Human Readable Property) to name fields.
+```cpp
+template <class ArchiveT>
+void serialize(ArchiveT &ar, const unsigned int version) {
+    ar & boost::serialization::make_nvp("InstanceName", this->GetInstanceName());
+    ar & boost::serialization::make_hrp("Speed", Speed, "m/s");
+}
+```
+
+## Checklist
+- [ ] Inherit from `uLib::Object`.
+- [ ] Use `ULIB_PROPERTY` for members that should appear in the GUI.
+- [ ] Call `ULIB_ACTIVATE_PROPERTIES` in the constructor.
+- [ ] Implement `serialize` if persistence is required.

.agents/skills/geant_simulation.md

@@ -0,0 +1,39 @@
+# Skill: HEP/Geant Simulation Rules
+
+This skill provides instructions for developing the Geant4 simulation components within `uLib`.
+
+## Context
+- **Domain Objects**: `Material`, `Solid`, `LogicalVolume`, `PhysicalVolume`.
+- **Integration**: `mutomGeant` library wraps Geant4 classes into `uLib::Object`s.
+
+## Patterns
+
+### 1. Adding a New Solid
+New solids must implement `GetPolyhedron()` to support VTK visualization.
+```cpp
+G4Polyhedron* MySolid::GetPolyhedron() const {
+    // Return the tessellated representation of the Geant4 solid
+    return m_G4Solid->GetPolyhedron();
+}
+```
+
+### 2. Physical Volume Hierarchy
+Maintain the relationship between `PhysicalVolume` and its parent `LogicalVolume`.
+```cpp
+auto* world = new LogicalVolume(worldSolid, worldMat);
+auto* detector = new PhysicalVolume(detectorLogic, world, "Detector1");
+detector->SetPosition({0, 0, 100}); // Relative to parent
+```
+
+### 3. Transformation Synchronization
+Use the centralized `TRS` object to manage position and rotation. Synchronization with Geant4's internal stores should be reactive.
+- Listen to `Object::Updated` on the `Solid` or `PhysicalVolume`.
+- Update the underlying `G4VPhysicalVolume` position/rotation.
+
+## Material Management
+Use the `Matter` class to manage Geant4 materials. Ensure materials are registered in the `G4NistManager` or custom material store if needed.
+
+## Checklist
+- [ ] Does the solid implement `GetPolyhedron()`?
+- [ ] Are parents correctly assigned in `PhysicalVolume` constructors?
+- [ ] Is the `TRS` object used for all spatial transformations?

.agents/skills/memory_management.md

@@ -0,0 +1,40 @@
+# Skill: Memory Management & Object Lifecycle
+
+This skill provides guidelines for managing memory safely within the `uLib` framework to prevent memory corruption and leaks.
+
+## Context
+- **Ownership**: `ObjectsContext` typically owns its children.
+- **Shared Access**: Use `SmartPointer<T>` for objects shared across multiple systems (e.g., Geant4 and VTK).
+- **Core Principle**: Avoid manual `delete` on objects managed by the framework.
+
+## Patterns
+
+### 1. Context Ownership
+When an object is added to an `ObjectsContext`, it is managed by that context.
+```cpp
+auto* context = new ObjectsContext();
+auto* obj = new MyObject();
+context->AddObject(obj); 
+// Do NOT delete obj; it will be deleted when context is destroyed.
+```
+
+### 2. Smart Pointers
+Use `SmartPointer<T>` for resources like `Material` or `Solid` that are used by both domain logic and external engines (Geant4).
+```cpp
+uLib::SmartPointer<Material> mat = new Material("Lead");
+solid->SetMaterial(mat); // Shared ownership
+```
+
+### 3. Geant4 Object Safety
+Geant4 often takes ownership of certain objects (like `G4VPhysicalVolume`). When wrapping these:
+- Ensure the wrapper doesn't double-free the Geant4-owned pointer.
+- Use `recursion_guard` if synchronizing transformations between `uLib::Object` and Geant4 volumes to prevent signal loops.
+
+## Debugging Memory Issues
+- **SIGABRT (invalid pointer)**: Usually caused by deleting an object that was already managed (and deleted) by an `ObjectsContext` or `SmartPointer`.
+- **Leaks**: Check if objects were created but never added to a context or wrapped in a `SmartPointer`.
+
+## Checklist
+- [ ] Are objects added to an `ObjectsContext`?
+- [ ] Is `SmartPointer` used for shared resources?
+- [ ] Is there a risk of double-freeing Geant4-managed pointers?

.agents/skills/object_context.md

@@ -0,0 +1,29 @@
+# Skill: Object Context & Scene Management
+
+Guidelines for managing the `uLib` object hierarchy, Geant4 volume instantiation, and Gcompose scene interaction.
+
+## 1. Object Creation & Context
+- **Factory Pattern**: Always use `ObjectFactory` to instantiate objects from the registry. Avoid direct `new` calls for domain objects to ensure proper metadata and property initialization.
+- **Context Ownership**: The `Context` is the source of truth. Every persistent object must be registered within the `Context` to participate in the tree hierarchy, property system, and serialization.
+
+## 2. Geant4: Logical vs. Physical Volumes
+In the Geant4/HEP domain, visibility and placement follow a strict two-tier hierarchy:
+- **LogicalVolume**: Defines **what** the object is (Solid/Shape, Material, and daughter volumes). It is a template and does **not** have a spatial position.
+- **PhysicalVolume**: Defines **where** and **how** an instance exists. It references a `LogicalVolume` and holds the **TRS** (Translation, Rotation Matrix/Scale).
+- **CRITICAL**: Adding a `Solid` or `LogicalVolume` to the scene is insufficient for visualization. To display an object in the VTK viewport, you **must**:
+    1. Define the `LogicalVolume`.
+    2. Instantiate a `PhysicalVolume` from that `LogicalVolume`.
+    3. Add the `PhysicalVolume` to the scene context and apply TRS transformations to it.
+
+## 3. Gcompose: Tree Hierarchy & Visualization
+- **3D Representations**: Objects with 3D actors are automatically wrapped in VTK representations (e.g., `vtkContainerBox`). Non-3D objects remain in the tree but have no viewport presence.
+- **Reference Handling**: 
+    - Internal object references (raw pointers or `SmartPointer`) are rendered as "virtual children" in the tree.
+    - **Instance Re-use**: One object can appear as a child under multiple parents if referenced multiple times; these are placeholders for the same underlying instance.
+- **Setting References**:
+    - **Property Selector**: Filter and select compatible types from the global context within the property editor.
+    - **Drag & Drop**: Drag an object from the tree and drop it onto a property field. The system automatically validates types and performs the necessary casting/assignment.
+
+## 4. Best Practices & Checks
+- **TRS Logic**: Always apply transformations to the `PhysicalVolume`. Changes to a `LogicalVolume` will affect all its instances but will not move them.
+- **Dependency Tracking**: Use the tree structure to identify shared references. Changing a property on a shared object affects all parent nodes that reference it.

.agents/skills/signal_bridge.md

@@ -0,0 +1,34 @@
+# Skill: Multi-System Signaling (uLib ↔ Qt)
+
+This skill manages the coexistence of `uLib::Object` signals and Qt's `Q_OBJECT` signaling system.
+
+## Context
+- **uLib Signals**: Used for domain logic and data changes (`uLib::Object::connect`).
+- **Qt Signals**: Used for UI events, widgets, and application-level control flow (`QObject::connect`).
+
+## Patterns
+
+### 1. Bridging Logic
+When a domain change needs to trigger a UI update, use a wrapper or a direct connection if the widget has access to the `uLib::Object`.
+```cpp
+// In a Qt Widget
+uLib::Object::connect(domainObj, &Object::Updated, [this]() {
+    this->update(); // Trigger Qt repaint
+});
+```
+
+### 2. Selection Flow
+Selection usually starts in the VTK Viewport (Qt) and flows to the domain context.
+1. `QViewport` emits `prop3dSelected(Prop3D*)` (Qt signal).
+2. `MainPanel` catches it and calls `contextPanel->selectObject(p->GetContent())`.
+3. `ContextPanel` updates the tree view and property editors.
+
+### 3. Connection Hygiene
+- Use `uLib::Object::connect` for everything involving `uLib::Property` changes.
+- Use Qt `connect` for button clicks, menu actions, and window events.
+- Be careful with lambda captures; ensure the captured object is still alive or use weak pointers if necessary.
+
+## Checklist
+- [ ] Is the correct signaling system being used for the task?
+- [ ] Are capture groups in lambdas safe?
+- [ ] Does selection flow correctly between the 3D view and the tree view?

.agents/skills/testing_guide.md

@@ -0,0 +1,34 @@
+# Skill: Standardized Testing & Validation
+
+This skill provides the standard workflow for testing and validating changes in the `uLib` project.
+
+## Context
+- **Tooling**: `ctest` and direct execution of test binaries in the `build/` directory.
+- **Location**: Test binaries are typically located in `build/src/*/testing/` or `build/Testing/`.
+
+## Workflow
+
+### 1. Running All Tests
+From the root directory:
+```bash
+ctest --test-dir build/clang-make --output-on-failure
+```
+
+### 2. Running Component Tests
+Run specific categories of tests:
+- **Core**: `./build/clang-make/src/Core/testing/CoreTest`
+- **Math**: `./build/clang-make/src/Math/testing/MathVectorTest`
+- **Geant**: `./build/clang-make/src/HEP/Geant/testing/GeantApp`
+- **VTK**: `./build/clang-make/src/Vtk/testing/vtkViewerTest`
+
+### 3. Debugging a Failing Test
+Run the binary directly through `gdb` or `valgrind` (if available):
+```bash
+gdb --args ./build/clang-make/src/Core/testing/ObjectWrapperTest
+```
+
+## Validation Checklist for New Features
+- [ ] Does `ctest` pass globally?
+- [ ] If changing visualization, does `vtkViewerTest` show the correct results?
+- [ ] If changing Geant logic, does `GeantApp` run without memory aborts?
+- [ ] Are new tests added to the appropriate `CMakeLists.txt`?

.agents/skills/vtk_visualization.md

@@ -0,0 +1,52 @@
+# Skill: VTK Visualization Pipeline
+
+This skill defines how to bridge domain objects with the VTK 3D visualization layer.
+
+## Context
+- **Wrapper**: `Prop3D` (wraps a `vtkProp`).
+- **Mapping**: `Viewport` maintains `m_ObjectToProp3D` for synchronization.
+- **GUI Integration**: `QViewport` handles Qt events and selection signals.
+
+## Implementation Patterns
+
+### 1. Creating a Prop3D
+A `Prop3D` should wrap a domain object and update its visual state when the object changes.
+```cpp
+class MyProp3D : public Prop3D {
+public:
+    MyProp3D(MyObject* obj) : Prop3D(obj) {
+        // Connect domain updates to visual refreshes
+        uLib::Object::connect(obj, &Object::Updated, [this]() { this->SyncFromObject(); });
+        
+        // Expose properties to the VTK side-panel
+        ULIB_ACTIVATE_DISPLAY_PROPERTIES(*this)
+    }
+    
+    void SyncFromObject() {
+        // Update VTK actors/mappers from MyObject's properties
+    }
+};
+```
+
+### 2. Display Properties
+Use `serialize_display` to choose which properties of the domain object or the `Prop3D` itself are visible in the sliding "Display Properties" panel in `gcompose`.
+```cpp
+void serialize_display(Archive::display_properties_archive &ar) {
+    ar & boost::serialization::make_hrp("Opacity", m_Opacity);
+    ar & boost::serialization::make_hrp("Wireframe", m_Wireframe);
+}
+```
+
+### 3. Transformation Sync (TRS)
+Always synchronize the object's `trs` (Translate, Rotate, Scale) with the VTK actor's user transform.
+```cpp
+void UpdateTransform() {
+    auto matrix = GetContent()->GetTransform().GetMatrix();
+    m_Actor->SetUserMatrix(uLib::ToVtkMatrix(matrix));
+}
+```
+
+## Checklist
+- [ ] Does the `Prop3D` connect to the object's `Updated()` signal?
+- [ ] Are `ULIB_ACTIVATE_DISPLAY_PROPERTIES` and `serialize_display` implemented?
+- [ ] Is the transformation (TRS) correctly mapped to the VTK actor?

.clangd

@@ -1,7 +1,7 @@
 CompileFlags:
   CompilationDatabase: build
   Add: 
-    - -I/home/rigoni/devel/cmt/ulib/src
+    - -I/home/rigoni/devel/cmt/uLib/src
     - -isystem/home/share/micromamba/envs/mutom/include
     - -isystem/home/share/micromamba/envs/mutom/include/eigen3
     - -isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include
@@ -27,7 +27,7 @@ Diagnostics:
 
 ---
 If:
-  PathExclude: [/home/rigoni/devel/cmt/ulib/src/.*]
+  PathExclude: [/home/rigoni/devel/cmt/uLib/src/.*]
 Diagnostics:
   Suppress: ["*"]
 

.gitattributes

@@ -0,0 +1,2 @@
+*.vtk filter=lfs diff=lfs merge=lfs -text
+*.vti filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,6 +1,7 @@
 CMakeFiles/
-build/
+build*/
 .cache/
+CMakeUserPresets.json
 build_warnings*.log
 final_build.log
 cmake_configure.log
@@ -13,3 +14,12 @@ src/Python/uLib/*.pyd
 src/Python/uLib/*.pyc
 src/Python/uLib/__pycache__
 src/Python/uLib/.nfs*
+test_props.xml
+test_props2.xml
+test_boost.cpp
+.claude/settings.json
+build_output.log
+configure_output.log
+test.xml
+test_ref_smartpointer.xml
+test_ref.xml

.vscode/gdb_wrapper.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+export DISPLAY=:1001.0
+/home/share/micromamba/bin/micromamba run -n uLib /usr/bin/gdb "$@"

.vscode/launch.json

@@ -0,0 +1,31 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "gcompose",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/build/app/gcompose/gcompose",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [
+                { "name": "DISPLAY", "value": ":1001.0" }
+            ],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ],
+            "preLaunchTask": "Build gcompose",
+            "miDebuggerPath": "${workspaceFolder}/.vscode/gdb_wrapper.sh"
+        }
+    ]
+}

.vscode/settings.json

@@ -1,13 +1,14 @@
 {
+    "clangd.path": "/home/share/micromamba/envs/uLib/bin/clangd",
     "clangd.fallbackFlags": [
-        "-I/home/rigoni/devel/cmt/ulib/src",
-        "-isystem/home/share/micromamba/envs/mutom/include",
-        "-isystem/home/share/micromamba/envs/mutom/include/eigen3",
-        "-isystem/home/share/micromamba/envs/mutom/targets/x86_64-linux/include",
-        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
-        "-isystem/home/share/micromamba/envs/mutom/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
-        "-isystem/home/share/micromamba/envs/mutom/x86_64-conda-linux-gnu/sysroot/usr/include",
-        "--gcc-toolchain=/home/share/micromamba/envs/mutom",
+        "-I/home/rigoni/devel/cmt/uLib/src",
+        "-isystem/home/share/micromamba/envs/uLib/include",
+        "-isystem/home/share/micromamba/envs/uLib/include/eigen3",
+        "-isystem/home/share/micromamba/envs/uLib/targets/x86_64-linux/include",
+        "-isystem/home/share/micromamba/envs/uLib/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++",
+        "-isystem/home/share/micromamba/envs/uLib/lib/gcc/x86_64-conda-linux-gnu/14.3.0/include/c++/x86_64-conda-linux-gnu",
+        "-isystem/home/share/micromamba/envs/uLib/x86_64-conda-linux-gnu/sysroot/usr/include",
+        "--gcc-toolchain=/home/share/micromamba/envs/uLib",
         "-D__host__=",
         "-D__device__=",
         "-D__global__=",
@@ -18,9 +19,8 @@
     ],
     "clangd.semanticHighlighting.enable": true,
     "clangd.arguments": [
-        "--compile-commands-dir=build",
-        "--query-driver=/home/share/micromamba/envs/mutom/bin/g++,/home/share/micromamba/envs/mutom/bin/gcc,/home/share/micromamba/envs/mutom/bin/nvcc",
-        "--suppress-system-warnings",
+        "--compile-commands-dir=build/clang-make",
+        "--query-driver=/home/share/micromamba/envs/uLib/bin/*",
         "--all-scopes-completion",
         "--completion-style=detailed",
         "--header-insertion=never",
@@ -28,5 +28,6 @@
         "--pch-storage=memory",
         "--background-index",
         "--log=verbose"
-    ]
+    ],
+    "C_Cpp.intelliSenseEngine": "disabled"
 }

.vscode/tasks.json

@@ -0,0 +1,17 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build gcompose",
+            "type": "shell",
+            "command": "/home/share/micromamba/bin/micromamba run -n uLib cmake --build build --target gcompose -j$(nproc)",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        }
+    ]
+}

CLAUDE.md

@@ -0,0 +1,102 @@
+
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+
+```bash
+# Activate the conda environment (required before any build/run)
+export MAMBA_EXE="/home/share/micromamba/bin/micromamba"
+export MAMBA_ROOT_PREFIX="/home/share/micromamba"
+eval "$(/home/share/micromamba/bin/micromamba shell hook --shell bash)"
+micromamba activate uLib
+
+# Configure (from repo root, using Conan preset — uses Ninja + ccache)
+cmake --preset conan-release
+
+# Build everything
+cmake --build build -j$(nproc)
+
+# Build a specific target
+cmake --build build --target gcompose -j$(nproc)
+
+# Run tests
+cmake --build build --target test
+# or
+ctest --test-dir build
+
+# Run a single test binary (example)
+./build/src/Core/testing/CoreTest
+
+# Run the gcompose GUI app
+./build/app/gcompose/gcompose
+```
+
+First-time setup (if `build/` does not exist):
+```bash
+conan profile detect
+conan install . --output-folder=build --build=missing
+cmake --preset conan-release
+```
+
+### Build acceleration (already configured)
+- **Ninja** generator — used automatically via the conan default profile (`~/.conan2/profiles/default`)
+- **ccache** — enabled via `CMAKE_CXX_COMPILER_LAUNCHER=ccache`; cached rebuilds are nearly instant (~0.3s vs ~25s cold)
+- **Clang 22 + lld** profile available (`~/.conan2/profiles/fast`) but blocked by template overload ambiguities in `src/Core/Archives.h` that need fixing for full compatibility
+
+To reconfigure with the fast profile once Archives.h is fixed:
+```bash
+conan install . --output-folder=build --build=missing --profile=fast
+cmake -B build -G Ninja -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j$(nproc)
+```
+
+## Architecture
+
+**uLib** is a C++ framework for Cosmic Muon Tomography (CMT), structured as layered shared libraries:
+
+```
+mutomCore  →  mutomMath  →  mutomDetectors  →  mutomGeant
+                                              ↘
+                                           mutomVtk  →  gcompose (Qt6 GUI app)
+                                           mutomRoot
+```
+
+### Core Object Model (`src/Core/`)
+- All framework objects inherit from `uLib::Object`
+- **Property system**: `Property<T>` wraps member pointers with change notification via `PropertyChanged` signal
+- **Signal/slot**: `uLib::Object::connect(sender, &Sender::Signal, callback)` — resembles Qt but works for non-QObject classes
+- **Serialization**: Boost archives (`xml_oarchive`, `text_oarchive`, `hrt_oarchive`); `hrp<T>` marks fields as "human-readable properties"
+- `ObjectsContext` is a container owning a list of `Object*` pointers; signals `ObjectAdded`/`ObjectRemoved`
+
+### VTK Layer (`src/Vtk/`)
+- `Prop3D` (inherits `uLib::Object`): wraps a VTK `vtkProp` for rendering. Has `GetContent()` returning the underlying domain object. Display-only properties are registered via `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro.
+- `Viewport`: base class managing the VTK renderer, picking, selection logic. Maintains `m_Prop3Ds` vector and `m_ObjectToProp3D` map.
+- `QViewport` (inherits `QWidget` + `Viewport`): Qt-embedded VTK widget. Emits Qt signal `prop3dSelected(Prop3D*)` on click-selection via `OnSelectionChanged`.
+- `vtkObjectsContext`: wraps `ObjectsContext`, creating/destroying `Prop3D`s as objects come/go. Emits `Prop3DAdded`/`Prop3DRemoved`.
+- Display properties: `serialize_display()` + `display_properties_archive` registers selected `hrp<T>` fields as `PropertyBase*` in the prop3d's `m_DisplayProperties`. `PropertyEditor::setObject(obj, displayOnly=true)` shows only those.
+
+### gcompose GUI App (`app/gcompose/src/`)
+- `MainPanel`: top-level widget. Owns `ContextPanel` (left) and `ViewportPane` (right). Wires together viewport↔context selection via signals.
+- `ContextPanel`: tree view of `ObjectsContext`. Emits `objectSelected(Object*)`. Contains an embedded `PropertiesPanel`.
+- `PropertiesPanel`: shows `uLib::Object` properties via `PropertyEditor`.
+- `ViewportPane`: embeds `QViewport` + a slide-out "Display Properties" panel (`PropertyEditor` in display-only mode).
+- `PropertyEditor`: populates widgets from `Object::GetProperties()` (all) or `Prop3D::GetDisplayProperties()` (display-only mode).
+
+### Selection Sync Flow
+```
+Viewport click  →  Viewport::SelectProp3D()  →  QViewport::OnSelectionChanged()
+                →  emit prop3dSelected(p)
+                →  MainPanel: contextPanel->selectObject(p->GetContent())  [updates tree + PropertiesPanel]
+                →  MainPanel: firstPane->setObject(p)  [updates Display Properties panel]
+
+ContextPanel tree click  →  emit objectSelected(obj)
+                →  MainPanel: viewport->SelectProp3D(prop3d)  [visual selection in VTK]
+                →  MainPanel: firstPane->setObject(prop3d)  [updates Display Properties panel]
+```
+
+### Key Patterns
+- **Two signal systems coexist**: Qt signals (`Q_OBJECT`, `connect(...)`) for GUI; `uLib::Object::connect(...)` for domain signals.
+- **Display properties** flow: `Prop3D::serialize_display()` → `display_properties_archive` → `RegisterDisplayProperty()` → `PropertyEditor(displayOnly=true)`. Must call `ULIB_ACTIVATE_DISPLAY_PROPERTIES` in the prop3d constructor.
+- **Prop3D ↔ Object map**: `Viewport::m_ObjectToProp3D` allows lookup by domain object; `vtkObjectsContext::GetProp3D(obj)` does the same.

CMake/uLibTargetMacros.cmake

@@ -84,6 +84,7 @@ macro(uLib_add_tests name)
     foreach(tn ${TESTS})
         add_executable(${tn} ${tn}.cpp)
         add_test(NAME ${tn} COMMAND ${tn})
+        set_tests_properties(${tn} PROPERTIES ENVIRONMENT "CTEST_PROJECT_NAME=uLib;QT_QPA_PLATFORM=offscreen")
 
         target_link_libraries(${tn} ${LIBRARIES})
 

CMakeConfig.in.h

@@ -34,7 +34,9 @@
 #cmakedefine HAVE_FLOOR
 
 /* Having Geant4 installed */
+#ifndef HAVE_GEANT4
 #cmakedefine HAVE_GEANT4
+#endif
 
 /* Define to 1 if you have the <inttypes.h> header file. */
 #cmakedefine HAVE_INTTYPES_H

CMakeLists.txt

@@ -3,18 +3,67 @@
 ##### CMAKE LISTS ##############################################################
 ################################################################################
 
+# Save compiler and launcher paths if they are absolute (e.g. from presets or CLI)
+# to prevent conan_toolchain.cmake from overwriting them with relative names.
+set(_ULIB_SAVE_CC  "${CMAKE_C_COMPILER}")
+set(_ULIB_SAVE_CXX "${CMAKE_CXX_COMPILER}")
+set(_ULIB_SAVE_CC_LAUNCHER  "${CMAKE_C_COMPILER_LAUNCHER}")
+set(_ULIB_SAVE_CXX_LAUNCHER "${CMAKE_CXX_COMPILER_LAUNCHER}")
+
+if(EXISTS "${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
+    include("${CMAKE_BINARY_DIR}/conan_toolchain.cmake")
+endif()
+
+if(_ULIB_SAVE_CC AND IS_ABSOLUTE "${_ULIB_SAVE_CC}")
+    set(CMAKE_C_COMPILER "${_ULIB_SAVE_CC}" CACHE FILEPATH "C compiler" FORCE)
+endif()
+if(_ULIB_SAVE_CXX AND IS_ABSOLUTE "${_ULIB_SAVE_CXX}")
+    set(CMAKE_CXX_COMPILER "${_ULIB_SAVE_CXX}" CACHE FILEPATH "C++ compiler" FORCE)
+endif()
+if(_ULIB_SAVE_CC_LAUNCHER AND IS_ABSOLUTE "${_ULIB_SAVE_CC_LAUNCHER}")
+    set(CMAKE_C_COMPILER_LAUNCHER "${_ULIB_SAVE_CC_LAUNCHER}" CACHE FILEPATH "C compiler launcher" FORCE)
+endif()
+if(_ULIB_SAVE_CXX_LAUNCHER AND IS_ABSOLUTE "${_ULIB_SAVE_CXX_LAUNCHER}")
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${_ULIB_SAVE_CXX_LAUNCHER}" CACHE FILEPATH "C++ compiler launcher" FORCE)
+endif()
+
+
 cmake_minimum_required (VERSION 3.26)
+
+set(QT_NO_VERSION_CHECK TRUE)
+
 if(POLICY CMP0167)
     cmake_policy(SET CMP0167 NEW)
 endif()
 
-
 ## -------------------------------------------------------------------------- ##
 
 project(uLib)
 
+option(ULIB_USE_CCACHE "Use ccache for build acceleration" ON)
+if(ULIB_USE_CCACHE)
+    find_program(CCACHE_PROGRAM ccache)
+    if(CCACHE_PROGRAM)
+        set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+        set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    endif()
+else()
+    set(CMAKE_CXX_COMPILER_LAUNCHER "")
+    set(CMAKE_C_COMPILER_LAUNCHER "")
+endif()
+
+# Applica la flag SOLO se il compilatore è GCC
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_compile_options(-fno-merge-constants)
+endif()
+
+# Disabilita il warning se il compilatore è Clang (o AppleClang)
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_compile_options(-Wno-ignored-optimization-argument)
+endif()
+
 # CUDA Toolkit seems to be missing locally. Toggle ON if nvcc is made available.
-option(USE_CUDA "Enable CUDA support" ON)
+option(USE_CUDA "Enable CUDA support" OFF)
 if(USE_CUDA)
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -allow-unsupported-compiler")
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
@@ -31,7 +80,7 @@ endif()
 
 # The version number.
 set(PROJECT_VERSION_MAJOR 0)
-set(PROJECT_VERSION_MINOR 6)
+set(PROJECT_VERSION_MINOR 7)
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 set(PROJECT_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
 
@@ -96,6 +145,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
 
 # CTEST framework
+set(CTEST_PROJECT_NAME "uLib")
 include(CTest)
 enable_testing()
 
@@ -107,26 +157,30 @@ set(Boost_USE_MULTITHREADED ON)
 set(Boost_USE_STATIC_RUNTIME OFF)
 message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
 
+find_package(HDF5 REQUIRED)
+
 find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
 include_directories(${Boost_INCLUDE_DIRS})
 
 find_package(Eigen3 CONFIG REQUIRED)
-get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
-include_directories(${EIGEN3_INCLUDE_DIRS})
+# if(NOT EIGEN3_INCLUDE_DIRS)
+#     get_target_property(EIGEN3_INCLUDE_DIRS Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+# else()
+#     include_directories(${EIGEN3_INCLUDE_DIRS})
+# endif()
+
+find_package(OpenMP)
 
 find_package(ROOT CONFIG REQUIRED)
 include(${ROOT_USE_FILE})
 
 find_package(VTK REQUIRED)
-# include(${VTK_USE_FILE})
-
 find_package(pybind11 REQUIRED)
 
-
 option(CENTOS_SUPPORT "VTK definitions for CentOS" OFF)
 if(CENTOS_SUPPORT)
     find_package(VTK CONFIG REQUIRED)
-    include(${VTK_USE_FILE})
+    # include(${VTK_USE_FILE})
 else()
     find_package(VTK REQUIRED
                      COMPONENTS CommonColor
@@ -138,6 +192,8 @@ else()
                                 IOXML
                                 IOXMLParser
                                 ImagingCore
+                                ImagingHybrid
+                                ImagingSources
                                 InteractionStyle
                                 InteractionWidgets
                                 RenderingAnnotation
@@ -146,7 +202,56 @@ else()
                                 RenderingFreeType
                                 RenderingGL2PSOpenGL2
                                 RenderingOpenGL2
-                                RenderingVolumeOpenGL2)
+                                RenderingVolumeOpenGL2
+                                IOGeometry
+                                GUISupportQt)
+endif()
+
+find_package(Qt6 COMPONENTS Widgets)
+if(Qt6_FOUND)
+    add_compile_definitions(HAVE_QT)
+endif()
+
+find_package(Geant4)
+if(Geant4_FOUND)
+    message(STATUS "Geant4 libs: ${Geant4_LIBRARIES}")
+    add_compile_definitions(HAVE_GEANT4)
+    set(HAVE_GEANT4 1)
+
+    # Workaround: Geant4's G4EXPATShim creates EXPAT::EXPAT (uppercase) with
+    # IMPORTED_LOCATION "${EXPAT_LIBRARY}", but EXPAT_LIBRARY is empty when using
+    # conda's config-mode expat package (which installs as expat::expat lowercase).
+    # Resolve the actual library path from expat::expat or via find_library.
+    if(TARGET EXPAT::EXPAT)
+        get_target_property(_expat_loc EXPAT::EXPAT IMPORTED_LOCATION)
+        if(NOT _expat_loc OR _expat_loc MATCHES "NOTFOUND|^$")
+            if(TARGET expat::expat)
+                get_target_property(_expat_loc expat::expat IMPORTED_LOCATION_NOCONFIG)
+            endif()
+            if(NOT _expat_loc OR _expat_loc MATCHES "NOTFOUND|^$")
+                find_library(_expat_loc NAMES expat)
+            endif()
+            if(_expat_loc)
+                set_target_properties(EXPAT::EXPAT PROPERTIES IMPORTED_LOCATION "${_expat_loc}")
+            endif()
+        endif()
+        unset(_expat_loc)
+    endif()
+
+    # Sanitize Geant4 targets to remove Qt5 dependencies that conflict with VTK/Qt6
+    if(TARGET Geant4::G4interfaces)
+        set_target_properties(Geant4::G4interfaces PROPERTIES 
+            INTERFACE_LINK_LIBRARIES "Geant4::G4global;Geant4::G4graphics_reps;Geant4::G4intercoms"
+        )
+    endif()
+    if(TARGET Geant4::G4OpenGL)
+        set_target_properties(Geant4::G4OpenGL PROPERTIES 
+            INTERFACE_LINK_LIBRARIES "Geant4::G4vis_management;Geant4::G4graphics_reps;Geant4::G4geometry;Geant4::G4materials;Geant4::G4intercoms;Geant4::G4global;OpenGL::GL;OpenGL::GLU"
+        )
+    endif()
+else()
+    message(STATUS "Geant4 NOT found - optional features will be disabled")
+    set(HAVE_GEANT4 0)
 endif()
 
 set(CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_INCLUDES math.h)
@@ -204,8 +309,8 @@ add_subdirectory(${SRC_DIR}/Core)
 include_directories(${SRC_DIR}/Math)
 add_subdirectory(${SRC_DIR}/Math)
 
-include_directories(${SRC_DIR}/Detectors)
-add_subdirectory(${SRC_DIR}/Detectors)
+include_directories(${SRC_DIR}/HEP)
+add_subdirectory(${SRC_DIR}/HEP)
 
 include_directories(${SRC_DIR}/Root)
 add_subdirectory(${SRC_DIR}/Root)
@@ -215,7 +320,7 @@ add_subdirectory(${SRC_DIR}/Vtk)
 
 add_subdirectory(${SRC_DIR}/Python)
 
-#add_subdirectory("${SRC_DIR}/utils/make_recipe")
+add_subdirectory(app)
 
 ## Documentation and packages
 

CMakePresets.json

@@ -2,15 +2,64 @@
     "version": 8,
     "configurePresets": [
         {
-            "name": "andrea",
+            "name": "gcc-make",
             "displayName": "Custom configure preset",
-            "description": "Sets Ninja generator, build and install directory",
-            "generator": "Ninja",
-            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "description": "Sets Makefile generator, build and install directory",
+            "generator": "Unix Makefiles",
+            "binaryDir": "${sourceDir}/build/${presetName}",
             "cacheVariables": {
                 "CMAKE_BUILD_TYPE": "Debug",
                 "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
             }
+        },
+        {
+            "name": "clang-ninja",
+            "displayName": "Ninja + clang + ccache",
+            "description": "Uses Ninja generator, clang/lld compiler, and ccache",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release",
+                "CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
+                "CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
+                "CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
+                "CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
+                "CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
+                "CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache"
+            }
+        },
+        {
+            "name": "clang-make",
+            "displayName": "Makefile + clang + ccache",
+            "description": "Uses Makefile generator, clang/lld compiler, and ccache",
+            "generator": "Unix Makefiles",
+            "binaryDir": "${sourceDir}/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release",
+                "CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
+                "CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
+                "CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
+                "CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
+                "CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
+                "CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache"
+            }
+        },
+        {
+            "name": "cuda",
+            "displayName": "Makefile + clang + ccache",
+            "description": "Uses Makefile generator, clang/lld compiler, and ccache",
+            "generator": "Unix Makefiles",
+            "binaryDir": "${sourceDir}/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release",
+                "CMAKE_C_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang",
+                "CMAKE_CXX_COMPILER": "/home/share/micromamba/envs/uLib/bin/clang++",
+                "CMAKE_EXE_LINKER_FLAGS": "-fuse-ld=lld",
+                "CMAKE_SHARED_LINKER_FLAGS": "-fuse-ld=lld",
+                "CMAKE_CXX_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
+                "CMAKE_C_COMPILER_LAUNCHER": "/home/share/micromamba/envs/uLib/bin/ccache",
+                "USE_CUDA": "ON"
+            }
         }
     ]
 }

CMakeUserPresets.json

@@ -1,9 +0,0 @@
-{
-    "version": 4,
-    "vendor": {
-        "conan": {}
-    },
-    "include": [
-        "build/CMakePresets.json"
-    ]
-}

README.md

@@ -30,18 +30,22 @@ You can create and activate the environment using either `micromamba` or `conda`
 **Using Micromamba:**
 ```bash
 micromamba env create -f condaenv.yml
-micromamba activate mutom
+micromamba activate uLib
 ```
 
 **Using Conda:**
 ```bash
 conda env create -f condaenv.yml
-conda activate mutom
+conda activate uLib
 ```
 
 ### Configure and Build
 
-1. **Configure Conan profile (if you haven't yet on your machine):**
+#### Standard build (GCC + Ninja + ccache)
+
+The default conan profile uses **Ninja** as the generator and **ccache** for compiler caching, dramatically speeding up incremental rebuilds.
+
+1. **Configure Conan profile (first time only):**
 ```bash
 conan profile detect
 ```
@@ -51,20 +55,52 @@ conan profile detect
 conan install . --output-folder=build --build=missing
 ```
 
-3. **Configure the project with CMake:**
+3. **Configure with CMake:**
 ```bash
 cmake --preset conan-release
 ```
-*(Alternatively: `cd build && cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release`)*
 
-4. **Build the project:**
+4. **Build:**
 ```bash
-cmake --build build -j10
+cmake --build build -j$(nproc)
 ```
 
+5. **Clean build (wipe and rebuild everything):**
+```bash
+cmake --build build --clean-first -j$(nproc)
+```
+
+6. **Run tests:**
+```bash
+cmake --build build --target test -j$(nproc)
+# or equivalently:
+ctest --test-dir build --output-on-failure -j$(nproc)
+```
+
+#### LLVM/Clang build (clang + lld + ccache — fastest)
+
+A `fast` conan profile is provided that uses **clang**, **lld** (LLVM linker), and **ccache**. Install them into your environment first:
+
+```bash
+micromamba install -n uLib -y clang clangxx lld -c conda-forge
+```
+
+Then build using the `fast` profile:
+
+```bash
+conan install . --output-folder=build/clang-ninja --build=missing --profile=fast
+cmake --preset clang-ninja
+cmake --build build/clang-ninja -j$(nproc)
+```
+
+The `fast` profile is defined at `~/.conan2/profiles/fast` and sets:
+- `CMAKE_C_COMPILER=clang` / `CMAKE_CXX_COMPILER=clang++`
+- `CMAKE_EXE_LINKER_FLAGS=-fuse-ld=lld`
+- `CMAKE_CXX_COMPILER_LAUNCHER=ccache`
+
 ### Make python package
 
 ```bash
-micromamba run -n mutom env USE_CUDA=ON poetry install
+micromamba run -n uLib env USE_CUDA=ON poetry install
 ```
 

Testing/Temporary/CTestCostData.txt

@@ -0,0 +1 @@
+---

Testing/Temporary/LastTest.log

@@ -0,0 +1,3 @@
+Start testing: Mar 25 18:59 UTC
+----------------------------------------------------------
+End testing: Mar 25 18:59 UTC

app/CMakeLists.txt

@@ -0,0 +1,3 @@
+if(HAVE_GEANT4)
+    add_subdirectory(gcompose)
+endif()

app/gcompose/CMakeLists.txt

@@ -0,0 +1,55 @@
+
+add_executable(gcompose 
+    src/main.cpp
+    src/MainWindow.h
+    src/MainWindow.cpp
+    src/ViewportPane.h
+    src/ViewportPane.cpp
+    src/MainPanel.h
+    src/MainPanel.cpp
+    src/ContextPanel.h
+    src/ContextPanel.cpp
+    src/ContextModel.h
+    src/ContextModel.cpp
+    src/StyleManager.h
+    src/StyleManager.cpp
+    src/PropertyWidgets.h
+    src/PropertyWidgets.cpp
+    src/PropertiesPanel.h
+    src/PropertiesPanel.cpp
+    src/PreferencesDialog.h
+    src/PreferencesDialog.cpp
+)
+
+set_target_properties(gcompose PROPERTIES
+    AUTOMOC ON
+    AUTOUIC ON
+    AUTORCC ON
+)
+
+target_include_directories(gcompose PRIVATE 
+    ${SRC_DIR}
+    ${PROJECT_BINARY_DIR}
+    ${Geant4_INCLUDE_DIRS}
+    ${VTK_INCLUDE_DIRS}
+)
+
+# Filter Geant4 libraries to remove Qt-dependent ones
+set(Geant4_LIBS_FILTERED ${Geant4_LIBRARIES})
+if(Geant4_LIBS_FILTERED)
+    list(REMOVE_ITEM Geant4_LIBS_FILTERED Geant4::G4interfaces Geant4::G4OpenGL Geant4::G4visQt3D)
+endif()
+
+target_link_libraries(gcompose
+    mutomCore
+    mutomMath
+    mutomGeant
+    mutomVtk
+    mutomRoot
+    ${Geant4_LIBS_FILTERED}
+    ${VTK_LIBRARIES}
+    Qt6::Widgets
+    VTK::GUISupportQt
+)
+
+install(TARGETS gcompose RUNTIME DESTINATION bin)

app/gcompose/src/ContextModel.cpp

@@ -0,0 +1,276 @@
+#include "ContextModel.h"
+#include <QString>
+#include <typeinfo>
+#include <cxxabi.h>
+#include <functional>
+#include "Core/Object.h"
+#include <QMimeData>
+#include <QDataStream>
+#include <QIODevice>
+#include <vector>
+#include <algorithm>
+
+ContextModel::ContextModel(QObject* parent) 
+    : QAbstractItemModel(parent), m_rootContext(nullptr) {}
+
+ContextModel::~ContextModel() {}
+
+void ContextModel::setContext(uLib::ObjectsContext* context) {
+    m_isReseting = true;
+    beginResetModel();
+    m_rootContext = context;
+    if (m_rootContext) {
+        auto refresh = [this]() {
+            if (this->m_isReseting) return;
+            this->m_isReseting = true;
+            this->beginResetModel();
+            this->endResetModel();
+            this->m_isReseting = false;
+        };
+
+        uLib::Object::connect(m_rootContext, &uLib::Object::Updated, refresh);
+        uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectAdded, [this, refresh](uLib::Object* obj) {
+            uLib::Object::connect(obj, &uLib::Object::Updated, refresh);
+            refresh();
+        });
+        uLib::Object::connect(m_rootContext, &uLib::ObjectsContext::ObjectRemoved, [this, refresh](uLib::Object* obj) {
+            refresh();
+        });
+
+        // Connect existing objects
+        for (const auto& obj : m_rootContext->GetObjects()) {
+            uLib::Object::connect(obj.get(), &uLib::Object::Updated, refresh);
+        }
+    }
+    endResetModel();
+    m_isReseting = false;
+}
+
+QModelIndex ContextModel::index(int row, int column, const QModelIndex& parent) const {
+    if (!hasIndex(row, column, parent) || !m_rootContext) {
+        return QModelIndex();
+    }
+
+    if (!parent.isValid()) {
+        if (row < m_rootContext->GetCount()) {
+            return createIndex(row, column, m_rootContext->GetObject(row));
+        }
+    } else {
+        uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+        uLib::ObjectsContext* parentCtx = parentObj->GetChildren();
+        if (parentCtx && row < (int)parentCtx->GetCount()) {
+            return createIndex(row, column, parentCtx->GetObject(row));
+        }
+    }
+    return QModelIndex();
+}
+
+QModelIndex ContextModel::parent(const QModelIndex& child) const {
+    if (!child.isValid() || !m_rootContext) {
+        return QModelIndex();
+    }
+
+    uLib::Object* childObj = static_cast<uLib::Object*>(child.internalPointer());
+    
+    // Finding the parent of childObj is O(N) since there is no parent pointer.
+    // We just do a recursive search starting from root context.
+    std::function<uLib::Object*(uLib::Object*, uLib::Object*)> findParent = 
+        [&findParent](uLib::Object* current, uLib::Object* target) -> uLib::Object* {
+        uLib::ObjectsContext* ctx = current->GetChildren();
+        if (ctx) {
+            for (const auto& obj : ctx->GetObjects()) {
+                if (obj == target) return current;
+                if (auto p = findParent(obj, target)) return p;
+            }
+        }
+        return nullptr;
+    };
+
+    uLib::Object* parentObj = findParent(m_rootContext, childObj);
+    if (!parentObj || parentObj == m_rootContext) {
+        return QModelIndex(); // Root items have invalid parent index
+    }
+
+    // Now need to find the row of parentObj in its own parent Context.
+    uLib::Object* grandParentObj = findParent(m_rootContext, parentObj);
+    uLib::ObjectsContext* grandParentCtx = grandParentObj ? grandParentObj->GetChildren() : m_rootContext;
+
+    int row = -1;
+    for (size_t i = 0; i < grandParentCtx->GetCount(); ++i) {
+        if (grandParentCtx->GetObject(i) == parentObj) {
+            row = (int)i;
+            break;
+        }
+    }
+
+    if (row != -1) {
+        return createIndex(row, 0, parentObj);
+    }
+    return QModelIndex();
+}
+
+int ContextModel::rowCount(const QModelIndex& parent) const {
+    if (!m_rootContext) return 0;
+
+    if (!parent.isValid()) {
+        return m_rootContext->GetCount();
+    }
+
+    uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+    if (auto parentCtx = parentObj->GetChildren()) {
+        return (int)parentCtx->GetCount();
+    }
+    return 0; // leaf node
+}
+
+int ContextModel::columnCount(const QModelIndex& parent) const {
+    return 1;
+}
+
+static QString getDemangledName(const std::type_info& info) {
+    int status = -4;
+    char* demangled = abi::__cxa_demangle(info.name(), nullptr, nullptr, &status);
+    QString res = (status == 0 && demangled) ? QString::fromUtf8(demangled) : QString::fromUtf8(info.name());
+    if (demangled) free(demangled);
+    
+    // Remove namespaces
+    int lastColon = res.lastIndexOf("::");
+    if (lastColon != -1) {
+        res = res.mid(lastColon + 2);
+    }
+    
+    // Remove "class " prefix if any
+    if (res.startsWith("class ")) res = res.mid(6);
+    return res;
+}
+
+QVariant ContextModel::data(const QModelIndex& index, int role) const {
+    if (!index.isValid()) return QVariant();
+
+    uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+    
+    if (role == Qt::DisplayRole) {
+        QString typeName = getDemangledName(typeid(*obj));
+        std::string instName = obj->GetInstanceName();
+        if (instName.empty()) return typeName;
+        return QString("%1 (%2)").arg(QString::fromStdString(instName)).arg(typeName);
+    }
+    
+    if (role == Qt::EditRole) {
+        return QString::fromStdString(obj->GetInstanceName());
+    }
+    
+    return QVariant();
+}
+
+QVariant ContextModel::headerData(int section, Qt::Orientation orientation, int role) const {
+    if (orientation == Qt::Horizontal && role == Qt::DisplayRole && section == 0) {
+        return "Object Context";
+    }
+    return QVariant();
+}
+
+Qt::ItemFlags ContextModel::flags(const QModelIndex& index) const {
+    if (!index.isValid()) return m_rootContext ? Qt::ItemIsDropEnabled : Qt::NoItemFlags;
+    
+    Qt::ItemFlags f = Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
+    uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+    if (dynamic_cast<uLib::ObjectsContext*>(obj)) {
+        f |= Qt::ItemIsDropEnabled;
+    }
+    return f;
+}
+
+Qt::DropActions ContextModel::supportedDropActions() const {
+    return Qt::MoveAction;
+}
+
+QStringList ContextModel::mimeTypes() const {
+    return {"application/x-ulib-object-ptr"};
+}
+
+QMimeData* ContextModel::mimeData(const QModelIndexList& indexes) const {
+    QMimeData* mimeData = new QMimeData();
+    QByteArray encodedData;
+    QDataStream stream(&encodedData, QIODevice::WriteOnly);
+    for (const auto& idx : indexes) {
+        if (idx.isValid() && idx.column() == 0) {
+            void* ptr = idx.internalPointer();
+            stream << reinterpret_cast<qlonglong>(ptr);
+        }
+    }
+    mimeData->setData("application/x-ulib-object-ptr", encodedData);
+    return mimeData;
+}
+
+bool ContextModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) {
+    if (action != Qt::MoveAction || !data->hasFormat("application/x-ulib-object-ptr")) return false;
+
+    uLib::ObjectsContext* targetCtx = m_rootContext;
+    if (parent.isValid()) {
+        uLib::Object* parentObj = static_cast<uLib::Object*>(parent.internalPointer());
+        targetCtx = dynamic_cast<uLib::ObjectsContext*>(parentObj);
+    }
+    if (!targetCtx) return false;
+
+    QByteArray encodedData = data->data("application/x-ulib-object-ptr");
+    QDataStream stream(&encodedData, QIODevice::ReadOnly);
+    std::vector<uLib::Object*> objectsToMove;
+    while (!stream.atEnd()) {
+        qlonglong ptrVal;
+        stream >> ptrVal;
+        objectsToMove.push_back(reinterpret_cast<uLib::Object*>(ptrVal));
+    }
+
+    if (objectsToMove.empty()) return false;
+
+    // Helper to find and remove from current parent
+    std::function<void(uLib::Object*, uLib::Object*)> findAndRemoveRecursive = 
+        [&findAndRemoveRecursive](uLib::Object* current, uLib::Object* target) {
+        if (auto ctx = current->GetChildren()) {
+            ctx->RemoveObject(target);
+            for (const auto& obj : ctx->GetObjects()) {
+                findAndRemoveRecursive(obj.get(), target);
+            }
+        }
+    };
+
+    m_isReseting = true;
+    beginResetModel();
+    for (auto* obj : objectsToMove) {
+        // Don't drop onto itself or its descendants
+        bool invalid = (obj == targetCtx || obj == (uLib::Object*)targetCtx);
+        if (!invalid) {
+             // check if targetCtx is descendant of obj
+             std::function<bool(uLib::Object*, uLib::Object*)> isDescendant = 
+                [&isDescendant](uLib::Object* root, uLib::Object* target) -> bool {
+                  if (auto ctx = root->GetChildren()) {
+                      for (const auto& child : ctx->GetObjects()) {
+                          if (child.get() == target) return true;
+                          if (isDescendant(child.get(), target)) return true;
+                      }
+                  }
+                 return false;
+             };
+             if (isDescendant(obj, (uLib::Object*)targetCtx)) invalid = true;
+        }
+        
+        if (!invalid) {
+            findAndRemoveRecursive(m_rootContext, obj);
+            targetCtx->AddObject(obj);
+        }
+    }
+    endResetModel();
+    m_isReseting = false;
+    return true;
+}
+
+bool ContextModel::setData(const QModelIndex& index, const QVariant& value, int role) {
+    if (index.isValid() && role == Qt::EditRole) {
+        uLib::Object* obj = static_cast<uLib::Object*>(index.internalPointer());
+        obj->SetInstanceName(value.toString().toStdString());
+        emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
+        return true;
+    }
+    return false;
+}

app/gcompose/src/ContextModel.h

@@ -0,0 +1,35 @@
+#ifndef CONTEXT_MODEL_H
+#define CONTEXT_MODEL_H
+
+#include <QAbstractItemModel>
+#include "Core/ObjectsContext.h"
+
+class ContextModel : public QAbstractItemModel {
+    Q_OBJECT
+public:
+    explicit ContextModel(QObject* parent = nullptr);
+    virtual ~ContextModel();
+
+    void setContext(uLib::ObjectsContext* context);
+
+    QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
+    QModelIndex parent(const QModelIndex& child) const override;
+    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
+    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+    Qt::ItemFlags flags(const QModelIndex& index) const override;
+    bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
+
+    // Drag and Drop support
+    Qt::DropActions supportedDropActions() const override;
+    QStringList mimeTypes() const override;
+    QMimeData* mimeData(const QModelIndexList& indexes) const override;
+    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override;
+
+private:
+    uLib::ObjectsContext* m_rootContext;
+    bool m_isReseting = false;
+};
+
+#endif // CONTEXT_MODEL_H

app/gcompose/src/ContextPanel.cpp

@@ -0,0 +1,148 @@
+#include "ContextPanel.h"
+#include "ContextModel.h"
+#include "PropertyWidgets.h"
+#include "PropertiesPanel.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QTreeView>
+#include <QSplitter>
+#include <QList>
+#include <QShortcut>
+#include <QItemSelectionModel>
+#include <functional>
+
+ContextPanel::ContextPanel(QWidget* parent) 
+    : QWidget(parent)
+    , m_context(nullptr) {
+    this->setObjectName("ContextPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 5, 0);
+
+    m_titleLabel = new QLabel("Context Panel", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+
+    m_layout->addWidget(m_titleBar);
+
+    m_treeView = new QTreeView(this);
+    m_treeView->setObjectName("ContextTree");
+    m_treeView->setHeaderHidden(false);
+    m_treeView->setDragEnabled(true);
+    m_treeView->setAcceptDrops(true);
+    m_treeView->setDropIndicatorShown(true);
+    m_treeView->setDragDropMode(QAbstractItemView::DragDrop);
+    
+    m_model = new ContextModel(this);
+    m_treeView->setModel(m_model);
+
+    m_splitter = new QSplitter(Qt::Vertical, this);
+    m_splitter->addWidget(m_treeView);
+    
+    m_propertiesPanel = new PropertiesPanel(m_splitter);
+    m_splitter->addWidget(m_propertiesPanel);
+
+    QList<int> sizes;
+    sizes << 400 << 600;
+    m_splitter->setSizes(sizes);
+
+    m_layout->addWidget(m_splitter);
+    
+    connect(m_propertiesPanel, &PropertiesPanel::propertyUpdated, this, &ContextPanel::propertyUpdated);
+
+    connect(m_treeView->selectionModel(), &QItemSelectionModel::selectionChanged,
+            this, &ContextPanel::onSelectionChanged);
+
+    auto* deleteShortcut = new QShortcut(QKeySequence::Delete, this);
+    connect(deleteShortcut, &QShortcut::activated, [this]() {
+        auto selectedIndexes = m_treeView->selectionModel()->selectedIndexes();
+        if (selectedIndexes.isEmpty() || !m_context) return;
+        
+        std::vector<uLib::Object*> toRemove;
+        for (const auto& idx : selectedIndexes) {
+            if (idx.column() == 0) {
+                toRemove.push_back(static_cast<uLib::Object*>(idx.internalPointer()));
+            }
+        }
+        
+        for (auto* obj : toRemove) {
+            m_context->RemoveObject(obj);
+        }
+    });
+}
+
+ContextPanel::~ContextPanel() {}
+
+void ContextPanel::setContext(uLib::ObjectsContext* context) {
+    m_context = context;
+    m_model->setContext(context);
+    m_treeView->expandAll();
+}
+
+void ContextPanel::setPropertyContext(uLib::ObjectsContext* context) {
+    m_propertiesPanel->setContext(context);
+}
+
+void ContextPanel::onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected) {
+    uLib::Object* target = nullptr;
+    if (!selected.indexes().isEmpty()) {
+        target = static_cast<uLib::Object*>(selected.indexes().first().internalPointer());
+    }
+
+    emit objectSelected(target);
+    m_propertiesPanel->setObject(target);
+}
+
+void ContextPanel::selectObject(uLib::Object* obj) {
+    if (!obj) {
+        clearSelection();
+        return;
+    }
+    
+    // Recursive search helper
+    std::function<QModelIndex(const QModelIndex&)> findIdx = [&](const QModelIndex& parent) -> QModelIndex {
+        for (int i = 0; i < m_model->rowCount(parent); ++i) {
+            QModelIndex idx = m_model->index(i, 0, parent);
+            if (idx.internalPointer() == obj) return idx;
+            
+            if (m_model->rowCount(idx) > 0) {
+                QModelIndex childIdx = findIdx(idx);
+                if (childIdx.isValid()) return childIdx;
+            }
+        }
+        return QModelIndex();
+    };
+
+    QModelIndex targetIdx = findIdx(QModelIndex());
+    if (targetIdx.isValid()) {
+        QSignalBlocker blocker(m_treeView->selectionModel());
+        
+        // Expand parents so the selection is visible
+        QModelIndex p = targetIdx.parent();
+        while (p.isValid()) {
+            m_treeView->expand(p);
+            p = p.parent();
+        }
+
+        m_treeView->selectionModel()->select(targetIdx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
+        m_treeView->scrollTo(targetIdx);
+        m_propertiesPanel->setObject(obj);
+    }
+}
+
+void ContextPanel::clearSelection() {
+    QSignalBlocker blocker(m_treeView->selectionModel());
+    m_treeView->selectionModel()->clearSelection();
+    m_propertiesPanel->setObject(nullptr);
+}

app/gcompose/src/ContextPanel.h

@@ -0,0 +1,47 @@
+#ifndef CONTEXTPANEL_H
+#define CONTEXTPANEL_H
+
+#include <QWidget>
+#include <QItemSelection>
+#include "Core/Object.h"
+
+class QVBoxLayout;
+class QHBoxLayout;
+class QLabel;
+class QTreeView;
+class QSplitter;
+class ContextModel;
+namespace uLib { class ObjectsContext; }
+
+class ContextPanel : public QWidget {
+    Q_OBJECT
+public:
+    ContextPanel(QWidget* parent = nullptr);
+    ~ContextPanel();
+
+    void setContext(uLib::ObjectsContext* context);
+    void setPropertyContext(uLib::ObjectsContext* context);
+    void selectObject(uLib::Object* obj);
+    void clearSelection();
+
+signals:
+    void objectSelected(uLib::Object* obj);
+    void propertyUpdated();
+
+private slots:
+    void onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
+
+private:
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    
+    QTreeView* m_treeView;
+    ContextModel* m_model;
+    QSplitter* m_splitter;
+
+    class PropertiesPanel* m_propertiesPanel;
+    uLib::ObjectsContext* m_context;
+};
+
+#endif // CONTEXTPANEL_H

app/gcompose/src/MainPanel.cpp

@@ -0,0 +1,279 @@
+#include "MainPanel.h"
+#include "ViewportPane.h"
+#include "ContextPanel.h"
+#include "PropertiesPanel.h"
+#include "Core/ObjectFactory.h"
+#include "Core/ObjectsContext.h"
+#include "Vtk/vtkObjectsContext.h"
+#include "Vtk/vtkQViewport.h"
+#include "Vtk/vtkViewportProperties.h"
+#include <Vtk/uLibVtkInterface.h>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QSplitter>
+#include <QLabel>
+#include <QPushButton>
+#include <QMenu>
+#include <QAction>
+#include <QShortcut>
+#include <QApplication>
+#include <QFileDialog>
+#include <QFileInfo>
+#include "StyleManager.h"
+#include "Math/VoxImage.h"
+#include "PreferencesDialog.h"
+#include "Settings.h"
+
+MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr), m_viewportProps(nullptr) {
+    this->setObjectName("MainPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    auto* mainLayout = new QVBoxLayout(this);
+    mainLayout->setContentsMargins(0, 0, 0, 0);
+    mainLayout->setSpacing(0);
+
+    // 1. Top Menu Panel
+    auto* menuPanel = new QWidget(this);
+    menuPanel->setObjectName("MenuPanel");
+    menuPanel->setFixedHeight(36);
+    
+    auto* menuLayout = new QHBoxLayout(menuPanel);
+    menuLayout->setContentsMargins(10, 0, 10, 0);
+    menuLayout->setSpacing(15);
+
+    auto* logo = new QLabel("G-COMPOSE", menuPanel);
+    logo->setObjectName("LogoLabel");
+
+    // File Menu Button
+    auto* btnFile = new QPushButton("File", menuPanel);
+    btnFile->setObjectName("MenuButton");
+    auto* fileMenu = new QMenu(btnFile);
+    fileMenu->addAction("Open", this, &MainPanel::onOpen);
+    fileMenu->addAction("Save", this, &MainPanel::onSave);
+    fileMenu->addAction("Save As", this, &MainPanel::onSaveAs);
+    fileMenu->addSeparator();
+    fileMenu->addAction("Preferences", this, &MainPanel::onPreferences);
+    fileMenu->addSeparator();
+    fileMenu->addAction("Exit", this, &MainPanel::onExit);
+    btnFile->setMenu(fileMenu);
+
+    // New Menu Button
+    auto* btnNew = new QPushButton("Add", menuPanel);
+    btnNew->setObjectName("MenuButton");
+    auto* newMenu = new QMenu(btnNew);
+    
+    auto classes = uLib::ObjectFactory::Instance().GetRegisteredClasses();
+    for (const auto& className : classes) {
+        auto* action = newMenu->addAction(QString::fromStdString(className));
+        connect(action, &QAction::triggered, [this, className]() {
+            this->onCreateObject(className);
+        });
+    }
+    btnNew->setMenu(newMenu);
+
+    menuLayout->addWidget(logo);
+    menuLayout->addWidget(btnFile);
+    menuLayout->addWidget(btnNew);
+    menuLayout->addStretch();
+
+    mainLayout->addWidget(menuPanel);
+
+    // 2. Central Splitter Area
+    m_rootSplitter = new QSplitter(Qt::Horizontal, this);
+    m_contextPanel = new ContextPanel(m_rootSplitter);
+    m_rootSplitter->addWidget(m_contextPanel);
+    m_rootSplitter->setStretchFactor(0, 0);
+
+    m_firstPane = new ViewportPane(m_rootSplitter);
+    m_rootSplitter->addWidget(m_firstPane);
+    m_rootSplitter->setStretchFactor(1, 1);
+    
+    connect(m_contextPanel, &ContextPanel::objectSelected, [this](uLib::Object* obj) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            uLib::Vtk::Prop3D* prop3d = nullptr;
+            if (m_mainVtkContext) {
+                prop3d = m_mainVtkContext->GetProp3D(obj);
+            }
+            viewport->SelectProp3D(prop3d);
+            // Update the display properties in the viewport pane itself - use the prop3d proxy if possible
+            m_firstPane->setObject(prop3d ? (uLib::Object*)prop3d : obj);
+        } else {
+            m_firstPane->setObject(obj);
+        }
+    });
+    
+    connect(m_contextPanel, &ContextPanel::propertyUpdated, [this](){
+        auto viewports = this->findChildren<uLib::Vtk::QViewport*>();
+        for (auto* vp : viewports) {
+            vp->Render();
+        }
+    });
+
+    // Set initial sizes: Context(250), Viewport(600), Properties(250)
+    QList<int> sizes;
+    sizes << 250 << 600 << 250;
+    m_rootSplitter->setSizes(sizes);
+
+    mainLayout->addWidget(m_rootSplitter, 1);
+    
+    // Shortcuts
+    auto* groupShortcut = new QShortcut(QKeySequence("Ctrl+G"), this);
+    connect(groupShortcut, &QShortcut::activated, [this]() {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            viewport->GroupSelection(m_context);
+        }
+    });
+}
+
+void MainPanel::setContext(uLib::ObjectsContext* context) {
+    m_context = context;
+    m_contextPanel->setContext(context);
+    
+    // Propagate context to all panels for reference property dropdowns
+    m_contextPanel->setPropertyContext(context);
+    m_firstPane->setContext(context);
+    if (m_mainVtkContext) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            viewport->RemoveProp3D(*m_mainVtkContext);
+        }
+        delete m_mainVtkContext;
+        m_mainVtkContext = nullptr;
+    }
+
+    if (context) {
+        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
+            m_mainVtkContext = new uLib::Vtk::ObjectsContext(context);
+            // viewport->AddProp3D(*m_mainVtkContext); // redundant
+
+            auto syncSelection = [this](uLib::Vtk::Prop3D* p) {
+                if (!p) {
+                    m_contextPanel->clearSelection();
+                    m_firstPane->setObject(nullptr);
+                } else {
+                    m_contextPanel->selectObject(p->GetContent());
+                    m_firstPane->setObject(p);
+                }
+            };
+            connect(viewport, &uLib::Vtk::QViewport::prop3dSelected, syncSelection);
+
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::ObjectsContext::Prop3DAdded, [this](uLib::Vtk::Prop3D* p) {
+                if (p) {
+                    auto panes = this->findChildren<ViewportPane*>();
+                    for (auto* pane : panes) {
+                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
+                            vp->AddProp3D(*p);
+                            vp->ZoomAuto();
+                            vp->Render();
+                        }
+                    }
+                }
+            });
+
+            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::ObjectsContext::Prop3DRemoved, [this](uLib::Vtk::Prop3D* p) {
+                if (p) {
+                    auto panes = this->findChildren<ViewportPane*>();
+                    for (auto* pane : panes) {
+                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
+                            vp->RemoveProp3D(*p);
+                            vp->Render();
+                        }
+                    }
+                }
+            });
+
+            // Add any prop3ds that were created during m_mainVtkContext's construction to all panes
+            auto panes = this->findChildren<ViewportPane*>();
+            for (const auto& obj : context->GetObjects()) {
+                if (auto* p = m_mainVtkContext->GetProp3D(obj.get())) {
+                    for (auto* pane : panes) {
+                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
+                            vp->AddProp3D(*p);
+                        }
+                    }
+                }
+            }
+
+            uLib::Object::connect(context, &uLib::Object::Updated, [viewport]() {
+                viewport->Render();
+            });
+            viewport->ZoomAuto();
+            viewport->Render();
+        }
+    }
+}
+
+void MainPanel::onCreateObject(const std::string& className) {
+    if (!m_context) return;
+    auto* obj = uLib::ObjectFactory::Instance().Create(className);
+    if (obj) {
+        m_context->AddObject(obj);
+    }
+}
+
+void MainPanel::onOpen() {
+    QString fileName = QFileDialog::getOpenFileName(this, "Open File", "", 
+        "VTK/VTI Images (*.vtk *.vti);;All Files (*.*)");
+    
+    if (fileName.isEmpty()) return;
+
+    QFileInfo info(fileName);
+    QString ext = info.suffix().toLower();
+
+    if (ext == "vti" || ext == "vtk") {
+        auto* obj = uLib::ObjectFactory::Instance().Create("VoxImage");
+        auto* vox = dynamic_cast<uLib::Abstract::VoxImage*>(obj);
+        if (vox) {
+            bool success = false;
+            if (ext == "vti") {
+                success = vox->ImportFromVti(fileName.toStdString().c_str());
+            } else {
+                success = vox->ImportFromVtk(fileName.toStdString().c_str());
+            }
+
+            if (success) {
+                obj->SetInstanceName(info.fileName().toStdString());
+                m_context->AddObject(obj);
+            } else {
+                delete obj;
+            }
+        } else {
+            delete obj;
+        }
+    }
+}
+
+void MainPanel::onSave() {
+    // Placeholder for save logic
+}
+
+void MainPanel::onSaveAs() {
+    // Placeholder for save as logic
+}
+
+void MainPanel::onExit() {
+    qApp->quit();
+}
+
+void MainPanel::onPreferences() {
+    uLib::Qt::PreferencesDialog dlg(this);
+    if (dlg.exec() == QDialog::Accepted) {
+        // Apply theme and GUI font
+        auto theme = uLib::Qt::Settings::Instance().GetTheme();
+        auto guiFont = uLib::Qt::Settings::Instance().GetGuiFont();
+        StyleManager::applyStyle(qApp, theme == uLib::Qt::Settings::Dark ? "dark" : "bright", guiFont);
+
+        // Apply rendering and font preferences to all viewports
+        bool throttled = uLib::Qt::Settings::Instance().GetThrottledRendering();
+        auto font = uLib::Qt::Settings::Instance().GetFont();
+        auto fontColor = uLib::Qt::Settings::Instance().GetFontColor();
+        
+        auto viewports = this->findChildren<uLib::Vtk::QViewport*>();
+        for (auto* vp : viewports) {
+            vp->SetThrottledRendering(throttled);
+            vp->SetFont(font);
+            vp->SetFontColor(fontColor);
+            vp->Render();
+        }
+    }
+}
+
+MainPanel::~MainPanel() {}

app/gcompose/src/MainPanel.h

@@ -0,0 +1,47 @@
+#ifndef MAINPANEL_H
+#define MAINPANEL_H
+
+#include <QWidget>
+
+class QSplitter;
+class ViewportPane;
+class ContextPanel;
+class PropertiesPanel;
+
+namespace uLib {
+    class ObjectsContext;
+    namespace Vtk {
+        class ObjectsContext;
+        class ViewportProperties;
+    }
+}
+
+class MainPanel : public QWidget {
+    Q_OBJECT
+public:
+    explicit MainPanel(QWidget* parent = nullptr);
+    virtual ~MainPanel();
+
+    void setContext(uLib::ObjectsContext* context);
+    ViewportPane* getFirstPane() const { return m_firstPane; }
+
+private slots:
+    void onOpen();
+    void onSave();
+    void onSaveAs();
+    void onExit();
+
+    void onPreferences();
+    
+    void onCreateObject(const std::string& className);
+
+private:
+    QSplitter* m_rootSplitter;
+    ViewportPane* m_firstPane;
+    ContextPanel* m_contextPanel;
+    uLib::ObjectsContext* m_context;
+    uLib::Vtk::ObjectsContext* m_mainVtkContext;
+    uLib::Vtk::ViewportProperties* m_viewportProps;
+};
+
+#endif // MAINPANEL_H

app/gcompose/src/MainWindow.cpp

@@ -0,0 +1,21 @@
+#include "MainWindow.h"
+#include <QSplitter>
+#include "MainPanel.h"
+#include "Core/ObjectsContext.h"
+
+using namespace uLib;
+
+MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
+    m_panel = new MainPanel(this);
+    setCentralWidget(m_panel);
+
+    setWindowTitle("gcompose - Qt VTK Interface");
+    resize(1200, 800);
+}
+
+MainWindow::~MainWindow() {
+}
+
+void MainWindow::setContext(uLib::ObjectsContext* context) {
+    m_panel->setContext(context);
+}

app/gcompose/src/MainWindow.h

@@ -0,0 +1,29 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QVTKOpenGLNativeWidget.h>
+
+class MainPanel;
+class ViewportPane;
+
+namespace uLib {
+namespace Vtk {
+}
+class ObjectsContext;
+}
+
+class MainWindow : public QMainWindow {
+    Q_OBJECT
+public:
+    MainWindow(QWidget* parent = nullptr);
+    virtual ~MainWindow();
+
+    void setContext(uLib::ObjectsContext* context);
+    MainPanel* getPanel() { return m_panel; }
+
+private:
+    MainPanel* m_panel;
+};
+
+#endif

app/gcompose/src/PreferencesDialog.cpp

@@ -0,0 +1,184 @@
+#include "PreferencesDialog.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QFormLayout>
+#include <QPushButton>
+#include <QLabel>
+#include <QGroupBox>
+#include <QColorDialog>
+#include <QFormLayout>
+
+namespace uLib {
+namespace Qt {
+
+PreferencesDialog::PreferencesDialog(QWidget* parent) : QDialog(parent) {
+    setWindowTitle("Preferences");
+    setMinimumWidth(400);
+    
+    auto* mainLayout = new QVBoxLayout(this);
+    mainLayout->setSpacing(20);
+    mainLayout->setContentsMargins(20, 20, 20, 20);
+
+    // ── General / Rendering Settings ────────────────────────────────────────
+    auto* renderingGroup = new QGroupBox("Appearance & Performance", this);
+    auto* renderingLayout = new QVBoxLayout(renderingGroup);
+    
+    auto* themeLayout = new QHBoxLayout();
+    themeLayout->addWidget(new QLabel("Color Theme:"));
+    m_themeCombo = new QComboBox(renderingGroup);
+    m_themeCombo->addItem("Dark");
+    m_themeCombo->addItem("Bright");
+    m_themeCombo->setCurrentIndex(Settings::Instance().GetTheme() == Settings::Dark ? 0 : 1);
+    themeLayout->addWidget(m_themeCombo);
+    themeLayout->addStretch();
+    
+    renderingLayout->addLayout(themeLayout);
+    renderingLayout->addSpacing(10);
+
+    m_throttledRendering = new QCheckBox("Enable throttled rendering (recommended for performance)", renderingGroup);
+    m_throttledRendering->setChecked(Settings::Instance().GetThrottledRendering());
+    m_throttledRendering->setToolTip("Limits framerate to ~60fps to reduce CPU/GPU usage.");
+    
+    renderingLayout->addWidget(m_throttledRendering);
+    mainLayout->addWidget(renderingGroup);
+
+    // ── Units Settings ──────────────────────────────────────────────────────
+    auto* unitsGroup = new QGroupBox("Preferred Units", this);
+    auto* unitsLayout = new QFormLayout(unitsGroup);
+    unitsLayout->setLabelAlignment(::Qt::AlignRight);
+    unitsLayout->setSpacing(10);
+
+    auto addUnitRow = [&](const QString& label, Settings::Dimension dim, const QStringList& units) {
+        auto* combo = new QComboBox(unitsGroup);
+        combo->addItems(units);
+        std::string current = Settings::Instance().GetPreferredUnit(dim);
+        int idx = combo->findText(QString::fromStdString(current));
+        if (idx >= 0) combo->setCurrentIndex(idx);
+        
+        unitsLayout->addRow(label + ":", combo);
+        m_unitCombos[dim] = combo;
+    };
+
+    addUnitRow("Length", Settings::Length, {"m", "cm", "mm", "um", "nm"});
+    addUnitRow("Angle", Settings::Angle, {"deg", "rad"});
+    addUnitRow("Energy", Settings::Energy, {"MeV", "GeV", "eV", "keV", "TeV"});
+    addUnitRow("Time", Settings::Time, {"ns", "s", "ms", "us"});
+
+    mainLayout->addWidget(unitsGroup);
+
+    // ── Font Configuration ──────────────────────────────────────────────────
+    auto* fontGroup = new QGroupBox("Viewport Font Configuration", this);
+    auto* fontLayout = new QFormLayout(fontGroup);
+    fontLayout->setLabelAlignment(::Qt::AlignRight);
+    
+    FontConfig currentFont = Settings::Instance().GetFont();
+    m_currentFontColor = Settings::Instance().GetFontColor();
+
+    m_fontFamilies = new QComboBox(fontGroup);
+    m_fontFamilies->addItems({"Arial", "Courier", "Times"});
+    m_fontFamilies->setCurrentText(QString::fromStdString(currentFont.family));
+    
+    m_fontSize = new QSpinBox(fontGroup);
+    m_fontSize->setRange(6, 72);
+    m_fontSize->setValue(currentFont.size);
+    
+    m_fontBold = new QCheckBox("Bold", fontGroup);
+    m_fontBold->setChecked(currentFont.bold);
+    
+    m_fontItalic = new QCheckBox("Italic", fontGroup);
+    m_fontItalic->setChecked(currentFont.italic);
+    
+    m_fontColorBtn = new QPushButton(fontGroup);
+    m_fontColorBtn->setFixedWidth(60);
+    updateFontColorButton();
+    connect(m_fontColorBtn, &QPushButton::clicked, [this](){
+        QColor c = QColor::fromRgbF(m_currentFontColor.x(), m_currentFontColor.y(), m_currentFontColor.z());
+        QColor selected = QColorDialog::getColor(c, this, "Select Font Color");
+        if (selected.isValid()) {
+            m_currentFontColor = Vector3d(selected.redF(), selected.greenF(), selected.blueF());
+            updateFontColorButton();
+        }
+    });
+
+    fontLayout->addRow("Family:", m_fontFamilies);
+    fontLayout->addRow("Size:", m_fontSize);
+    fontLayout->addRow(m_fontBold);
+    fontLayout->addRow(m_fontItalic);
+    fontLayout->addRow("Color:", m_fontColorBtn);
+
+    mainLayout->addWidget(fontGroup);
+
+    // ── GUI Font Configuration ──────────────────────────────────────────────
+    auto* guiFontGroup = new QGroupBox("GUI Font Configuration", this);
+    auto* guiFontLayout = new QFormLayout(guiFontGroup);
+    guiFontLayout->setLabelAlignment(::Qt::AlignRight);
+    
+    FontConfig currentGuiFont = Settings::Instance().GetGuiFont();
+
+    m_guiFontFamilies = new QComboBox(guiFontGroup);
+    m_guiFontFamilies->setEditable(true);
+    m_guiFontFamilies->addItems({"Inter", "Roboto", "Segoe UI", "Arial", "Ubuntu"});
+    m_guiFontFamilies->setCurrentText(QString::fromStdString(currentGuiFont.family));
+    
+    m_guiFontSize = new QSpinBox(guiFontGroup);
+    m_guiFontSize->setRange(6, 48);
+    m_guiFontSize->setValue(currentGuiFont.size);
+    
+    m_guiFontBold = new QCheckBox("Bold", guiFontGroup);
+    m_guiFontBold->setChecked(currentGuiFont.bold);
+    
+    m_guiFontItalic = new QCheckBox("Italic", guiFontGroup);
+    m_guiFontItalic->setChecked(currentGuiFont.italic);
+
+    guiFontLayout->addRow("Family:", m_guiFontFamilies);
+    guiFontLayout->addRow("Size:", m_guiFontSize);
+    guiFontLayout->addRow(m_guiFontBold);
+    guiFontLayout->addRow(m_guiFontItalic);
+
+    mainLayout->addWidget(guiFontGroup);
+
+    mainLayout->addStretch();
+
+    // ── Buttons ─────────────────────────────────────────────────────────────
+    auto* buttonLayout = new QHBoxLayout();
+    buttonLayout->addStretch();
+    
+    auto* btnCancel = new QPushButton("Cancel", this);
+    connect(btnCancel, &QPushButton::clicked, this, &QDialog::reject);
+    
+    auto* btnOk = new QPushButton("Apply", this);
+    btnOk->setDefault(true);
+    btnOk->setObjectName("DisplayToggleBtn"); // Reusing high-contrast style
+    btnOk->setMinimumWidth(100);
+    connect(btnOk, &QPushButton::clicked, this, &PreferencesDialog::onAccept);
+    
+    buttonLayout->addWidget(btnCancel);
+    buttonLayout->addWidget(btnOk);
+    mainLayout->addLayout(buttonLayout);
+}
+
+void PreferencesDialog::onAccept() {
+    Settings::Instance().SetThrottledRendering(m_throttledRendering->isChecked());
+    Settings::Instance().SetTheme(m_themeCombo->currentIndex() == 0 ? Settings::Dark : Settings::Bright);
+    
+    for (auto const& pair : m_unitCombos) {
+        Settings::Instance().SetPreferredUnit(pair.first, pair.second->currentText().toStdString());
+    }
+    
+    FontConfig font(m_fontFamilies->currentText().toStdString(), m_fontSize->value(), m_fontBold->isChecked(), m_fontItalic->isChecked());
+    Settings::Instance().SetFont(font);
+    Settings::Instance().SetFontColor(m_currentFontColor);
+
+    FontConfig guiFont(m_guiFontFamilies->currentText().toStdString(), m_guiFontSize->value(), m_guiFontBold->isChecked(), m_guiFontItalic->isChecked());
+    Settings::Instance().SetGuiFont(guiFont);
+
+    accept();
+}
+
+void PreferencesDialog::updateFontColorButton() {
+    QColor c = QColor::fromRgbF(m_currentFontColor.x(), m_currentFontColor.y(), m_currentFontColor.z());
+    m_fontColorBtn->setStyleSheet(QString("background-color: %1; border: 1px solid #555; height: 18px;").arg(c.name()));
+}
+
+} // namespace Qt
+} // namespace uLib

app/gcompose/src/PreferencesDialog.h

@@ -0,0 +1,49 @@
+#ifndef GCOMPOSE_PREFERENCESDIALOG_H
+#define GCOMPOSE_PREFERENCESDIALOG_H
+
+#include <QDialog>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QSpinBox>
+#include <QPushButton>
+#include <map>
+#include <string>
+#include "Settings.h"
+
+namespace uLib {
+namespace Qt {
+
+class PreferencesDialog : public QDialog {
+    Q_OBJECT
+public:
+    explicit PreferencesDialog(QWidget* parent = nullptr);
+
+private slots:
+    void onAccept();
+
+private:
+    QCheckBox* m_throttledRendering;
+    QComboBox* m_themeCombo;
+    std::map<Settings::Dimension, QComboBox*> m_unitCombos;
+
+    // Font Configuration
+    QComboBox* m_fontFamilies;
+    QSpinBox* m_fontSize;
+    QCheckBox* m_fontBold;
+    QCheckBox* m_fontItalic;
+    QPushButton* m_fontColorBtn;
+    Vector3d m_currentFontColor;
+    
+    // GUI Font Configuration
+    QComboBox* m_guiFontFamilies;
+    QSpinBox* m_guiFontSize;
+    QCheckBox* m_guiFontBold;
+    QCheckBox* m_guiFontItalic;
+
+    void updateFontColorButton();
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif

app/gcompose/src/PropertiesPanel.cpp

@@ -0,0 +1,54 @@
+#include "PropertiesPanel.h"
+#include "PropertyWidgets.h"
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include "Core/Object.h"
+
+PropertiesPanel::PropertiesPanel(QWidget* parent) : QWidget(parent) {
+    this->setObjectName("PropertiesPanel");
+    this->setAttribute(Qt::WA_StyledBackground);
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 5, 0);
+
+    m_titleLabel = new QLabel("Properties", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+
+    m_layout->addWidget(m_titleBar);
+
+    // Editor
+    m_editor = new uLib::Qt::PropertyEditor(this);
+    m_layout->addWidget(m_editor, 1);
+
+    connect(m_editor, &uLib::Qt::PropertyEditor::propertyUpdated, [this](uLib::PropertyBase*){
+        emit propertyUpdated();
+    });
+}
+
+void PropertiesPanel::setObject(uLib::Object* obj) {
+    if (obj) {
+        m_titleLabel->setText(QString("Properties: %1 (%2)")
+            .arg(QString::fromStdString(obj->GetInstanceName()))
+            .arg(obj->GetClassName()));
+    } else {
+        m_titleLabel->setText("Properties: (No selection)");
+    }
+    m_editor->setObject(obj);
+}
+
+void PropertiesPanel::setContext(uLib::ObjectsContext* context) {
+    m_editor->setContext(context);
+}
+
+PropertiesPanel::~PropertiesPanel() {}

app/gcompose/src/PropertiesPanel.h

@@ -0,0 +1,42 @@
+#ifndef PROPERTIES_PANEL_H
+#define PROPERTIES_PANEL_H
+
+#include <QWidget>
+
+namespace uLib {
+    class Object;
+    class ObjectsContext;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QVBoxLayout;
+class QLabel;
+
+/**
+ * @class PropertiesPanel
+ * @brief A panel dedicated to inspecting and editing properties of a selected uLib::Object.
+ */
+class PropertiesPanel : public QWidget {
+    Q_OBJECT
+public:
+    explicit PropertiesPanel(QWidget* parent = nullptr);
+    virtual ~PropertiesPanel();
+
+    /** @brief Sets the object to be inspected. */
+    void setObject(uLib::Object* obj);
+    
+    /** @brief Sets the context for reference property dropdowns. */
+    void setContext(uLib::ObjectsContext* context);
+
+signals:
+    void propertyUpdated();
+
+private:
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    
+    uLib::Qt::PropertyEditor* m_editor;
+};
+
+#endif // PROPERTIES_PANEL_H

app/gcompose/src/PropertyWidgets.cpp

@@ -0,0 +1,605 @@
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+#include <QRegularExpression>
+#include <QRegularExpressionMatch>
+#include <QComboBox>
+#include <QCheckBox>
+#include "Vtk/uLibVtkInterface.h"
+#include "Math/Units.h"
+#include "Math/Dense.h"
+#include <QPushButton>
+#include <QColorDialog>
+#include <QFrame>
+#include <QSlider>
+#include <QFontDialog>
+#include "Settings.h"
+#include "Core/ObjectsContext.h"
+
+namespace uLib {
+namespace Qt {
+
+PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent) 
+    : QWidget(parent), m_BaseProperty(prop) {
+    m_Layout = new QHBoxLayout(this);
+    m_Layout->setContentsMargins(4, 2, 4, 2);
+    
+    std::string unit = prop->GetUnits();
+    QString labelText = QString::fromStdString(prop->GetName());
+    if (!unit.empty() && unit != "color") {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        if (!pref.empty()) {
+            labelText += " [" + QString::fromStdString(pref) + "]";
+        } else {
+            labelText += " [" + QString::fromStdString(unit) + "]";
+        }
+    }
+    
+    m_Label = new QLabel(labelText, this);
+    m_Label->setMinimumWidth(120);
+    m_Layout->addWidget(m_Label);
+
+    this->setEnabled(!prop->IsReadOnly());
+}
+PropertyWidgetBase::~PropertyWidgetBase() {
+    m_Connection.disconnect();
+}
+
+// Helper for unit parsing
+double parseWithUnits(const QString& text, double* factorOut, QString* suffixOut) {
+    static QRegularExpression re("^\\s*([-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?)\\s*(_?[a-zA-Z]+)?\\s*$");
+    QRegularExpressionMatch match = re.match(text);
+    if (!match.hasMatch()) return 0.0;
+
+    double num = match.captured(1).toDouble();
+    QString unit = match.captured(3);
+    double factor = factorOut ? *factorOut : 1.0;
+
+    if (!unit.isEmpty()) {
+        QString u = unit.startsWith('_') ? unit.mid(1) : unit;
+        if (u == "m") factor = CLHEP::meter;
+        else if (u == "cm") factor = CLHEP::centimeter;
+        else if (u == "mm") factor = CLHEP::millimeter;
+        else if (u == "um") factor = CLHEP::micrometer;
+        else if (u == "nm") factor = CLHEP::nanometer;
+        else if (u == "km") factor = CLHEP::kilometer;
+        else if (u == "deg") factor = CLHEP::degree;
+        else if (u == "rad") factor = CLHEP::radian;
+        else if (u == "ns") factor = CLHEP::nanosecond;
+        else if (u == "s") factor = CLHEP::second;
+        else if (u == "ms") factor = CLHEP::millisecond;
+        else if (u == "MeV") factor = CLHEP::megaelectronvolt;
+        else if (u == "eV") factor = CLHEP::electronvolt;
+        else if (u == "keV") factor = CLHEP::kiloelectronvolt;
+        else if (u == "GeV") factor = CLHEP::gigaelectronvolt;
+        else if (u == "TeV") factor = CLHEP::teraelectronvolt;
+        if (suffixOut) *suffixOut = u;
+    } else if (suffixOut) {
+        // Reuse previous suffix if none provided, or empty
+    }
+
+    if (factorOut) *factorOut = factor;
+    return num * factor;
+}
+
+// UnitLineEdit implementation
+UnitLineEdit::UnitLineEdit(QWidget* parent) : QLineEdit(parent), m_Value(0), m_Factor(1.0), m_Suffix(""), m_IsInteger(false) {
+    connect(this, &QLineEdit::editingFinished, this, &UnitLineEdit::onEditingFinished);
+}
+
+void UnitLineEdit::setUnits(const QString& suffix, double factor) {
+    m_Suffix = suffix;
+    m_Factor = factor;
+    updateText();
+}
+
+void UnitLineEdit::setValue(double val) {
+    if (m_Value != val) {
+        m_Value = val;
+        // Suffix heuristic ONLY if it was mm and no explicit unit was given?
+        // Actually, if m_Suffix is empty or we have a specific one, we should respect it.
+        // The original code had a heuristic, but it's better to let property decide.
+        // Let's keep it ONLY if m_Suffix was mm (legacy behavior)
+        if (!m_IsInteger && m_Suffix == "mm" && std::abs(val) >= 1000.0) { m_Suffix = "m"; m_Factor = CLHEP::meter; }
+        updateText();
+    }
+}
+
+void UnitLineEdit::onEditingFinished() {
+    double factor = m_Factor;
+    QString suffix = m_Suffix;
+    double parsedVal = parseWithUnits(text(), &factor, &suffix);
+    if (m_IsInteger) {
+        parsedVal = std::round(parsedVal);
+    }
+    
+    if (m_Value != parsedVal) {
+        m_Value = parsedVal;
+        emit valueManualChanged(m_Value);
+    }
+    updateText();
+}
+
+void UnitLineEdit::updateText() {
+    QSignalBlocker blocker(this);
+    QString s;
+    if (m_IsInteger) {
+        s = QString::number((int)m_Value);
+        if (s.isEmpty()) s = "0";
+    } else {
+        double displayVal = m_Value / m_Factor;
+        s = QString::number(displayVal, 'g', 6);
+        if (!s.contains('.') && !s.contains('e')) {
+            s += ".0";
+        }
+    }
+    setText(s);
+}
+
+void UnitLineEdit::setIntegerOnly(bool integerOnly) {
+    m_IsInteger = integerOnly;
+    updateText();
+}
+
+DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    m_Edit->setValue(prop->Get());
+    m_Layout->addWidget(m_Edit, 1);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); emit updated(); });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
+        m_Edit->setValue(m_Prop->Get());
+    });
+}
+
+FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    m_Edit->setValue(prop->Get());
+    m_Layout->addWidget(m_Edit, 1);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((float)val); emit updated(); });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<float>::Updated, [this](){
+        m_Edit->setValue((double)m_Prop->Get());
+    });
+}
+
+IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Edit = new UnitLineEdit(this);
+    m_Edit->setIntegerOnly(true);
+    std::string unit = prop->GetUnits();
+    if (!unit.empty()) {
+        auto dim = Settings::Instance().IdentifyDimension(unit);
+        std::string pref = Settings::Instance().GetPreferredUnit(dim);
+        double factor = Settings::Instance().GetUnitFactor(pref);
+        m_Edit->setUnits(QString::fromStdString(pref), factor);
+    }
+    m_Edit->setValue(prop->Get());
+    m_Layout->addWidget(m_Edit, 1);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((int)val); emit updated(); });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<int>::Updated, [this](){
+        m_Edit->setValue((double)m_Prop->Get());
+    });
+}
+
+BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_CheckBox = new QCheckBox(this);
+    m_CheckBox->setChecked(prop->Get());
+    m_Layout->addWidget(m_CheckBox, 1);
+    connect(m_CheckBox, &QCheckBox::toggled, [this](bool val){ if (m_Prop->Get() != val) { m_Prop->Set(val); emit updated(); } });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::Updated, [this](){
+        if (m_CheckBox->isChecked() != m_Prop->Get()) {
+            QSignalBlocker blocker(m_CheckBox);
+            m_CheckBox->setChecked(m_Prop->Get());
+        }
+    });
+}
+BoolPropertyWidget::~BoolPropertyWidget() {}
+
+RangePropertyWidget::RangePropertyWidget(Property<double>* prop, QWidget* parent) 
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Slider = new QSlider(::Qt::Horizontal, this);
+    m_Slider->setRange(0, 100);
+    m_Slider->setMinimumWidth(80);
+    
+    m_Edit = new UnitLineEdit(this);
+    m_Edit->setFixedWidth(50);
+    
+    m_Layout->addWidget(m_Slider, 1);
+    m_Layout->addWidget(m_Edit, 0);
+
+    connect(m_Slider, &QSlider::valueChanged, this, &RangePropertyWidget::onSliderChanged);
+    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); emit updated(); });
+    
+    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::Updated, [this](){
+        this->updateUi();
+    });
+    updateUi();
+}
+RangePropertyWidget::~RangePropertyWidget() { m_Connection.disconnect(); }
+
+void RangePropertyWidget::updateUi() {
+    double val = m_Prop->Get();
+    m_Edit->setValue(val);
+    if (m_Prop->GetMax() != m_Prop->GetMin()) {
+        int sliderVal = (int)((val - m_Prop->GetMin()) / (m_Prop->GetMax() - m_Prop->GetMin()) * 100.0);
+        QSignalBlocker blocker(m_Slider);
+        m_Slider->setValue(sliderVal);
+    }
+}
+
+void RangePropertyWidget::onSliderChanged(int val) {
+    double realVal = m_Prop->GetMin() + (val / 100.0) * (m_Prop->GetMax() - m_Prop->GetMin());
+    m_Prop->Set(realVal);
+    emit updated();
+}
+
+ColorPropertyWidget::ColorPropertyWidget(Property<Vector3d>* prop, QWidget* parent) 
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Button = new QPushButton(this);
+    m_Button->setFixedWidth(60);
+    this->updateButtonColor();
+    m_Layout->addWidget(m_Button, 0, ::Qt::AlignRight);
+    
+    connect(m_Button, &QPushButton::clicked, this, &ColorPropertyWidget::onClicked);
+    m_Connection = uLib::Object::connect(m_Prop, &Property<Vector3d>::Updated, [this](){
+        this->updateButtonColor();
+    });
+}
+ColorPropertyWidget::~ColorPropertyWidget() {}
+
+void ColorPropertyWidget::updateButtonColor() {
+    Vector3d c = m_Prop->Get();
+    QColor color = QColor::fromRgbF(std::max(0.0, std::min(1.0, c.x())), 
+                                    std::max(0.0, std::min(1.0, c.y())), 
+                                    std::max(0.0, std::min(1.0, c.z())));
+    m_Button->setStyleSheet(QString("background-color: %1; border: 1px solid #555; height: 18px;").arg(color.name()));
+}
+
+void ColorPropertyWidget::onClicked() {
+    Vector3d c = m_Prop->Get();
+    QColor current = QColor::fromRgbF(std::max(0.0, std::min(1.0, c.x())), 
+                                      std::max(0.0, std::min(1.0, c.y())), 
+                                      std::max(0.0, std::min(1.0, c.z())));
+    QColor selected = QColorDialog::getColor(current, this, "Select Color");
+    if (selected.isValid()) {
+        m_Prop->Set(Vector3d(selected.redF(), selected.greenF(), selected.blueF()));
+        emit updated();
+    }
+}
+
+StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_LineEdit = new QLineEdit(this);
+    m_LineEdit->setText(QString::fromStdString(prop->Get()));
+    m_Layout->addWidget(m_LineEdit, 1);
+    connect(m_LineEdit, &QLineEdit::editingFinished, [this](){
+        std::string val = m_LineEdit->text().toStdString();
+        if (m_Prop->Get() != val) { m_Prop->Set(val); emit updated(); }
+    });
+    m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::Updated, [this](){
+        if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
+            QSignalBlocker blocker(m_LineEdit);
+            m_LineEdit->setText(QString::fromStdString(m_Prop->Get()));
+        }
+    });
+}
+StringPropertyWidget::~StringPropertyWidget() {}
+
+FontPropertyWidget::FontPropertyWidget(Property<FontConfig>* prop, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+    m_Button = new QPushButton(this);
+    m_Button->setMinimumWidth(100);
+    this->updateButtonText();
+    m_Layout->addWidget(m_Button, 1);
+    
+    connect(m_Button, &QPushButton::clicked, this, &FontPropertyWidget::onClicked);
+    m_Connection = uLib::Object::connect(m_Prop, &Property<FontConfig>::Updated, [this](){
+        this->updateButtonText();
+    });
+}
+FontPropertyWidget::~FontPropertyWidget() {}
+
+void FontPropertyWidget::updateButtonText() {
+    FontConfig f = m_Prop->Get();
+    m_Button->setText(QString::fromStdString(f.family) + " " + QString::number(f.size));
+}
+
+void FontPropertyWidget::onClicked() {
+    FontConfig current = m_Prop->Get();
+    QFont font(QString::fromStdString(current.family), current.size);
+    font.setBold(current.bold);
+    font.setItalic(current.italic);
+    
+    bool ok;
+    QFont selected = QFontDialog::getFont(&ok, font, this, "Select Font");
+    if (ok) {
+        FontConfig newF(selected.family().toStdString(), selected.pointSize(), selected.bold(), selected.italic());
+        m_Prop->Set(newF);
+        emit updated();
+    }
+}
+
+class GroupHeaderWidget : public QWidget {
+public:
+    GroupHeaderWidget(const QString& name, QWidget* parent = nullptr) : QWidget(parent) {
+        auto* layout = new QVBoxLayout(this);
+        layout->setContentsMargins(0, 8, 0, 4);
+        auto* line = new QFrame(this);
+        line->setFrameShape(QFrame::HLine);
+        line->setFrameShadow(QFrame::Sunken);
+        line->setStyleSheet("color: #555;");
+        layout->addWidget(line);
+        auto* label = new QLabel(name, this);
+        QFont font = label->font();
+        font.setBold(true);
+        font.setPointSize(font.pointSize() + 1);
+        label->setFont(font);
+        label->setStyleSheet("color: #aaa; text-transform: uppercase;");
+        layout->addWidget(label);
+    }
+};
+
+class EnumPropertyWidget : public PropertyWidgetBase {
+    PropertyBase* m_Prop;
+    QComboBox* m_Combo;
+public:
+    EnumPropertyWidget(PropertyBase* prop, QWidget* parent)
+        : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+        m_Combo = new QComboBox(this);
+        const auto& labels = prop->GetEnumLabels();
+        for (const auto& label : labels) {
+            m_Combo->addItem(QString::fromStdString(label));
+        }
+
+        // Get initial value
+        if (auto* p = dynamic_cast<Property<int>*>(prop)) {
+            m_Combo->setCurrentIndex(p->Get());
+            connect(m_Combo, &QComboBox::currentIndexChanged, [this, p](int index){
+                p->Set(index);
+                emit updated();
+            });
+            // Store connection in base m_Connection so it's auto-disconnected on destruction.
+            m_Connection = uLib::Object::connect(p, &Property<int>::Updated, [this, p](){
+                if (m_Combo->currentIndex() != p->Get()) {
+                    QSignalBlocker blocker(m_Combo);
+                    m_Combo->setCurrentIndex(p->Get());
+                }
+            });
+        }
+
+        m_Layout->addWidget(m_Combo, 1);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// ReferencePropertyWidget
+
+ReferencePropertyWidget::ReferencePropertyWidget(ReferencePropertyBase* prop, ::uLib::ObjectsContext* context, QWidget* parent)
+    : PropertyWidgetBase(prop, parent), m_RefProp(prop), m_Context(context) {
+    m_Combo = new QComboBox(static_cast<QWidget*>(this));
+    m_Layout->addWidget(m_Combo, 1);
+    refreshCombo();
+    connect(m_Combo, &QComboBox::currentIndexChanged, this, &ReferencePropertyWidget::onComboChanged);
+
+    // Listen for property updates to refresh selected item
+    m_Connection = uLib::Object::connect(prop, &uLib::Object::Updated, [this](){
+        QSignalBlocker blocker(m_Combo);
+        refreshCombo();
+    });
+
+    // Listen for context changes to refresh the dropdown list
+    if (m_Context) {
+        m_ContextConnection = uLib::Object::connect(m_Context, &uLib::Object::Updated, [this](){
+            QSignalBlocker blocker(m_Combo);
+            refreshCombo();
+        });
+    }
+}
+
+ReferencePropertyWidget::~ReferencePropertyWidget() {
+    m_Connection.disconnect();
+    m_ContextConnection.disconnect();
+}
+
+void ReferencePropertyWidget::refreshCombo() {
+    m_Combo->clear();
+    m_Combo->addItem("(none)", QVariant::fromValue((quintptr)0));
+
+    int selectedIdx = 0;
+    Object* currentRef = m_RefProp->GetReferencedObject();
+
+    if (m_Context) {
+        const auto& objects = m_Context->GetObjects();
+        for (const auto& obj : objects) {
+            if (m_RefProp->IsCompatible(obj.get())) {
+                QString label = QString::fromStdString(obj->GetInstanceName());
+                if (label.isEmpty()) {
+                    label = QString::fromStdString(std::string(obj->GetClassName()));
+                }
+                // Add index suffix if name is empty to disambiguate
+                m_Combo->addItem(label, QVariant::fromValue((quintptr)obj.get()));
+                if (obj.get() == currentRef) {
+                    selectedIdx = m_Combo->count() - 1;
+                }
+            }
+        }
+    }
+    m_Combo->setCurrentIndex(selectedIdx);
+}
+
+void ReferencePropertyWidget::onComboChanged(int index) {
+    if (index < 0) return;
+    quintptr ptr = m_Combo->itemData(index).value<quintptr>();
+    Object* obj = reinterpret_cast<Object*>(ptr);
+    m_RefProp->SetReferencedObject(obj);
+    Q_EMIT updated();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PropertyEditor
+
+PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr), m_Context(nullptr) {
+    m_MainLayout = new QVBoxLayout(this);
+    m_MainLayout->setContentsMargins(0, 0, 0, 0);
+    m_ScrollArea = new QScrollArea(this);
+    m_ScrollArea->setWidgetResizable(true);
+    m_MainLayout->addWidget(m_ScrollArea);
+    m_Container = new QWidget();
+    m_ContainerLayout = new QVBoxLayout(m_Container);
+    m_ContainerLayout->setAlignment(::Qt::AlignTop);
+    m_ScrollArea->setWidget(m_Container);
+    
+    registerFactory<double>([](PropertyBase* p, QWidget* parent){
+        return new DoublePropertyWidget(static_cast<Property<double>*>(p), parent);
+    });
+    registerFactory<float>([](PropertyBase* p, QWidget* parent){
+        return new FloatPropertyWidget(static_cast<Property<float>*>(p), parent);
+    });
+    registerFactory<int>([](PropertyBase* p, QWidget* parent){
+        return new IntPropertyWidget(static_cast<Property<int>*>(p), parent);
+    });
+    registerFactory<bool>([](PropertyBase* p, QWidget* parent){
+        return new BoolPropertyWidget(static_cast<Property<bool>*>(p), parent);
+    });
+    registerFactory<std::string>([](PropertyBase* p, QWidget* parent){
+        return new StringPropertyWidget(static_cast<Property<std::string>*>(p), parent);
+    });
+    registerFactory<FontConfig>([](PropertyBase* p, QWidget* parent){
+        return new FontPropertyWidget(static_cast<Property<FontConfig>*>(p), parent);
+    });
+    
+    // Register EnumProperty specifically (needs to check type since it holds Property<int> but is EnumProperty)
+    m_Factories[std::type_index(typeid(EnumProperty))] = [](PropertyBase* p, QWidget* parent) {
+        return new EnumPropertyWidget(p, parent);
+    };
+
+    // Vector Registration
+    registerFactory<Vector2i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2i, 2>(static_cast<Property<Vector2i>*>(p), parent); });
+    registerFactory<Vector2f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2f, 2>(static_cast<Property<Vector2f>*>(p), parent); });
+    registerFactory<Vector2d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2d, 2>(static_cast<Property<Vector2d>*>(p), parent); });
+    registerFactory<Vector3i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3i, 3>(static_cast<Property<Vector3i>*>(p), parent); });
+    registerFactory<Vector3f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3f, 3>(static_cast<Property<Vector3f>*>(p), parent); });
+    registerFactory<Vector3d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3d, 3>(static_cast<Property<Vector3d>*>(p), parent); });
+    registerFactory<Vector4i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4i, 4>(static_cast<Property<Vector4i>*>(p), parent); });
+    registerFactory<Vector4f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4f, 4>(static_cast<Property<Vector4f>*>(p), parent); });
+    registerFactory<Vector4d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4d, 4>(static_cast<Property<Vector4d>*>(p), parent); });
+}
+
+PropertyEditor::~PropertyEditor() {}
+
+void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
+    m_Object = obj;
+    clear();
+    if (!obj) return;
+    
+    // Choose which properties to show
+    const std::vector<::uLib::PropertyBase*>* props = &obj->GetProperties();
+    
+    if (displayOnly) {
+        if (auto* prop3d = dynamic_cast<::uLib::Vtk::Prop3D*>(obj)) {
+            props = &prop3d->GetDisplayProperties();
+        } else {
+            // If it's not a prop3d but displayOnly is requested, showing nothing or fallback?
+            // Fallback: core properties.
+        }
+    }
+
+    // Group properties by their group string
+    std::map<std::string, std::vector<::uLib::PropertyBase*>> groupedProps;
+    std::vector<std::string> groupOrder;
+    
+    for (auto* prop : *props) {
+        std::string group = prop->GetGroup();
+        if (groupedProps.find(group) == groupedProps.end()) {
+            groupOrder.push_back(group);
+        }
+        groupedProps[group].push_back(prop);
+    }
+
+    for (const auto& groupName : groupOrder) {
+        if (!groupName.empty()) {
+            m_ContainerLayout->addWidget(new GroupHeaderWidget(QString::fromStdString(groupName), m_Container));
+        }
+
+        for (auto* prop : groupedProps[groupName]) {
+            QWidget* widget = nullptr;
+            
+            // Priority 1: Check if it provides enum labels
+            if (!prop->GetEnumLabels().empty()) {
+                widget = new EnumPropertyWidget(prop, m_Container);
+            } else if (prop->GetUnits() == "color") {
+                // Color Picker for Vector3d
+                if (auto* pvec = dynamic_cast<Property<Vector3d>*>(prop)) {
+                    widget = new ColorPropertyWidget(pvec, m_Container);
+                }
+            } else if (prop->HasRange()) {
+                // Slider for ranged doubles
+                if (auto* pdbl = dynamic_cast<Property<double>*>(prop)) {
+                    widget = new RangePropertyWidget(pdbl, m_Container);
+                } else if (auto* pflt = dynamic_cast<Property<float>*>(prop)) {
+                     // widget = new RangePropertyWidget<float>(pflt, m_Container);
+                }
+            } else {
+                // Priority 2: Check for reference properties (SmartPointer<T>)
+                if (auto* refProp = dynamic_cast<::uLib::ReferencePropertyBase*>(prop)) {
+                    widget = static_cast<QWidget*>(new ReferencePropertyWidget(refProp, m_Context, m_Container));
+                } else {
+                    // Priority 3: Standard factory lookup
+                    auto it = m_Factories.find(prop->GetTypeIndex());
+                    if (it != m_Factories.end()) {
+                        widget = it->second(prop, m_Container);
+                    } else {
+                        // Debug info for unknown types
+                        std::cout << "PropertyEditor: No factory for " << prop->GetQualifiedName() 
+                                  << " (Type: " << prop->GetTypeName() << ")" << std::endl;
+
+                        widget = new PropertyWidgetBase(prop, m_Container);
+                        widget->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
+                    }
+                }
+            }
+
+            if (widget) {
+                if (auto* propWidget = qobject_cast<PropertyWidgetBase*>(widget)) {
+                    connect(propWidget, &PropertyWidgetBase::updated, [this, prop](){
+                        emit propertyUpdated(prop);
+                    });
+                }
+
+                if (!groupName.empty()) {
+                    // Indent grouped properties
+                    widget->setContentsMargins(16, 0, 0, 0);
+                }
+                m_ContainerLayout->addWidget(widget);
+            }
+        }
+    }
+    m_ContainerLayout->addStretch(1);
+}
+
+void PropertyEditor::clear() {
+    QLayoutItem* item;
+    while ((item = m_ContainerLayout->takeAt(0)) != nullptr) {
+        delete item->widget();
+        delete item;
+    }
+}
+
+} // namespace Qt
+} // namespace uLib

app/gcompose/src/PropertyWidgets.h

@@ -0,0 +1,261 @@
+#ifndef PROPERTY_WIDGETS_H
+#define PROPERTY_WIDGETS_H
+
+#include <QWidget>
+class QPushButton;
+class QSlider;
+class QComboBox;
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QLineEdit>
+#include <QCheckBox>
+#include <QScrollArea>
+#include <map>
+#include <typeindex>
+#include <functional>
+
+#include "Core/Property.h"
+#include "Core/Object.h"
+#include "Core/Signal.h"
+#include "Core/FontConfig.h"
+#include "Math/Dense.h"
+#include "Settings.h"
+
+namespace uLib { class ObjectsContext; }
+
+namespace uLib {
+namespace Qt {
+
+double parseWithUnits(const QString& text, double* factorOut = nullptr, QString* suffixOut = nullptr);
+
+class PropertyWidgetBase : public QWidget {
+    Q_OBJECT
+public:
+    PropertyWidgetBase(PropertyBase* prop, QWidget* parent = nullptr);
+    virtual ~PropertyWidgetBase();
+    PropertyBase* getProperty() const { return m_BaseProperty; }
+
+signals:
+    void updated();
+
+protected:
+    PropertyBase* m_BaseProperty;
+    QHBoxLayout* m_Layout;
+    QLabel* m_Label;
+    // Stores the uLib signal connection so it can be disconnected on destruction,
+    // preventing use-after-free when PropertyEditor::clear() deletes widgets.
+    Connection m_Connection;
+};
+
+class UnitLineEdit : public QLineEdit {
+    Q_OBJECT
+public:
+    UnitLineEdit(QWidget* parent = nullptr);
+    void setValue(double val);
+    void setUnits(const QString& suffix, double factor = 1.0);
+    double getValue() const { return m_Value; }
+    void setIntegerOnly(bool b);
+
+signals:
+    void valueManualChanged(double val);
+
+private slots:
+    void onEditingFinished();
+
+private:
+    void updateText();
+    double m_Value;
+    double m_Factor;
+    QString m_Suffix;
+    bool m_IsInteger;
+};
+
+class DoublePropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    DoublePropertyWidget(Property<double>* prop, QWidget* parent = nullptr);
+private:
+    Property<double>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+class FloatPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    FloatPropertyWidget(Property<float>* prop, QWidget* parent = nullptr);
+private:
+    Property<float>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+class IntPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    IntPropertyWidget(Property<int>* prop, QWidget* parent = nullptr);
+private:
+    Property<int>* m_Prop;
+    UnitLineEdit* m_Edit;
+};
+
+template <typename VecT, int Size>
+class VectorPropertyWidget : public PropertyWidgetBase {
+public:
+    VectorPropertyWidget(Property<VecT>* prop, QWidget* parent = nullptr)
+        : PropertyWidgetBase(prop, parent), m_Prop(prop) {
+        
+        std::string unit = prop->GetUnits();
+        double factor = 1.0;
+        QString prefSuffix;
+        if (!unit.empty()) {
+            auto dim = Settings::Instance().IdentifyDimension(unit);
+            std::string pref = Settings::Instance().GetPreferredUnit(dim);
+            factor = Settings::Instance().GetUnitFactor(pref);
+            prefSuffix = QString::fromStdString(pref);
+        }
+
+        for (int i = 0; i < Size; ++i) {
+            m_Edits[i] = new UnitLineEdit(this);
+            if (std::is_integral<typename VecT::Scalar>::value) {
+                m_Edits[i]->setIntegerOnly(true);
+            }
+            if (!prefSuffix.isEmpty()) {
+               m_Edits[i]->setUnits(prefSuffix, factor);
+            }
+            m_Edits[i]->setEnabled(!prop->IsReadOnly());
+            m_Layout->addWidget(m_Edits[i], 1);
+            
+            connect(m_Edits[i], &UnitLineEdit::valueManualChanged, [this, i](double val){
+                VecT v = m_Prop->Get();
+                v(i) = (typename VecT::Scalar)val;
+                if (m_Prop->Get() != v) {
+                    m_Prop->Set(v);
+                    emit updated();
+                }
+            });
+        }
+        updateEdits();
+        m_Connection = uLib::Object::connect(m_Prop, &Property<VecT>::Updated, [this](){
+            updateEdits();
+        });
+    }
+    ~VectorPropertyWidget() { m_Connection.disconnect(); }
+
+private:
+    void updateEdits() {
+        VecT v = m_Prop->Get();
+        for (int i = 0; i < Size; ++i) {
+            if (!m_Edits[i]->hasFocus()) {
+                m_Edits[i]->setValue((double)v(i));
+            }
+        }
+    }
+    Property<VecT>* m_Prop;
+    UnitLineEdit* m_Edits[Size];
+};
+
+class RangePropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    RangePropertyWidget(Property<double>* prop, QWidget* parent = nullptr);
+    virtual ~RangePropertyWidget();
+private slots:
+    void onSliderChanged(int val);
+private:
+    void updateUi();
+    Property<double>* m_Prop;
+    QSlider* m_Slider;
+    UnitLineEdit* m_Edit;
+};
+
+class BoolPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    BoolPropertyWidget(Property<bool>* prop, QWidget* parent = nullptr);
+    virtual ~BoolPropertyWidget();
+private:
+    Property<bool>* m_Prop;
+    QCheckBox* m_CheckBox;
+};
+
+class ColorPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    ColorPropertyWidget(Property<Vector3d>* prop, QWidget* parent = nullptr);
+    virtual ~ColorPropertyWidget();
+private slots:
+    void onClicked();
+private:
+    void updateButtonColor();
+    Property<Vector3d>* m_Prop;
+    QPushButton* m_Button;
+};
+
+class StringPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    StringPropertyWidget(Property<std::string>* prop, QWidget* parent = nullptr);
+    virtual ~StringPropertyWidget();
+private:
+    Property<std::string>* m_Prop;
+    QLineEdit* m_LineEdit;
+};
+
+class FontPropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    FontPropertyWidget(Property<FontConfig>* prop, QWidget* parent = nullptr);
+    virtual ~FontPropertyWidget();
+private slots:
+    void onClicked();
+private:
+    void updateButtonText();
+    Property<FontConfig>* m_Prop;
+    QPushButton* m_Button;
+};
+
+class ReferencePropertyWidget : public PropertyWidgetBase {
+    Q_OBJECT
+public:
+    ReferencePropertyWidget(ReferencePropertyBase* prop, ::uLib::ObjectsContext* context, QWidget* parent = nullptr);
+    virtual ~ReferencePropertyWidget();
+private slots:
+    void onComboChanged(int index);
+private:
+    void refreshCombo();
+    ReferencePropertyBase* m_RefProp;
+    ::uLib::ObjectsContext* m_Context;
+    QComboBox* m_Combo;
+    Connection m_ContextConnection;
+};
+
+class PropertyEditor : public QWidget {
+    Q_OBJECT
+public:
+    PropertyEditor(QWidget* parent = nullptr);
+    virtual ~PropertyEditor();
+    void setObject(uLib::Object* obj, bool displayOnly = false);
+    void setContext(uLib::ObjectsContext* context) { m_Context = context; }
+    template<typename T>
+    void registerFactory(std::function<QWidget*(PropertyBase*, QWidget*)> factory) {
+        m_Factories[std::type_index(typeid(T))] = factory;
+    }
+
+signals:
+    void propertyUpdated(PropertyBase* prop = nullptr);
+
+private:
+    void clear();
+    uLib::Object* m_Object;
+    uLib::ObjectsContext* m_Context;
+    QVBoxLayout* m_MainLayout;
+    QScrollArea* m_ScrollArea;
+    QWidget* m_Container;
+    QVBoxLayout* m_ContainerLayout;
+    std::map<std::type_index, std::function<QWidget*(PropertyBase*, QWidget*)>> m_Factories;
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif // PROPERTY_WIDGETS_H

app/gcompose/src/QViewportPane.cpp

@@ -0,0 +1,231 @@
+#include "QViewportPane.h"
+#include <Vtk/vtkQViewport.h>
+#include <Root/QCanvas.h>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QToolButton>
+#include <QMenu>
+#include <QAction>
+#include <QSplitter>
+#include <vtkCamera.h>
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+
+QViewportPane::QViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullptr) {
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 0, 0);
+
+    m_titleLabel = new QLabel("Viewport", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    
+    m_toggleBtn = new QPushButton("Display", m_titleBar);
+    m_toggleBtn->setCheckable(true);
+    m_toggleBtn->setFixedSize(60, 18);
+    m_toggleBtn->setObjectName("DisplayToggleBtn");
+
+    auto* closeBtn = new QToolButton(m_titleBar);
+    closeBtn->setObjectName("PaneCloseButton");
+    closeBtn->setText("X");
+    closeBtn->setFixedSize(18, 18);
+
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+    titleLayout->addWidget(m_toggleBtn);
+    titleLayout->addSpacing(5);
+    titleLayout->addWidget(closeBtn);
+
+    m_layout->addWidget(m_titleBar);
+
+    // Main horizontal container for viewport and display panel
+    QWidget* mainArea = new QWidget(this);
+    QHBoxLayout* hLayout = new QHBoxLayout(mainArea);
+    hLayout->setContentsMargins(0, 0, 0, 0);
+    hLayout->setSpacing(0);
+    m_layout->addWidget(mainArea);
+
+    // Viewport will be added here via setViewport
+    m_viewport = new uLib::Vtk::QViewport(mainArea);
+    hLayout->addWidget(m_viewport);
+
+    // Display Panel (Overlay/Slide-out)
+    m_displayPanel = new QFrame(mainArea);
+    m_displayPanel->setObjectName("DisplayPropertiesPanel");
+    m_displayPanel->setFixedWidth(250);
+    m_displayPanel->hide();
+    
+    QVBoxLayout* panelLayout = new QVBoxLayout(m_displayPanel);
+    panelLayout->setContentsMargins(5, 5, 5, 5);
+    
+    QLabel* panelHeader = new QLabel("Display Properties", m_displayPanel);
+    panelHeader->setStyleSheet("font-weight: bold; padding: 5px;");
+    panelLayout->addWidget(panelHeader);
+
+    m_displayEditor = new uLib::Qt::PropertyEditor(m_displayPanel);
+    panelLayout->addWidget(m_displayEditor);
+    
+    hLayout->addWidget(m_displayPanel);
+
+    connect(m_toggleBtn, &QPushButton::toggled, this, &QViewportPane::toggleDisplayPanel);
+    connect(m_titleBar, &QWidget::customContextMenuRequested, this, &QViewportPane::showContextMenu);
+    connect(closeBtn, &QToolButton::clicked, this, &QViewportPane::onCloseRequested);
+
+    m_titleBar->setContextMenuPolicy(Qt::CustomContextMenu);
+}
+
+void QViewportPane::toggleDisplayPanel() {
+    m_displayPanel->setVisible(m_toggleBtn->isChecked());
+}
+
+void QViewportPane::setObject(uLib::Object* obj) {
+    m_displayEditor->setObject(obj, true);
+    // Auto-show panel if it's a prop3d and we want to highlight this feature?
+    // User asked for "hiding panel", so maybe we don't auto-show.
+}
+
+void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
+    if (m_viewport) {
+        m_viewport->parentWidget()->layout()->removeWidget(m_viewport);
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    auto* mainAreaLayout = static_cast<QHBoxLayout*>(m_displayPanel->parentWidget()->layout());
+    mainAreaLayout->insertWidget(0, m_viewport);
+}
+
+
+QViewportPane::~QViewportPane() {}
+
+void QViewportPane::setViewport(QWidget* viewport, const QString& title) {
+    if (m_viewport) {
+        m_layout->removeWidget(m_viewport);
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    m_layout->addWidget(m_viewport);
+}
+
+void QViewportPane::addVtkViewport() {
+    auto* viewport = new uLib::Vtk::QViewport(this);
+    setViewport(viewport, "VTK Viewport");
+}
+
+void QViewportPane::addRootCanvas() {
+    auto* canvas = new uLib::Root::QCanvas(this);
+    setViewport(canvas, "ROOT Canvas");
+}
+
+void QViewportPane::onCloseRequested() {
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(parentWidget());
+    if (parentSplitter && parentSplitter->count() > 1) {
+        deleteLater();
+    } else {
+        // Can't close the last viewport in the splitter safely. Re-initialize to default VTK canvas.
+        addVtkViewport();
+    }
+}
+
+void QViewportPane::showContextMenu(const QPoint& pos) {
+    QMenu menu(this);
+    QAction* hSplit = menu.addAction("H split");
+    QAction* vSplit = menu.addAction("V split");
+    menu.addSeparator();
+    
+    bool isVtk = (qobject_cast<uLib::Vtk::QViewport*>(m_viewport) != nullptr);
+
+    QAction* changeType = menu.addAction(isVtk ? "Change to ROOT Canvas" : "Change to VTK Viewport");
+
+    QAction* selected = menu.exec(m_titleBar->mapToGlobal(pos));
+    
+    if (selected == hSplit) {
+        AttemptSplit(Qt::Horizontal);
+    } else if (selected == vSplit) {
+        AttemptSplit(Qt::Vertical);
+    } else if (selected == changeType) {
+        if (isVtk) {
+            addRootCanvas();
+        } else {
+            addVtkViewport();
+        }
+    }
+}
+
+void QViewportPane::AttemptSplit(Qt::Orientation orientation) {
+    QWidget* p = parentWidget();
+    if (!p) return;
+
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(p);
+    if (!parentSplitter) return;
+
+    QViewportPane* newPane = new QViewportPane();
+
+    // 1. Synchronize viewport content and camera (VTK Viewport only for now)
+    auto* currentVtk = qobject_cast<uLib::Vtk::QViewport*>(m_viewport);
+    if (currentVtk) {
+        auto* newVtk = qobject_cast<uLib::Vtk::QViewport*>(newPane->currentViewport());
+        if (newVtk) {
+            // Copy prop3ds
+            for (auto* prop3d : currentVtk->getProp3Ds()) {
+                newVtk->AddProp3D(*prop3d);
+            }
+            // Copy camera
+            if (currentVtk->GetRenderer() && newVtk->GetRenderer()) {
+                vtkCamera* currentCam = currentVtk->GetRenderer()->GetActiveCamera();
+                vtkCamera* newCam = newVtk->GetRenderer()->GetActiveCamera();
+                if (currentCam && newCam) {
+                    newCam->DeepCopy(currentCam);
+                }
+            }
+            // Sync grid visible and axis
+            newVtk->SetGridVisible(currentVtk->GetGridVisible());
+            newVtk->SetGridAxis(currentVtk->GetGridAxis());
+        }
+    }
+
+    // 2. Adjust for ROOT Canvas if that was the active view
+    bool isRoot = (qobject_cast<uLib::Root::QCanvas*>(m_viewport) != nullptr);
+    if (isRoot) {
+        newPane->addRootCanvas();
+    }
+
+    if (parentSplitter->orientation() == orientation) {
+        int index = parentSplitter->indexOf(this);
+        QList<int> sizes = parentSplitter->sizes();
+        int currentSize = sizes.value(index, 0);
+        int half = currentSize / 2;
+        sizes[index] = half;
+        sizes.insert(index + 1, currentSize - half);
+        
+        parentSplitter->insertWidget(index + 1, newPane);
+        parentSplitter->setSizes(sizes);
+    } else {
+        int index = parentSplitter->indexOf(this);
+        QList<int> parentSizes = parentSplitter->sizes();
+        
+        QSplitter* newSplitter = new QSplitter(orientation);
+        newSplitter->addWidget(this);
+        newSplitter->addWidget(newPane);
+        
+        QList<int> subSizes;
+        subSizes << 500 << 500;
+        newSplitter->setSizes(subSizes);
+        
+        parentSplitter->insertWidget(index, newSplitter);
+        parentSplitter->setSizes(parentSizes);
+    }
+}

app/gcompose/src/QViewportPane.h

@@ -0,0 +1,50 @@
+#ifndef QVIEWPORTPANE_H
+#define QVIEWPORTPANE_H
+
+#include <QWidget>
+#include <QFrame>
+#include <QPushButton>
+
+namespace uLib {
+    class Object;
+    namespace Qt { class PropertyEditor; }
+}
+
+class QVBoxLayout;
+class QLabel;
+
+class QViewportPane : public QWidget {
+    Q_OBJECT
+public:
+    explicit QViewportPane(QWidget* parent = nullptr);
+    virtual ~QViewportPane();
+
+    void addVtkViewport();
+    void addRootCanvas();
+
+    QWidget* currentViewport() const { return m_viewport; }
+    
+    /** @brief Update the display properties for the given object. */
+    void setObject(uLib::Object* obj);
+
+private slots:
+    void onCloseRequested();
+    void showContextMenu(const QPoint& pos);
+    void toggleDisplayPanel();
+
+private:
+    void AttemptSplit(Qt::Orientation orientation);
+    void setViewport(QWidget* viewport, const QString& title);
+
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    QWidget* m_viewport;
+
+    // Display Properties Overlay
+    QFrame* m_displayPanel;
+    uLib::Qt::PropertyEditor* m_displayEditor;
+    QPushButton* m_toggleBtn;
+};
+
+#endif // QVIEWPORTPANE_H

app/gcompose/src/Settings.h

@@ -0,0 +1,102 @@
+#ifndef GCOMPOSE_SETTINGS_H
+#define GCOMPOSE_SETTINGS_H
+
+#include <string>
+#include <map>
+#include "Math/Units.h"
+#include "Core/FontConfig.h"
+#include "Math/Dense.h"
+
+namespace uLib {
+namespace Qt {
+
+class Settings {
+public:
+    static Settings& Instance() {
+        static Settings instance;
+        return instance;
+    }
+
+    enum Dimension {
+        Length,
+        Angle,
+        Energy,
+        Time,
+        Dimensionless
+    };
+
+    enum Theme {
+        Dark,
+        Bright
+    };
+
+    void SetPreferredUnit(Dimension dim, const std::string& unit) {
+        m_PreferredUnits[dim] = unit;
+    }
+
+    std::string GetPreferredUnit(Dimension dim) const {
+        auto it = m_PreferredUnits.find(dim);
+        if (it != m_PreferredUnits.end()) return it->second;
+        
+        switch(dim) {
+            case Length: return "mm";
+            case Angle: return "deg";
+            case Energy: return "MeV";
+            case Time: return "ns";
+            default: return "";
+        }
+    }
+
+    double GetUnitFactor(const std::string& unit) const {
+        if (unit == "m") return CLHEP::meter;
+        if (unit == "cm") return CLHEP::centimeter;
+        if (unit == "mm") return CLHEP::millimeter;
+        if (unit == "um") return CLHEP::micrometer;
+        if (unit == "deg") return CLHEP::degree;
+        if (unit == "rad") return CLHEP::radian;
+        if (unit == "ns") return CLHEP::nanosecond;
+        if (unit == "s") return CLHEP::second;
+        if (unit == "ms") return CLHEP::millisecond;
+        if (unit == "MeV") return CLHEP::megaelectronvolt;
+        if (unit == "GeV") return CLHEP::gigaelectronvolt;
+        if (unit == "eV") return CLHEP::electronvolt;
+        return 1.0;
+    }
+
+    Dimension IdentifyDimension(const std::string& unit) const {
+        if (unit == "m" || unit == "cm" || unit == "mm" || unit == "um" || unit == "nm") return Length;
+        if (unit == "deg" || unit == "rad") return Angle;
+        if (unit == "MeV" || unit == "GeV" || unit == "eV" || unit == "keV" || unit == "TeV") return Energy;
+        if (unit == "ns" || unit == "s" || unit == "ms" || unit == "us") return Time;
+        return Dimensionless;
+    }
+
+    bool GetThrottledRendering() const { return m_ThrottledRendering; }
+    void SetThrottledRendering(bool enabled) { m_ThrottledRendering = enabled; }
+
+    Theme GetTheme() const { return m_Theme; }
+    void SetTheme(Theme theme) { m_Theme = theme; }
+
+    FontConfig GetFont() const { return m_Font; }
+    void SetFont(const FontConfig& font) { m_Font = font; }
+
+    FontConfig GetGuiFont() const { return m_GuiFont; }
+    void SetGuiFont(const FontConfig& font) { m_GuiFont = font; }
+
+    Vector3d GetFontColor() const { return m_FontColor; }
+    void SetFontColor(const Vector3d& color) { m_FontColor = color; }
+
+private:
+    Settings() : m_ThrottledRendering(true), m_Theme(Dark), m_Font("Arial", 10), m_GuiFont("Inter", 9), m_FontColor(1.0, 1.0, 1.0) {}
+    std::map<Dimension, std::string> m_PreferredUnits;
+    bool m_ThrottledRendering;
+    Theme m_Theme;
+    FontConfig m_Font;
+    FontConfig m_GuiFont;
+    Vector3d m_FontColor;
+};
+
+} // namespace Qt
+} // namespace uLib
+
+#endif

app/gcompose/src/StyleManager.cpp

@@ -0,0 +1,128 @@
+#include "StyleManager.h"
+#include <QApplication>
+#include "Core/FontConfig.h"
+
+static const QString DARK_THEME = R"(
+QWidget#MenuPanel { background-color: #2b2b2b; border-bottom: 1px solid #111; }
+QLabel#LogoLabel { font-weight: bold; color: #0078d7; font-size: 14px; letter-spacing: 1px; }
+QPushButton#MenuButton { background: transparent; color: #ccc; border: none; padding: 5px 10px; }
+QPushButton#MenuButton:hover { background: #3c3c3c; color: white; border-radius: 4px; }
+QPushButton { background-color: #3e3e42; color: white; border: 1px solid #555; padding: 4px 12px; border-radius: 2px; }
+QPushButton:hover { background-color: #505050; border-color: #0078d7; }
+QPushButton:pressed { background-color: #0078d7; }
+QWidget#PaneTitleBar { background-color: #333; color: white; border-bottom: 2px solid #222; }
+QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
+QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #ccc; }
+QToolButton#PaneCloseButton:hover { color: white; background: #c42b1c; }
+
+/* Global & Panel Backgrounds */
+QMainWindow, QWidget#MainPanel { background-color: #1e1e1e; }
+QWidget#DisplayPropertiesPanel, QWidget#PropertiesPanel, QWidget#ContextPanel { background-color: #252526; border-left: 1px solid #3e3e42; }
+QPushButton#DisplayToggleBtn { background-color: #333337; border: 1px solid #3e3e42; border-radius: 2px; color: #f1f1f1; font-size: 11px; }
+QPushButton#DisplayToggleBtn:checked { background-color: #0078d7; color: white; border-color: #005a9e; font-weight: bold; }
+QPushButton#DisplayToggleBtn:hover { border-color: #0078d7; }
+
+QScrollArea { border: none; background: transparent; }
+QScrollArea > QWidget > QWidget { background: transparent; }
+
+/* Property Widgets Styling */
+QLabel { color: #cccccc; }
+QDoubleSpinBox, QSpinBox, QLineEdit, QComboBox { background: #3c3c3c; color: #f1f1f1; border: 1px solid #3e3e42; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
+QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus, QComboBox:focus { border-color: #0078d7; }
+QComboBox::drop-down { border-left-width: 1px; border-left-color: #3e3e42; border-left-style: solid; width: 20px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; }
+QComboBox::down-arrow { image: none; border: 5px solid transparent; border-top-color: #ccc; margin-top: 5px; }
+QAbstractItemView { background-color: #2b2b2b; color: white; border: 1px solid #3e3e42; selection-background-color: #0078d7; outline: 0; }
+QCheckBox { color: #cccccc; spacing: 5px; }
+QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #3e3e42; background: #333337; border-radius: 2px; }
+QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
+QCheckBox::indicator:hover { border-color: #0078d7; }
+
+QMenu { background-color: #2b2b2b; color: white; border: 1px solid #111; }
+QMenu::item:selected { background-color: #3c3c3c; }
+QTreeView#ContextTree { background-color: #1e1e1e; color: #ccc; border: none; }
+QTreeView#ContextTree::item:hover { background-color: #2a2d2e; }
+QTreeView#ContextTree::item:selected { background-color: #094771; color: white; }
+QHeaderView::section { background-color: #252526; color: #ccc; border: 1px solid #323233; padding: 4px; }
+
+/* ScrollBars */
+QScrollBar:vertical { background: #1e1e1e; width: 12px; margin: 0px; }
+QScrollBar::handle:vertical { background: #3e3e42; min-height: 20px; border-radius: 6px; margin: 2px; }
+QScrollBar::handle:vertical:hover { background: #505050; }
+QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
+
+/* Dialogs & Preferences */
+QDialog { background-color: #252526; color: #f1f1f1; }
+QGroupBox { font-weight: bold; color: #0078d7; border: 1px solid #3e3e42; margin-top: 1.1em; padding-top: 0.5em; border-radius: 4px; }
+QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top left; padding: 0 3px; left: 10px; }
+)";
+
+static const QString BRIGHT_THEME = R"(
+QWidget#MenuPanel { background-color: #f3f3f3; border-bottom: 1px solid #ccc; }
+QLabel#LogoLabel { font-weight: bold; color: #005a9e; font-size: 14px; letter-spacing: 1px; }
+QPushButton#MenuButton { background: transparent; color: #333; border: none; padding: 5px 10px; }
+QPushButton#MenuButton:hover { background: #e5e5e5; color: black; border-radius: 4px; }
+QPushButton { background-color: #ffffff; color: #333; border: 1px solid #cccccc; padding: 4px 12px; border-radius: 2px; }
+QPushButton:hover { background-color: #f2f2f2; border-color: #0078d7; }
+QPushButton:pressed { background-color: #0078d7; color: white; }
+QWidget#PaneTitleBar { background-color: #eeeeee; color: black; border-bottom: 2px solid #ddd; }
+QLabel#TitleLabel { font-weight: bold; margin-left: 2px; }
+QToolButton#PaneCloseButton { border: none; font-weight: bold; background: transparent; color: #666; }
+QToolButton#PaneCloseButton:hover { color: white; background: #e81123; }
+
+/* Global & Panel Backgrounds */
+QMainWindow, QWidget#MainPanel { background-color: #f3f3f3; }
+QWidget#DisplayPropertiesPanel, QWidget#PropertiesPanel, QWidget#ContextPanel { background-color: #ffffff; border-left: 1px solid #cccccc; }
+QPushButton#DisplayToggleBtn { background-color: #ffffff; border: 1px solid #cccccc; border-radius: 2px; color: #333; font-size: 11px; }
+QPushButton#DisplayToggleBtn:checked { background-color: #0078d7; color: white; border-color: #005a9e; font-weight: bold; }
+QPushButton#DisplayToggleBtn:hover { border-color: #0078d7; }
+
+QScrollArea { border: none; background: transparent; }
+QScrollArea > QWidget > QWidget { background: transparent; }
+
+/* Property Widgets Styling */
+QLabel { color: #333333; }
+QDoubleSpinBox, QSpinBox, QLineEdit, QComboBox { background: #ffffff; color: #333333; border: 1px solid #cccccc; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
+QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus, QComboBox:focus { border-color: #0078d7; }
+QComboBox::drop-down { border-left-width: 1px; border-left-color: #cccccc; border-left-style: solid; width: 20px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; }
+QComboBox::down-arrow { image: none; border: 5px solid transparent; border-top-color: #666; margin-top: 5px; }
+QAbstractItemView { background-color: #ffffff; color: #333; border: 1px solid #cccccc; selection-background-color: #0078d7; outline: 0; }
+QCheckBox { color: #333333; spacing: 5px; }
+QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #cccccc; background: #ffffff; border-radius: 2px; }
+QCheckBox::indicator:checked { background: #0078d7; border-color: #005a9e; }
+QCheckBox::indicator:hover { border-color: #0078d7; }
+
+QMenu { background-color: #f3f3f3; color: black; border: 1px solid #ccc; }
+QMenu::item:selected { background-color: #d0d0d0; }
+QTreeView#ContextTree { background-color: #ffffff; color: #333; border: none; }
+QTreeView#ContextTree::item:hover { background-color: #f2f2f2; }
+QTreeView#ContextTree::item:selected { background-color: #0078d7; color: white; }
+QHeaderView::section { background-color: #f3f3f3; color: #333; border: 1px solid #ccc; padding: 4px; }
+
+/* ScrollBars */
+QScrollBar:vertical { background: #ffffff; width: 12px; margin: 0px; }
+QScrollBar::handle:vertical { background: #cccccc; min-height: 20px; border-radius: 6px; margin: 2px; }
+QScrollBar::handle:vertical:hover { background: #aaaaaa; }
+QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0px; }
+
+/* Dialogs & Preferences */
+QDialog { background-color: #f3f3f3; color: #333; }
+QGroupBox { font-weight: bold; color: #005a9e; border: 1px solid #cccccc; margin-top: 1.1em; padding-top: 0.5em; border-radius: 4px; }
+QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top left; padding: 0 3px; left: 10px; }
+)";
+
+void StyleManager::applyStyle(QApplication* app, const QString& themeName, const uLib::FontConfig& fontCfg) {
+    if (!app) return;
+    
+    QString baseStyle = (themeName == "bright") ? BRIGHT_THEME : DARK_THEME;
+    
+    QString fontStyle = QString(
+        "QWidget { font-family: '%1'; font-size: %2pt; }\n"
+    ).arg(QString::fromStdString(fontCfg.family))
+     .arg(fontCfg.size);
+     
+    // If bold/italic are needed globally
+    if (fontCfg.bold) fontStyle += "QWidget { font-weight: bold; }\n";
+    if (fontCfg.italic) fontStyle += "QWidget { font-style: italic; }\n";
+
+    app->setStyleSheet(fontStyle + baseStyle);
+}

app/gcompose/src/StyleManager.h

@@ -0,0 +1,15 @@
+#ifndef STYLEMANAGER_H
+#define STYLEMANAGER_H
+
+#include <QString>
+
+class QApplication;
+
+namespace uLib { class FontConfig; }
+
+class StyleManager {
+public:
+    static void applyStyle(QApplication* app, const QString& themeName, const uLib::FontConfig& font);
+};
+
+#endif // STYLEMANAGER_H

app/gcompose/src/ViewportPane.cpp

@@ -0,0 +1,195 @@
+#include "ViewportPane.h"
+#include <Vtk/vtkQViewport.h>
+#include <Root/QCanvas.h>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QToolButton>
+#include <QMenu>
+#include <QAction>
+#include <QSplitter>
+#include <vtkCamera.h>
+#include "PropertyWidgets.h"
+#include <QSignalBlocker>
+
+ViewportPane::ViewportPane(QWidget* parent) : QWidget(parent), m_viewport(nullptr) {
+    m_layout = new QVBoxLayout(this);
+    m_layout->setContentsMargins(0, 0, 0, 0);
+    m_layout->setSpacing(0);
+
+    // Title bar setup
+    m_titleBar = new QWidget(this);
+    m_titleBar->setObjectName("PaneTitleBar");
+    m_titleBar->setFixedHeight(22);
+    
+    auto* titleLayout = new QHBoxLayout(m_titleBar);
+    titleLayout->setContentsMargins(5, 0, 0, 0);
+
+    m_titleLabel = new QLabel("Viewport", m_titleBar);
+    m_titleLabel->setObjectName("TitleLabel");
+    
+    m_toggleBtn = new QPushButton("Display", m_titleBar);
+    m_toggleBtn->setCheckable(true);
+    m_toggleBtn->setFixedSize(60, 18);
+    m_toggleBtn->setObjectName("DisplayToggleBtn");
+
+    auto* closeBtn = new QToolButton(m_titleBar);
+    closeBtn->setObjectName("PaneCloseButton");
+    closeBtn->setText("X");
+    closeBtn->setFixedSize(18, 18);
+
+    titleLayout->addWidget(m_titleLabel);
+    titleLayout->addStretch();
+    titleLayout->addWidget(m_toggleBtn);
+    titleLayout->addSpacing(5);
+    titleLayout->addWidget(closeBtn);
+
+    m_layout->addWidget(m_titleBar);
+
+    // Main area with splitter for viewport and display panel
+    m_areaSplitter = new QSplitter(Qt::Horizontal, this);
+    m_areaSplitter->setObjectName("ViewportAreaSplitter");
+    m_layout->addWidget(m_areaSplitter, 1);
+
+    // Viewport will be added here via setViewport
+    m_viewport = new uLib::Vtk::QViewport(m_areaSplitter);
+    m_areaSplitter->addWidget(m_viewport);
+
+    // Display Panel (Overlay/Slide-out)
+    m_displayPanel = new QFrame(m_areaSplitter);
+    m_displayPanel->setObjectName("DisplayPropertiesPanel");
+    m_displayPanel->setMinimumWidth(150);
+    m_displayPanel->hide();
+    
+    m_areaSplitter->addWidget(m_displayPanel);
+    m_areaSplitter->setStretchFactor(0, 1);
+    m_areaSplitter->setStretchFactor(1, 0);
+    
+    QVBoxLayout* panelLayout = new QVBoxLayout(m_displayPanel);
+    panelLayout->setContentsMargins(5, 5, 5, 5);
+    
+    QLabel* panelHeader = new QLabel("Display Properties", m_displayPanel);
+    panelHeader->setStyleSheet("font-weight: bold; padding: 5px;");
+    panelLayout->addWidget(panelHeader);
+
+    m_displayEditor = new uLib::Qt::PropertyEditor(m_displayPanel);
+    panelLayout->addWidget(m_displayEditor);
+
+    connect(m_toggleBtn, &QPushButton::toggled, this, &ViewportPane::toggleDisplayPanel);
+    connect(m_titleBar, &QWidget::customContextMenuRequested, this, &ViewportPane::showContextMenu);
+    connect(closeBtn, &QToolButton::clicked, this, &ViewportPane::onCloseRequested);
+
+    m_titleBar->setContextMenuPolicy(Qt::CustomContextMenu);
+}
+
+ViewportPane::~ViewportPane() {}
+
+void ViewportPane::toggleDisplayPanel() {
+    bool visible = m_toggleBtn->isChecked();
+    m_displayPanel->setVisible(visible);
+    if (visible && m_areaSplitter->sizes().value(1, 0) == 0) {
+        QList<int> sizes = m_areaSplitter->sizes();
+        int total = sizes[0] + sizes[1];
+        sizes[1] = 250;
+        sizes[0] = total - 250;
+        m_areaSplitter->setSizes(sizes);
+    }
+}
+
+void ViewportPane::setObject(uLib::Object* obj) {
+    m_displayEditor->setObject(obj, true);
+    
+    // Check if the object is a Prop3D (meaning it has display properties)
+    bool isProp3D = (dynamic_cast<::uLib::Vtk::Prop3D*>(obj) != nullptr);
+    
+    // Only show the "Display" toggle button if it's a prop3d
+    m_toggleBtn->setVisible(isProp3D);
+    
+    // If it's a prop3d, we might want to keep the panel state if it was already open,
+    // or if it's NOT a prop3d, definitely hide the toggle and panel.
+    if (!isProp3D) {
+        m_toggleBtn->setChecked(false);
+        m_displayPanel->hide();
+    }
+}
+
+void ViewportPane::setContext(uLib::ObjectsContext* context) {
+    m_displayEditor->setContext(context);
+}
+
+void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
+    if (m_viewport) {
+        delete m_viewport;
+    }
+    m_viewport = viewport;
+    m_titleLabel->setText(title);
+
+    m_viewport->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    m_areaSplitter->insertWidget(0, m_viewport);
+    m_areaSplitter->setStretchFactor(0, 1);
+}
+
+uLib::Vtk::Viewport* ViewportPane::viewport() const {
+    return dynamic_cast<uLib::Vtk::Viewport*>(m_viewport);
+}
+
+void ViewportPane::addVtkViewport() {
+    auto* viewport = new uLib::Vtk::QViewport(this);
+    setViewport(viewport, "VTK Viewport");
+}
+
+void ViewportPane::addRootCanvas() {
+    auto* canvas = new uLib::Root::QCanvas(this);
+    setViewport(canvas, "ROOT Canvas");
+}
+
+void ViewportPane::onCloseRequested() {
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(parentWidget());
+    if (parentSplitter && parentSplitter->count() > 1) {
+        deleteLater();
+    } else {
+        addVtkViewport();
+    }
+}
+
+void ViewportPane::showContextMenu(const QPoint& pos) {
+    QMenu menu(this);
+    QAction* hSplit = menu.addAction("H split");
+    QAction* vSplit = menu.addAction("V split");
+    menu.addSeparator();
+    bool isVtk = (qobject_cast<uLib::Vtk::QViewport*>(m_viewport) != nullptr);
+    QAction* changeType = menu.addAction(isVtk ? "Change to ROOT Canvas" : "Change to VTK Viewport");
+    QAction* selected = menu.exec(m_titleBar->mapToGlobal(pos));
+    if (selected == hSplit) AttemptSplit(Qt::Horizontal);
+    else if (selected == vSplit) AttemptSplit(Qt::Vertical);
+    else if (selected == changeType) isVtk ? addRootCanvas() : addVtkViewport();
+}
+
+void ViewportPane::AttemptSplit(Qt::Orientation orientation) {
+    QWidget* p = parentWidget();
+    if (!p) return;
+    QSplitter* parentSplitter = qobject_cast<QSplitter*>(p);
+    if (!parentSplitter) return;
+    ViewportPane* newPane = new ViewportPane();
+    if (parentSplitter->orientation() == orientation) {
+        int index = parentSplitter->indexOf(this);
+        QList<int> sizes = parentSplitter->sizes();
+        int currentSize = sizes.value(index, 0);
+        int half = currentSize / 2;
+        sizes[index] = half;
+        sizes.insert(index + 1, currentSize - half);
+        parentSplitter->insertWidget(index + 1, newPane);
+        parentSplitter->setSizes(sizes);
+    } else {
+        int index = parentSplitter->indexOf(this);
+        QList<int> parentSizes = parentSplitter->sizes();
+        QSplitter* newSplitter = new QSplitter(orientation);
+        newSplitter->addWidget(this);
+        newSplitter->addWidget(newPane);
+        QList<int> subSizes;
+        subSizes << 500 << 500;
+        newSplitter->setSizes(subSizes);
+        parentSplitter->insertWidget(index, newSplitter);
+        parentSplitter->setSizes(parentSizes);
+    }
+}

app/gcompose/src/ViewportPane.h

@@ -0,0 +1,58 @@
+#ifndef VIEWPORTPANE_H
+#define VIEWPORTPANE_H
+
+#include <QWidget>
+#include <QFrame>
+#include <QPushButton>
+
+namespace uLib {
+    class Object;
+    class ObjectsContext;
+    namespace Qt { class PropertyEditor; }
+    namespace Vtk { class Viewport; }
+}
+
+class QSplitter;
+class QVBoxLayout;
+class QLabel;
+
+class ViewportPane : public QWidget {
+    Q_OBJECT
+public:
+    explicit ViewportPane(QWidget* parent = nullptr);
+    virtual ~ViewportPane();
+
+    void addVtkViewport();
+    void addRootCanvas();
+
+    QWidget* currentViewport() const { return m_viewport; }
+    uLib::Vtk::Viewport* viewport() const;
+    
+    /** @brief Update the display properties for the given object. */
+    void setObject(uLib::Object* obj);
+    
+    /** @brief Sets the context for reference property dropdowns. */
+    void setContext(uLib::ObjectsContext* context);
+
+private slots:
+    void onCloseRequested();
+    void showContextMenu(const QPoint& pos);
+    void toggleDisplayPanel();
+
+private:
+    void AttemptSplit(Qt::Orientation orientation);
+    void setViewport(QWidget* viewport, const QString& title);
+
+    QVBoxLayout* m_layout;
+    QWidget* m_titleBar;
+    QLabel* m_titleLabel;
+    QSplitter* m_areaSplitter;
+    QWidget* m_viewport;
+
+    // Display Properties Overlay
+    QFrame* m_displayPanel;
+    uLib::Qt::PropertyEditor* m_displayEditor;
+    QPushButton* m_toggleBtn;
+};
+
+#endif // VIEWPORTPANE_H

app/gcompose/src/main.cpp

@@ -0,0 +1,59 @@
+#include <QApplication>
+#include "MainWindow.h"
+#include "MainPanel.h"
+#include "ViewportPane.h"
+#include "StyleManager.h"
+#include "Settings.h"
+#include "Core/FontConfig.h"
+
+#include "Math/ContainerBox.h"
+#include <HEP/Geant/Scene.h>
+#include "HEP/Detectors/DetectorChamber.h"
+#include "Vtk/HEP/Detectors/vtkDetectorChamber.h"
+
+#include <Vtk/Math/vtkContainerBox.h>
+#include <Vtk/vtkQViewport.h>
+
+#include "Core/ObjectsContext.h"
+
+#include <vtkSmartPointer.h>
+#include <vtkCubeSource.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkActor.h>
+#include <vtkRenderer.h>
+
+
+#include "Math/Units.h"
+#include <iostream>
+
+using namespace uLib;
+using namespace uLib::literals;
+
+int main(int argc, char** argv) {
+    QApplication app(argc, argv);
+    auto theme = uLib::Qt::Settings::Instance().GetTheme();
+    auto initialGuiFont = uLib::Qt::Settings::Instance().GetGuiFont();
+    StyleManager::applyStyle(&app, theme == uLib::Qt::Settings::Dark ? "dark" : "bright", initialGuiFont);
+    std::cout << "Starting gcompose Qt application..." << std::endl;
+
+    // ContainerBox world_box(Vector3f(1, 1, 1));
+    // world_box.Scale(Vector3f(2_mm, 2_mm, 2_mm));
+    // world_box.SetPosition(Vector3f(-1_mm, -1_mm, -1_mm));    
+
+    // Geant::Scene scene;
+    // scene.ConstructWorldBox(world_box.GetSize(), "G4_AIR");
+    // scene.Initialize();
+
+    uLib::ObjectsContext globalContext;
+    // globalContext.AddObject(&world_box);
+    // globalContext.AddObject(&scene);
+
+    // 2. Initialize MainWindow (contains embedded VTK QViewport)
+    MainWindow window;
+    window.setContext(&globalContext);
+    
+    std::cout << "Geant4 and VTK scenes are ready." << std::endl;
+    
+    window.show();
+    return app.exec();
+}

cmake_output.log

@@ -0,0 +1,217 @@
+-- Using Conan toolchain: /home/rigoni/devel/cmt/uLib/build/clang-make/conan_toolchain.cmake
+-- Conan toolchain: Defining architecture flag: -m64
+-- Conan toolchain: Defining libcxx as C++ flags: -stdlib=libstdc++
+-- Conan toolchain: C++ Standard 17 with extensions ON
+-- The C compiler identification is Clang 21.1.0
+-- The CXX compiler identification is Clang 21.1.0
+-- Detecting C compiler ABI info
+-- Detecting C compiler ABI info - done
+-- Check for working C compiler: /home/share/micromamba/envs/uLib/bin/clang - skipped
+-- Detecting C compile features
+-- Detecting C compile features - done
+-- Detecting CXX compiler ABI info
+-- Detecting CXX compiler ABI info - done
+-- Check for working CXX compiler: /home/share/micromamba/envs/uLib/bin/clang++ - skipped
+-- Detecting CXX compile features
+-- Detecting CXX compile features - done
+-- Project name = uLib
+-- Package name = mutom-0.7
+-- Package version = 0.7
+-- Module path = /home/rigoni/devel/cmt/uLib/CMake;/home/rigoni/devel/cmt/uLib/build/clang-make
+-- CMAKE_PREFIX_PATH is /home/rigoni/devel/cmt/uLib/build/clang-make
+-- Conan: Component target declared 'hdf5::hdf5'
+-- Conan: Component target declared 'hdf5::hdf5_cpp'
+-- Conan: Component target declared 'hdf5::hdf5_hl'
+-- Conan: Component target declared 'hdf5::hdf5_hl_cpp'
+-- Conan: Target declared 'HDF5::HDF5'
+-- Conan: Target declared 'ZLIB::ZLIB'
+-- Conan: Including build module from '/home/rigoni/.conan2/p/b/hdf509daaae89dd98/p/lib/cmake/conan-official-hdf5-variables.cmake'
+-- Conan: Component target declared 'Boost::diagnostic_definitions'
+-- Conan: Component target declared 'Boost::disable_autolinking'
+-- Conan: Component target declared 'Boost::dynamic_linking'
+-- Conan: Component target declared 'Boost::headers'
+-- Conan: Component target declared 'Boost::boost'
+-- Conan: Component target declared 'boost::_libboost'
+-- Conan: Component target declared 'Boost::atomic'
+-- Conan: Component target declared 'Boost::charconv'
+-- Conan: Component target declared 'Boost::container'
+-- Conan: Component target declared 'Boost::context'
+-- Conan: Component target declared 'Boost::date_time'
+-- Conan: Component target declared 'Boost::exception'
+-- Conan: Component target declared 'Boost::math'
+-- Conan: Component target declared 'Boost::program_options'
+-- Conan: Component target declared 'Boost::regex'
+-- Conan: Component target declared 'Boost::serialization'
+-- Conan: Component target declared 'Boost::stacktrace'
+-- Conan: Component target declared 'Boost::system'
+-- Conan: Component target declared 'Boost::timer'
+-- Conan: Component target declared 'Boost::chrono'
+-- Conan: Component target declared 'Boost::coroutine'
+-- Conan: Component target declared 'Boost::filesystem'
+-- Conan: Component target declared 'Boost::json'
+-- Conan: Component target declared 'Boost::math_c99'
+-- Conan: Component target declared 'Boost::math_c99f'
+-- Conan: Component target declared 'Boost::math_c99l'
+-- Conan: Component target declared 'Boost::math_tr1'
+-- Conan: Component target declared 'Boost::math_tr1f'
+-- Conan: Component target declared 'Boost::math_tr1l'
+-- Conan: Component target declared 'Boost::random'
+-- Conan: Component target declared 'Boost::stacktrace_addr2line'
+-- Conan: Component target declared 'Boost::stacktrace_backtrace'
+-- Conan: Component target declared 'Boost::stacktrace_basic'
+-- Conan: Component target declared 'Boost::stacktrace_from_exception'
+-- Conan: Component target declared 'Boost::stacktrace_noop'
+-- Conan: Component target declared 'Boost::test'
+-- Conan: Component target declared 'Boost::url'
+-- Conan: Component target declared 'Boost::wserialization'
+-- Conan: Component target declared 'Boost::fiber'
+-- Conan: Component target declared 'Boost::graph'
+-- Conan: Component target declared 'Boost::iostreams'
+-- Conan: Component target declared 'Boost::nowide'
+-- Conan: Component target declared 'Boost::prg_exec_monitor'
+-- Conan: Component target declared 'Boost::process'
+-- Conan: Component target declared 'Boost::test_exec_monitor'
+-- Conan: Component target declared 'Boost::thread'
+-- Conan: Component target declared 'Boost::wave'
+-- Conan: Component target declared 'Boost::contract'
+-- Conan: Component target declared 'Boost::fiber_numa'
+-- Conan: Component target declared 'Boost::locale'
+-- Conan: Component target declared 'Boost::log'
+-- Conan: Component target declared 'Boost::type_erasure'
+-- Conan: Component target declared 'Boost::unit_test_framework'
+-- Conan: Component target declared 'Boost::log_setup'
+-- Conan: Target declared 'boost::boost'
+-- Conan: Target declared 'BZip2::BZip2'
+-- Conan: Including build module from '/home/rigoni/.conan2/p/b/bzip2b5764e08a4f7d/p/lib/cmake/conan-official-bzip2-variables.cmake'
+-- Conan: Target declared 'libbacktrace::libbacktrace'
+-- Found OpenMP_C: -fopenmp=libomp (found version "5.1")
+-- Found OpenMP_CXX: -fopenmp=libomp (found version "5.1")
+-- Found OpenMP: TRUE (found version "5.1")
+-- Found nlohmann_json: /home/share/micromamba/envs/uLib/share/cmake/nlohmann_json/nlohmann_jsonConfig.cmake (found suitable version "3.12.0", minimum required is "3.12.0")
+-- Found Vdt: /home/share/micromamba/envs/uLib/include (found version "0.4")
+-- Warning: Standard CMAKE_CXX_STANDARD value defined in conan_toolchain.cmake to 17 has been modified to 20 by /home/share/micromamba/envs/uLib/cmake/ROOTUseFile.cmake
+-- Found Python3: /home/share/micromamba/envs/uLib/bin/python3.12 (found suitable version "3.12.13", minimum required is "3.12") found components: Interpreter Development.Module Development.Embed
+-- Found nlohmann_json: /home/share/micromamba/envs/uLib/share/cmake/nlohmann_json/nlohmann_jsonConfig.cmake (found version "3.12.0")
+-- Performing Test CMAKE_HAVE_LIBC_PTHREAD
+-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Success
+-- Found Threads: TRUE
+-- Performing Test HAVE_STDATOMIC
+-- Performing Test HAVE_STDATOMIC - Success
+-- Found WrapAtomic: TRUE
+-- Found OpenGL: /home/share/micromamba/envs/uLib/lib/libOpenGL.so
+-- Found WrapOpenGL: TRUE
+-- Could NOT find WrapVulkanHeaders (missing: Vulkan_INCLUDE_DIR) 
+-- Found X11: /home/share/micromamba/envs/uLib/include
+-- Looking for XOpenDisplay in /home/share/micromamba/envs/uLib/lib/libX11.so;/home/share/micromamba/envs/uLib/lib/libXext.so
+-- Looking for XOpenDisplay in /home/share/micromamba/envs/uLib/lib/libX11.so;/home/share/micromamba/envs/uLib/lib/libXext.so - found
+-- Looking for gethostbyname
+-- Looking for gethostbyname - found
+-- Looking for connect
+-- Looking for connect - found
+-- Looking for remove
+-- Looking for remove - found
+-- Looking for shmat
+-- Looking for shmat - found
+-- Looking for IceConnectionNumber in ICE
+-- Looking for IceConnectionNumber in ICE - found
+-- Performing Test Iconv_IS_BUILT_IN
+-- Performing Test Iconv_IS_BUILT_IN - Failed
+-- Found Iconv: /home/share/micromamba/envs/uLib/lib/libiconv.so (found version "1.18")
+-- Found ICU: /home/share/micromamba/envs/uLib/include (found version "75.1") found components: data i18n uc
+-- Looking for lzma_auto_decoder in /home/share/micromamba/envs/uLib/lib/liblzma.so
+-- Looking for lzma_auto_decoder in /home/share/micromamba/envs/uLib/lib/liblzma.so - found
+-- Looking for lzma_easy_encoder in /home/share/micromamba/envs/uLib/lib/liblzma.so
+-- Looking for lzma_easy_encoder in /home/share/micromamba/envs/uLib/lib/liblzma.so - found
+-- Looking for lzma_lzma_preset in /home/share/micromamba/envs/uLib/lib/liblzma.so
+-- Looking for lzma_lzma_preset in /home/share/micromamba/envs/uLib/lib/liblzma.so - found
+-- Found LibLZMA: /home/share/micromamba/envs/uLib/lib/liblzma.so (found version "5.8.2")
+-- Conan: Including build module from '/home/rigoni/.conan2/p/b/hdf509daaae89dd98/p/lib/cmake/conan-official-hdf5-variables.cmake'
+-- Found utf8cpp: /home/share/micromamba/envs/uLib/include
+-- Found THEORA: /home/share/micromamba/envs/uLib/lib/libtheora.so
+-- Found OGG: /home/share/micromamba/envs/uLib/lib/libogg.so
+-- Found NetCDF: /home/share/micromamba/envs/uLib/include (found version "4.9.2")
+-- Found JsonCpp: /home/share/micromamba/envs/uLib/lib/libjsoncpp.so (found suitable version "1.9.6", minimum required is "0.7.0")
+-- Found PNG: /home/share/micromamba/envs/uLib/lib/libpng.so (found version "1.6.56")
+-- Found GL2PS: /home/share/micromamba/envs/uLib/lib/libgl2ps.so (found suitable version "1.4.2", minimum required is "1.4.2")
+-- Found LibPROJ: /home/share/micromamba/envs/uLib/lib/libproj.so (found version "9.6.2")
+-- Found SQLite3: /home/share/micromamba/envs/uLib/lib/libsqlite3.so (found version "3.52.0")
+-- Could NOT find WrapVulkanHeaders (missing: Vulkan_INCLUDE_DIR) 
+-- Found LZ4: /home/share/micromamba/envs/uLib/lib/liblz4.so (found version "1.10.0")
+-- Found LZMA: /home/share/micromamba/envs/uLib/lib/liblzma.so (found version "5.8.2")
+-- Found JPEG: /home/share/micromamba/envs/uLib/lib/libjpeg.so (found version "80")
+-- Found TIFF: /home/share/micromamba/envs/uLib/lib/libtiff.so (found version "4.7.1")
+-- Could NOT find freetype (missing: freetype_DIR)
+-- Found Freetype: /home/share/micromamba/envs/uLib/lib/libfreetype.so (found version "2.14.3")
+-- Performing Test HAS_FLTO_THIN
+-- Performing Test HAS_FLTO_THIN - Failed
+-- Performing Test HAS_FLTO_AUTO
+-- Performing Test HAS_FLTO_AUTO - Failed
+-- Performing Test HAS_FLTO
+-- Performing Test HAS_FLTO - Failed
+-- Found pybind11: /home/share/micromamba/envs/uLib/include (found version "3.0.3")
+-- Could NOT find freetype (missing: freetype_DIR)
+CMake Deprecation Warning at /home/share/micromamba/envs/uLib/lib/cmake/Geant4/PTL/PTLConfig.cmake:30 (cmake_minimum_required):
+  Compatibility with CMake < 3.10 will be removed from a future version of
+  CMake.
+
+  Update the VERSION argument <min> value.  Or, use the <min>...<max> syntax
+  to tell CMake that the project requires at least <min> but has been updated
+  to work with policies introduced by <max> or earlier.
+Call Stack (most recent call first):
+  /home/share/micromamba/envs/uLib/share/cmake-4.2/Modules/CMakeFindDependencyMacro.cmake:93 (find_package)
+  /home/share/micromamba/envs/uLib/share/cmake-4.2/Modules/CMakeFindDependencyMacro.cmake:125 (__find_dependency_common)
+  /home/share/micromamba/envs/uLib/lib/cmake/Geant4/Geant4Config.cmake:286 (find_dependency)
+  CMakeLists.txt:194 (find_package)
+
+
+-- Found XercesC: /home/share/micromamba/envs/uLib/lib/libxerces-c.so (found suitable version "3.2.5", minimum required is "3.2.5")
+-- Found Freetype: /home/share/micromamba/envs/uLib/lib/libfreetype.so (found suitable version "2.14.3", minimum required is "2.12.1")
+-- Found Geant4: /home/share/micromamba/envs/uLib/lib/cmake/Geant4/Geant4Config.cmake (found version "11.2.2")
+-- Geant4 libs: Geant4::G4Tree;Geant4::G4FR;Geant4::G4GMocren;Geant4::G4visHepRep;Geant4::G4RayTracer;Geant4::G4VRML;Geant4::G4ToolsSG;Geant4::G4vis_management;Geant4::G4modeling;Geant4::G4interfaces;Geant4::G4mctruth;Geant4::G4geomtext;Geant4::G4gdml;Geant4::G4analysis;Geant4::G4error_propagation;Geant4::G4readout;Geant4::G4physicslists;Geant4::G4run;Geant4::G4event;Geant4::G4tracking;Geant4::G4parmodels;Geant4::G4processes;Geant4::G4digits_hits;Geant4::G4track;Geant4::G4particles;Geant4::G4geometry;Geant4::G4materials;Geant4::G4graphics_reps;Geant4::G4intercoms;Geant4::G4global;Geant4::G4tools;Geant4::G4ptl
+-- Looking for include file inittypes.h
+-- Looking for include file inittypes.h - not found
+-- Looking for include file stdbool.h
+-- Looking for include file stdbool.h - not found
+-- Looking for include file stdint.h
+-- Looking for include file stdint.h - not found
+-- Looking for include file stdlib.h
+-- Looking for include file stdlib.h - not found
+-- Looking for include file dlfcn.h
+-- Looking for include file dlfcn.h - not found
+-- Looking for include file malloc.h
+-- Looking for include file malloc.h - not found
+-- Looking for malloc
+-- Looking for malloc - not found
+-- Looking for include file memory.h
+-- Looking for include file memory.h - not found
+-- Looking for include file math.h
+-- Looking for include file math.h - not found
+-- Looking for fsetround
+-- Looking for fsetround - not found
+-- Looking for floor
+-- Looking for floor - not found
+-- Looking for pow
+-- Looking for pow - not found
+-- Looking for sqrt
+-- Looking for sqrt - not found
+-- Looking for strdup
+-- Looking for strdup - not found
+-- Looking for strstr
+-- Looking for strstr - not found
+-- Looking for include file strings.h
+-- Looking for include file strings.h - not found
+-- Looking for include file string.h
+-- Looking for include file string.h - not found
+-- Looking for include file sys/stat.h
+-- Looking for include file sys/stat.h - not found
+-- Looking for include file sys/types.h
+-- Looking for include file sys/types.h - not found
+-- Looking for include file unistd.h
+-- Looking for include file unistd.h - not found
+-- Looking for include file assert.h
+-- Looking for include file assert.h - not found
+-- Geant4 found: 11.2.2
+-- Found Python3: /home/share/micromamba/envs/uLib/bin/python3.12 (found version "3.12.13") found components: Interpreter
+-- Configuring done (9.2s)
+-- Generating done (1.6s)
+-- Build files have been written to: /home/rigoni/devel/cmt/uLib/build/clang-make

conanfile.txt

@@ -1,8 +1,13 @@
 [requires]
-eigen/3.4.0
-boost/1.83.0
-pybind11/3.0.2
+# eigen/5.0.1
+boost/1.86.0
+# pybind11/3.0.2
+hdf5/1.14.3
 
 [generators]
 CMakeDeps
 CMakeToolchain
+
+[options]
+hdf5/*:threadsafe=True
+hdf5/*:enable_unsupported=True

condaenv.yml

@@ -1,4 +1,4 @@
-name: mutom
+name: uLib
 channels:
   - conda-forge
 dependencies:
@@ -7,4 +7,15 @@ dependencies:
   - cmake
   - conan
   - root
-  - vtk
+  - vtk=9.4 # VTK 9.4
+  - pybind11
+#  - boost=1.86.0 # requested by VTK 9.4
+  - ninja
+  - clang
+  - clangxx
+  - lld
+  - ccache
+  - OpenMP
+  - Geant4
+  - gdb
+  - valgrind

docs/archives.md

@@ -0,0 +1,84 @@
+# Serialization and Archives Internals
+
+This document explains the internal design of the `uLib` serialization system, which is built on top of **Boost.Serialization**. It provides custom archive implementations for various formats (XML, Text, Logging) and introduces **Human Readable Pairs (HRP)** for metadata-rich serialization.
+
+---
+
+## Architecture Overview
+
+The `uLib` archive system extends the standard `boost::archive` templates to add domain-specific features. The main components are:
+
+1.  **Custom Interface Layer**: Extends the default Boost archive API with additional operators and utilities.
+2.  **Specialized Archive Implementations**: Specialized classes for XML, Text, and Logging.
+3.  **HRP Support**: First-class support for `hrp` (Human Readable Pair) wrappers, which carry units, ranges, and descriptions.
+4.  **Static Registration System**: Macros and explicit instantiations to handle polymorphic types and compilation isolation.
+
+---
+
+## Custom Interface Layer
+
+All `uLib` archives use a custom interface defined in `Archives.h` via `uLib_interface_iarchive` and `uLib_interface_oarchive`. These templates add several key features:
+
+| Feature | Operator/Method | Description |
+|---|---|---|
+| **Mapping Operator** | `operator==` | Aliased to `operator&` (Boost's standard mapping operator). |
+| **Trace Operator** | `operator!=` | Used for trace/debug output of strings during serialization. |
+| **Type Registration** | `register_type<T>()` | Registers a class type with the archive's internal serializer map. |
+| **Standard IO** | `operator<<` / `operator>>` | Standard redirect for saving and loading. |
+
+These interfaces are applied to the archives using template specialization of `boost::archive::detail::interface_iarchive` and `interface_oarchive`.
+
+---
+
+## Archive Variants
+
+### XML Archives (`xml_iarchive`, `xml_oarchive`)
+These inherit from `boost::archive::xml_iarchive_impl` and `xml_oarchive_impl`. 
+- **Internals**: They override `load_override` and `save_override` to handle `boost::serialization::hrp<T>` specifically. 
+- **XML Mapping**: When saving an `hrp`, it uses `save_start(name)` and `save_end(name)` to wrap the value in a named XML tag.
+
+### Text Archives (`text_iarchive`, `text_oarchive`)
+Standard text-based archives used for compact serialization. They use `StringReader` to consume decorative text markers during loading.
+
+### Human Readable Text (`hrt_iarchive`, `hrt_oarchive`)
+These are "naked" text archives that suppress most of Boost's internal metadata (object IDs, class IDs, versions).
+- **Goal**: Produce text output that is easy for humans to read and edit.
+- **Internals**: All overrides for Boost internal types (like `object_id_type`, `version_type`, etc.) are implemented as no-ops.
+
+### Log Archive (`log_archive`)
+An XML-based output archive specifically for debug logging.
+- **Internals**: It forces every object into a Name-Value Pair (NVP) even if not provided by the user, and strips all technical metadata to keep the logs clean.
+
+---
+
+## HRP (Human Readable Pair) Integration
+
+`hrp` is a core `uLib` wrapper (defined in `Serializable.h`) that extends Boost's `nvp`:
+
+```cpp
+// Example of HRP usage
+ar & HRP2("Energy", m_energy, "MeV").range(0, 100);
+```
+
+### Internal Handling in Archives
+Archives in `Archives.h` provide specific `save_override`/`load_override` for `hrp<T>`:
+- **XML**: Maps the `name()` to an XML tag.
+- **HRT**: Formats as `name: value [units]\n`.
+- **Log**: Converts it to a standard Boost `nvp` for consistent XML logging.
+
+---
+
+## Registration and Polymorphism
+
+### Registration Macro
+The `ULIB_SERIALIZATION_REGISTER_ARCHIVE(Archive)` macro is crucial for polymorphic serialization. It instantiates the necessary template machinery to link the custom `Archive` type with any `Serializable` class exported via `BOOST_CLASS_EXPORT`.
+
+### Explicit Instantiation
+To reduce compilation times and provide a single point of failure for link-time issues, `uLib` uses explicit instantiations in `src/Core/Archives.cpp`. This file includes the `.ipp` implementation files from Boost and instantiates the `archive_serializer_map` and implementation classes for all `uLib` archive types.
+
+---
+
+## Utility: StringReader
+The `StringReader` utility is used internally by text-based archives to parse and skip literals. For example:
+- When loading a string literal from a text archive, `StringReader` consumes whitespace and ensures the stream matches the expected string, failing if there is a mismatch.
+- This is vital for maintaining the structure of human-readable formats.

docs/code/vtk/vtk_Prop3D.md

@@ -0,0 +1,48 @@
+# Prop3D
+
+`uLib::Vtk::Prop3D` is a bridge class that wraps VTK 3D representations (`vtkProp`, `vtkProp3D`) and integrates them into the `uLib` object model. It allows the framework to manage visual objects, synchronize them with underlying data models, and expose display-specific properties to the GUI.
+
+## Inheritance
+`uLib::Vtk::Prop3D` : `uLib::Object`
+
+## Key Functionalities
+
+### VTK Integration
+The class provides access to the underlying VTK objects:
+- `GetProp()`: Returns the `vtkProp`.
+- `GetProxyProp()`: Returns the `vtkProp3D`.
+- `GetParts()` / `GetProps()`: Returns `vtkPropCollection` for composite objects.
+
+### Model-View Synchronization
+`Prop3D` ensures that the visual representation stays in sync with the domain model:
+- `Update()`: Synchronizes the VTK representation based on current internal state and properties. Should be called when model data changes.
+- `SyncFromVtk()`: Updates internal state using data from the VTK representation (e.g., after user interaction via gizmos in the 3D view).
+- `GetContent()`: Returns the `uLib::Object` that this `Prop3D` represents visually.
+
+### Visual Appearance
+- **Color & Opacity**: `SetColor(r, g, b)` and `SetOpacity(alpha)`.
+- **Selection**: `SetSelectable(bool)` and `SetSelected(bool)` to manage interactivity and highlighting.
+- **BBox/Scale**: `ShowBoundingBox(bool)` and `ShowScaleMeasures(bool)`.
+
+### Rendering Modes
+The rendering style can be controlled via the `Representation` enum:
+- `Points`
+- `Wireframe`
+- `Surface`
+- `SurfaceWithEdges`
+- `Volume`
+- `Outline`
+- `Slice`
+
+### Display Properties System
+`Prop3D` implements a system to expose specific properties (often marked as `hrp` - human readable properties) to a property editor in the GUI.
+
+- `GetDisplayProperties()`: Returns the list of properties registered for display.
+- `RegisterDisplayProperty(uLib::PropertyBase*)`: Adds a property to the display list.
+- `serialize_display(...)`: A virtual method that subclasses implement to define which properties should be exposed.
+
+#### Activating Display Properties
+To automatically populate the display properties list, the `ULIB_ACTIVATE_DISPLAY_PROPERTIES` macro should be called in the constructor. This triggers `serialize_display` using a `display_properties_archive`.
+
+## Implementation Details
+`Prop3D` uses the Pimpl idiom (via `Prop3DData *pd`) to hide VTK-specific implementation details and reduce header dependencies.

docs/geant_integration.md

@@ -0,0 +1,34 @@
+# Geant integration
+
+Geant4 integration in uLib is done through the `HEP/Geant` module.
+The module represets a set of wrapper for geant objects that are also deriving from uLib::Object so they can be used in the uLib::Object tree and visualized with the uLib::Vtk module and driven py properties.
+
+# Geant Solid Integration
+
+Geant4 solids in `uLib` are encapsulated within the `uLib::Geant::Solid` hierarchy, with primary implementations such as `BoxSolid` and `TessellatedSolid`. These classes act as reactive wrappers around native Geant4 `G4VSolid` objects, bridging the gap between Geant4's static geometry and `uLib`'s dynamic property system.
+
+### Property Mapping and Synchronization
+The integration relies on a mapping between `uLib` properties and Geant4 parameters. This allows geometry to be driven by Qt-based property panels or interactive VTK handles. When a property is modified, the library handles the update through the following mechanism:
+
+*   **Parameter Application**: If the underlying Geant4 object supports dynamic updates (e.g., changing box dimensions via `SetXHalfLength`), `uLib` applies the change directly to the existing object.
+*   **Solid Re-instantiation**: In cases where Geant4 does not support on-the-fly parameter changes, the library transparently recreates the underlying `G4VSolid`. This ensures that the simulation model always reflects the current state of the design environment.
+*   **Global Signaling**: Once the underlying Geant4 state is synchronized, the `uLib::Geant::Solid` emits an `updated()` signal. This triggers cascading updates across all dependent observers, such as the VTK rendering pipeline and the Geant4 scene manager, ensuring visual and logical consistency.
+
+## VTK Visualization Layer
+
+The visualization of Geant4 solids in VTK is managed by the `uLib::Vtk::GeantSolid` class and its specializations (e.g., `vtkBoxSolid`). This class serves as a bridge between the domain model (`uLib::Geant::Solid`) and the VTK rendering pipeline, inheriting from `uLib::Vtk::Prop3D` to leverage the framework's standard transformation and property management features.
+
+### Geometry Extraction and Rendering
+Since Geant4 solids are defined by analytical or tessellated boundary representations, `GeantSolid` converts them into a format suitable for VTK:
+1.  **Faceted Representation**: It retrieves the `G4Polyhedron` tessellation from the underlying `G4VSolid`.
+2.  **PolyData Mapping**: The vertices and facets of the polyhedron are extracted and mapped to a `vtkPolyData` object.
+3.  **Actor Configuration**: This geometry is assigned to a `vtkActor`, which is then added to the `Prop3D`. Default visual properties—such as semi-transparent surfaces and edge visibility—are applied to aid in debugging and design.
+
+### Transform Synchronization
+The spatial state (Translation, Rotation, and Scale) is synchronized between the Geant4 geometry tree and the VTK viewer ensuring a consistent representation across both domains.
+
+*   **Geant4 to VTK (Forward)**: When a solid's placement is updated in Geant4, `GeantSolid` extracts the translation and rotation from the associated `G4VPhysicalVolume`. These are converted into a `vtkTransform` and applied to the actor, aligning the visual model with the simulation's coordinate system.
+*   **VTK to Geant4 (Interactive)**: Interaction in the viewer (e.g., using a transformation handler) triggers the `SyncFromVtk()` method. This pushes the new transformation matrix back to the `uLib::Geant::Solid` domain object, which then updates the Geant4 physical volume.
+*   **Feedback Loop Prevention**: To avoid infinite recursion during interactive updates, the synchronization logic utilizes temporary signal blocking. This ensures that a transform update originating from VTK does not trigger a redundant re-update of the VTK representation from the domain model.
+
+

docs/object_context.md

@@ -0,0 +1,28 @@
+# Creating Objects and adding to context
+
+In uLib the context is meant to hold a set of objects and their hierarchy. In addition ObjectFactory is used to create objects from a predefined registry. 
+
+Object context can be thouught as a collection of uLib::Object instances. And there exists nested collection of objects if a context is added to another context. A nested context is a Group of elements that appears like a single object in the parent context and a hierarchy of objects inside the tree structure. 
+
+## SmartPointer access
+
+SmartPointer is a class that is used to hold a reference to another object. It is a template class that can be used to hold a reference to any object that is derived from uLib::Object. It is a smart pointer because it will automatically delete the object when it is no longer needed. It is also a smart pointer because it will automatically update the object when it is no longer needed. 
+
+The ObjectContext is responsible to keep track of all the objects that are added to it and to provide a way to access them, but also it holds the SmartPointer instances that point to the objects that are added to it. In this way Objects added to a Context are disposed only when the context is destroyed.
+For this reason the access to a object context for a Object via Get/Set is done using the SmartPointer instances. 
+
+
+## Geant Physical Volumes
+
+The Geant library add a further layer of complexity. The physical volumes are created from a what is called LogicalVolume (which holds information about the shape, material and daughter volumes) and represent the actual instances of the volumes in the detector. So in this sense they represent what could be the Prop3D in the uLib Vtk library. The PhysicalVolume is created from the LogicalVolume and is the one that is actually placed in the scene, with its own relative TRS: position and rotation (rotation here is a rotation matrix comprising the scaling). 
+
+so Adding a Solid or a Logical volume on the scene is not enough. We need to create a PhysicalVolume from the LogicalVolume and add it to the scene to see its instance and apply the TRS to the PhysicalVolume and so to eventually to the representation. 
+
+## Gcompose interaction with objects that have Prop3d and object without 3D actor
+
+In VTK and Qt the objects are organized in a tree structure. When We will add a new object to the scene it will be added to the tree structure and it will be displayed once wrapped in a vtk representation (like vtkContainerBox for instance). 
+
+For objects without 3D representation, they are added to the tree structure but they are not displayed in the scene. But when Object have a internal member that is a reference to another object, this will be represented in the tree structure as a child of the object that contains a reference to it. It is also important to note that the reference can be either the object itself or a smart pointer to the object. So the representation of the child in the tree structure is a placeholder for the object that is referenced and it can be added to many parents, creating multiple instances of the same reference in the tree structure. 
+
+When a object contains a reference to another object, the reference can be set from properties by selecting form the possible instances in the context that are compatible (can be casted) to the type of the reference. 
+In this way the reference appears also as a child in the tree. On the other hand the same add operation can be performed by dragging the object from the tree structure and dropping it on the property of the object that contains the reference. In this case the reference will be set to the parent selecting the compatible menber automatically.

docs/update_properties.md

@@ -0,0 +1,94 @@
+
+# Properties and the vtk-gui representation
+
+This is the rationale behind the connection between TRS properties and Prop3D Transformation.
+
+The properties from model get propoagated via Object signalling system (the Update signal) to the vtkRepresentation and to the Qt widgets so that the overall transformation of the model reflects into a modification of its representation in vtk and in the gui. 
+
+In addition the properties need to be adjusted also from vtk, for example if user uses handlerwidget to change the transformation this is eventually applied to Prop3D and Prop3D should propagate the transformation change to the vtk representation object (for instance vtkContainerBox) and the latter eventually propagates the change into the model.
+
+the Prop3D or the vtk representation wrapper ( vtkContainerBox for instance is the wrapper od ContainerBox ) should not directly show the transformation of the handlerwidget but it should show the transformation of the model once applied so we are always seeing the actual aspect of the model reflected to the vtk representation and not the other way around.
+
+So in syntesis the model is the master and the vtk representation and the gui are the slaves of any modification, but the vtkHandlerWidget is able to apply a transform that should be applied to the model and then the model should propagate the transformation change to the vtk representation and to the gui.
+
+## The Prop3D
+
+The prop3d is the proxy of the spatial placement of objects in the scene. Prop3Ds should have an internal ContainerBox that is shown in the scene around the content to be able to pick Prop3D from vtkViewport using the handler widget. The HandlerWidget moves the Prop3D ContainerBox (the red Highlight element whe selected) to reflect the handler current transformation, but the transformation is propagated to the derived Prop3D classes like vtkContainerBox. 
+
+The vtkHandlerWidget should handle the transformation of the prop3d internal ContainerBox. The changes of the ContainerBox will be propagated to the derived classes and eventually to the model. 
+
+
+
+
+
+
+## ACTIVATE PROPERTIES
+
+ULIB_ACTIVATE_PROPERTIES must run after all member initialization, with the vtable pointing to the most-derived type. This is why it has to be in each constructor — in C++, virtual dispatch only works correctly after a class's vtable is installed, which happens at the start of each level's constructor body.
+
+### Option 1 — End-of-class macro (no constructor boilerplate)
+Declare a private member activator as the last member of the class. Its constructor runs after all other members, and at that point the vtable is already Derived's:
+
+
+// In Property.h, add alongside ULIB_ACTIVATE_PROPERTIES:
+#define ULIB_DECLARE_PROPERTIES(SelfType) \
+private: \
+    struct _PropActivator { \
+        _PropActivator(SelfType* self) { \
+            uLib::Archive::property_register_archive ar(self); \
+            ar & *self; \
+        } \
+    } _prop_activator{this};
+Usage in ContainerBox.h — place it just before the closing brace:
+
+
+class ContainerBox : public TRS {
+public:
+    // ... all constructors, no more ULIB_ACTIVATE_PROPERTIES(*this)
+
+    ULIB_DECLARE_PROPERTIES(ContainerBox)  // ← replaces all 3 constructor calls
+};
+Tradeoff: Works perfectly for single-level classes. For hierarchies where multiple levels use the macro, RegisterDynamicProperty must deduplicate by name (skip if already registered). Requires one line per class in the class body, but zero lines in constructors.
+
+### Option 2 — Lazy init via virtual InitProperties() in Object
+Modify Object to call a virtual hook on first GetProperties():
+
+
+// In Object.h:
+class Object {
+protected:
+    virtual void InitProperties() {}   // override in derived
+public:
+    const std::vector<PropertyBase*>& GetProperties() const {
+        if (!m_propertiesInitialized) {
+            const_cast<Object*>(this)->m_propertiesInitialized = true;
+            const_cast<Object*>(this)->InitProperties();
+        }
+        return m_properties;
+    }
+};
+Then a CRTP base handles the rest without any macro:
+
+
+template<typename Derived>
+class PropertyObject : public Object {
+protected:
+    void InitProperties() override {
+        uLib::Archive::property_register_archive ar(this);
+        ar & *static_cast<Derived*>(this);
+    }
+};
+Usage — just change the base class:
+
+
+class ContainerBox : public PropertyObject<ContainerBox>, public TRS { ... };
+// Nothing else needed — properties activated on first GetProperties() call
+Tradeoff: Most "automatic" — pure inheritance, no constructor or class-body macros. But requires modifying Object (adding m_propertiesInitialized flag + virtual hook), and lazy init means properties aren't available until first access. Also doesn't work well with multiple inheritance (which TRS likely involves).
+
+Option 3 — CRTP doesn't work from the base constructor
+Just to be explicit: a CRTP base that calls ULIB_ACTIVATE_PROPERTIES in its own constructor won't work, because when PropertyObject<Derived>'s constructor runs, the vtable is PropertyObject<Derived>'s — Derived::serialize() hasn't been installed yet. So ar & *self calls Object::serialize() (a no-op).
+
+Recommendation
+Option 1 is the least invasive and safest. Add deduplication to RegisterDynamicProperty in Object.cpp to guard against re-registration when hierarchies stack activators, then replace every ULIB_ACTIVATE_PROPERTIES(*this) in constructors with a single ULIB_DECLARE_PROPERTIES(ClassName) at the end of the class body.
+
+Option 2 is cleaner to use but requires changing the Object interface and has the lazy-init semantic change — only worth it if you want zero-touch activation across the entire framework.

src/Core/Archives.h

@@ -28,6 +28,8 @@
 
 #include <boost/archive/detail/basic_pointer_iserializer.hpp>
 #include <boost/archive/detail/basic_pointer_oserializer.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <cstring>
 #include <iostream>
 
 #include <boost/archive/text_iarchive.hpp>
@@ -59,6 +61,8 @@ class xml_iarchive;
 class xml_oarchive;
 class text_iarchive;
 class text_oarchive;
+class hrt_iarchive;
+class hrt_oarchive;
 class log_archive;
 
 } // namespace Archive
@@ -76,6 +80,9 @@ template <class ArchiveImplementation> class polymorphic_iarchive_route;
 namespace boost {
 namespace serialization {
 template <typename T> struct hrp;
+template <typename T> struct hrp_val;
+template <typename T> struct hrp_enum;
+template <typename T> struct hrp_enum_val;
 }
 } // namespace boost
 
@@ -150,7 +157,7 @@ public:
   Archive *This() { return static_cast<Archive *>(this); }
 
   template <class T>
-  const basic_pointer_iserializer *register_type(T * = NULL) {
+  const basic_pointer_iserializer *register_type(T * = nullptr) {
     const basic_pointer_iserializer &bpis = boost::serialization::singleton<
         pointer_iserializer<Archive, T>>::get_const_instance();
     this->This()->register_basic_serializer(bpis.get_basic_serializer());
@@ -161,15 +168,69 @@ public:
     return *this->This();
   }
 
+  template <class T>
+  Archive &operator>>(const boost::serialization::nvp<T> &t) {
+    this->This()->load_override(t);
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp<T> &>(t));
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp_val<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp_val<T> &>(t));
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp_enum<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp_enum<T> &>(t));
+    return *this->This();
+  }
+
+  template <class T>
+  Archive &operator>>(const boost::serialization::hrp_enum_val<T> &t) {
+    this->This()->load_override(const_cast<boost::serialization::hrp_enum_val<T> &>(t));
+    return *this->This();
+  }
+
   // the & operator
   template <class T> Archive &operator&(T &t) { return *(this->This()) >> t; }
 
+  template <class T>
+  Archive &operator&(const boost::serialization::nvp<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_val<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum<T> &t) {
+    return *(this->This()) >> t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum_val<T> &t) {
+    return *(this->This()) >> t;
+  }
+
   // the == operator
   template <class T> Archive &operator==(T &t) { return this->operator&(t); }
 
   // the != operator for human readable access
   template <class T> Archive &operator!=(T &t) {
-    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
     return *this->This();
   }
 };
@@ -191,27 +252,73 @@ public:
   Archive *This() { return static_cast<Archive *>(this); }
 
   template <class T>
-  const basic_pointer_oserializer *register_type(const T * = NULL) {
+  const basic_pointer_oserializer *register_type(const T * = nullptr) {
     const basic_pointer_oserializer &bpos = boost::serialization::singleton<
         pointer_oserializer<Archive, T>>::get_const_instance();
     this->This()->register_basic_serializer(bpos.get_basic_serializer());
     return &bpos;
   }
 
-  template <class T> Archive &operator<<(T &t) {
+  template <class T> Archive &operator<<(const T &t) {
     // to get access you must redefine save_override by typing
     // "using save_override" in archive impl
     this->This()->save_override(t);
     return *this->This();
   }
 
+  template <class T> Archive &operator<<(const boost::serialization::hrp<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::hrp_val<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::hrp_enum<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::hrp_enum_val<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+
+  template <class T> Archive &operator<<(const boost::serialization::nvp<T> &t) {
+    this->This()->save_override(t);
+    return *this->This();
+  }
+ 
   // the & operator
-  template <class T> Archive &operator&(T &t) {
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    return *this->This() << const_cast<const T &>(t);
-#else
+  template <class T> Archive &operator&(const T &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_val<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::hrp_enum_val<T> &t) {
+    return *this->This() << t;
+  }
+
+  template <class T>
+  Archive &operator&(const boost::serialization::nvp<T> &t) {
     return *this->This() << t;
-#endif
   }
 
   // the == operator
@@ -219,7 +326,6 @@ public:
 
   // the != operator for human readable access
   template <class T> Archive &operator!=(T &t) {
-    std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
     return *this->This();
   }
 };
@@ -244,23 +350,22 @@ template <>
 class interface_oarchive<uLib::Archive::text_oarchive>
     : public uLib_interface_oarchive<uLib::Archive::text_oarchive> {};
 
+template <>
+class interface_iarchive<uLib::Archive::hrt_iarchive>
+    : public uLib_interface_iarchive<uLib::Archive::hrt_iarchive> {};
+
+template <>
+class interface_oarchive<uLib::Archive::hrt_oarchive>
+    : public uLib_interface_oarchive<uLib::Archive::hrt_oarchive> {};
+
+template <>
+class interface_iarchive<uLib::Archive::log_archive>
+    : public uLib_interface_iarchive<uLib::Archive::log_archive> {};
+
 template <>
 class interface_oarchive<uLib::Archive::log_archive>
     : public uLib_interface_oarchive<uLib::Archive::log_archive> {};
 
-//// Veritical repetition macro // FINIRE !!!!!!!!!!!!!!!!!!!!!!!!!
-// #define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata)           \
-//     template <class TypeSeq>                             \
-//     struct inherit_nofold<TypeSeq,BOOST_PP_INC(vn)> :    \
-//     BOOST_PP_REPEAT(BOOST_PP_INC(vn),_INERIT_NOFOLD_H,~) \
-//     {};
-
-//// Multiple size declaration //
-// BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
-
-// #undef  _INERIT_NOFOLD_H
-// #undef  _INERIT_NOFOLD_V
-
 } // namespace detail
 } // namespace archive
 } // namespace boost
@@ -279,36 +384,6 @@ class interface_oarchive<uLib::Archive::log_archive>
 namespace boost {
 namespace archive {
 
-// template<class Archive>
-// inline void load_const_override(Archive & ar, const char *t ){
-//     typedef typename mpl::identity<detail::load_non_pointer_type<Archive>
-//     >::type typex; typex::invoke(ar, t);
-// }
-
-// template<class Archive, class T>
-// inline void load(Archive & ar, T &t){
-//     // if this assertion trips. It means we're trying to load a
-//     // const object with a compiler that doesn't have correct
-//     // funtion template ordering.  On other compilers, this is
-//     // handled below.
-//     //    detail::check_const_loading< T >();
-//     typedef
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer< T >,
-//             mpl::identity<detail::load_pointer_type<Archive> >
-//         ,//else
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array< T >,
-//             mpl::identity<detail::load_array_type<Archive> >
-//         ,//else
-//         BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum< T >,
-//             mpl::identity<detail::load_enum_type<Archive> >
-//         ,//else
-//             mpl::identity<detail::load_non_pointer_type<Archive> >
-//         >
-//         >
-//         >::type typex;
-//     typex::invoke(ar, t);
-// }
-
 } // namespace archive
 } // namespace boost
 
@@ -316,42 +391,38 @@ namespace uLib {
 
 namespace Archive {
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-// POLYMORPHIC //
-
-// class polymorphic_iarchive :
-//         public boost::archive::polymorphic_iarchive {
-
-// public:
-//     void load_override(const char *t, BOOST_PFTO int)
-//     {
-//         boost::archive::load_const_override(* this->This(),
-//         const_cast<char*>(t));
-//     }
-
-//};
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // XML //
 
+// ULIB_SERIALIZATION_VERSION should be get from the build system
+#ifndef ULIB_SERIALIZATION_VERSION
+#define ULIB_SERIALIZATION_VERSION "0.0"
+#endif
+
 class xml_iarchive : public boost::archive::xml_iarchive_impl<xml_iarchive> {
   typedef xml_iarchive Archive;
   typedef boost::archive::xml_iarchive_impl<Archive> base;
 
+  unsigned int m_flags;
+
   // give serialization implementation access to this class
   friend class boost::archive::detail::interface_iarchive<Archive>;
   friend class boost::archive::basic_xml_iarchive<Archive>;
   friend class boost::archive::load_access;
-
 public:
   xml_iarchive(std::istream &is, unsigned int flags = 0)
-      : xml_iarchive_impl<xml_iarchive>(is, flags) {}
-
-  using basic_xml_iarchive::load_override;
+      : boost::archive::xml_iarchive_impl<xml_iarchive>(
+            is, flags | boost::archive::no_header), m_flags(flags) {
+    if (0 == (flags & boost::archive::no_header)) {
+      std::string line;
+      std::getline(is, line); // <?xml ... ?>
+      std::getline(is, line); // <!DOCTYPE ...>
+      std::getline(is, line); // <ulib_serialization ...>
+    }
+  }
 
   // Anything not an attribute should be a name value pair as nvp or hrp
   typedef boost::archive::detail::common_iarchive<Archive>
@@ -364,13 +435,15 @@ public:
       boost::serialization::hrp<T> &t) {
     this->This()->load_start(t.name());
     this->detail_common_iarchive::load_override(t.value());
-    //        t.stov();
     this->This()->load_end(t.name());
   }
 
   // class_name_type can't be handled here as it depends upon the
   // char type used by the stream.  So require the derived implementation.
   // derived in this case is xml_iarchive_impl or base ..
+  // Note: using base::load_override covers all basic_xml_iarchive overloads
+  // transitively, so a separate 'using basic_xml_iarchive::load_override'
+  // is redundant and creates ambiguity with clang.
   using base::load_override;
 
   void load_override(const char *str) {
@@ -378,13 +451,9 @@ public:
     // sr >> str;
   }
 
-  ~xml_iarchive() {};
+  virtual ~xml_iarchive() {}
 };
 
-// typedef boost::archive::detail::polymorphic_iarchive_route<
-// boost::archive::xml_iarchive_impl<xml_iarchive>
-//> polymorphic_xml_iarchive;
-
 template <class ArchiveImpl>
 struct polymorphic_iarchive_route
     : boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl> {
@@ -394,31 +463,39 @@ struct polymorphic_iarchive_route
 class polymorphic_xml_iarchive
     : public polymorphic_iarchive_route<
           boost::archive::xml_iarchive_impl<xml_iarchive>> {
-  // give serialization implementation access to this class
-  //    friend class boost::archive::detail::interface_iarchive<Archive>;
-  //    friend class boost::archive::basic_xml_iarchive<Archive>;
-  //    friend class boost::archive::load_access;
 public:
-  virtual void load_override(const char *str) { ; }
+  virtual void load_override(const char *str) {}
 };
 
 class xml_oarchive : public boost::archive::xml_oarchive_impl<xml_oarchive> {
   typedef xml_oarchive Archive;
   typedef boost::archive::xml_oarchive_impl<Archive> base;
 
+  unsigned int m_flags;
+
   // give serialization implementation access to this class
   friend class boost::archive::detail::interface_oarchive<Archive>;
   friend class boost::archive::basic_xml_oarchive<Archive>;
   friend class boost::archive::save_access;
-
 public:
   xml_oarchive(std::ostream &os, unsigned int flags = 0)
-      : boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
+      : boost::archive::xml_oarchive_impl<xml_oarchive>(
+            os, flags | boost::archive::no_header), m_flags(flags) {
+    if (0 == (flags & boost::archive::no_header)) {
+      this->This()->put(
+          "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
+      this->This()->put("<!DOCTYPE ulib_serialization>\n");
+      this->This()->put("<ulib_serialization signature=\"serialization::archive\" ");
+      this->write_attribute("version", (const char *)ULIB_SERIALIZATION_VERSION);
+      this->This()->put(">\n");
+    }
+  }
 
-  // example of implementing save_override for const char* //
-  //    void save_override(const char *t, int) {
-  //        std::cout << "found char: " << t << "\n";
-  //    }
+  virtual ~xml_oarchive() {
+    if (0 == (m_flags & boost::archive::no_header)) {
+      this->This()->put("</ulib_serialization>\n");
+    }
+  }
 
   using basic_xml_oarchive::save_override;
 
@@ -432,8 +509,7 @@ public:
 #endif
       ::boost::serialization::hrp<T> &t) {
     this->This()->save_start(t.name());
-    //        t.vtos();
-    //        this->detail_common_oarchive::save_override(t.const_value());
+    this->detail_common_oarchive::save_override(t.const_value());
     this->This()->save_end(t.name());
   }
 
@@ -441,8 +517,6 @@ public:
     // Do not save any human decoration string //
     // basic_text_oprimitive::save(str);
   }
-
-  ~xml_oarchive() {}
 };
 
 // typedef boost::archive::detail::polymorphic_oarchive_route<
@@ -467,29 +541,21 @@ public:
   text_iarchive(std::istream &is, unsigned int flags = 0)
       : text_iarchive_impl<Archive>(is, flags) {}
 
-  using basic_text_iarchive::load_override;
+  using base::load_override;
 
   void load_override(boost::archive::object_id_type &t) {}
 
-  // class_name_type can't be handled here as it depends upon the
-  // char type used by the stream.  So require the derived implementation.
-  // derived in this case is xml_iarchive_impl or base ..
-  using base::load_override;
 
   void load_override(const char *str) {
     StringReader sr(basic_text_iprimitive::is);
     sr >> str;
   }
 
-  ~text_iarchive() {};
+  virtual ~text_iarchive() {}
 };
 
 typedef text_iarchive naked_text_iarchive;
 
-// typedef boost::archive::detail::polymorphic_iarchive_route<
-// naked_text_iarchive
-//> polymorphic_text_iarchive;
-
 class text_oarchive : public boost::archive::text_oarchive_impl<text_oarchive> {
   typedef text_oarchive Archive;
   typedef boost::archive::text_oarchive_impl<Archive> base;
@@ -507,13 +573,9 @@ public:
 
   void save_override(const char *str) { basic_text_oprimitive::save(str); }
 
-  ~text_oarchive() {}
+  virtual ~text_oarchive() {}
 };
 
-// typedef boost::archive::detail::polymorphic_oarchive_route<
-// boost::archive::text_oarchive_impl<text_oarchive>
-//> polymorphic_text_oarchive;
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -532,7 +594,7 @@ public:
   hrt_iarchive(std::istream &is, unsigned int flags = 0)
       : base(is, flags | boost::archive::no_header) {}
 
-  using basic_text_iarchive::load_override;
+  using base::load_override;
 
   // hide all archive props //
   void load_override(boost::archive::object_id_type &t) {}
@@ -544,17 +606,13 @@ public:
   void load_override(boost::archive::class_name_type &t) {}
   void load_override(boost::archive::tracking_type &t) {}
 
-  // class_name_type can't be handled here as it depends upon the
-  // char type used by the stream.  So require the derived implementation.
-  // derived in this case is xml_iarchive_impl or base ..
-  using base::load_override;
 
   void load_override(const char *str) {
     StringReader sr(basic_text_iprimitive::is);
     sr >> str;
   }
 
-  ~hrt_iarchive() {};
+  virtual ~hrt_iarchive() {}
 };
 
 class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
@@ -583,7 +641,14 @@ public:
 
   void save_override(const char *str) { basic_text_oprimitive::save(str); }
 
-  ~hrt_oarchive() {}
+  template <class T>
+  void save_override(const boost::serialization::hrp<T> &t) {
+    *this << t.name() << ": ";
+    *this << t.const_value();
+    *this << "\n";
+  }
+
+  virtual ~hrt_oarchive() {}
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -611,22 +676,18 @@ public:
     //        basic_text_oprimitive::save(str);
   }
 
-  template <class T> void save_override(T &t) {
-    base::save_override(boost::serialization::make_nvp(NULL, t));
+  template <class T> void save_override(const T &t) {
+    base::save_override(boost::serialization::make_nvp(nullptr, t));
   }
 
-  // activate this if you want to trap non nvp objects //
-  //    template<class T>
-  //    void save_override(T & t)
-  //    {
-  //        BOOST_MPL_ASSERT((boost::serialization::is_wrapper< T >));
-  //        //        this->detail_common_oarchive::save_override(t);
-  //    }
-
   template <class T> void save_override(const boost::serialization::nvp<T> &t) {
     base::save_override(t);
   }
 
+  template <class T> void save_override(const boost::serialization::hrp<T> &t) {
+    base::save_override(boost::serialization::make_nvp(t.name(), t.const_value()));
+  }
+
   // specific overrides for attributes - not name value pairs so we
   // want to trap them before the above "fall through"
   // since we don't want to see these in the output - make them no-ops.
@@ -643,11 +704,9 @@ public:
   log_archive(std::ostream &os, unsigned int flags = 0)
       : boost::archive::xml_oarchive_impl<log_archive>(
             os, flags | boost::archive::no_header) {}
-};
 
-// typedef boost::archive::detail::polymorphic_oarchive_route<
-// boost::archive::xml_oarchive_impl<log_archive>
-//> polymorphic_log_archive;
+  virtual ~log_archive() {}
+};
 
 } // namespace Archive
 
@@ -661,10 +720,4 @@ ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_iarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_oarchive)
 ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::log_archive)
 
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
-// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
-
 #endif // U_CORE_ARCHIVES_H

src/Core/CMakeLists.txt

@@ -10,6 +10,8 @@ set(HEADERS
     Macros.h 
     Mpl.h 
     Object.h 
+    ObjectFactory.h
+    ObjectsContext.h
     Options.h 
     Serializable.h 
     Signal.h 
@@ -17,6 +19,9 @@ set(HEADERS
     SmartPointer.h 
     StaticInterface.h 
     StringReader.h 
+    Threads.h
+    Monitor.h
+    Property.h
     Types.h 
     Uuid.h 
     Vector.h
@@ -26,13 +31,20 @@ set(SOURCES
     Archives.cpp 
     Debug.cpp 
     Object.cpp 
+    ObjectFactory.cpp
+    ObjectsContext.cpp
     Options.cpp 
     Serializable.cpp 
     Signal.cpp 
     Uuid.cpp
+    Threads.cpp
 )
 
-set(LIBRARIES Boost::program_options Boost::serialization)
+set(LIBRARIES 
+    Boost::program_options 
+    Boost::serialization
+    OpenMP::OpenMP_CXX
+)
 
 set(libname ${PACKAGE_LIBPREFIX}Core)
 set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -47,9 +59,10 @@ if(USE_CUDA)
 endif()
 
 target_link_libraries(${libname} ${LIBRARIES})
+target_compile_definitions(${libname} PUBLIC ULIB_SERIALIZATION_VERSION="${PROJECT_VERSION}")
 
 install(TARGETS ${libname}
-        EXPORT "${PROJECT_NAME}Targets"
+        EXPORT "uLibTargets"
         RUNTIME DESTINATION ${INSTALL_BIN_DIR} COMPONENT bin
         LIBRARY DESTINATION ${INSTALL_LIB_DIR} COMPONENT lib)
 

src/Core/DataAllocator.h

@@ -52,6 +52,7 @@ public:
       else
         m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
     }
+    // std::cout << "DataAllocator Constructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
   }
 
   DataAllocator(const DataAllocator<T> &other)
@@ -63,8 +64,13 @@ public:
           m_RamData = new T[m_Size];
         else
           m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
+        
+        if (m_OwnsObjects) {
+            std::copy(other.m_RamData, other.m_RamData + m_Size, m_RamData);
+        } else {
             std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
         }
+      }
 #ifdef USE_CUDA
       if (other.m_VramData) {
         cudaMalloc((void **)&m_VramData, m_Size * sizeof(T));
@@ -73,14 +79,17 @@ public:
       }
 #endif
     }
+    // std::cout << "DataAllocator CopyConstructor: from=" << other.m_RamData << " to=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
   }
 
   ~DataAllocator() {
+    // std::cout << "DataAllocator Destructor: ptr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
     if (m_RamData) {
       if (m_OwnsObjects)
         delete[] m_RamData;
       else
         ::operator delete(m_RamData);
+      m_RamData = nullptr;
     }
 #ifdef USE_CUDA
     if (m_VramData) {
@@ -91,6 +100,13 @@ public:
 
   DataAllocator &operator=(const DataAllocator &other) {
     if (this != &other) {
+      if (m_Size == other.m_Size && m_OwnsObjects != other.m_OwnsObjects) {
+          // Ownership changed but size is same: we must force reallocation
+          // to avoid using the wrong delete operator later.
+          size_t oldSize = m_Size;
+          m_Size = 0; 
+          resize(oldSize); // This will free the old buffer with the OLD ownership
+      }
       m_OwnsObjects = other.m_OwnsObjects;
       resize(other.m_Size);
       m_Device = other.m_Device;
@@ -101,8 +117,12 @@ public:
           else
             m_RamData = static_cast<T *>(::operator new(m_Size * sizeof(T)));
         }
+        if (m_OwnsObjects) {
+            std::copy(other.m_RamData, other.m_RamData + m_Size, m_RamData);
+        } else {
             std::memcpy(m_RamData, other.m_RamData, m_Size * sizeof(T));
         }
+      }
 #ifdef USE_CUDA
       if (other.m_VramData) {
         if (!m_VramData)
@@ -112,6 +132,7 @@ public:
       }
 #endif
     }
+    // std::cout << "DataAllocator AssigmentOp: otherPtr=" << other.m_RamData << " thisPtr=" << m_RamData << " size=" << m_Size << " own=" << m_OwnsObjects << std::endl;
     return *this;
   }
 
@@ -152,6 +173,8 @@ public:
     if (m_Size == size)
       return;
 
+    // std::cout << "DataAllocator Resize: from=" << m_Size << " to=" << size << " ptr=" << m_RamData << " own=" << m_OwnsObjects << std::endl;
+
     T *newRam = nullptr;
     T *newVram = nullptr;
 
@@ -162,8 +185,12 @@ public:
         newRam = static_cast<T *>(::operator new(size * sizeof(T)));
 
       if (m_RamData) {
+        if (m_OwnsObjects) {
+            std::copy(m_RamData, m_RamData + std::min(m_Size, size), newRam);
+        } else {
             std::memcpy(newRam, m_RamData, std::min(m_Size, size) * sizeof(T));
         }
+      }
 
 #ifdef USE_CUDA
       cudaMalloc((void **)&newVram, size * sizeof(T));

src/Core/Debug.h

@@ -36,7 +36,77 @@
 #include "SmartPointer.h"
 
 #include <boost/any.hpp>
-#include <TObject.h>
+
+
+
+/**
+ * @file Debug.h
+ * @brief Unified Debugging and Monitoring System for uLib.
+ *
+ * # Debug System Documentation
+ *
+ * The `Debug` system provides a flexible, adapter-based mechanism for monitoring
+ * and outputting internal variables and states without hardcoding output logic
+ * into core classes. 
+ *
+ * ## Architecture
+ * 
+ * The system follows an adapter pattern:
+ * 
+ * - **`DebugAdapterInterface`**: The base interface for all output targets. 
+ *   Subclasses define how primitive types and strings are handled (e.g., printing 
+ *   to `std::cout`, writing to a log file, or updating a real-time UI widget).
+ *
+ * - **`Debug` Class**: The central registry. It stores:
+ *   1.  A list of "Adapters" (`DebugAdapterInterface`).
+ *   2.  A list of "Items" to monitor. Each item is a reference to a variable 
+ *       associated with a name.
+ *
+ * - **Type Safety**: Although variables are stored using `boost::any` (type erasure), 
+ *   the system automatically preserves the original type information via 
+ *   internal template adapters (`AnyCastAdapter`), ensuring that the correct 
+ *   overload of the adapter interface is called.
+ *
+ * ## Core Components
+ * 
+ * | Component | Description |
+ * | :--- | :--- |
+ * | `Debug` | The main controller used to add adapters and register variables. |
+ * | `DebugAdapterInterface` | Virtual base for creating new output methods. |
+ * | `DebugAdapterText` | A simple built-in adapter for `std::ostream` output. |
+ *
+ * ## How to Use
+ *
+ * ### 1. Initialize the Debug Object
+ * ```cpp
+ * uLib::Debug dbg;
+ * ```
+ *
+ * ### 2. Add an Adapter
+ * ```cpp
+ * uLib::DebugAdapterText console(std::cout);
+ * dbg.AddAdapter(console);
+ * ```
+ *
+ * ### 3. Register Variables to Monitor
+ * Use the `operator()` to bind a variable by reference.
+ * ```cpp
+ * int frameCount = 0;
+ * std::string state = "Initializing";
+ * dbg("Frames", frameCount);
+ * dbg("Status", state);
+ * ```
+ *
+ * ### 4. Update
+ * Call `Update()` periodically (e.g., once per frame) to push the current 
+ * values of all registered variables to all connected adapters.
+ * ```cpp
+ * while(running) {
+ *    frameCount++;
+ *    dbg.Update(); // This triggers the output
+ * }
+ * ```
+ */
 
 namespace uLib {
 
@@ -107,7 +177,6 @@ public:
 
 
 
-
 class Debug {
     typedef detail::DebugAdapterInterface AdapterInterface;
     typedef SmartPointer<detail::DebugAdapterInterface> Adapter;
@@ -119,8 +188,8 @@ public:
     void AddAdapter(AdapterInterface &ad) { m_a.push_back(Adapter(ad)); }
 
     void Update() {
-        foreach(Adapter &ad, m_a) {
-            foreach(DItem &item, m_v) {
+        for(Adapter &ad : m_a) {
+            for(DItem &item : m_v) {
                 item.m_adapter->operator()(ad, item.m_value);
             }
         }

src/Core/FontConfig.h

@@ -0,0 +1,48 @@
+#ifndef U_CORE_FONTCONFIG_H
+#define U_CORE_FONTCONFIG_H
+
+#include <string>
+#include <ostream>
+#include <boost/serialization/nvp.hpp>
+
+namespace uLib {
+
+/**
+ * @struct FontConfig
+ * @brief Basic font configuration for text properties.
+ */
+struct FontConfig {
+    std::string family;
+    int size;
+    bool bold;
+    bool italic;
+
+    FontConfig() : family("Arial"), size(10), bold(false), italic(false) {}
+    FontConfig(const std::string& fam, int sz, bool b = false, bool i = false)
+        : family(fam), size(sz), bold(b), italic(i) {}
+
+    bool operator==(const FontConfig& other) const {
+        return family == other.family && size == other.size && 
+               bold == other.bold && italic == other.italic;
+    }
+    bool operator!=(const FontConfig& other) const { return !(*this == other); }
+
+    template<class Archive>
+    void serialize(Archive& ar, const unsigned int version) {
+        ar & boost::serialization::make_nvp("family", family);
+        ar & boost::serialization::make_nvp("size", size);
+        ar & boost::serialization::make_nvp("bold", bold);
+        ar & boost::serialization::make_nvp("italic", italic);
+    }
+};
+
+inline std::ostream& operator<<(std::ostream& os, const FontConfig& f) {
+    os << f.family << " " << f.size;
+    if (f.bold) os << " Bold";
+    if (f.italic) os << " Italic";
+    return os;
+}
+
+} // namespace uLib
+
+#endif // U_CORE_FONTCONFIG_H

src/Core/Monitor.h

@@ -0,0 +1,215 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CORE_MONITOR_H
+#define U_CORE_MONITOR_H
+
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
+#include <utility>
+
+namespace uLib {
+
+/**
+ * @brief Mutex class wraps std::timed_mutex and is used for thread synchronization.
+ */
+class Mutex {
+public:
+  Mutex() = default;
+  ~Mutex() = default;
+
+  /** @brief Locks the mutex, blocking if necessary. */
+  void Lock() { m_Mutex.lock(); }
+
+  /** @brief Unlocks the mutex. */
+  void Unlock() { m_Mutex.unlock(); }
+
+  /** @brief Tries to lock the mutex without blocking. */
+  bool TryLock() { return m_Mutex.try_lock(); }
+
+  /** @brief Tries to lock the mutex within a timeout in milliseconds. */
+  bool TryLockFor(int timeout_ms) {
+      if (timeout_ms < 0) { Lock(); return true; }
+      return m_Mutex.try_lock_for(std::chrono::milliseconds(timeout_ms));
+  }
+
+  /** @brief RAII helper for scoped locking. */
+  class ScopedLock {
+  public:
+    ScopedLock(Mutex &mutex) : m_Mutex(mutex) { m_Mutex.Lock(); }
+    ~ScopedLock() { m_Mutex.Unlock(); }
+  private:
+    Mutex &m_Mutex;
+    // Non-copyable
+    ScopedLock(const ScopedLock&) = delete;
+    ScopedLock& operator=(const ScopedLock&) = delete;
+  };
+
+  /** @brief Returns the underlying std::timed_mutex. */
+  std::timed_mutex& GetNative() { return m_Mutex; }
+
+private:
+  std::timed_mutex m_Mutex;
+  // Non-copyable
+  Mutex(const Mutex &) = delete;
+  Mutex &operator=(const Mutex &) = delete;
+};
+
+namespace detail {
+
+/** @brief Internal implementation for the ULIB_MUTEX_LOCK macros. */
+class ScopedTimedLock {
+public:
+    ScopedTimedLock(Mutex& mutex, int timeout_ms) 
+        : m_RawMutex(nullptr), m_MutexWrapper(&mutex), m_Locked(false) {
+        m_Locked = m_MutexWrapper->TryLockFor(timeout_ms);
+    }
+    
+    ScopedTimedLock(std::timed_mutex& mutex, int timeout_ms) 
+        : m_RawMutex(&mutex), m_MutexWrapper(nullptr), m_Locked(false) {
+        if (timeout_ms < 0) { m_RawMutex->lock(); m_Locked = true; }
+        else m_Locked = m_RawMutex->try_lock_for(std::chrono::milliseconds(timeout_ms));
+    }
+
+    ~ScopedTimedLock() {
+        if (m_Locked) {
+            if (m_RawMutex) m_RawMutex->unlock();
+            else if (m_MutexWrapper) m_MutexWrapper->Unlock();
+        }
+    }
+    
+    operator bool() const { return m_Locked; }
+    void unlock() { if (m_Locked) { 
+        if (m_RawMutex) m_RawMutex->unlock();
+        else if (m_MutexWrapper) m_MutexWrapper->Unlock();
+        m_Locked = false; 
+    } }
+
+private:
+    std::timed_mutex* m_RawMutex = nullptr;
+    Mutex* m_MutexWrapper = nullptr;
+    bool m_Locked;
+    
+    // Non-copyable/movable to be safe in the 'for' loop
+    ScopedTimedLock(const ScopedTimedLock&) = delete;
+    ScopedTimedLock& operator=(const ScopedTimedLock&) = delete;
+    ScopedTimedLock(ScopedTimedLock&&) = default; 
+};
+
+inline ScopedTimedLock makeScopedMutexLock(Mutex& mutex, int timeout_ms) {
+    return ScopedTimedLock(mutex, timeout_ms);
+}
+
+inline ScopedTimedLock makeScopedMutexLock(std::timed_mutex& mutex, int timeout_ms) {
+    return ScopedTimedLock(mutex, timeout_ms);
+}
+
+} // namespace detail
+
+/**
+ * @brief Macro for block-scoped locking of a static mutex.
+ * @param timeout Timeout in ms (-1 for infinite).
+ */
+#define ULIB_STATIC_LOCK(timeout) \
+    static std::timed_mutex __ulib_static_mutex; \
+    for (auto __ulib_lock = uLib::detail::makeScopedMutexLock(__ulib_static_mutex, timeout); \
+         __ulib_lock; \
+         __ulib_lock.unlock())
+
+/**
+ * @brief Macro for block-scoped locking of a provided mutex.
+ * @param mutex The uLib::Mutex or std::timed_mutex to lock.
+ * @param timeout Timeout in ms (-1 for infinite).
+ */
+#define ULIB_MUTEX_LOCK(mutex, timeout) \
+    for (auto __ulib_lock = uLib::detail::makeScopedMutexLock(mutex, timeout); \
+         __ulib_lock; \
+         __ulib_lock.unlock())
+
+/**
+ * @brief RecursiveMutex class wraps std::recursive_timed_mutex.
+ */
+class RecursiveMutex {
+public:
+  RecursiveMutex() = default;
+  ~RecursiveMutex() = default;
+
+  /** @brief Locks the mutex, blocking if necessary. */
+  void Lock() { m_Mutex.lock(); }
+
+  /** @brief Unlocks the mutex. */
+  void Unlock() { m_Mutex.unlock(); }
+
+  /** @brief Tries to lock the mutex without blocking. */
+  bool TryLock() { return m_Mutex.try_lock(); }
+
+  /** @brief Tries to lock the mutex within a timeout in milliseconds. */
+  bool TryLockFor(int timeout_ms) {
+      if (timeout_ms < 0) { Lock(); return true; }
+      return m_Mutex.try_lock_for(std::chrono::milliseconds(timeout_ms));
+  }
+
+  /** @brief RAII helper for scoped locking. */
+  class ScopedLock {
+  public:
+    ScopedLock(RecursiveMutex &mutex) : m_Mutex(mutex) { m_Mutex.Lock(); }
+    ~ScopedLock() { m_Mutex.Unlock(); }
+  private:
+    RecursiveMutex &m_Mutex;
+    ScopedLock(const ScopedLock&) = delete;
+    ScopedLock& operator=(const ScopedLock&) = delete;
+  };
+
+private:
+  std::recursive_timed_mutex m_Mutex;
+  RecursiveMutex(const RecursiveMutex &) = delete;
+  RecursiveMutex &operator=(const RecursiveMutex &) = delete;
+};
+
+/**
+ * @brief Monitor class provides a base for objects that need thread-safe access.
+ */
+template <typename T>
+class Monitor {
+protected:
+  T* m_Resource;
+  Mutex m_Mutex;
+
+public:
+  Monitor(T* resource) : m_Resource(resource) {}
+  virtual ~Monitor() { delete m_Resource; }
+
+  /** @brief Thread-safe access to the resource through a lambda. */
+  template <typename F>
+  auto Access(F f) -> decltype(f(*m_Resource)) {
+    Mutex::ScopedLock lock(m_Mutex);
+    return f(*m_Resource);
+  }
+};
+
+} // namespace uLib
+
+#endif // U_CORE_MONITOR_H

src/Core/Object.cpp

@@ -35,6 +35,9 @@
 #include "boost/archive/polymorphic_xml_iarchive.hpp"
 #include "boost/archive/polymorphic_xml_oarchive.hpp"
 
+#include <vector>
+#include "Property.h"
+
 namespace uLib {
 
 const char *Version::PackageName = PACKAGE_NAME;
@@ -57,25 +60,123 @@ public:
     std::string slostr;
   };
 
-  Vector<Signal> sigv;
-  Vector<Slot> slov;
+  ~ObjectPrivate() {
+    for (auto& s : sigv) delete s.signal;
+  }
+  
+  std::string m_InstanceName;
+  std::vector<Signal> sigv;
+  std::vector<Slot> slov;
+  std::vector<PropertyBase*> m_Properties;
+  std::vector<PropertyBase*> m_DynamicProperties;
+  std::vector<PropertyBase*> m_DisplayProperties;
+  bool m_SignalsBlocked;
 };
 
+// Implementations of Property methods
+void Object::RegisterDisplayProperty(PropertyBase* prop) {
+    if (prop) {
+        for (auto* existing : d->m_DisplayProperties) {
+            if (existing == prop) return;
+            if (existing->GetName() == prop->GetName()) return;
+        }
+        d->m_DisplayProperties.push_back(prop);
+    }
+}
+
+const std::vector<PropertyBase*>& Object::GetDisplayProperties() const {
+    return d->m_DisplayProperties;
+}
+
+void Object::RegisterProperty(PropertyBase* prop) {
+    if (prop) {
+        for (auto* existing : d->m_Properties) {
+            if (existing == prop) return;
+            if (existing->GetName() == prop->GetName()) return;
+        }
+        d->m_Properties.push_back(prop);
+    }
+}
+
+void Object::RegisterDynamicProperty(PropertyBase* prop) {
+    if (prop) {
+        for (auto* existing : d->m_DynamicProperties) {
+            if (existing == prop) return;
+            if (existing->GetQualifiedName() == prop->GetQualifiedName()) return;
+        }
+        d->m_DynamicProperties.push_back(prop);
+    }
+}
+
+const std::vector<PropertyBase*>& Object::GetProperties() const {
+    return d->m_Properties;
+}
+
+PropertyBase* Object::GetProperty(const std::string& name) const {
+    for (auto* p : d->m_Properties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
+    for (auto* p : d->m_DynamicProperties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
+    for (auto* p : d->m_DisplayProperties) {
+        if (p->GetName() == name || p->GetQualifiedName() == name) return p;
+    }
+    return nullptr;
+}
+
+void Object::NotifyPropertiesUpdated() {
+    // Only notify properties in the primary list to avoid duplicates, 
+    // as all registered properties should be there.
+    for (auto* p : d->m_Properties) p->Updated();
+}
+
+void Object::Updated() { ULIB_SIGNAL_EMIT(Object::Updated); }
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // OBJECT IMPLEMENTATION
 
-Object::Object() : d(new ObjectPrivate) {}
+Object::Object() : d(new ObjectPrivate) {
+    d->m_SignalsBlocked = false;
+}
+Object::Object(const Object &copy) : d(new ObjectPrivate) {
+    if (copy.d) {
+        d->m_InstanceName = copy.d->m_InstanceName;
+        d->m_SignalsBlocked = copy.d->m_SignalsBlocked;
+    }
+}
 
-Object::Object(const Object &copy) : d(new ObjectPrivate(*copy.d)) {}
+Object& Object::operator=(const Object &other) {
+    // Intentionally does NOT share 'd'. Each Object owns its own ObjectPrivate.
+    // Without this, the compiler-generated operator= would copy the 'd' pointer,
+    // causing two objects to share the same ObjectPrivate. When both are
+    // destroyed, 'd' would be deleted twice, corrupting the heap.
+    if (this != &other && other.d) {
+        d->m_InstanceName = other.d->m_InstanceName;
+        d->m_SignalsBlocked = other.d->m_SignalsBlocked;
+    }
+    return *this;
+}
 
-Object::~Object() { delete d; }
+Object::~Object() {
+    for (auto* p : d->m_DynamicProperties) {
+        delete p;
+    }
+    for (auto* p : d->m_DisplayProperties) {
+        delete p;
+    }
+    delete d;
+}
 
 void Object::DeepCopy(const Object &copy) {
-  // should lock to be tread safe //
-  memcpy(d, copy.d, sizeof(ObjectPrivate));
-  // ERROR! does not copy parameters ... <<<< FIXXXXX
+    if (this == &copy) return;
+    if (copy.d) d->m_InstanceName = copy.d->m_InstanceName;
+    std::cout << "Object DeepCopy: from d=" << copy.d << " to d=" << d << std::endl;
+    // Note: signals, slots and properties are intentionally not copied 
+    // to maintain instance uniquely and avoid duplicate registrations.
+    this->Updated();
 }
 
 void Object::SaveXml(std::ostream &os, Object &ob) {
@@ -99,9 +200,8 @@ void Object::LoadConfig(std::istream &is, int version) {
 
 void Object::PrintSelf(std::ostream &o) const {
   o << "OBJECT signals: ------------------\n";
-  Vector<ObjectPrivate::Signal>::Iterator itr;
-  for (itr = d->sigv.begin(); itr < d->sigv.end(); itr++) {
-    o << "  signal:[ " << itr->sigstr << " ]\n";
+  for (const auto& sig : d->sigv) {
+    o << "  signal:[ " << sig.sigstr << " ]\n";
   }
   o << "--------------------------------------\n\n";
 }
@@ -145,6 +245,25 @@ GenericMFPtr *Object::findSlotImpl(const char *name) const {
   return NULL;
 }
 
+const std::string& Object::GetInstanceName() const {
+  return d->m_InstanceName;
+}
+
+void Object::SetInstanceName(const std::string& name) {
+  d->m_InstanceName = name;
+  this->Updated();
+}
+ 
+bool Object::blockSignals(bool block) {
+  bool old = d->m_SignalsBlocked;
+  d->m_SignalsBlocked = block;
+  return old;
+}
+ 
+bool Object::signalsBlocked() const {
+  return d->m_SignalsBlocked;
+}
+
 // std::ostream &
 // operator << (std::ostream &os, uLib::Object &ob)
 // {

src/Core/Object.h

@@ -27,6 +27,7 @@
 #define U_CORE_OBJECT_H
 
 #include <iostream>
+#include <string>
 
 // WARNING: COPILE ERROR if this goes after mpl/vector //
 // #include "Core/Vector.h"
@@ -50,6 +51,9 @@ class polymorphic_oarchive;
 
 namespace uLib {
 
+class PropertyBase;
+class ObjectsContext;
+
 class Version {
 public:
   static const char *PackageName;
@@ -72,7 +76,33 @@ public:
 
   Object();
   Object(const Object &copy);
-  ~Object();
+  virtual ~Object();
+
+  virtual const char *GetClassName() const { return type_name(); }
+  virtual const char *type_name() const { return "Object"; }
+
+  const std::string &GetInstanceName() const;
+  void SetInstanceName(const std::string &name);
+
+  /** @brief Temporarily blocks all signal emissions from this object. Returns
+   * previous state. */
+  bool blockSignals(bool block);
+
+  /** @brief Checks if signals are currently blocked. */
+  bool signalsBlocked() const;
+
+  ////////////////////////////////////////////////////////////////////////////
+  // PROPERTIES //
+  virtual void RegisterProperty(PropertyBase *property);
+  virtual void RegisterDynamicProperty(PropertyBase *property);
+  virtual void RegisterDisplayProperty(PropertyBase *property);
+  virtual const std::vector<PropertyBase *> &GetProperties() const;
+  virtual const std::vector<PropertyBase *> &GetDisplayProperties() const;
+  PropertyBase *GetProperty(const std::string &name) const;
+
+  /** @brief Sends an Updated signal for all properties of this object. useful
+   * for real-time UI refresh. */
+  void NotifyPropertiesUpdated();
 
   ////////////////////////////////////////////////////////////////////////////
   // PARAMETERS //
@@ -80,11 +110,30 @@ public:
   // FIXX !!!
   virtual void DeepCopy(const Object &copy);
 
+  /** @brief Returns a nested context for children objects, if any. */
+  virtual ObjectsContext *GetChildren() { return nullptr; }
+
   ////////////////////////////////////////////////////////////////////////////
   // SERIALIZATION //
 
   template <class ArchiveT>
-  void serialize(ArchiveT &ar, const unsigned int version) {}
+  void serialize(ArchiveT &ar, const unsigned int version);
+
+  virtual void serialize(Archive::xml_oarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::xml_iarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::text_oarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::text_iarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::hrt_oarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::hrt_iarchive &ar,
+                         const unsigned int version) {}
+  virtual void serialize(Archive::log_archive &ar, const unsigned int version) {
+  }
+
   template <class ArchiveT>
   void save_override(ArchiveT &ar, const unsigned int version) {}
 
@@ -97,6 +146,9 @@ public:
   ////////////////////////////////////////////////////////////////////////////
   // SIGNALS //
 
+signals:
+  virtual void Updated();
+
   // Qt4 style connector //
   static bool connect(const Object *ob1, const char *signal_name,
                       const Object *receiver, const char *slot_name) {
@@ -112,20 +164,37 @@ public:
 
   // Qt5 style connector //
   template <typename Func1, typename Func2>
-  static bool
+  static Connection
   connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
           typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
     SignalBase *sigb = sender->findOrAddSignal(sigf);
-    ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(sigb, slof,
-                                                                    receiver);
+    return ConnectSignal<typename FunctionPointer<Func1>::SignalSignature>(
+        sigb, slof, receiver);
+  }
+
+  // Lambda/Function object connector //
+  template <typename Func1, typename SlotT>
+  static Connection connect(typename FunctionPointer<Func1>::Object *sender,
+                            Func1 sigf, SlotT slof) {
+    SignalBase *sigb = sender->findOrAddSignal(sigf);
+    typedef typename FunctionPointer<Func1>::SignalSignature SigSignature;
+    typedef typename Signal<SigSignature>::type SigT;
+    return reinterpret_cast<SigT *>(sigb)->connect(slof);
+  }
+
+  template <typename Func1, typename Func2>
+  static bool
+  disconnect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
+             typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
+    // TODO: implement actual disconnect in Signal.h //
     return true;
   }
 
   template <typename FuncT>
-  static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
-    ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(sigb, slof,
-                                                                    receiver);
-    return true;
+  static inline Connection connect(SignalBase *sigb, FuncT slof,
+                                   Object *receiver) {
+    return ConnectSignal<typename FunctionPointer<FuncT>::SignalSignature>(
+        sigb, slof, receiver);
   }
 
   template <typename FuncT>
@@ -179,10 +248,7 @@ public:
 
   void PrintSelf(std::ostream &o) const;
 
-  inline const Object &operator=(const Object &copy) {
-    this->DeepCopy(copy);
-    return *this;
-  }
+  Object &operator=(const Object &other);
 
 private:
   bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);

src/Core/ObjectFactory.cpp

@@ -0,0 +1,32 @@
+#include "ObjectFactory.h"
+
+namespace uLib {
+
+ObjectFactory& ObjectFactory::Instance() {
+    static ObjectFactory instance;
+    return instance;
+}
+
+void ObjectFactory::Register(const std::string& className, FactoryFunction func) {
+    if (m_factoryMap.find(className) == m_factoryMap.end()) {
+        m_factoryMap[className] = func;
+    }
+}
+
+Object* ObjectFactory::Create(const std::string& className) {
+    auto it = m_factoryMap.find(className);
+    if (it != m_factoryMap.end()) {
+        return (it->second)();
+    }
+    return nullptr;
+}
+
+std::vector<std::string> ObjectFactory::GetRegisteredClasses() const {
+    std::vector<std::string> classes;
+    for (auto const& [name, func] : m_factoryMap) {
+        classes.push_back(name);
+    }
+    return classes;
+}
+
+} // namespace uLib

src/Core/ObjectFactory.h

@@ -0,0 +1,142 @@
+#ifndef U_CORE_OBJECTFACTORY_H
+#define U_CORE_OBJECTFACTORY_H
+
+#include "Core/Object.h"
+#include <functional>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace uLib {
+
+/**
+ * @brief Singleton factory for dynamic Object instantiation based on class
+ * name.
+ */
+class ObjectFactory {
+public:
+  typedef std::function<Object *()> FactoryFunction;
+
+  /** @brief Get the singleton instance. */
+  static ObjectFactory &Instance();
+
+  /** @brief Register a factory function for a given class name. */
+  void Register(const std::string &className, FactoryFunction func);
+
+  /** @brief Create a new instance of the specified class. */
+  Object *Create(const std::string &className);
+
+  /** @brief Get the names of all registered classes. */
+  std::vector<std::string> GetRegisteredClasses() const;
+
+private:
+  ObjectFactory() = default;
+  ~ObjectFactory() = default;
+
+  // Prevent copy and assignment
+  ObjectFactory(const ObjectFactory &) = delete;
+  ObjectFactory &operator=(const ObjectFactory &) = delete;
+
+  std::map<std::string, FactoryFunction> m_factoryMap;
+};
+
+/**
+ * @brief Helper class to statically register a factory function.
+ */
+template <typename T> class ObjectRegistrar {
+public:
+  ObjectRegistrar(const std::string &className) {
+    ObjectFactory::Instance().Register(className,
+                                       []() -> Object * { return new T(); });
+  }
+};
+
+#define ULIB_REG_CONCAT_IMPL(a, b) a##b
+#define ULIB_REG_CONCAT(a, b) ULIB_REG_CONCAT_IMPL(a, b)
+
+/**
+ * @brief Macro to register a class to the factory.
+ * Put this in the .cpp file of the class.
+ */
+#define ULIB_REGISTER_OBJECT(className)                                        \
+  static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(                     \
+      g_ObjectRegistrar_, __LINE__)(#className);
+
+#define ULIB_REGISTER_OBJECT_NAME(className, registeredName)                   \
+  static uLib::ObjectRegistrar<className> ULIB_REG_CONCAT(                     \
+      g_ObjectRegistrar_, __LINE__)(registeredName);
+
+
+
+
+
+/**
+ * @brief Utility wrapper that bridges factory registration and shared ownership.
+ * 
+ * ObjectWrapper provides a high-level interface to handle objects that can be
+ * both registered in the ObjectFactory and managed through shared ownership
+ * using SmartPointer.
+ * 
+ * One of its key roles is static registration: when instantiated with a 
+ * class name string, it automatically registers a factory function for type T 
+ * in the ObjectFactory singleton. This allows the factory to subsequently 
+ * create instances of T dynamically by name.
+ * 
+ * It supports multiple initialization paths, including factory-based 
+ * construction and direct model wrapping.
+ */
+template <typename T> class ObjectWrapper {
+public:
+  ObjectWrapper(const std::string &className) {
+    ObjectFactory::Instance().Register(className,
+                                       []() -> Object * { return new T(); });
+  }
+
+  ObjectWrapper(T *model) : m_model(model) {}
+  ObjectWrapper(T &model) : m_model(model) {}
+
+  template <typename U = T,
+            typename = std::enable_if_t<std::is_default_constructible_v<U>>>
+  ObjectWrapper() : m_model(new T()) {}
+
+  ObjectWrapper(const ObjectWrapper &other) : m_model(other.m_model) {}
+
+  ObjectWrapper &operator=(const ObjectWrapper &other) {
+    m_model = other.m_model;
+    return *this;
+  }
+
+  ObjectWrapper(ObjectWrapper &&other) noexcept
+      : m_model(std::move(other.m_model)) {}
+
+  ObjectWrapper &operator=(ObjectWrapper &&other) noexcept {
+    m_model = std::move(other.m_model);
+    return *this;
+  }
+
+  ~ObjectWrapper() = default;
+
+  T *operator->() const { return m_model.get(); }
+
+  T &operator*() const { return *m_model; }
+
+  T *GetWrapped() const { return m_model.get(); }
+
+  bool operator==(const ObjectWrapper &other) const {
+    return m_model == other.m_model;
+  }
+
+  bool operator!=(const ObjectWrapper &other) const {
+    return m_model != other.m_model;
+  }
+
+  explicit operator bool() const { return m_model != nullptr; }
+
+protected:
+  SmartPointer<T> m_model;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_OBJECTFACTORY_H

src/Core/ObjectsContext.cpp

@@ -0,0 +1,76 @@
+#include "Core/ObjectsContext.h"
+#include <algorithm>
+
+namespace uLib {
+
+ObjectsContext::ObjectsContext() : Object() {}
+
+ObjectsContext::~ObjectsContext() {}
+
+void ObjectsContext::AddObject(Object* obj) {
+    if (obj) {
+        auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
+            return sp.get() == obj;
+        });
+        if (it == m_objects.end()) {
+            m_objects.push_back(SmartPointer<Object>(obj));
+            // Connect child's update to context's update to trigger re-renders
+            Object::connect(obj, &Object::Updated, this, &Object::Updated);
+            ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+            this->Updated(); // Signal that the context has been updated
+        }
+    }
+}
+
+void ObjectsContext::RemoveObject(Object* obj) {
+    auto it = std::find_if(m_objects.begin(), m_objects.end(), [obj](const SmartPointer<Object>& sp) {
+        return sp.get() == obj;
+    });
+    if (it != m_objects.end()) {
+        Object* removedObj = it->get();
+        // Since we are about to erase it from the vector, if it was the last reference
+        // it would be deleted. We might want to emit the signal BEFORE erasing.
+        ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, removedObj);
+        m_objects.erase(it);
+        this->Updated(); // Signal that the context has been updated
+    }
+}
+
+void ObjectsContext::Clear() {
+    if (!m_objects.empty()) {
+        // Create a copy of the pointers to emit signals since m_objects might be modified or cleared
+        std::vector<Object*> toRemove;
+        for (const auto& sp : m_objects) toRemove.push_back(sp.get());
+
+        for (auto obj : toRemove) {
+            ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
+        }
+        m_objects.clear();
+        this->Updated();
+    }
+}
+
+const std::vector<SmartPointer<Object>>& ObjectsContext::GetObjects() const {
+    return m_objects;
+}
+
+size_t ObjectsContext::GetCount() const {
+    return m_objects.size();
+}
+
+Object* ObjectsContext::GetObject(size_t index) const {
+    if (index < m_objects.size()) {
+        return m_objects[index].get();
+    }
+    return nullptr;
+}
+
+void ObjectsContext::ObjectAdded(Object* obj) {
+    ULIB_SIGNAL_EMIT(ObjectsContext::ObjectAdded, obj);
+}
+
+void ObjectsContext::ObjectRemoved(Object* obj) {
+    ULIB_SIGNAL_EMIT(ObjectsContext::ObjectRemoved, obj);
+}
+
+} // namespace uLib

src/Core/ObjectsContext.h

@@ -0,0 +1,69 @@
+#ifndef U_CORE_OBJECTS_CONTEXT_H
+#define U_CORE_OBJECTS_CONTEXT_H
+
+#include "Core/Object.h"
+#include "Core/SmartPointer.h"
+#include <vector>
+
+namespace uLib {
+
+/**
+ * @brief ObjectsContext represents a collection of Object instances.
+ */
+class ObjectsContext : virtual public Object {
+public:
+    ObjectsContext();
+    virtual ~ObjectsContext();
+
+    uLibTypeMacro(ObjectsContext, Object)
+    virtual ObjectsContext* GetChildren() override { return this; }
+
+    /**
+     * @brief Adds an object to the context.
+     * @param obj Pointer to the object to add.
+     */
+    virtual void AddObject(Object* obj);
+
+    /**
+     * @brief Removes an object from the context.
+     * @param obj Pointer to the object to remove.
+     */
+    virtual void RemoveObject(Object* obj);
+
+    /**
+     * @brief Clears all objects from the context.
+     */
+    void Clear();
+
+    /**
+     * @brief Returns the collection of objects.
+     * @return Const reference to the vector of SmartPointer<Object>.
+     */
+    const std::vector<SmartPointer<Object>>& GetObjects() const;
+    
+    signals:
+    /** @brief Signal emitted when an object is added. */
+    virtual void ObjectAdded(Object* obj);
+    /** @brief Signal emitted when an object is removed. */
+    virtual void ObjectRemoved(Object* obj);
+
+    /**
+     * @brief Returns the number of objects in the context.
+     * @return Size of the collection.
+     */
+    size_t GetCount() const;
+
+    /**
+     * @brief Returns an object by index.
+     * @param index The index of the object.
+     * @return Pointer to the object or nullptr if index is out of bounds.
+     */
+    Object* GetObject(size_t index) const;
+
+private:
+    std::vector<SmartPointer<Object>> m_objects;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_OBJECTS_CONTEXT_H

src/Core/Property.h

@@ -0,0 +1,531 @@
+#ifndef U_CORE_PROPERTY_H
+#define U_CORE_PROPERTY_H
+
+#include <string>
+#include <vector>
+#include <sstream>
+#include <typeinfo>
+#include <typeindex>
+#include <boost/serialization/nvp.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/mpl/bool.hpp>
+#include <set>
+#include <boost/type_traits/is_base_of.hpp>
+#include "Core/Archives.h"
+#include "Core/Signal.h"
+#include "Core/Object.h"
+#include "Core/SmartPointer.h"
+
+// Type traits for detecting SmartPointer<T>
+namespace uLib {
+template<typename T> struct is_smart_pointer : std::false_type {};
+template<typename T> struct is_smart_pointer<SmartPointer<T>> : std::true_type {};
+template<typename T> struct smart_pointer_element { using type = void; };
+template<typename T> struct smart_pointer_element<SmartPointer<T>> { using type = T; };
+} // namespace uLib
+
+namespace uLib {
+
+namespace Archive {
+class property_register_archive;
+}
+
+/**
+ * @brief Base class for properties to allow runtime listing and identification.
+ */
+class PropertyBase : public Object {
+public:
+  virtual ~PropertyBase() {}
+  virtual const std::string& GetName() const = 0;
+  virtual const char* GetTypeName() const = 0;
+  virtual std::string GetValueAsString() const = 0;
+  virtual std::type_index GetTypeIndex() const = 0;
+  virtual const std::string& GetUnits() const = 0;
+  virtual void SetUnits(const std::string& units) = 0;
+  virtual const std::vector<std::string>& GetEnumLabels() const {
+      static std::vector<std::string> empty;
+      return empty;
+  }
+  virtual const std::string& GetGroup() const = 0;
+  virtual void SetGroup(const std::string& group) = 0;
+
+  virtual bool HasRange() const { return false; }
+  virtual double GetMin() const { return 0; }
+  virtual double GetMax() const { return 0; }
+  virtual bool HasDefault() const { return false; }
+  virtual std::string GetDefaultValueAsString() const { return ""; }
+  virtual bool IsReadOnly() const = 0;
+
+  std::string GetQualifiedName() const {
+      if (GetGroup().empty()) return GetName();
+      return GetGroup() + "." + GetName();
+  }
+
+
+  // Serialization support for different uLib archives
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) override = 0;
+  virtual void serialize(Archive::log_archive & ar, const unsigned int version) override = 0;
+  
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) = 0;
+};
+
+/**
+ * @brief Template class for typed properties.
+ */
+template <typename T>
+class Property : public PropertyBase {
+public:
+  Property(Object* owner, const std::string& name, T* valuePtr, const std::string& units = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(valuePtr), m_own(false),
+      m_HasRange(false), m_HasDefault(false), m_ReadOnly(false) {
+      if (m_owner) m_owner->RegisterProperty(this);
+  }
+
+  Property(Object* owner, const std::string& name, const T& defaultValue = T(), const std::string& units = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_value(new T(defaultValue)), m_own(true),
+      m_HasRange(false), m_HasDefault(true), m_Default(defaultValue), m_ReadOnly(false) {
+      if (m_owner) m_owner->RegisterProperty(this);
+  }
+
+  virtual ~Property() { if (m_own) delete m_value; }
+
+  // Identification
+  virtual const std::string& GetName() const override { return m_name; }
+  virtual const char* GetTypeName() const override { return typeid(T).name(); }
+  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(T)); }
+  virtual const std::string& GetUnits() const override { return m_units; }
+  virtual void SetUnits(const std::string& units) override { m_units = units; }
+  virtual const std::string& GetGroup() const override { return m_group; }
+  virtual void SetGroup(const std::string& group) override { m_group = group; }
+
+  std::string GetValueAsString() const override {
+      try { return boost::lexical_cast<std::string>(*m_value); }
+      catch (...) { std::stringstream ss; ss << *m_value; return ss.str(); }
+  }
+
+  // Accessors
+  const T& Get() const { return *m_value; }
+  void Set(const T& value) {
+    if (!m_value) return;
+    T val = value;
+    if constexpr (std::is_arithmetic<T>::value) {
+      if (m_HasRange) { if (val < m_Min) val = m_Min; if (val > m_Max) val = m_Max; }
+    }
+    if (*m_value != val) {
+      *m_value = val;
+      ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
+      this->Updated();
+      if (m_owner) m_owner->Updated();
+    }
+  }
+
+  void SetRange(const T& min, const T& max) { m_Min = min; m_Max = max; m_HasRange = true; }
+  void SetDefault(const T& def) { m_Default = def; m_HasDefault = true; }
+  void SetReadOnly(bool ro) { m_ReadOnly = ro; }
+
+  virtual bool IsReadOnly() const override { return m_ReadOnly; }
+  virtual bool HasRange() const override { return m_HasRange; }
+  virtual double GetMin() const override { return m_HasRange ? convert_to_double(m_Min) : 0.0; }
+  virtual double GetMax() const override { return m_HasRange ? convert_to_double(m_Max) : 0.0; }
+  
+  const T& GetMinTyped() const { return m_Min; }
+  const T& GetMaxTyped() const { return m_Max; }
+
+  virtual bool HasDefault() const override { return m_HasDefault; }
+  virtual std::string GetDefaultValueAsString() const override {
+      try { return boost::lexical_cast<std::string>(m_Default); } catch (...) { return ""; }
+  }
+
+  // Operators
+  operator const T&() const { return *m_value; }
+  Property& operator=(const T& value) { Set(value); return *this; }
+
+  signals:
+  virtual void PropertyChanged() { ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged); }
+
+private:
+  template <typename U>
+  static double convert_to_double(const U& val) {
+    return convert_to_double_impl(val, typename std::is_arithmetic<U>::type());
+  }
+  template <typename U>
+  static double convert_to_double_impl(const U& val, std::true_type) { return (double)val; }
+  template <typename U>
+  static double convert_to_double_impl(const U& val, std::false_type) { return 0.0; }
+
+public:
+  // Serialization
+  template <class ArchiveT>
+  void serialize_helper(ArchiveT & ar, const unsigned int version) {
+    ar & boost::serialization::make_hrp(m_name.c_str(), *m_value, m_units.c_str());
+  }
+
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_helper(ar, v); }
+  virtual void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_helper(ar, v); }
+  
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override;
+
+
+protected:
+  std::string m_name;
+  std::string m_units;
+  std::string m_group;
+  T* m_value;
+  bool m_own;
+  Object* m_owner;
+  bool m_HasRange;
+  T m_Min;
+  T m_Max;
+  bool m_HasDefault;
+  T m_Default;
+  bool m_ReadOnly;
+};
+
+/**
+ * @brief Property specialized for enumerations.
+ */
+class EnumProperty : public Property<int> {
+public:
+  EnumProperty(Object* owner, const std::string& name, int* valuePtr, const std::vector<std::string>& labels, const std::string& units = "", const std::string& group = "")
+    : Property<int>(owner, name, valuePtr, units, group), m_Labels(labels) {}
+
+  const std::vector<std::string>& GetEnumLabels() const override { return m_Labels; }
+  const char* GetTypeName() const override { return "Enum"; }
+  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(EnumProperty)); }
+
+  template <class ArchiveT>
+  void serialize_enum_helper(ArchiveT & ar, const unsigned int version) {
+    ar & boost::serialization::make_hrp_enum(m_name.c_str(), *m_value, m_Labels, m_units.c_str());
+  }
+
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  virtual void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_enum_helper(ar, v); }
+  
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override;
+
+private:
+  std::vector<std::string> m_Labels;
+};
+
+} // namespace uLib
+
+namespace uLib {
+
+/**
+ * @brief Base class for reference properties (SmartPointer<T> fields).
+ * Provides a type-erased interface for getting/setting object references
+ * and checking type compatibility.
+ */
+class ReferencePropertyBase : public PropertyBase {
+public:
+  virtual ~ReferencePropertyBase() {}
+  virtual Object* GetReferencedObject() const = 0;
+  virtual void SetReferencedObject(Object* obj) = 0;
+  virtual bool IsCompatible(Object* obj) const = 0;
+  virtual const char* GetReferenceTypeName() const = 0;
+};
+
+/**
+ * @brief Typed reference property for SmartPointer<T> fields.
+ * Filters context objects by dynamic_cast compatibility with T.
+ */
+template <typename T>
+class ReferenceProperty : public ReferencePropertyBase {
+public:
+  ReferenceProperty(Object* owner, const std::string& name, SmartPointer<T>& ref,
+                    const std::string& units = "", const std::string& group = "")
+    : m_owner(owner), m_name(name), m_units(units), m_group(group), m_ref(ref), m_ReadOnly(false) {
+      if (m_owner) m_owner->RegisterProperty(this);
+  }
+
+  virtual ~ReferenceProperty() {}
+
+  // PropertyBase interface
+  virtual const std::string& GetName() const override { return m_name; }
+  virtual const char* GetTypeName() const override { return typeid(SmartPointer<T>).name(); }
+  virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(ReferencePropertyBase)); }
+  virtual const std::string& GetUnits() const override { return m_units; }
+  virtual void SetUnits(const std::string& units) override { m_units = units; }
+  virtual const std::string& GetGroup() const override { return m_group; }
+  virtual void SetGroup(const std::string& group) override { m_group = group; }
+  virtual bool IsReadOnly() const override { return m_ReadOnly; }
+  void SetReadOnly(bool ro) { m_ReadOnly = ro; }
+
+  virtual std::string GetValueAsString() const override {
+    T* ptr = m_ref.Get();
+    if (!ptr) return "(none)";
+    Object* obj = dynamic_cast<Object*>(ptr);
+    if (obj) {
+      std::string iname = obj->GetInstanceName();
+      if (!iname.empty()) return iname;
+      return obj->GetClassName();
+    }
+    return "(set)";
+  }
+
+  // ReferencePropertyBase interface
+  virtual Object* GetReferencedObject() const override {
+    return dynamic_cast<Object*>(m_ref.Get());
+  }
+
+  virtual void SetReferencedObject(Object* obj) override {
+    if (!obj) {
+      m_ref = SmartPointer<T>(nullptr);
+      this->Updated();
+      if (m_owner) m_owner->Updated();
+      return;
+    }
+    T* casted = dynamic_cast<T*>(obj);
+    if (casted) {
+      m_ref = SmartPointer<T>(casted);
+      this->Updated();
+      if (m_owner) m_owner->Updated();
+    }
+  }
+
+  virtual bool IsCompatible(Object* obj) const override {
+    return dynamic_cast<T*>(obj) != nullptr;
+  }
+
+  virtual const char* GetReferenceTypeName() const override {
+    return typeid(T).name();
+  }
+
+  // Serialization stubs
+  virtual void serialize(Archive::xml_oarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::xml_iarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::text_oarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::text_iarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::log_archive & ar, const unsigned int v) override {}
+  virtual void serialize(Archive::property_register_archive & ar, const unsigned int v) override {}
+
+private:
+  Object* m_owner;
+  std::string m_name;
+  std::string m_units;
+  std::string m_group;
+  SmartPointer<T>& m_ref;
+  bool m_ReadOnly;
+};
+
+} // namespace uLib
+
+namespace uLib {
+namespace Archive {
+
+class property_register_archive
+    : public boost::archive::detail::common_oarchive<property_register_archive> {
+protected:
+    Object* m_Object;
+    bool m_DisplayOnly;
+public:
+    friend class boost::archive::detail::interface_oarchive<property_register_archive>;
+    friend class boost::archive::save_access;
+
+    using boost::archive::detail::common_oarchive<property_register_archive>::save_override;
+
+    property_register_archive(Object* obj, bool displayOnly = false) : 
+        boost::archive::detail::common_oarchive<property_register_archive>(boost::archive::no_header),
+        m_Object(obj), m_DisplayOnly(displayOnly) {
+        if (obj) m_Visited.insert(dynamic_cast<const void*>(obj));
+    }
+
+    template<class T> property_register_archive &operator&(const T &t) { this->save_override(t); return *this; }
+    template<class T> property_register_archive &operator<<(const T &t) { this->save_override(t); return *this; }
+    
+    std::string GetCurrentGroup() const {
+        std::string group;
+        for (const auto& g : m_GroupStack) {
+            if (!group.empty()) group += ".";
+            group += g;
+        }
+        return group;
+    }
+
+    template<class T> void register_property(Property<T>& p) {
+        save_property_impl(p.GetName().c_str(), const_cast<T&>(p.Get()), p.GetUnits().c_str(), 
+                          p.HasRange(), p.GetMinTyped(), p.GetMaxTyped(), p.IsReadOnly());
+    }
+
+    void register_enum_property(EnumProperty& p) {
+        if (!m_Object) return;
+        EnumProperty* newP = new EnumProperty(m_Object, p.GetName(), const_cast<int*>(&p.Get()), p.GetEnumLabels(), p.GetUnits(), GetCurrentGroup());
+        newP->SetReadOnly(p.IsReadOnly());
+        if (m_DisplayOnly) {
+            m_Object->RegisterDisplayProperty(newP);
+            Object* obj = m_Object;
+            Object::connect(newP, &Object::Updated, [obj]() { obj->Updated(); });
+        } else {
+            m_Object->RegisterDynamicProperty(newP);
+        }
+    }
+
+    template<class T> void save_property_impl(const char* name, T& val, const char* units, bool hasRange, const T& minVal, const T& maxVal, bool isReadOnly) {
+        if (!m_Object) return;
+        if constexpr (is_smart_pointer<T>::value) {
+            // SmartPointer<U> field: create a ReferenceProperty<U> for type-safe selection
+            using ElementT = typename smart_pointer_element<T>::type;
+            auto* p = new ReferenceProperty<ElementT>(m_Object, name, val, units ? units : "", GetCurrentGroup());
+            p->SetReadOnly(isReadOnly);
+            if (m_DisplayOnly) {
+                m_Object->RegisterDisplayProperty(p);
+                Object* obj = m_Object;
+                Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); });
+            } else {
+                m_Object->RegisterDynamicProperty(p);
+            }
+        } else {
+            Property<T>* p = new Property<T>(m_Object, name, &val, units ? units : "", GetCurrentGroup());
+            set_range_helper(p, hasRange, minVal, maxVal, typename std::is_arithmetic<T>::type());
+            p->SetReadOnly(isReadOnly);
+            if (m_DisplayOnly) {
+                m_Object->RegisterDisplayProperty(p);
+                Object* obj = m_Object;
+                Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); });
+            } else {
+                m_Object->RegisterDynamicProperty(p);
+            }
+        }
+    }
+
+    template<class U> static void set_range_helper(Property<U>* p, bool hasRange, const U& minVal, const U& maxVal, std::true_type) { if (hasRange) p->SetRange(minVal, maxVal); }
+    template<class U> static void set_range_helper(Property<U>* p, bool hasRange, const U& minVal, const U& maxVal, std::false_type) {}
+
+    template<class T> void save_override(const boost::serialization::hrp<T> &t) {
+        // To handle T correctly without deduction issues, we assume T can be passed to save_property_impl
+        T dummy = T(); // Ensure we can construct T
+        save_property_impl(t.name(), const_cast<boost::serialization::hrp<T>&>(t).value(), t.units(), t.has_range(), t.has_range() ? t.min_val() : dummy, t.has_range() ? t.max_val() : dummy, t.is_read_only());
+    }
+    template<class T> void save_override(const boost::serialization::hrp_val<T> &t) {
+        T dummy = T();
+        save_property_impl(t.name(), const_cast<boost::serialization::hrp_val<T>&>(t).value(), t.units(), t.has_range(), t.has_range() ? t.min_val() : dummy, t.has_range() ? t.max_val() : dummy, t.is_read_only());
+    }
+    template<class T> void save_override(const boost::serialization::hrp_enum<T> &t) {
+        if (m_Object) {
+            EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
+            p->SetReadOnly(t.is_read_only());
+            if (m_DisplayOnly) { m_Object->RegisterDisplayProperty(p); Object* obj = m_Object; Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); }); }
+            else { m_Object->RegisterDynamicProperty(p); }
+        }
+    }
+    template<class T> void save_override(const boost::serialization::hrp_enum_val<T> &t) {
+        if (m_Object) {
+            EnumProperty* p = new EnumProperty(m_Object, t.name(), (int*)&const_cast<boost::serialization::hrp_enum_val<T>&>(t).value(), t.labels(), t.units() ? t.units() : "", GetCurrentGroup());
+            p->SetReadOnly(t.is_read_only());
+            if (m_DisplayOnly) { m_Object->RegisterDisplayProperty(p); Object* obj = m_Object; Object::connect(p, &Object::Updated, [obj]() { obj->Updated(); }); }
+            else { m_Object->RegisterDynamicProperty(p); }
+        }
+    }
+
+    template<class T> void save_override(const boost::serialization::nvp<T> &t) {
+        if (t.name()) m_GroupStack.push_back(t.name());
+        this->save_helper(t.const_value(), typename boost::is_class<T>::type());
+        if (t.name()) m_GroupStack.pop_back();
+    }
+
+    void save_override(const std::string &t) {}
+    template<class T> void save_override(T * const & t) {
+        if (!t) return;
+        this->save_pointer_helper(t, typename boost::is_base_of<Object, T>::type());
+    }
+    template<class T> void save_pointer_helper(T* t, boost::mpl::true_) {
+        const void* ptr = dynamic_cast<const void*>(t);
+        if (m_Visited.find(ptr) != m_Visited.end()) return;
+        m_Visited.insert(ptr);
+        this->save_override(*t);
+    }
+    template<class T> void save_pointer_helper(T* t, boost::mpl::false_) {}
+    template<class T> void save_override(const T &t) { this->save_helper(t, typename boost::is_class<T>::type()); }
+    template<class T> void save_helper(const T &t, boost::mpl::true_) { boost::serialization::serialize_adl(*this, const_cast<T&>(t), 0); }
+    void save_helper(const std::string &t, boost::mpl::true_) {}
+    template<class T> void save_helper(const T &t, boost::mpl::false_) {}
+
+    void save_override(const boost::archive::object_id_type & t) {}
+    void save_override(const boost::archive::object_reference_type & t) {}
+    void save_override(const boost::archive::version_type & t) {}
+    void save_override(const boost::archive::class_id_type & t) {}
+    void save_override(const boost::archive::class_id_optional_type & t) {}
+    void save_override(const boost::archive::class_id_reference_type & t) {}
+    void save_override(const boost::archive::class_name_type & t) {}
+    void save_override(const boost::archive::tracking_type & t) {}
+
+protected:
+    std::vector<std::string> m_GroupStack;
+    std::set<const void*> m_Visited;
+};
+
+} // namespace Archive
+} // namespace uLib
+
+namespace uLib {
+
+template <typename T>
+inline void Property<T>::serialize(Archive::property_register_archive & ar, const unsigned int v) {
+  ar.register_property(*this);
+}
+
+inline void EnumProperty::serialize(Archive::property_register_archive & ar, const unsigned int v) {
+  ar.register_enum_property(*this);
+}
+
+namespace Archive {
+
+#define ULIB_ACTIVATE_PROPERTIES(obj) \
+    { uLib::Archive::property_register_archive _ar_tmp(&(obj)); _ar_tmp & (obj); }
+
+#define ULIB_DECLARE_PROPERTIES(SelfType) \
+private: \
+    struct _PropActivator { \
+        _PropActivator(SelfType* self) { \
+            uLib::Archive::property_register_archive _ar(self); \
+            _ar & *self; \
+        } \
+    } _prop_activator{this};
+
+} // namespace Archive
+
+// Convenience macro: declares a named Property<T> member with a default value.
+// Usage inside a class body (requires 'this' to be available, so use in-class initializer):
+//   ULIB_PROPERTY(int, MyProp, 42)
+#define ULIB_PROPERTY(type, name, defaultVal) \
+    ::uLib::Property<type> name{this, #name, (type)(defaultVal)};
+
+// Common property type aliases
+typedef Property<bool>        BoolProperty;
+typedef Property<int>         IntProperty;
+typedef Property<float>       FloatProperty;
+typedef Property<double>      DoubleProperty;
+typedef Property<std::string> StringProperty;
+
+template <class ArchiveT>
+void serialize_properties_helper(ArchiveT &ar, const std::vector<PropertyBase*> &props, unsigned int version) {
+    for (auto* prop : props) prop->serialize(ar, version);
+}
+
+template <class ArchiveT>
+void Object::serialize(ArchiveT &ar, const unsigned int version) {
+    ar & boost::serialization::make_nvp("InstanceName", this->GetInstanceName());
+    serialize_properties_helper(ar, this->GetProperties(), version);
+}
+
+} // namespace uLib
+
+#endif // U_CORE_PROPERTY_H

src/Core/Serializable.h

@@ -42,6 +42,8 @@ TODO:
 #include <boost/mpl/for_each.hpp>
 #include <boost/mpl/remove_if.hpp>
 #include <boost/serialization/nvp.hpp>
+#include <boost/serialization/shared_ptr.hpp>
+#include <boost/serialization/unique_ptr.hpp>
 
 // #include <boost/archive/xml_iarchive.hpp>
 // #include <boost/archive/xml_oarchive.hpp>
@@ -71,44 +73,205 @@ namespace serialization {
 // ACCESS 2 //
 template <class T> struct access2 {};
 
-// NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
-template <class T> class hrp : public wrapper_traits<const hrp<T>> {
+template <class T>
+class hrp : public boost::serialization::wrapper_traits<hrp<T>> {
+  
   const char *m_name;
-  T *m_value;
-  std::string *m_str;
+  const char *m_units;
+  T &m_value;
+  
+  bool m_has_range;
+  T m_min, m_max;
+
+  bool m_has_default;
+  T m_default;
 
 public:
-  explicit hrp(const char *name_, T &t)
-      : m_str(new std::string), m_name(name_), m_value(&t) {}
+  explicit hrp(const char *name_, T &t, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_has_range(false), m_has_default(false) {}
+
+  hrp& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
+  hrp& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
 
   const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const T &const_value() const { return this->m_value; }
+
+  bool has_range() const { return m_has_range; }
+  const T& min_val() const { return m_min; }
+  const T& max_val() const { return m_max; }
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return false; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
 
   template <class Archivex>
-  void save(Archivex &ar, const unsigned int /* file_version */) const {
-    ////        ar.operator<<(const_value());
-    //        std::stringstream ss;
-    //        uLib::Archive::hrt_oarchive har(ss);
-    //        har << make_nvp(m_name,*m_value);
-    //        //        (*m_str) = ss.str();
-    ////        ar.operator << (make_nvp(m_name, ss.str());
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
   }
+
   template <class Archivex>
-  void load(Archivex &ar, const unsigned int /* file_version */) {
-    //        ar.operator>>(value());
+  void load(Archivex &ar, const unsigned int /* version */) {
+    ar >> boost::serialization::make_nvp(m_name, m_value);
   }
-  BOOST_SERIALIZATION_SPLIT_MEMBER()
 };
 
 template <class T>
-inline
-#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-    const
-#endif
-    hrp<T> make_hrp(const char *name, T &t) {
-  return hrp<T>(name, t);
+class hrp_enum : public boost::serialization::wrapper_traits<hrp_enum<T>> {
+  const char *m_name;
+  const char *m_units;
+  T &m_value;
+  std::vector<std::string> m_labels;
+  bool m_has_default;
+  T m_default;
+
+public:
+  explicit hrp_enum(const char *name_, T &t, const std::vector<std::string>& labels, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_labels(labels), m_has_default(false) {}
+
+  hrp_enum& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const std::vector<std::string>& labels() const { return m_labels; }
+
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return false; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
   }
 
-#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    ar >> boost::serialization::make_nvp(m_name, m_value);
+  }
+};
+
+template <class T>
+class hrp_val : public boost::serialization::wrapper_traits<hrp_val<T>> {
+  const char *m_name;
+  const char *m_units;
+  T m_value;
+  bool m_has_range;
+  T m_min, m_max;
+  bool m_has_default;
+  T m_default;
+  
+public:
+  explicit hrp_val(const char *name_, T t, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_has_range(false), m_has_default(false) {}
+
+  hrp_val& range(const T& min_val, const T& max_val) { m_min = min_val; m_max = max_val; m_has_range = true; return *this; }
+  hrp_val& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const T &const_value() const { return this->m_value; }
+
+  bool has_range() const { return m_has_range; }
+  const T& min_val() const { return m_min; }
+  const T& max_val() const { return m_max; }
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return true; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
+  }
+
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    // Only for output archives
+  }
+};
+
+template <class T>
+class hrp_enum_val : public boost::serialization::wrapper_traits<hrp_enum_val<T>> {
+  const char *m_name;
+  const char *m_units;
+  T m_value;
+  std::vector<std::string> m_labels;
+  bool m_has_default;
+  T m_default;
+
+public:
+  explicit hrp_enum_val(const char *name_, T t, const std::vector<std::string>& labels, const char* units_ = nullptr) 
+    : m_name(name_), m_units(units_), m_value(t), m_labels(labels), m_has_default(false) {}
+
+  hrp_enum_val& set_default(const T& def_val) { m_default = def_val; m_has_default = true; return *this; }
+
+  const char *name() const { return this->m_name; }
+  const char *units() const { return this->m_units; }
+  T &value() { return this->m_value; }
+  const std::vector<std::string>& labels() const { return m_labels; }
+
+  bool has_default() const { return m_has_default; }
+  const T& default_val() const { return m_default; }
+
+  static constexpr bool is_read_only() { return true; }
+
+  BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+  template <class Archivex>
+  void save(Archivex &ar, const unsigned int /* version */) const {
+    ar << boost::serialization::make_nvp(m_name, m_value);
+  }
+
+  template <class Archivex>
+  void load(Archivex &ar, const unsigned int /* version */) {
+    // Only for output archives
+  }
+};
+
+template <class T>
+inline hrp<T> make_hrp(const char *name, T &t, const char* units = nullptr) {
+  return hrp<T>(name, t, units);
+}
+
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_val<T> make_hrp(const char *name, T &&t, const char* units = nullptr) {
+  return hrp_val<T>(name, t, units);
+}
+
+template <class T>
+inline hrp_enum<T> make_hrp_enum(const char *name, T &t, const std::vector<std::string>& labels, const char* units = nullptr) {
+  return hrp_enum<T>(name, t, labels, units);
+}
+
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_enum_val<T> make_hrp_enum(const char *name, T &&t, const std::vector<std::string>& labels, const char* units = nullptr) {
+  return hrp_enum_val<T>(name, t, labels, units);
+}
+
+template <class T>
+inline hrp<T> make_nvp(const char *name, T &t, const char* units) {
+  return hrp<T>(name, t, units);
+}
+
+// Specialization for rvalues (value-based storage)
+template <class T>
+inline hrp_val<T> make_nvp(const char *name, T &&t, const char* units) {
+  return hrp_val<T>(name, t, units);
+}
+
+
 
 } // namespace serialization
 } // namespace boost
@@ -128,7 +291,41 @@ namespace uLib {
 
 #define _AR_OP(r, data, elem) data &BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
 
-#define NVP(data) BOOST_SERIALIZATION_NVP(data)
+// NAME VALUE PAIR //
+#define NVP_GET_MACRO(_1, _2, _3, NAME, ...) NAME
+#define NVP(...) NVP_GET_MACRO(__VA_ARGS__, NVP3, NVP2, NVP1)(__VA_ARGS__)
+
+#define NVP1(data) BOOST_SERIALIZATION_NVP(data)
+#define NVP2(name, data) boost::serialization::make_nvp(name, data)
+#define NVP3(name, data, units) boost::serialization::make_nvp(name, data, units)
+
+
+// HUMAN READABLE PROPERTY //
+#define HRP_GET_MACRO(_1, _2, _3, _4, _5, _6, NAME, ...) NAME
+#define HRP(...) HRP_GET_MACRO(__VA_ARGS__, HRP6, HRP5, HRP4, HRP3, HRP2, HRP1)(__VA_ARGS__)
+
+#define HRP1(data) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(data), data)
+#define HRP2(name, data) boost::serialization::make_hrp(name, data)
+#define HRP3(name, data, units) boost::serialization::make_hrp(name, data, units)
+#define HRP4(name, data, units, default) boost::serialization::make_hrp(name, data, units).set_default(default)
+#define HRP5(name, data, units, min, max) boost::serialization::make_hrp(name, data, units).range(min, max)
+#define HRP6(name, data, units, default, min, max) boost::serialization::make_hrp(name, data, units).set_default(default).range(min, max)
+
+#define HRPE(name, data, labels) boost::serialization::make_hrp_enum(name, data, labels)
+
+// LEFT FOR BACKWARD COMPATIBILITY
+#define HRPU(name, units) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name, units)
+
+
+
+
+
+namespace serialization {
+using boost::serialization::make_nvp;
+using boost::serialization::make_hrp;
+using boost::serialization::make_hrp_enum;
+} // serialization
+
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -156,7 +353,7 @@ namespace uLib {
 #define ULIB_SERIALIZE_OBJECT(_Ob, ...)                                        \
   _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
 #define AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
-#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
+#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_HR_(_name)
 #endif
 
 #define ULIB_SERIALIZE_ACCESS                                                  \
@@ -170,13 +367,13 @@ namespace uLib {
   BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
 
 #define _SERIALIZE_IMPL_SEQ  \
-  (uLib::Archive::text_iarchive)(uLib::Archive::text_oarchive)(                               \
-      uLib::Archive::                                                                         \
-          hrt_iarchive)(uLib::Archive::                                                       \
-                            hrt_oarchive)(uLib::Archive::                                     \
-                                              xml_iarchive)(uLib::Archive::                   \
-                                                                xml_oarchive)(uLib::Archive:: \
-                                                                                  log_archive)
+  (uLib::Archive::text_iarchive) \
+  (uLib::Archive::text_oarchive) \
+  (uLib::Archive::hrt_iarchive)  \
+  (uLib::Archive::hrt_oarchive)  \
+  (uLib::Archive::xml_iarchive)  \
+  (uLib::Archive::xml_oarchive)  \
+  (uLib::Archive::log_archive)
 
 /** Solving virtual class check problem */
 #define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived)               \
@@ -247,6 +444,11 @@ namespace uLib {
   template <class ArchiveT>                                                    \
   void _Ob::save_override(ArchiveT &ar, const unsigned int version)
 
+
+
+
+
+  
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -351,7 +553,8 @@ namespace uLib {
   void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {        \
     /* PP  serialize */ BOOST_PP_SEQ_FOR_EACH(                                 \
         _UNAR_OP, ob, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));                   \
-  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }                                                          \
+  /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>                     \
+  (uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ }\
   template <class ArchiveT>                                                    \
   inline void load_construct_data(ArchiveT &ar, _Ob *ob,                       \
                                   const unsigned int file_version) {           \
@@ -376,8 +579,16 @@ namespace uLib {
   void boost::serialization::access2<_Ob>::save_override(                      \
       ArchiveT &ar, _Ob &ob, const unsigned int version) 
 
+    
 #define _ULIB_DETAIL_UNINTRUSIVE_AR_(name)                                     \
   boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), ob.name)
+#define _ULIB_DETAIL_UNINTRUSIVE_HR_(name)                                     \
+  boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), ob.name)
+
+
+
+
+
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////

src/Core/Signal.h

@@ -31,6 +31,8 @@
 #include <boost/signals2/signal.hpp>
 #include <boost/signals2/signal_type.hpp>
 #include <boost/signals2/slot.hpp>
+#include <boost/signals2/connection.hpp>
+#include <boost/signals2/shared_connection_block.hpp>
 
 #include "Function.h"
 #include <boost/bind/bind.hpp>
@@ -43,17 +45,31 @@ using namespace boost::placeholders;
 // Signals macro //
 
 #define default(vlaue)
-#define slots
+#ifndef Q_MOC_RUN
+#ifndef signals
 #define signals /*virtual void init_signals();*/ public
+#endif
+#ifndef slots
+#define slots
+#endif
+#ifndef emit
 #define emit
+#endif
+#endif
+#ifndef SLOT
 #define SLOT(a) BOOST_STRINGIZE(a)
+#endif
+#ifndef SIGNAL
 #define SIGNAL(a) BOOST_STRINGIZE(a)
+#endif
 
 #define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...)                                   \
   do {                                                                         \
+    if (!this->signalsBlocked()) {                                             \
         BOOST_AUTO(sig, this->findOrAddSignal(&_name));                        \
         if (sig)                                                               \
           sig->operator()(__VA_ARGS__);                                        \
+    }                                                                          \
   } while (0)
 
 /**
@@ -78,6 +94,9 @@ namespace uLib {
 // TODO ...
 
 typedef boost::signals2::signal_base SignalBase;
+typedef boost::signals2::connection Connection;
+typedef boost::signals2::shared_connection_block ConnectionBlock;
+
 
 template <typename T> struct Signal {
   typedef boost::signals2::signal<T> type;
@@ -92,57 +111,57 @@ struct ConnectSignal {};
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 0> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(slof);
+    return reinterpret_cast<SigT *>(sigb)->connect(slof);
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 1> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
+    return reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 2> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
+    return reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 3> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(
+    return reinterpret_cast<SigT *>(sigb)->connect(
         boost::bind(slof, receiver, _1, _2));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 4> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(
+    return reinterpret_cast<SigT *>(sigb)->connect(
         boost::bind(slof, receiver, _1, _2, _3));
   }
 };
 
 template <typename FuncT, typename SigSignature>
 struct ConnectSignal<FuncT, SigSignature, 5> {
-  static void connect(SignalBase *sigb, FuncT slof,
+  static Connection connect(SignalBase *sigb, FuncT slof,
                       typename FunctionPointer<FuncT>::Object *receiver) {
     typedef typename Signal<SigSignature>::type SigT;
-    reinterpret_cast<SigT *>(sigb)->connect(
+    return reinterpret_cast<SigT *>(sigb)->connect(
         boost::bind(slof, receiver, _1, _2, _3, _4));
   }
 };
@@ -155,9 +174,9 @@ template <typename FuncT> SignalBase *NewSignal(FuncT f) {
 }
 
 template <typename SigSignature, typename FuncT>
-void ConnectSignal(SignalBase *sigb, FuncT slof,
+Connection ConnectSignal(SignalBase *sigb, FuncT slof,
                    typename FunctionPointer<FuncT>::Object *receiver) {
-  detail::ConnectSignal<FuncT, SigSignature,
+  return detail::ConnectSignal<FuncT, SigSignature,
                          FunctionPointer<FuncT>::arity>::connect(sigb, slof,
                                                                  receiver);
 }

src/Core/SmartPointer.h

@@ -3,7 +3,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
   Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
+  All Padua preserved
 
   Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
 
@@ -23,89 +23,225 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
 #ifndef U_CORE_SMARTPOINTER_H
 #define U_CORE_SMARTPOINTER_H
 
+#include <atomic>
+#include <functional>
+#include <type_traits>
+
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
 
 namespace uLib {
 
+/**
+ * @brief Internal control block for shared ownership across polymorphic SmartPointers.
+ */
+struct ControlBlock {
+    std::atomic<uint32_t> count;
+    std::function<void()> deleter;
+
+    explicit ControlBlock(uint32_t initial_count = 1) : count(initial_count) {}
+
+private:
+    friend class boost::serialization::access;
+    template <class Archive>
+    void serialize(Archive& ar, const unsigned int /*version*/) {
+        // ControlBlock identity is tracked by Boost via the cb pointer in ReferenceCounter.
+        // We only save the count value.
+        uint32_t c = count.load();
+        ar & boost::serialization::make_nvp("count", c);
+        if constexpr (Archive::is_loading::value) count.store(c);
+    }
+};
+
+/**
+ * @brief A smart pointer implementation inspired by std::shared_ptr.
+ */
 template <typename T>
 class SmartPointer {
-    typedef T element_type;
 public:
+    using element_type = T;
 
-    explicit
-    SmartPointer(T* ptr = NULL) : m_counter(0) {
-        if(!ptr) ptr = new T;
+    /**
+     * @brief Nested reference counter structure. 
+     * Preserved as a nested template for Boost serialization compatibility.
+     */
+    struct ReferenceCounter {
+        T* ptr;
+        ControlBlock* cb;
+
+        ReferenceCounter() : ptr(nullptr), cb(nullptr) {}
+        explicit ReferenceCounter(T* p) : ptr(p), cb(new ControlBlock(1)) {
+            cb->deleter = [p]() { delete p; };
+        }
+        template <typename D>
+        ReferenceCounter(T* p, D d) : ptr(p), cb(new ControlBlock(1)) {
+            cb->deleter = [p, d]() { d(p); };
+        }
+
+    private:
+        friend class boost::serialization::access;
+        template <class Archive>
+        void serialize(Archive& ar, const unsigned int /*version*/) {
+            ar & boost::serialization::make_nvp("ptr", ptr);
+            ar & boost::serialization::make_nvp("cb", cb);
+        }
+    };
+
+    SmartPointer() : m_counter(nullptr) {
+        if constexpr (std::is_default_constructible_v<T>) {
+            m_counter = new ReferenceCounter(new T());
+        }
+    }
+
+    SmartPointer(std::nullptr_t) noexcept : m_counter(nullptr) {}
+
+    /**
+     * @brief Constructor from raw pointer (Implicit conversion allowed for legacy compatibility).
+     */
+    SmartPointer(T* ptr) : m_counter(nullptr) {
         if (ptr) m_counter = new ReferenceCounter(ptr);
     }
 
-    // TakeReference //
-    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref,0)) { }
-
-    SmartPointer(const SmartPointer& copy) throw () {
-        acquire(copy.m_counter);
+    template <typename D>
+    SmartPointer(T* ptr, D deleter) : m_counter(nullptr) {
+        if (ptr) m_counter = new ReferenceCounter(ptr, deleter);
     }
 
-    SmartPointer(SmartPointer * copy) throw () {
-        acquire(copy->m_counter);
+    SmartPointer(T &ref) : m_counter(new ReferenceCounter(&ref, [](T*){})) { }
+
+    SmartPointer(const SmartPointer& other) noexcept : m_counter(nullptr) {
+        acquire(other.m_counter);
     }
 
-    virtual ~SmartPointer()  {  release();  }
+    SmartPointer(const SmartPointer* other) noexcept : m_counter(nullptr) {
+        if (other) acquire(other->m_counter);
+    }
 
-    SmartPointer & operator=(const SmartPointer& copy) {
-        if (this != &copy)
-        {
+    template <typename U, typename = std::enable_if_t<std::is_convertible_v<U*, T*>>>
+    SmartPointer(const SmartPointer<U>& other) noexcept : m_counter(nullptr) {
+        if (other.m_counter) {
+            m_counter = new ReferenceCounter();
+            m_counter->ptr = static_cast<T*>(other.m_counter->ptr);
+            m_counter->cb = other.m_counter->cb;
+            if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
+        }
+    }
+
+    template <typename U>
+    SmartPointer(const SmartPointer<U>& other, T* ptr) noexcept : m_counter(nullptr) {
+        if (other.m_counter) {
+            m_counter = new ReferenceCounter();
+            m_counter->ptr = ptr;
+            m_counter->cb = other.m_counter->cb;
+            if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
+        }
+    }
+
+    SmartPointer(SmartPointer&& other) noexcept : m_counter(other.m_counter) {
+        other.m_counter = nullptr;
+    }
+
+    ~SmartPointer() { release(); }
+
+    SmartPointer& operator=(const SmartPointer& other) noexcept {
+        if (this != &other) {
             release();
-            acquire(copy.m_counter);
+            acquire(other.m_counter);
         }
         return *this;
     }
 
-    T & operator*() const throw () {  return *m_counter->ptr; }
-    T * operator->() const throw () {  return m_counter->ptr; }
+    SmartPointer& operator=(T* ptr) noexcept {
+        reset(ptr);
+        return *this;
+    }
 
-    T * get() const throw () {
-        return m_counter ? m_counter->ptr : 0; }
-    bool unique() const throw () {
-        return (m_counter ? m_counter->count == 1 : true);  }
+    SmartPointer& operator=(SmartPointer&& other) noexcept {
+        if (this != &other) {
+            release();
+            m_counter = other.m_counter;
+            other.m_counter = nullptr;
+        }
+        return *this;
+    }
 
+    void reset(T* ptr = nullptr) {
+        release();
+        if (ptr) m_counter = new ReferenceCounter(ptr);
+    }
+
+    void swap(SmartPointer& other) noexcept {
+        std::swap(m_counter, other.m_counter);
+    }
+
+    T& operator*() const noexcept { return *(m_counter->ptr); }
+    T* operator->() const noexcept { return m_counter->ptr; }
+    T* get() const noexcept { return m_counter ? m_counter->ptr : nullptr; }
+    T* Get() const noexcept { return get(); }
+    operator T*() const noexcept { return get(); }
+
+    uint32_t use_count() const noexcept {
+        return (m_counter && m_counter->cb) ? m_counter->cb->count.load(std::memory_order_relaxed) : 0;
+    }
+
+    bool unique() const noexcept { return use_count() == 1; }
+    explicit operator bool() const noexcept { return get() != nullptr; }
+
+    BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+    template <class Archive>
+    void save(Archive& ar, const unsigned int /*version*/) const {
+        ar & boost::serialization::make_nvp("counter", m_counter);
+    }
+
+    template <class Archive>
+    void load(Archive& ar, const unsigned int /*version*/) {
+        release();
+        ar & boost::serialization::make_nvp("counter", m_counter);
+        if (m_counter && m_counter->cb) {
+            m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
+        }
+    }
 
 private:
+    template <typename U> friend class SmartPointer;
+    friend class boost::serialization::access;
 
-    struct ReferenceCounter
-    {
-      ReferenceCounter(T* ptr = 0, unsigned c = 1) : ptr(ptr), count(c) { }
-      T*       ptr;
-      unsigned count;
-    } * m_counter;
+    ReferenceCounter* m_counter;
 
-    // increment the count
-    void acquire(ReferenceCounter* c) throw ()
-    {
-        m_counter = c;
-        if (c && c->count>0) ++c->count;
+    void acquire(ReferenceCounter* c) noexcept {
+        if (c) {
+            m_counter = new ReferenceCounter();
+            m_counter->ptr = c->ptr;
+            m_counter->cb = c->cb;
+            if (m_counter->cb) m_counter->cb->count.fetch_add(1, std::memory_order_relaxed);
+        }
     }
 
-    // decrement the count, delete if it is 0
-    void release() {
+    void release() noexcept {
         if (m_counter) {
-            if (--m_counter->count == 0) {
-                delete m_counter->ptr;
+            if (m_counter->cb && m_counter->cb->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+                if (m_counter->cb->deleter) m_counter->cb->deleter();
+                delete m_counter->cb;
             }
-            if (m_counter->count <= 0) {
             delete m_counter;
-                m_counter = NULL;
+            m_counter = nullptr;
         }
     }
-    }
-
 };
 
-
-
+template <typename T, typename U> SmartPointer<T> static_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, static_cast<T*>(r.get())); }
+template <typename T, typename U> SmartPointer<T> dynamic_pointer_cast(const SmartPointer<U>& r) noexcept { 
+    if (auto p = dynamic_cast<T*>(r.get())) return SmartPointer<T>(r, p);
+    return SmartPointer<T>(nullptr);
 }
+template <typename T, typename U> SmartPointer<T> const_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, const_cast<T*>(r.get())); }
+template <typename T, typename U> SmartPointer<T> reinterpret_pointer_cast(const SmartPointer<U>& r) noexcept { return SmartPointer<T>(r, reinterpret_cast<T*>(r.get())); }
 
-#endif // SMARTPOINTER_H
+} // namespace uLib
+
+#endif // U_CORE_SMARTPOINTER_H

src/Core/Threads.cpp

@@ -0,0 +1,202 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#include "Threads.h"
+#include <chrono>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#ifdef __linux__
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+namespace uLib {
+
+Thread::Thread() : m_Running(false) {}
+
+Thread::~Thread() {
+  if (m_Thread.joinable()) {
+    m_Thread.detach();
+  }
+}
+
+void Thread::Start() {
+  Mutex::ScopedLock lock(m_ThreadMutex);
+  if (m_Running) return;
+  
+  m_Running = true;
+  m_Thread = std::thread(&Thread::ThreadEntryPoint, this);
+}
+
+void Thread::Join() {
+  if (m_Thread.joinable()) {
+    m_Thread.join();
+  }
+}
+
+void Thread::Detach() {
+  if (m_Thread.joinable()) {
+    m_Thread.detach();
+  }
+}
+
+bool Thread::IsJoinable() const {
+  return m_Thread.joinable();
+}
+
+bool Thread::IsRunning() const {
+  return m_Running;
+}
+
+void Thread::Run() {
+  // Override in subclasses
+}
+
+void Thread::ThreadEntryPoint() {
+  this->Run();
+  m_Running = false;
+}
+
+void Thread::Sleep(int milliseconds) {
+  std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+}
+
+void Thread::Yield() {
+  std::this_thread::yield();
+}
+
+void Thread::SetAffinity(int cpu) {
+#ifdef __linux__
+  if (m_Thread.joinable()) {
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(cpu, &cpuset);
+    pthread_setaffinity_np(m_Thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+  }
+#endif
+}
+
+void Thread::SetAffinity(const std::vector<int>& cpus) {
+#ifdef __linux__
+  if (m_Thread.joinable()) {
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    for (int cpu : cpus) {
+        CPU_SET(cpu, &cpuset);
+    }
+    pthread_setaffinity_np(m_Thread.native_handle(), sizeof(cpu_set_t), &cpuset);
+  }
+#endif
+}
+
+void Thread::SetNumThreads(int n) {
+#ifdef _OPENMP
+  omp_set_num_threads(n);
+#endif
+}
+
+int Thread::GetNumThreads() {
+#ifdef _OPENMP
+  return omp_get_max_threads();
+#else
+  return 1;
+#endif
+}
+
+int Thread::GetThreadNum() {
+#ifdef _OPENMP
+  return omp_get_thread_num();
+#else
+  return 0;
+#endif
+}
+
+// Team Implementation //
+
+Team::Team(int num_threads) : m_Size(num_threads), m_UseOpenMP(false) {
+#ifdef _OPENMP
+  m_UseOpenMP = true;
+  if (m_Size > 0) omp_set_num_threads(m_Size);
+  else m_Size = omp_get_max_threads();
+#else
+  if (m_Size <= 0) m_Size = 1;
+#endif
+}
+
+Team::~Team() {
+  Wait();
+}
+
+void Team::Run(Task* task) {
+  if (!task) return;
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp task
+    task->Execute();
+    return;
+  }
+#endif
+  // Fallback to synchronous execution if no OpenMP
+  task->Execute();
+}
+
+void Team::Wait() {
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp taskwait
+  }
+#endif
+}
+
+void Team::SetSize(int n) {
+  m_Size = n;
+#ifdef _OPENMP
+  if (m_UseOpenMP) omp_set_num_threads(m_Size);
+#endif
+}
+
+void Team::SetAffinity(const std::vector<int>& cpus) {
+  if (cpus.empty()) return;
+#ifdef __linux__
+#ifdef _OPENMP
+  if (m_UseOpenMP) {
+    #pragma omp parallel
+    {
+      int tid = omp_get_thread_num();
+      int cpu = cpus[tid % cpus.size()];
+      cpu_set_t cpuset;
+      CPU_ZERO(&cpuset);
+      CPU_SET(cpu, &cpuset);
+      pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+    }
+  }
+#endif
+#endif
+}
+
+} // namespace uLib

src/Core/Threads.h

@@ -0,0 +1,147 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CORE_THREADS_H
+#define U_CORE_THREADS_H
+
+#include <thread>
+#include <functional>
+#include <atomic>
+#include <vector>
+#include <deque>
+#include "Core/Monitor.h"
+#include "Core/Object.h"
+
+namespace uLib {
+
+/**
+ * @brief Thread class wraps std::thread and provides a common interface.
+ */
+class Thread : public Object {
+public:
+  Thread();
+  virtual ~Thread();
+
+  /** @brief Starts the thread by calling Run(). */
+  void Start();
+
+  /** @brief Joins the thread. */
+  void Join();
+
+  /** @brief Detaches the thread. */
+  void Detach();
+
+  /** @brief Returns true if the thread is currently joinable. */
+  bool IsJoinable() const;
+  
+  /** @brief Returns true if the thread is currently running. */
+  bool IsRunning() const;
+
+  /** @brief The entry point for the thread. Override this in subclasses. */
+  virtual void Run();
+
+  /** @brief Static helper to sleep the current thread. */
+  static void Sleep(int milliseconds);
+
+  /** @brief Static helper to yield the current thread. */
+  static void Yield();
+
+  /** @brief Returns the native handle of the thread. */
+  std::thread::native_handle_type GetNativeHandle() { return m_Thread.native_handle(); }
+
+  /** @brief Sets CPU affinity for the thread. (Linux only) */
+  void SetAffinity(int cpu);
+  
+  /** @brief Sets CPU affinity for the thread using a list of CPUs. (Linux only) */
+  void SetAffinity(const std::vector<int>& cpus);
+
+  // OpenMP Support //
+  
+  /** @brief Sets the number of threads for OpenMP parallel regions. */
+  static void SetNumThreads(int n);
+  
+  /** @brief Returns the number of threads for OpenMP parallel regions. */
+  static int GetNumThreads();
+
+  /** @brief Returns the ID of the current thread in an OpenMP parallel region. */
+  static int GetThreadNum();
+
+protected:
+  // Internal thread entry point
+  void ThreadEntryPoint();
+
+  std::thread m_Thread;
+  std::atomic<bool> m_Running;
+  mutable Mutex m_ThreadMutex;
+};
+
+/**
+ * @brief Task class wraps a function call to be executed by a Team.
+ */
+class Task : public Object {
+public:
+  Task(std::function<void()> func) : m_Func(func) {}
+  virtual ~Task() = default;
+
+  /** @brief Executes the task. */
+  virtual void Execute() { if (m_Func) m_Func(); }
+
+protected:
+  std::function<void()> m_Func;
+};
+
+/**
+ * @brief Team class manages a group of threads and can execute Tasks.
+ * This is designed to be compatible with OpenMP tasks and teams.
+ */
+class Team : public Object {
+public:
+  Team(int num_threads = -1);
+  virtual ~Team();
+
+  /** @brief Runs a task within the team. Uses OpenMP task if available. */
+  void Run(Task* task);
+
+  /** @brief Waits for all tasks in the team to finish. */
+  void Wait();
+
+  /** @brief Sets the number of threads for this team. */
+  void SetSize(int n);
+
+  /** @brief Returns the number of threads in the team. */
+  int GetSize() const { return m_Size; }
+
+  /** @brief Sets CPU affinity for all threads in the team. */
+  void SetAffinity(const std::vector<int>& cpus);
+
+protected:
+  int m_Size;
+  bool m_UseOpenMP;
+  std::vector<Thread*> m_Threads;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_THREADS_H

src/Core/Types.h

@@ -181,7 +181,7 @@ typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
                                                                                \
 public:                                                                        \
   typedef type_info::BaseClass BaseClass;                                      \
-  virtual const char *type_name() const { return type_info::name; }            \
+  virtual const char *type_name() const override { return type_info::name; }   \
   /**/
 
 /**

src/Core/testing/AffinityTest.cpp

@@ -0,0 +1,105 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <vector>
+#include <cassert>
+
+#ifdef __linux__
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+using namespace uLib;
+
+std::vector<int> GetAvailableCpus() {
+    std::vector<int> available;
+#ifdef __linux__
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    if (sched_getaffinity(0, sizeof(cpu_set_t), &cpuset) == 0) {
+        for (int i = 0; i < CPU_SETSIZE; ++i) {
+            if (CPU_ISSET(i, &cpuset)) {
+                available.push_back(i);
+            }
+        }
+    }
+#endif
+    return available;
+}
+
+class TestThread : public Thread {
+public:
+    void Run() override {
+        Thread::Sleep(200);
+    }
+};
+
+void TestThreadAffinity() {
+    std::cout << "Testing Thread Affinity..." << std::endl;
+#ifdef __linux__
+    auto available = GetAvailableCpus();
+    if (available.empty()) {
+        std::cout << "  No CPUs available for affinity test, skipping." << std::endl;
+        return;
+    }
+    int target_cpu = available[0];
+    std::cout << "  Using CPU " << target_cpu << std::endl;
+
+    TestThread t;
+    t.Start();
+    t.SetAffinity(target_cpu); 
+    
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    int s = pthread_getaffinity_np(t.GetNativeHandle(), sizeof(cpu_set_t), &cpuset);
+    if (s != 0) {
+        std::cerr << "Error: pthread_getaffinity_np failed with code " << s << std::endl;
+        assert(false);
+    }
+    assert(CPU_ISSET(target_cpu, &cpuset));
+    
+    t.Join();
+    std::cout << "  Passed (Thread bound to CPU 0)." << std::endl;
+#else
+    std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
+#endif
+}
+
+void TestTeamAffinity() {
+    std::cout << "Testing Team Affinity..." << std::endl;
+#ifdef __linux__
+    auto available = GetAvailableCpus();
+    if (available.size() < 2) {
+        std::cout << "  Not enough CPUs available for Team affinity test, skipping." << std::endl;
+        return;
+    }
+    std::vector<int> cpus = {available[0], available[1]};
+    std::cout << "  Using CPUs " << cpus[0] << ", " << cpus[1] << std::endl;
+
+    Team team(2);
+    team.SetAffinity(cpus);
+    
+    // We check affinity inside a parallel region
+    #pragma omp parallel
+    {
+        cpu_set_t cpuset;
+        CPU_ZERO(&cpuset);
+        pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
+        int tid = Thread::GetThreadNum();
+        int expected_cpu = cpus[tid % cpus.size()];
+        assert(CPU_ISSET(expected_cpu, &cpuset));
+    }
+    std::cout << "  Passed (Team threads bound correctly)." << std::endl;
+#else
+    std::cout << "  Affinity not supported on this OS, skipping." << std::endl;
+#endif
+}
+
+// Helper to get native handle if needed (oops, I forgot to add it to Thread class)
+// I'll add GetNativeHandle() to Thread class in Threads.h
+
+int main() {
+    TestThreadAffinity();
+    TestTeamAffinity();
+    std::cout << "All Affinity tests finished!" << std::endl;
+    return 0;
+}

src/Core/testing/CMakeLists.txt

@@ -2,6 +2,8 @@
 # TESTS
 set( TESTS
         SmartVectorTest
+        SmartPointerTest
+        ObjectWrapperTest
         VectorTest
         ObjectFlagsTest
         ObjectParametersTest
@@ -21,6 +23,15 @@ set( TESTS
         OptionsTest
         PingPongTest
         VectorMetaAllocatorTest
+        PropertyTypesTest
+        HRPTest
+        PropertyGroupingTest
+        MutexTest
+        ThreadsTest
+        OpenMPTest
+        TeamTest
+        AffinityTest
+        ReadOnlyPropertyTest
 )
 
 set(LIBRARIES
@@ -29,6 +40,7 @@ set(LIBRARIES
        Boost::serialization
        Boost::program_options
        ${ROOT_LIBRARIES}
+       OpenMP::OpenMP_CXX
 )
 uLib_add_tests(Core)
 

src/Core/testing/HRPTest.cpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <sstream>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
+#include "Core/Archives.h"
+
+using namespace uLib;
+
+struct SimpleObject {
+    int value;
+    std::string name;
+ 
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(value);
+        ar & HRP(name);
+    }
+};
+ 
+struct DynamicObject : public Object {
+    float width;
+    int height;
+ 
+    DynamicObject() : width(10.0f), height(20) {
+        // Automatic registration of properties based on serialize/HRP
+        ULIB_ACTIVATE_PROPERTIES(*this);
+    }
+ 
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(width);
+        ar & HRP(height);
+    }
+};
+
+int main() {
+    SimpleObject obj;
+    obj.value = 42;
+    obj.name = "TestObject";
+
+    std::cout << "Testing HRP Serialization to Log..." << std::endl;
+    std::stringstream ss;
+    {
+        uLib::Archive::log_archive ar(ss);
+        ar << boost::serialization::make_nvp("Object", obj);
+    }
+    std::cout << ss.str() << std::endl;
+
+    std::cout << "Testing HRP Serialization to HRT..." << std::endl;
+    ss.str("");
+    {
+        uLib::Archive::hrt_oarchive ar(ss);
+        ar << obj;
+    }
+    std::cout << ss.str() << std::endl;
+ 
+    std::cout << "Testing HRP Serialization to XML..." << std::endl;
+    ss.str("");
+    {
+        uLib::Archive::xml_oarchive ar(ss);
+        ar << boost::serialization::make_nvp("Object", obj);
+    }
+    std::cout << ss.str() << std::endl;
+ 
+    std::cout << "Testing Dynamic Property Creation via ULIB_ACTIVATE_PROPERTIES macro..." << std::endl;
+    DynamicObject dynObj;
+    // (properties were already created in DynamicObject constructor via macro)
+    
+    std::cout << "Registered Properties in dynObj:" << std::endl;
+    const auto& props = dynObj.GetProperties();
+    for (auto* p : props) {
+        std::cout << "  - [" << p->GetTypeName() << "] " << p->GetName() << " = " << p->GetValueAsString() << std::endl;
+    }
+    
+    if (props.size() == 2) {
+        std::cout << "Dynamic Property Creation SUCCESS!" << std::endl;
+    } else {
+        std::cout << "Dynamic Property Creation FAILED (Expected 2, got " << props.size() << ")" << std::endl;
+    }
+ 
+    return 0;
+}

src/Core/testing/MutexTest.cpp

@@ -0,0 +1,109 @@
+#include "Core/Monitor.h"
+#include <iostream>
+#include <chrono>
+#include <thread>
+#include <vector>
+#include <cassert>
+
+using namespace uLib;
+
+void TestBasicLock() {
+    std::cout << "Testing basic Mutex Lock/Unlock..." << std::endl;
+    Mutex m;
+    m.Lock();
+    m.Unlock();
+    assert(m.TryLock());
+    m.Unlock();
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestScopedLock() {
+    std::cout << "Testing Mutex::ScopedLock..." << std::endl;
+    Mutex m;
+    {
+        Mutex::ScopedLock lock(m);
+        assert(!m.TryLock());
+    }
+    assert(m.TryLock());
+    m.Unlock();
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestTimedLock() {
+    std::cout << "Testing Mutex TryLockFor..." << std::endl;
+    Mutex m;
+    m.Lock();
+    auto start = std::chrono::steady_clock::now();
+    bool locked = m.TryLockFor(100);
+    auto end = std::chrono::steady_clock::now();
+    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+    
+    assert(!locked);
+    assert(diff >= 100);
+    m.Unlock();
+    std::cout << "  Passed (waited " << diff << "ms)." << std::endl;
+}
+
+void TestMacros() {
+    std::cout << "Testing ULIB_STATIC_LOCK and ULIB_MUTEX_LOCK macros..." << std::endl;
+    
+    int counter = 0;
+    auto task = [&]() {
+        for(int i=0; i<500; ++i) {
+            ULIB_STATIC_LOCK(-1) {
+                counter++;
+            }
+        }
+    };
+    
+    std::vector<std::thread> threads;
+    for(int i=0; i<4; ++i) threads.emplace_back(task);
+    for(auto& t : threads) t.join();
+    
+    assert(counter == 2000);
+    
+    Mutex m;
+    int counter2 = 0;
+    ULIB_MUTEX_LOCK(m, -1) {
+        counter2++;
+    }
+    assert(counter2 == 1);
+    
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestMonitor() {
+    std::cout << "Testing Monitor pattern..." << std::endl;
+    struct Resource {
+        int value = 0;
+        void increment() { value++; }
+    };
+    
+    Monitor<Resource> monitor(new Resource());
+    
+    auto task = [&]() {
+        for(int i=0; i<1000; ++i) {
+            monitor.Access([](Resource& r) {
+                r.increment();
+            });
+        }
+    };
+    
+    std::vector<std::thread> threads;
+    for(int i=0; i<5; ++i) threads.emplace_back(task);
+    for(auto& t : threads) t.join();
+    
+    int final_value = monitor.Access([](Resource& r) { return r.value; });
+    assert(final_value == 5000);
+    std::cout << "  Passed (final value: " << final_value << ")." << std::endl;
+}
+
+int main() {
+    TestBasicLock();
+    TestScopedLock();
+    TestTimedLock();
+    TestMacros();
+    TestMonitor();
+    std::cout << "All Mutex and Monitor tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/ObjectWrapperTest.cpp

@@ -0,0 +1,28 @@
+#include "Core/ObjectFactory.h"
+#include <iostream>
+
+struct NonDefault {
+    NonDefault(int) {}
+};
+
+struct Default {
+    Default() : value(42) {}
+    int value;
+};
+
+int main() {
+    std::cout << "Testing ObjectWrapper with Default Constructible type..." << std::endl;
+    uLib::ObjectWrapper<Default> w1;
+    
+    std::cout << "Testing ObjectWrapper with Non-Default Constructible type..." << std::endl;
+    NonDefault nd(10);
+    uLib::ObjectWrapper<NonDefault> w2(nd);
+    
+    // The following would NOT compile without SFINAE:
+    // uLib::ObjectWrapper<NonDefault> w3; 
+
+    std::cout << "Tests passed (compilation and manual instantiation)!" << std::endl;
+    return 0;
+}
+
+

src/Core/testing/OpenMPTest.cpp

@@ -0,0 +1,47 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <cassert>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+using namespace uLib;
+
+class OpenMPThread : public Thread {
+public:
+    void Run() override {
+#ifdef _OPENMP
+        Thread::SetNumThreads(2);
+        int max = Thread::GetNumThreads();
+        std::cout << "  OpenMP max threads in uLib::Thread: " << max << std::endl;
+        
+        int shared_counter = 0;
+        #pragma omp parallel reduction(+:shared_counter)
+        {
+            shared_counter += 1;
+        }
+        std::cout << "  Parallel region executed with " << shared_counter << " threads." << std::endl;
+        assert(shared_counter <= max);
+#else
+        std::cout << "  OpenMP not available, skipping parallel check." << std::endl;
+        assert(Thread::GetNumThreads() == 1);
+#endif
+    }
+};
+
+int main() {
+    std::cout << "Testing OpenMP compatibility..." << std::endl;
+#ifdef _OPENMP
+    std::cout << "  OpenMP is AVAILABLE." << std::endl;
+#else
+    std::cout << "  OpenMP is NOT available." << std::endl;
+#endif
+
+    OpenMPThread t;
+    t.Start();
+    t.Join();
+
+    std::cout << "OpenMP compatibility test finished!" << std::endl;
+    return 0;
+}

src/Core/testing/PropertiesTest.cpp

@@ -23,74 +23,138 @@
 
 //////////////////////////////////////////////////////////////////////////////*/
 
-
-
-
 #include <iostream>
-
-#include <boost/signals2/signal.hpp>
-
+#include <fstream>
+#include <string>
 
 #include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Archives.h"
+#include "Core/Serializable.h"
 #include "testing-prototype.h"
 
-#define emit
-
-
-
-
-template <typename T, bool copyable = true>
-class property
-{
-    typedef boost::signals2::signal<void(const property<T>& )> signal_t;
+using namespace uLib;
 
+/**
+ * @brief A test class to demonstrate property registration via SERIALIZE_OBJECT.
+ */
+class TestObject : public Object {
 public:
-    property() : m_changed(new signal_t) {}
-    property(const T in) : value(in) , m_changed(new signal_t) {}
+    uLibTypeMacro(TestObject, Object)
 
-    inline operator T const & () const { return value; }
-    inline operator T & () { return value; }
-    inline T & operator = (const T &i) { value = i; return value; }
-    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }    // Assign exact identical types only.
-    inline signal_t & valueChanged() { return *m_changed; }
+    TestObject() : m_Value(10.5f), m_Status("Initialized"), m_Counter(0) {}
+
+    float m_Value;
+    std::string m_Status;
+    int m_Counter;
+
+    // Static properties (registered in constructor/initializer)
+    ULIB_PROPERTY(int, StaticProp, 42)
+
+    ULIB_SERIALIZE_ACCESS
+
+    template <typename Ar>
+    void serialize(Ar& ar, unsigned int version) {
+        ar & HRP("value", m_Value, "mm").range(0, 100).set_default(1.);
+        ar & HRP("status", m_Status);
+        ar & HRP("counter", m_Counter);
+    }
 
-private:
-    T value;
-    boost::shared_ptr<signal_t> m_changed;
 };
 
 
-//template <typename T>
-//class property <T,false> {
-//    typedef boost::signals2::signal<void( T )> signal_t;
+class TestObject2 : public TestObject {
+public:
+    uLibTypeMacro(TestObject2, TestObject)
 
-//public:
-//    property() : m_changed() {}
-//    property(const T in) : value(in) , m_changed() {}
+    TestObject2() : TestObject(), m_Value2(20.5f) {}
 
-//    inline operator T const & () const { return value; }
-//    inline operator T & () { valueChanged()(value); return value; }
-//    inline T & operator = (const T &i) { value = i; valueChanged()(value); return value; }
-//    template <typename T2> T2 & operator = (const T2 &i) { T2 &guard = value; }     // Assign exact identical types only.
-//    inline signal_t &valueChanged() { return m_changed; }
-
-//private:
-//    property(const property<T> &);
-//    property<T> &operator = (const property<T>&);
-
-//    T value;
-//    signal_t m_changed;
-//};
-
-// test generic void function slot //
-void PrintSlot(const property<int> &i) { std::cout << "slot called, new value = " << i << "!\n"; }
-
-
-
-
-
-int main()
-{    
+    float m_Value2;
 
+    ULIB_SERIALIZE_ACCESS
+};
 
+ULIB_SERIALIZABLE_OBJECT(TestObject2)
+ULIB_SERIALIZE_OBJECT(TestObject2, TestObject) { 
+    std::cout << "Serializing TestObject2" << std::endl;
+    // ar & boost::serialization::make_hrp("value2", ob.m_Value2, "mm").set_default(1.);
+    ar & HRP("value2", ob.m_Value2, "mm").set_default(1.);
+}
+
+
+int main() {
+    BEGIN_TESTING(Properties Serialization)
+
+    TestObject obj;
+    
+    // 1. Initial state: check static property
+    ASSERT_EQUAL(obj.StaticProp, 42);
+    
+    // 2. Activate dynamic properties via the property_register_archive
+    // This calls the serialize method with a special archive that populates m_DynamicProperties
+    ULIB_ACTIVATE_PROPERTIES(obj);
+    
+    const auto& props = obj.GetProperties();
+    // This is problematic because GetProperties currently returns d->m_Properties (only static) 
+    
+    // For now, let's just assert on the dynamic property presence if possible
+    PropertyBase* pVal = obj.GetProperty("value");
+    ASSERT_NOT_NULL(pVal);
+    ASSERT_EQUAL(pVal->GetValueAsString(), "10.5");
+    ASSERT_EQUAL(pVal->GetUnits(), "mm");
+
+    // Check other dynamic properties
+    ASSERT_NOT_NULL(obj.GetProperty("status"));
+    ASSERT_NOT_NULL(obj.GetProperty("counter"));
+
+    // 4. Serialization round-trip (XML)
+    {
+        std::ofstream ofs("test_props.xml");
+        Archive::xml_oarchive(ofs) << NVP("test_obj", obj);
+    }
+
+    TestObject obj2;
+    obj2.m_Value = 0;
+    obj2.m_Status = "";
+    {
+        std::ifstream ifs("test_props.xml");
+        Archive::xml_iarchive(ifs) >> NVP("test_obj", obj2);
+    }
+
+    ASSERT_EQUAL(obj2.m_Value, 10.5f);
+    ASSERT_EQUAL(obj2.m_Status, "Initialized");
+
+    TestObject2 obj3;
+    obj3.m_Value = 12.5;
+    obj3.m_Status = "Initialized";
+    obj3.m_Value2 = 22.5;
+
+    ULIB_ACTIVATE_PROPERTIES(obj3);
+
+    PropertyBase* pVal3 = obj3.GetProperty("value2");
+    ASSERT_NOT_NULL(pVal3);
+    ASSERT_EQUAL(pVal3->GetValueAsString(), "22.5");
+    ASSERT_EQUAL(pVal3->GetUnits(), "mm");
+
+    // 5. Serialization round-trip (XML)
+    {   
+        std::ofstream ofs("test_props2.xml");
+        Archive::xml_oarchive(ofs) << NVP("test_obj2", obj3);
+    }
+
+    TestObject2 obj4;
+    obj4.m_Value = 0;
+    obj4.m_Status = "";
+    obj4.m_Value2 = 0;
+    ULIB_ACTIVATE_PROPERTIES(obj4);
+    {   
+        std::ifstream ifs("test_props2.xml");
+        Archive::xml_iarchive(ifs) >> NVP("test_obj2", obj4);
+    }
+    ASSERT_EQUAL(obj4.m_Value, 12.5f);
+    ASSERT_EQUAL(obj4.m_Status, "Initialized");
+    ASSERT_EQUAL(obj4.m_Value2, 22.5f);
+
+
+    END_TESTING
 }

src/Core/testing/PropertyGroupingTest.cpp

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+
+using namespace uLib;
+
+struct Nested {
+    float x = 1.0f;
+    float y = 2.0f;
+
+    ULIB_SERIALIZE_ACCESS
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & HRP(x);
+        ar & HRP(y);
+    }
+};
+
+class GroupObject : public Object {
+    uLibTypeMacro(GroupObject, Object)
+public:
+    Nested position;
+    Nested orientation;
+    float weight = 50.0f;
+
+    ULIB_SERIALIZE_ACCESS
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        ar & boost::serialization::make_nvp("Position", position);
+        ar & boost::serialization::make_nvp("Orientation", orientation);
+        ar & HRP(weight);
+    }
+};
+
+int main() {
+    std::cout << "Testing Property Grouping..." << std::endl;
+
+    GroupObject obj;
+    ULIB_ACTIVATE_PROPERTIES(obj);
+
+    auto props = obj.GetProperties();
+    std::cout << "Registered " << props.size() << " properties." << std::endl;
+
+    for (auto* p : props) {
+        std::cout << "Prop: " << p->GetName() 
+                  << " Group: " << p->GetGroup() 
+                  << " Qualified: " << p->GetQualifiedName() << std::endl;
+    }
+
+    // Check if nested properties are registered
+    PropertyBase* p1 = obj.GetProperty("Position.x");
+    PropertyBase* p2 = obj.GetProperty("Position.y");
+    PropertyBase* p3 = obj.GetProperty("Orientation.x");
+    PropertyBase* p4 = obj.GetProperty("Orientation.y");
+    PropertyBase* p5 = obj.GetProperty("weight");
+
+    assert(p1 != nullptr && "Position.x not found");
+    assert(p2 != nullptr && "Position.y not found");
+    assert(p3 != nullptr && "Orientation.x not found");
+    assert(p4 != nullptr && "Orientation.y not found");
+    assert(p5 != nullptr && "weight not found");
+
+    assert(p1->GetGroup() == "Position");
+    assert(p2->GetGroup() == "Position");
+    assert(p3->GetGroup() == "Orientation");
+    assert(p4->GetGroup() == "Orientation");
+    assert(p5->GetGroup() == "");
+
+    assert(p1->GetQualifiedName() == "Position.x");
+    assert(p5->GetQualifiedName() == "weight");
+
+    std::cout << "Property Grouping Tests PASSED!" << std::endl;
+
+    return 0;
+}

src/Core/testing/PropertySystemTest.cpp

@@ -0,0 +1,63 @@
+#include <iostream>
+#include <sstream>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include <cassert>
+
+using namespace uLib;
+
+class TestObject : public Object {
+public:
+  uLibTypeMacro(TestObject, Object)
+  TestObject() : Object(), 
+    IntProp(this, "IntProp", 10),
+    StringProp(this, "StringProp", "Initial") 
+  {}
+
+  Property<int> IntProp;
+  Property<std::string> StringProp;
+};
+
+int main() {
+  TestObject obj;
+  
+  std::cout << "Testing Properties..." << std::endl;
+  
+  // 1. Check registration
+  const auto& props = obj.GetProperties();
+  assert(props.size() == 2);
+  assert(props[0]->GetName() == "IntProp");
+  assert(props[1]->GetName() == "StringProp");
+  
+  // 2. Check value access and signals
+  bool signalCalled = false;
+  uLib::Object::connect(&obj.IntProp, &Property<int>::PropertyChanged, [&signalCalled]() {
+      signalCalled = true;
+  });
+  
+  assert(obj.IntProp.Get() == 10);
+  obj.IntProp = 20;
+  assert(obj.IntProp.Get() == 20);
+  assert(signalCalled == true);
+  
+  // 3. Check serialization
+  std::stringstream ss;
+  Object::SaveXml(ss, obj);
+  std::string xml = ss.str();
+  std::cout << "Serialized XML: \n" << xml << std::endl;
+  
+  assert(xml.find("<IntProp>20</IntProp>") != std::string::npos);
+  assert(xml.find("<StringProp>Initial</StringProp>") != std::string::npos);
+  
+  // 4. Check deserialization
+  TestObject obj2;
+  std::stringstream ss2(xml);
+  Object::LoadXml(ss2, obj2);
+  
+  assert(obj2.IntProp.Get() == 20);
+  assert(obj2.StringProp.Get() == "Initial");
+  
+  std::cout << "All Property Tests PASSED!" << std::endl;
+  
+  return 0;
+}

src/Core/testing/PropertyTypesTest.cpp

@@ -0,0 +1,67 @@
+#include <iostream>
+#include <sstream>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Math/Dense.h"
+
+using namespace uLib;
+
+class TestObject : public Object {
+public:
+  uLibTypeMacro(TestObject, Object)
+  TestObject() : Object() {}
+
+  // Use new typedefs
+  StringProperty  StringProp = StringProperty(this, "StringProp", "Initial");
+  IntProperty     IntProp    = IntProperty(this, "IntProp", 42);
+  FloatProperty   FloatProp  = FloatProperty(this, "FloatProp", 3.14f);
+  BoolProperty    BoolProp   = BoolProperty(this, "BoolProp", true);
+
+  // Use new macro
+  ULIB_PROPERTY(Matrix3f, MatrixProp, Matrix3f::Identity())
+
+  // Use new Dense typedefs
+  Vector3fProperty Vector3fProp = Vector3fProperty(this, "Vector3fProp", Vector3f(1.1f, 2.2f, 3.3f));
+  Matrix4fProperty Matrix4fProp = Matrix4fProperty(this, "Matrix4fProp", Matrix4f::Identity());
+};
+
+int main() {
+  TestObject obj;
+  
+  std::cout << "Testing Property Types..." << std::endl;
+  
+  // 1. Verify string representation
+  std::cout << "StringProp: " << obj.StringProp.GetValueAsString() << std::endl;
+  assert(obj.StringProp.GetValueAsString() == "Initial");
+
+  std::cout << "IntProp: " << obj.IntProp.GetValueAsString() << std::endl;
+  assert(obj.IntProp.GetValueAsString() == "42");
+
+  std::cout << "FloatProp: " << obj.FloatProp.GetValueAsString() << std::endl;
+  // boost::lexical_cast might have different precision, but for 3.14 it should be okay or we check find
+  assert(obj.FloatProp.GetValueAsString().find("3.14") != std::string::npos);
+
+  std::cout << "BoolProp: " << obj.BoolProp.GetValueAsString() << std::endl;
+  // Bool might be "1" or "true" depending on lexical_cast/stringstream
+  assert(obj.BoolProp.GetValueAsString() == "1" || obj.BoolProp.GetValueAsString() == "true");
+
+  // 2. Verify Matrix/Vector string representation (uses operator<<)
+  std::cout << "MatrixProp: \n" << obj.MatrixProp.GetValueAsString() << std::endl;
+  assert(obj.MatrixProp.GetValueAsString().find("1 0 0") != std::string::npos);
+
+  std::cout << "Vector3fProp: " << obj.Vector3fProp.GetValueAsString() << std::endl;
+  assert(obj.Vector3fProp.GetValueAsString().find("1.1 2.2 3.3") != std::string::npos);
+
+  std::cout << "Matrix4fProp: \n" << obj.Matrix4fProp.GetValueAsString() << std::endl;
+  assert(obj.Matrix4fProp.GetValueAsString().find("1 0 0 0") != std::string::npos);
+
+  // 3. Verify updates and signals
+  obj.IntProp = 100;
+  assert(obj.IntProp.Get() == 100);
+  assert(obj.IntProp.GetValueAsString() == "100");
+
+  std::cout << "All Property Type Tests PASSED!" << std::endl;
+  
+  return 0;
+}

src/Core/testing/ReadOnlyPropertyTest.cpp

@@ -0,0 +1,82 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cassert>
+#include "Core/Object.h"
+#include "Core/Property.h"
+#include "Core/Serializable.h"
+
+#include "Core/Serializable.h"
+
+using namespace uLib;
+
+class ReadOnlyTestObject : public Object {
+public:
+    int m_value;
+    int getValue() const { return m_value; }
+    
+    enum State { State1, State2 };
+    State m_state;
+    State getState() const { return m_state; }
+
+    ReadOnlyTestObject() : m_value(10), m_state(State1) {
+        ULIB_ACTIVATE_PROPERTIES(*this);
+    }
+
+    template<class Archive>
+    void serialize(Archive & ar, const unsigned int version) {
+        // Lvalue reference - should be NOT read-only
+        ar & HRP("lvalue_prop", m_value);
+        
+        // Rvalue from getter - should be read-only
+        ar & HRP("rvalue_prop", getValue());
+        
+        // Enum lvalue - should be NOT read-only
+        ar & boost::serialization::make_hrp_enum("lvalue_enum", (int&)m_state, {"State1", "State2"});
+        
+        // Enum rvalue - should be read-only
+        ar & boost::serialization::make_hrp_enum("rvalue_enum", (int)getState(), {"State1", "State2"});
+    }
+};
+
+int main() {
+    std::cout << "Testing Read-Only Property Feature..." << std::endl;
+    
+    ReadOnlyTestObject obj;
+    const auto& props = obj.GetProperties();
+    
+    std::cout << "Registered Properties in ReadOnlyTestObject:" << std::endl;
+    bool found_lvalue = false;
+    bool found_rvalue = false;
+    bool found_lvalue_enum = false;
+    bool found_rvalue_enum = false;
+
+    for (auto* p : props) {
+        bool ro = p->IsReadOnly();
+        std::cout << "  - Name: " << p->GetName() 
+                  << " | Type: " << p->GetTypeName() 
+                  << " | ReadOnly: " << (ro ? "YES" : "NO") << std::endl;
+        
+        if (p->GetName() == "lvalue_prop") {
+            if (ro) { std::cerr << "FAIL: lvalue_prop should NOT be read-only" << std::endl; return 1; }
+            found_lvalue = true;
+        } else if (p->GetName() == "rvalue_prop") {
+            if (!ro) { std::cerr << "FAIL: rvalue_prop SHOULD be read-only" << std::endl; return 1; }
+            found_rvalue = true;
+        } else if (p->GetName() == "lvalue_enum") {
+            if (ro) { std::cerr << "FAIL: lvalue_enum should NOT be read-only" << std::endl; return 1; }
+            found_lvalue_enum = true;
+        } else if (p->GetName() == "rvalue_enum") {
+            if (!ro) { std::cerr << "FAIL: rvalue_enum SHOULD be read-only" << std::endl; return 1; }
+            found_rvalue_enum = true;
+        }
+    }
+    
+    if (found_lvalue && found_rvalue && found_lvalue_enum && found_rvalue_enum) {
+        std::cout << "TEST PASSED SUCCESSFULLY!" << std::endl;
+        return 0;
+    } else {
+        std::cerr << "TEST FAILED: Some properties were not found!" << std::endl;
+        return 1;
+    }
+}

src/Core/testing/SerializeDreadDiamondTest.cpp

@@ -70,7 +70,30 @@ ULIB_SERIALIZABLE_OBJECT(D)
 ULIB_SERIALIZE_OBJECT(D, A, B) { ar & AR(numd); }
 
 int main() {
-  A o;
+  BEGIN_TESTING(DreadDiamond Serialization)
   
-  Archive::xml_oarchive(std::cout) << NVP(o);
+  D o;
+  C c;
+  c.numb = 123;
+  {
+    std::ofstream file("test.xml");
+    Archive::xml_oarchive(file) << NVP("dd_test", o) << NVP("c", c);
+  }
+  {
+    D o2;
+    C c2;
+    std::ifstream file("test.xml");
+    Archive::xml_iarchive(file) >> NVP("dd_test", o2) >> NVP("c", c2);
+    
+    // D //
+    ASSERT_EQUAL(o.numa, o2.numa);
+    ASSERT_EQUAL(o.numb, o2.numb);
+    ASSERT_EQUAL(o.numd, o2.numd);
+    
+    // C //
+    ASSERT_EQUAL(c.numb, c2.numb);
+    ASSERT_EQUAL(c.numc, c2.numc);
+  }
+  
+  END_TESTING
 }

src/Core/testing/SerializeTest.cpp

@@ -143,22 +143,105 @@ int testing_hrt_class() {
   }
   a.a() = 0;
   a.p_a = "zero string";
-  {
-    // ERRORE FIX !
-    //        std::ifstream file("test.xml");
-    //        Archive::hrt_iarchive(file) >> NVP(a);
-  }
 
   Archive::hrt_oarchive(std::cout) << NVP(a);
   return (a.a() == 5552368 && a.p_a == "A property string");
 }
 
+
+
+
+
+class B : public virtual Object {
+  uLibTypeMacro(B, Object)
+  ULIB_SERIALIZE_ACCESS
+  
+public:
+  B() : m_b(1234567), m_a(nullptr) {}  
+
+  int m_b;
+
+  // reference to A (serializes through ID)
+  A *m_a;
+};
+
+ULIB_SERIALIZABLE_OBJECT(B)
+ULIB_SERIALIZE_OBJECT(B, Object) {
+  ar & "Object B : " & "--> m_b = " & AR(m_b) & "--> m_a = " & AR(m_a);
+}
+
+
+
+class C : public virtual Object {
+  uLibTypeMacro(C, Object)
+  ULIB_SERIALIZE_ACCESS
+  
+public:
+  C() : m_c(1234566) {}
+
+  int m_c;
+
+  // reference to A (serializes through ID)
+  SmartPointer<A> m_a;
+};
+
+ULIB_SERIALIZABLE_OBJECT(C)
+ULIB_SERIALIZE_OBJECT(C, Object) {
+  ar & "Object C : " & "--> m_c = " & AR(m_c) & "--> m_a = " & AR(m_a);
+}
+
+
+
+int test_referece_serialization() {  
+  A a;
+  {
+    B b,b2  ;
+    b.m_a = &a;
+    b2.m_a = &a;
+
+    std::ofstream file("test_ref.xml");
+    Archive::xml_oarchive(file) << NVP(b) << NVP(b2);
+  }
+  
+  
+  B b,b2;
+  {
+    std::ifstream file("test_ref.xml");
+    Archive::xml_iarchive(file) >> NVP(b) >> NVP(b2);
+  }
+
+  return (b.m_a->a() == a.a() && b2.m_a->a() == a.a());
+}
+
+int test_referece_smartpointer_serialization() {
+  SmartPointer<A> a;
+  a->init_properties();
+  {
+    C c, c2; c.m_a = a; c2.m_a = a; 
+    
+    std::ofstream file("test_ref_smartpointer.xml");
+    Archive::xml_oarchive(file) << NVP(c) << NVP(c2);
+  }
+  
+  
+  C c, c2;
+  {
+    std::ifstream file("test_ref_smartpointer.xml");
+    Archive::xml_iarchive(file) >> NVP(c) >> NVP(c2);
+  }
+
+  return (c.m_a->a() == a->a() && c2.m_a->a() == a->a());
+}
+
+
 int main() {
   BEGIN_TESTING(Serialize Test);
 
   TEST1(test_V3f());
   TEST1(testing_xml_class());
-  //    testing_hrt_class(); ///// << ERRORE in HRT with properties
+  TEST1(test_referece_serialization());
+  TEST1(test_referece_smartpointer_serialization());
+  // TEST1(testing_hrt_class());
 
   END_TESTING;
 }

src/Core/testing/SmartPointerTest.cpp

@@ -27,6 +27,7 @@
 
 
 #include <iostream>
+#include "Core/Object.h"
 #include "Core/SmartPointer.h"
 #include "testing-prototype.h"
 
@@ -34,12 +35,12 @@ using namespace uLib;
 
 namespace Test {
 
-struct ObjectMockInterface {
+struct ObjectMockInterface : public Object {
     virtual void PrintValue()=0;
     virtual int& Value()=0;
 };
 
-class ObjectMock : ObjectMockInterface {
+class ObjectMock : public ObjectMockInterface {
     int value;
 public:
     int& Value() { return value; }
@@ -72,12 +73,15 @@ int main () {
         SmartPointer<Test::ObjectMock> spt(new Test::ObjectMock);
         TEST1(test_smpt(spt));
     }
+
     {
         SmartPointer<Test::ObjectMock> spt;
         TEST1(test_smpt(spt));
     }
+
     {
-        SmartPointer<Test::ObjectMock> spt = new SmartPointer<Test::ObjectMock>;
+        SmartPointer<Test::ObjectMock> base_spt;
+        SmartPointer<Test::ObjectMock> spt = &base_spt;
         TEST1(test_smpt(spt));
     }
 
@@ -88,7 +92,28 @@ int main () {
         TEST1(test_smpt(spt));
     }
 
+    {
+        Test::ObjectMock obj;
+        SmartPointer<Object> spt1 = obj;
+        SmartPointer<Test::ObjectMock> spt2 = obj;
+        SmartPointer<Test::ObjectMockInterface> spt = obj;
+    }
 
+    { 
+      Test::ObjectMock *obj = new Test::ObjectMock; 
+      SmartPointer<Test::ObjectMock> spt(obj); 
+      SmartPointer<Test::ObjectMock> spt2(spt); 
+      SmartPointer<Test::ObjectMock> spt3(spt); 
+      SmartPointer<Test::ObjectMock> spt4(spt2); 
+      spt->Value() = 123;
+      spt2->Value() = 456;
+      spt3->Value() = 789;
+      spt4->Value() = 101112;
+      TEST1(spt->Value() == 101112);
+      TEST1(spt2->Value() == 101112);
+      TEST1(spt3->Value() == 101112);
+      TEST1(spt4->Value() == 101112);
+    }
 
     END_TESTING;
 }

src/Core/testing/TeamTest.cpp

@@ -0,0 +1,40 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <atomic>
+#include <cassert>
+#include <vector>
+
+using namespace uLib;
+
+void TestTaskTeam() {
+    std::cout << "Testing Task and Team..." << std::endl;
+    
+    std::atomic<int> counter(0);
+    auto task_func = [&]() {
+        counter++;
+        Thread::Sleep(10);
+    };
+    
+    Team team(4);
+    std::cout << "  Team size: " << team.GetSize() << std::endl;
+
+#ifdef _OPENMP
+    #pragma omp parallel
+    #pragma omp single
+#endif
+    {
+        for (int i = 0; i < 20; ++i) {
+            team.Run(new Task(task_func));
+        }
+        team.Wait();
+    }
+    
+    assert(counter == 20);
+    std::cout << "  Passed (counter: " << counter << ")." << std::endl;
+}
+
+int main() {
+    TestTaskTeam();
+    std::cout << "All Team tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/ThreadsTest.cpp

@@ -0,0 +1,72 @@
+#include "Core/Threads.h"
+#include <iostream>
+#include <atomic>
+#include <cassert>
+
+using namespace uLib;
+
+class MyThread : public Thread {
+public:
+    MyThread() : counter(0) {}
+    void Run() override {
+        for (int i = 0; i < 5; ++i) {
+            counter++;
+            Thread::Sleep(10);
+        }
+    }
+    std::atomic<int> counter;
+};
+
+void TestBasicThread() {
+    std::cout << "Testing basic Thread lifecycle..." << std::endl;
+    MyThread t;
+    assert(!t.IsRunning());
+    t.Start();
+    assert(t.IsRunning());
+    t.Join();
+    assert(!t.IsRunning());
+    assert(t.counter == 5);
+    std::cout << "  Passed." << std::endl;
+}
+
+void TestThreadDetach() {
+    std::cout << "Testing Thread Detach..." << std::endl;
+    std::atomic<bool> done(false);
+    
+    // Using a lambda or a simple subclass
+    class DetachedThread : public Thread {
+    public:
+        DetachedThread(std::atomic<bool>& d) : m_done(d) {}
+        void Run() override {
+            Thread::Sleep(50);
+            m_done = true;
+        }
+        std::atomic<bool>& m_done;
+    };
+    
+    {
+        DetachedThread* t = new DetachedThread(done);
+        t->Start();
+        t->Detach();
+        // The thread object 't' is still alive here, 
+        // but it will be destroyed soon if we delete it.
+        // For a detached thread using members, we MUST keep it alive.
+        
+        int wait_count = 0;
+        while(!done && wait_count < 20) {
+            Thread::Sleep(10);
+            wait_count++;
+        }
+        delete t;
+    }
+    
+    assert(done);
+    std::cout << "  Passed." << std::endl;
+}
+
+int main() {
+    TestBasicThread();
+    TestThreadDetach();
+    std::cout << "All Thread tests passed!" << std::endl;
+    return 0;
+}

src/Core/testing/VectorTest.cpp

@@ -38,7 +38,7 @@ inline const unsigned long VectorSplice(const _Tp &_it, const _Tp &_end,
 
   _Tp it = _it;
   _Tp end = _end - 1;
-  for (it; it != end;) {
+  for (; it != end;) {
     if (_comp(*it, value))
       it++;
     else if (_comp(*end, value)) {

src/Core/testing/testing-prototype.h

@@ -33,5 +33,7 @@ printf("..:: Testing " #name " ::..\n");
 
 #define TEST1(val) _fail += (val)==0
 #define TEST0(val) _fail += (val)!=0
+#define ASSERT_EQUAL(a,b) if((a)!=(b)) { printf("Assertion failed: " #a " != " #b " at line %d\n", __LINE__); _fail++; }
+#define ASSERT_NOT_NULL(ptr) if((ptr)==NULL) { printf("Assertion failed: " #ptr " is NULL at line %d\n", __LINE__); _fail++; }
 #define END_TESTING return _fail;
 

src/Detectors/CMakeLists.txt

@@ -1,12 +0,0 @@
-set(HEADERS MuonScatter.h MuonError.h MuonEvent.h)
-
-set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
-
-
-install(FILES ${HEADERS}
-        DESTINATION ${INSTALL_INC_DIR}/Detectors)
-
-if(BUILD_TESTING)
-  include(uLibTargetMacros)
-  add_subdirectory(testing)
-endif()

src/Detectors/Solid.cpp

@@ -1,114 +0,0 @@
-/*//////////////////////////////////////////////////////////////////////////////
-// CMT Cosmic Muon Tomography project //////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
-  All rights reserved
-
-  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
-
-  ------------------------------------------------------------------
-  This library is free software;  you  can  redistribute  it  and/or
-  modify it  under the  terms  of  the  GNU  Lesser  General  Public
-  License as published  by  the  Free  Software  Foundation;  either
-  version 3.0 of the License, or (at your option) any later version.
-
-  This library is  distributed in  the hope that it will  be useful,
-  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
-  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of  the GNU Lesser General  Public
-  License along with this library.
-
-//////////////////////////////////////////////////////////////////////////////*/
-
-
-
-// G4 Solid //
-#include <Geant4/G4Material.hh>
-#include <Geant4/G4NistManager.hh>
-#include <Geant4/G4LogicalVolume.hh>
-
-// Tessellated solid //
-#include <Geant4/G4TessellatedSolid.hh>
-#include <Geant4/G4TriangularFacet.hh>
-#include <Geant4/G4ThreeVector.hh>
-
-
-#include "Math/Dense.h"
-
-#include "Solid.h"
-
-namespace uLib {
-
-class DetectorsSolidPimpl {
-public:
-    static G4ThreeVector getG4Vector3f(const Vector3f &vector) {
-        return G4ThreeVector( vector(0), vector(1), vector(2) );
-    }
-};
-
-
-
-Solid::Solid() :
-    m_Logical (new G4LogicalVolume(NULL,NULL,"unnamed_solid")),
-    m_Material(NULL)
-{}
-
-Solid::Solid(const char *name) :
-    m_Logical(new G4LogicalVolume(NULL,NULL,name)),
-    m_Material(NULL)
-{}
-
-
-
-void Solid::SetNistMaterial(const char *name)
-{
-    G4NistManager *nist = G4NistManager::Instance();
-    if (m_Material) delete m_Material;
-    m_Material = nist->FindOrBuildMaterial(name);
-    m_Logical->SetMaterial(m_Material);
-}
-
-void Solid::SetMaterial(G4Material *material)
-{
-    if(material)
-    {
-        m_Material = material;
-        m_Logical->SetMaterial(material);
-    }
-}
-
-
-
-
-
-
-
-
-
-
-TessellatedSolid::TessellatedSolid(const char *name) :
-    BaseClass(name),
-    m_Solid(new G4TessellatedSolid(name))
-{}
-
-
-void TessellatedSolid::SetMesh(TriangleMesh &mesh)
-{
-    G4TessellatedSolid *ts = this->m_Solid;
-    for (int i=0; i<mesh.Triangles().size(); ++i) {
-        const Vector3i &trg = mesh.Triangles().at(i);
-        G4TriangularFacet *facet = new G4TriangularFacet(
-                    DetectorsSolidPimpl::getG4Vector3f(mesh.Points().at(trg(0))),
-                    DetectorsSolidPimpl::getG4Vector3f(mesh.Points().at(trg(1))),
-                    DetectorsSolidPimpl::getG4Vector3f(mesh.Points().at(trg(2))),
-                    ABSOLUTE);
-        ts->AddFacet((G4VFacet *)facet);
-    }
-    this->m_Logical->SetSolid(ts);
-}
-
-
-}

src/Detectors/testing/Makefile.am

@@ -1,16 +0,0 @@
-
-include $(top_srcdir)/Common.am
-
-#AM_DEFAULT_SOURCE_EXT = .cpp
-
-# if HAVE_CHECK
-TESTS = GDMLSolidTest
-
-# else
-# TEST =
-# endif
-
-LDADD = $(top_srcdir)/libmutom-${PACKAGE_VERSION}.la
-
-check_PROGRAMS = $(TESTS)
-