refactor: improve Geant4 solid synchronization and update documentation for VTK integration

app/gcompose/src/ContextPanel.cpp

@@ -57,6 +57,8 @@ ContextPanel::ContextPanel(QWidget* parent)
     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);

app/gcompose/src/ContextPanel.h

@@ -25,6 +25,7 @@ public:
 
 signals:
     void objectSelected(uLib::Object* obj);
+    void propertyUpdated();
 
 private slots:
     void onSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);

app/gcompose/src/MainPanel.cpp

@@ -6,6 +6,8 @@
 #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>
@@ -22,7 +24,7 @@
 #include "PreferencesDialog.h"
 #include "Settings.h"
 
-MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(nullptr) {
+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);
@@ -98,6 +100,13 @@ MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_m
             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;
@@ -244,15 +253,21 @@ void MainPanel::onExit() {
 void MainPanel::onPreferences() {
     uLib::Qt::PreferencesDialog dlg(this);
     if (dlg.exec() == QDialog::Accepted) {
-        // Apply theme
+        // Apply theme and GUI font
         auto theme = uLib::Qt::Settings::Instance().GetTheme();
-        StyleManager::applyStyle(qApp, theme == uLib::Qt::Settings::Dark ? "dark" : "bright");
+        auto guiFont = uLib::Qt::Settings::Instance().GetGuiFont();
+        StyleManager::applyStyle(qApp, theme == uLib::Qt::Settings::Dark ? "dark" : "bright", guiFont);
 
-        // Apply rendering preference to all viewports
+        // 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();
         }
     }

app/gcompose/src/MainPanel.h

@@ -12,6 +12,7 @@ namespace uLib {
     class ObjectsContext;
     namespace Vtk {
         class ObjectsContext;
+        class ViewportProperties;
     }
 }
 
@@ -40,6 +41,7 @@ private:
     ContextPanel* m_contextPanel;
     uLib::ObjectsContext* m_context;
     uLib::Vtk::ObjectsContext* m_mainVtkContext;
+    uLib::Vtk::ViewportProperties* m_viewportProps;
 };
 
 #endif // MAINPANEL_H

app/gcompose/src/PreferencesDialog.cpp

@@ -5,6 +5,8 @@
 #include <QPushButton>
 #include <QLabel>
 #include <QGroupBox>
+#include <QColorDialog>
+#include <QFormLayout>
 
 namespace uLib {
 namespace Qt {
@@ -64,6 +66,77 @@ PreferencesDialog::PreferencesDialog(QWidget* parent) : QDialog(parent) {
 
     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 ─────────────────────────────────────────────────────────────
@@ -92,8 +165,20 @@ void PreferencesDialog::onAccept() {
         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

@@ -4,6 +4,8 @@
 #include <QDialog>
 #include <QCheckBox>
 #include <QComboBox>
+#include <QSpinBox>
+#include <QPushButton>
 #include <map>
 #include <string>
 #include "Settings.h"
@@ -23,6 +25,22 @@ 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

app/gcompose/src/PropertiesPanel.cpp

@@ -30,6 +30,10 @@ PropertiesPanel::PropertiesPanel(QWidget* parent) : QWidget(parent) {
     // 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) {

app/gcompose/src/PropertiesPanel.h

@@ -24,6 +24,9 @@ public:
     /** @brief Sets the object to be inspected. */
     void setObject(uLib::Object* obj);
 
+signals:
+    void propertyUpdated();
+
 private:
     QVBoxLayout* m_layout;
     QWidget* m_titleBar;

app/gcompose/src/PropertyWidgets.cpp

@@ -11,6 +11,7 @@
 #include <QColorDialog>
 #include <QFrame>
 #include <QSlider>
+#include <QFontDialog>
 #include "Settings.h"
 
 namespace uLib {
@@ -151,7 +152,7 @@ DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* pare
     }
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
-    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
+    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());
     });
@@ -169,7 +170,7 @@ FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
     }
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
-    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((float)val); });
+    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());
     });
@@ -188,7 +189,7 @@ IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
     }
     m_Edit->setValue(prop->Get());
     m_Layout->addWidget(m_Edit, 1);
-    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((int)val); });
+    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());
     });
@@ -199,7 +200,7 @@ BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
     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); });
+    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);
@@ -222,7 +223,7 @@ RangePropertyWidget::RangePropertyWidget(Property<double>* prop, QWidget* parent
     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); });
+    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();
@@ -244,6 +245,7 @@ void RangePropertyWidget::updateUi() {
 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) 
@@ -276,6 +278,7 @@ void ColorPropertyWidget::onClicked() {
     QColor selected = QColorDialog::getColor(current, this, "Select Color");
     if (selected.isValid()) {
         m_Prop->Set(Vector3d(selected.redF(), selected.greenF(), selected.blueF()));
+        emit updated();
     }
 }
 
@@ -286,7 +289,7 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
     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);
+        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()) {
@@ -297,6 +300,40 @@ StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget*
 }
 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) {
@@ -332,8 +369,9 @@ public:
         // Get initial value
         if (auto* p = dynamic_cast<Property<int>*>(prop)) {
             m_Combo->setCurrentIndex(p->Get());
-            connect(m_Combo, &QComboBox::currentIndexChanged, [p](int index){
+            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](){
@@ -374,6 +412,9 @@ PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(null
     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) {
@@ -462,6 +503,12 @@ void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
             }
 
             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);

app/gcompose/src/PropertyWidgets.h

@@ -17,6 +17,7 @@ class QSlider;
 #include "Core/Property.h"
 #include "Core/Object.h"
 #include "Core/Signal.h"
+#include "Core/FontConfig.h"
 #include "Math/Dense.h"
 #include "Settings.h"
 
@@ -32,6 +33,9 @@ public:
     virtual ~PropertyWidgetBase();
     PropertyBase* getProperty() const { return m_BaseProperty; }
 
+signals:
+    void updated();
+
 protected:
     PropertyBase* m_BaseProperty;
     QHBoxLayout* m_Layout;
@@ -121,7 +125,10 @@ public:
             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);
+                if (m_Prop->Get() != v) {
+                    m_Prop->Set(v);
+                    emit updated();
+                }
             });
         }
         updateEdits();
@@ -191,6 +198,19 @@ private:
     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 PropertyEditor : public QWidget {
     Q_OBJECT
 public:
@@ -202,6 +222,9 @@ public:
         m_Factories[std::type_index(typeid(T))] = factory;
     }
 
+signals:
+    void propertyUpdated(PropertyBase* prop = nullptr);
+
 private:
     void clear();
     uLib::Object* m_Object;

app/gcompose/src/Settings.h

@@ -4,6 +4,8 @@
 #include <string>
 #include <map>
 #include "Math/Units.h"
+#include "Core/FontConfig.h"
+#include "Math/Dense.h"
 
 namespace uLib {
 namespace Qt {
@@ -75,11 +77,23 @@ public:
     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) {}
+    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

app/gcompose/src/StyleManager.cpp

@@ -1,11 +1,15 @@
 #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; }
@@ -23,8 +27,11 @@ QScrollArea > QWidget > QWidget { background: transparent; }
 
 /* Property Widgets Styling */
 QLabel { color: #cccccc; }
-QDoubleSpinBox, QSpinBox, QLineEdit { background: #3c3c3c; color: #f1f1f1; border: 1px solid #3e3e42; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
-QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
+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; }
@@ -42,6 +49,11 @@ 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"(
@@ -49,6 +61,9 @@ 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; }
@@ -66,8 +81,11 @@ QScrollArea > QWidget > QWidget { background: transparent; }
 
 /* Property Widgets Styling */
 QLabel { color: #333333; }
-QDoubleSpinBox, QSpinBox, QLineEdit { background: #ffffff; color: #333333; border: 1px solid #cccccc; padding: 2px 4px; border-radius: 2px; selection-background-color: #0078d7; }
-QDoubleSpinBox:focus, QSpinBox:focus, QLineEdit:focus { border-color: #0078d7; }
+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; }
@@ -85,14 +103,26 @@ 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) {
+void StyleManager::applyStyle(QApplication* app, const QString& themeName, const uLib::FontConfig& fontCfg) {
     if (!app) return;
     
-    if (themeName == "bright") {
-        app->setStyleSheet(BRIGHT_THEME);
-    } else {
-        app->setStyleSheet(DARK_THEME); // default
-    }
+    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

@@ -5,9 +5,11 @@
 
 class QApplication;
 
+namespace uLib { class FontConfig; }
+
 class StyleManager {
 public:
-    static void applyStyle(QApplication* app, const QString& themeName);
+    static void applyStyle(QApplication* app, const QString& themeName, const uLib::FontConfig& font);
 };
 
 #endif // STYLEMANAGER_H

app/gcompose/src/ViewportPane.cpp

@@ -125,6 +125,10 @@ void ViewportPane::setViewport(QWidget* viewport, const QString& title) {
     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");

app/gcompose/src/ViewportPane.h

@@ -8,6 +8,7 @@
 namespace uLib {
     class Object;
     namespace Qt { class PropertyEditor; }
+    namespace Vtk { class Viewport; }
 }
 
 class QSplitter;
@@ -24,6 +25,7 @@ public:
     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);

app/gcompose/src/main.cpp

@@ -3,6 +3,8 @@
 #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>
@@ -29,7 +31,9 @@ using namespace uLib::literals;
 
 int main(int argc, char** argv) {
     QApplication app(argc, argv);
-    StyleManager::applyStyle(&app, "dark");
+    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));

docs/geant_integration.md

@@ -3,9 +3,32 @@
 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
+# 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.
 
-Geant solid in uLib is represented by the `uLib::Geant::Solid` class and mainly BoxSolid and TessellatedSolid. The solids in Geant does not have the possibility to set properties on the fly so we need to create a new solid every time we want to change the properties of a solid. This is done by creating a new `uLib::Geant::Solid` object and setting the properties of the new solid. The new solid is then added to the `uLib::Geant::Solid` object as a child. The old solid is then removed from the `uLib::Geant::Solid` object as a child. The old solid is then deleted. However id some of the properties can be set then the library will drive the change in the solid update.
 
-The idea is to have a mapping of solid properties that can be used in uLib for Qt representation or vtk representation. then when the property is changed the signaling will update the property in uLib and then the solid will be updated. If the Geant property can be applied to the G4 object underneath then the update will apply the change, in case it is not possible to apply the change to the G4 object underneath then the G4 element will be recreated. 
-In any case a updated singal is emitted and the related element that use that solid is updated ( for instance the scene ).

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/HEP/Geant/Solid.cpp

@@ -107,6 +107,8 @@ void Solid::SetTransform(Matrix4f transform) {
     }
 
     std::cout << "Solid " << GetName() << " position: " << pos << " rotation: " << m << std::endl;
+
+    this->Updated();
 }
 
 void Solid::SetParent(Solid *parent) {
@@ -181,11 +183,14 @@ void TessellatedSolid::Update() {
 BoxSolid::BoxSolid(const char *name) : 
     BaseClass(name), 
     m_ContainerBox(new ContainerBox()), 
-    m_Solid(new G4Box(name, 1, 1, 1))
-  {}
+    m_Solid(new G4Box(name, 0.5, 0.5, 0.5))
+  {
+    Object::connect(m_ContainerBox, &ContainerBox::Updated, this, &BoxSolid::Update);
+    Update();
+  }
 
 BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
-  m_Solid = new G4Box(name, 1, 1, 1);
+  m_Solid = new G4Box(name, 0.5, 0.5, 0.5);
   m_ContainerBox = box;
   Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
   if (m_Logical) {

src/HEP/Geant/Solid.h

@@ -53,6 +53,7 @@ public:
   void SetMaterial(G4Material *material);
   
   void SetSizeUnit(const char *unit);
+  
   // Implementiamo SetParent qui, per tutti.
   virtual void SetParent(Solid *parent); 
 
@@ -71,11 +72,8 @@ public:
 
   template < typename Ar >
   void serialize(Ar &ar, const unsigned int version) {
-    ar & m_Name;
+    ar & boost::serialization::make_nvp("Name", m_Name);
   }
-    
-    
-
 
 protected:
 
@@ -123,6 +121,7 @@ public:
 
   BoxSolid(const char *name = "");
   BoxSolid(const char *name, ContainerBox *box);
+
   virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
   
   ContainerBox* GetObject() const { return m_ContainerBox; }

src/HEP/Geant/testing/SolidTest.cpp

@@ -25,6 +25,32 @@ int main() {
         TEST1(solid.GetMaterial()->GetName() == "G4_AIR");
     }
 
+    // Test BoxSolid //
+    {
+        Geant::BoxSolid boxsolid("test_boxsolid");
+        boxsolid.SetNistMaterial("G4_AIR");
+        TEST1(boxsolid.GetLogical() != nullptr);
+        // TEST1(boxsolid.GetSolid() != nullptr);
+    }
+
+    // Test BoxSolid with a container box //
+    {
+        ContainerBox box;
+        
+        // box.SetPosition(Vector3f(1,1,1));
+        // box.SetRotation(Rotation(Vector3f(0,1,0), 45_deg));
+        
+        Geant::BoxSolid boxsolid("test_boxsolid", &box);
+        boxsolid.SetNistMaterial("G4_AIR");
+        TEST1(boxsolid.GetLogical() != nullptr);
+        // TEST1(boxsolid.GetSolid() != nullptr);
+        // TEST1(boxsolid.GetSolid()->GetXHalfLength() == 0.5);
+        // TEST1(boxsolid.GetSolid()->GetYHalfLength() == 0.5);
+        // TEST1(boxsolid.GetSolid()->GetZHalfLength() == 0.5);
+
+        
+    }
+
     // Test TessellatedSolid with a simple mesh //
     {
         Geant::TessellatedSolid tsolid("test_tessellated");

src/Vtk/HEP/Geant/vtkBoxSolid.cpp

@@ -40,13 +40,15 @@ BoxSolid::~BoxSolid() {
 
 void BoxSolid::Update() {
   ConnectionBlock blocker(m_UpdateConnection);
-  this->UpdateGeometry();
-  // Ensure base Prop3D properties (color, opacity, etc) and transform are applied
+  // Ensure base GeantSolid logic (G4Polyhedron and Transform) runs
+  this->GeantSolid::Update();
+  // Ensure base Prop3D properties (color, opacity, etc) are applied
   this->Prop3D::Update();
 }
 
 void BoxSolid::SyncFromVtk() {
   this->Prop3D::SyncFromVtk();
+  
   if (auto* proxy = vtkProp3D::SafeDownCast(this->GetProxyProp())) {
       if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
           m_BoxContent->SetTransform(VtkToMatrix4f(mat));
@@ -54,16 +56,6 @@ void BoxSolid::SyncFromVtk() {
   }
 }
 
-void BoxSolid::UpdateGeometry() {
-  // Sync geometry from G4VSolid provided by GeantSolid (tessellation)
-  GeantSolid::UpdateGeometry();
-}
-
-void BoxSolid::UpdateTransform() {
-  // Take transform from Prop3D base (which uses GetContent() -> ContainerBox TRS)
-  this->Prop3D::Update();
-}
-
 void BoxSolid::serialize_display(uLib::Archive::display_properties_archive &ar,
                                     const unsigned int version) {
   // Expose Geant solid properties and underlying Box/TRS properties

src/Vtk/HEP/Geant/vtkBoxSolid.h

@@ -49,8 +49,6 @@ public:
   virtual ~BoxSolid();
 
   virtual void Update() override;
-  virtual void UpdateGeometry() override;
-  virtual void UpdateTransform() override;
   virtual void SyncFromVtk() override;
 
   virtual uLib::Object *GetContent() const override { 

src/Vtk/vtkViewport.cpp

@@ -123,10 +123,9 @@ void Viewport::SetupPipeline(vtkRenderWindowInteractor* iren)
     iren->SetInteractorStyle(style);
 
     // Corner annotation
-    pv->m_Annotation->GetTextProperty()->SetColor(1, 1, 1);
-    pv->m_Annotation->GetTextProperty()->SetFontFamilyToArial();
+    SetFontColor(Vector3d(1.0, 1.0, 1.0));
+    SetFont(FontConfig("Arial", 10));
     pv->m_Annotation->GetTextProperty()->SetOpacity(0.5);
-    pv->m_Annotation->SetMaximumFontSize(10);
     pv->m_Annotation->SetText(0, "uLib VTK viewer.");
     pv->m_Renderer->AddViewProp(pv->m_Annotation);
 
@@ -603,6 +602,44 @@ bool Viewport::GetParallelProjection() const
     return false;
 }
 
+void Viewport::SetFont(const FontConfig& font) {
+    if (!pv->m_Annotation) return;
+    auto* prop = pv->m_Annotation->GetTextProperty();
+    if (font.family == "Arial") prop->SetFontFamilyToArial();
+    else if (font.family == "Courier") prop->SetFontFamilyToCourier();
+    else if (font.family == "Times") prop->SetFontFamilyToTimes();
+    else prop->SetFontFamilyToArial(); // fallback
+
+    pv->m_Annotation->SetMaximumFontSize(font.size);
+    prop->SetBold(font.bold);
+    prop->SetItalic(font.italic);
+    this->Render();
+}
+
+FontConfig Viewport::GetFont() const {
+    if (!pv->m_Annotation) return FontConfig();
+    auto* prop = pv->m_Annotation->GetTextProperty();
+    FontConfig f;
+    f.family = prop->GetFontFamilyAsString();
+    f.size = pv->m_Annotation->GetMaximumFontSize();
+    f.bold = prop->GetBold();
+    f.italic = prop->GetItalic();
+    return f;
+}
+
+void Viewport::SetFontColor(const Vector3d& color) {
+    if (!pv->m_Annotation) return;
+    pv->m_Annotation->GetTextProperty()->SetColor(color.x(), color.y(), color.z());
+    this->Render();
+}
+
+Vector3d Viewport::GetFontColor() const {
+    if (!pv->m_Annotation) return Vector3d(1,1,1);
+    double c[3];
+    pv->m_Annotation->GetTextProperty()->GetColor(c);
+    return Vector3d(c[0], c[1], c[2]);
+}
+
 void Viewport::SetGridAxis(Axis axis)
 {
     m_GridAxis = axis;

src/Vtk/vtkViewport.h

@@ -4,6 +4,8 @@
 #include "uLibVtkInterface.h"
 #include <vector>
 #include <map>
+#include "Core/FontConfig.h"
+#include "Math/Dense.h"
 
 namespace uLib { class Object; }
 
@@ -83,6 +85,12 @@ public:
     void SetParallelProjection(bool parallel);
     bool GetParallelProjection() const;
 
+    // Font configuration
+    void SetFont(const FontConfig& font);
+    FontConfig GetFont() const;
+    void SetFontColor(const Vector3d& color);
+    Vector3d GetFontColor() const;
+
 protected:
     void SetupPipeline(vtkRenderWindowInteractor* iren);
 

src/Vtk/vtkViewportProperties.h

@@ -0,0 +1,56 @@
+#ifndef ULIB_VTK_VIEWPORTPROPERTIES_H
+#define ULIB_VTK_VIEWPORTPROPERTIES_H
+
+#include "uLibVtkInterface.h"
+#include "vtkViewport.h"
+#include "Core/Property.h"
+
+namespace uLib {
+namespace Vtk {
+
+/**
+ * @class ViewportProperties
+ * @brief Exposes Viewport settings as a uLib::Object for the properties panel.
+ */
+class ViewportProperties : public uLib::Object {
+public:
+    uLibTypeMacro(ViewportProperties, uLib::Object)
+
+    ViewportProperties(Viewport* vp) : m_Viewport(vp)
+    {
+        SetInstanceName("Viewport Settings");
+
+        // Initialize properties from viewport
+        Font.Set(vp->GetFont());
+        Color.Set(vp->GetFontColor());
+        GridVisible.Set(vp->GetGridVisible());
+        Parallel.Set(vp->GetParallelProjection());
+
+        // Connect properties to viewport setters
+        uLib::Object::connect(&Font, &Property<FontConfig>::Updated, [this](){
+            if (m_Viewport) m_Viewport->SetFont(Font.Get());
+        });
+        uLib::Object::connect(&Color, &Property<Vector3d>::Updated, [this](){
+            if (m_Viewport) m_Viewport->SetFontColor(Color.Get());
+        });
+        uLib::Object::connect(&GridVisible, &Property<bool>::Updated, [this](){
+            if (m_Viewport) m_Viewport->SetGridVisible(GridVisible.Get());
+        });
+        uLib::Object::connect(&Parallel, &Property<bool>::Updated, [this](){
+            if (m_Viewport) m_Viewport->SetParallelProjection(Parallel.Get());
+        });
+    }
+
+    ULIB_PROPERTY(FontConfig, Font, FontConfig())
+    ULIB_PROPERTY(Vector3d, Color, Vector3d(1.0, 1.0, 1.0))
+    ULIB_PROPERTY(bool, GridVisible, true)
+    ULIB_PROPERTY(bool, Parallel, false)
+
+private:
+    Viewport* m_Viewport;
+};
+
+} // namespace Vtk
+} // namespace uLib
+
+#endif // ULIB_VTK_VIEWPORTPROPERTIES_H