uLib/app/gcompose/src/MainPanel.cpp

#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 <QVBoxLayout>
#include <QHBoxLayout>
#include <QSplitter>
#include <QLabel>
#include <QPushButton>
#include <QMenu>
#include <QAction>
#include <QApplication>
#include "StyleManager.h"

MainPanel::MainPanel(QWidget* parent) : QWidget(parent), m_context(nullptr), m_mainVtkContext(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->addAction("Exit", this, &MainPanel::onExit);
    btnFile->setMenu(fileMenu);

    // Theme Menu Button
    auto* btnTheme = new QPushButton("Theme", menuPanel);
    btnTheme->setObjectName("MenuButton");
    auto* themeMenu = new QMenu(btnTheme);
    themeMenu->addAction("Dark", this, &MainPanel::onDarkTheme);
    themeMenu->addAction("Bright", this, &MainPanel::onBrightTheme);
    btnTheme->setMenu(themeMenu);

    // 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->addWidget(btnTheme);
    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::Puppet* puppet = nullptr;
            if (m_mainVtkContext) {
                puppet = m_mainVtkContext->GetPuppet(obj);
            }
            viewport->SelectPuppet(puppet);
            // Update the display properties in the viewport pane itself - use the puppet proxy if possible
            m_firstPane->setObject(puppet ? (uLib::Object*)puppet : obj);
        } else {
            m_firstPane->setObject(obj);
        }
    });

    // 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);
}

void MainPanel::setContext(uLib::ObjectsContext* context) {
    m_context = context;
    m_contextPanel->setContext(context);

    if (m_mainVtkContext) {
        if (auto* viewport = qobject_cast<uLib::Vtk::QViewport*>(m_firstPane->currentViewport())) {
            viewport->RemovePuppet(*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::vtkObjectsContext(context);
            // viewport->AddPuppet(*m_mainVtkContext); // redundant

            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetAdded, [this](uLib::Vtk::Puppet* p) {
                if (p) {
                    auto panes = this->findChildren<ViewportPane*>();
                    for (auto* pane : panes) {
                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
                            vp->AddPuppet(*p);
                            vp->ZoomAuto();
                            vp->Render();
                        }
                    }
                }
            });

            uLib::Object::connect(m_mainVtkContext, &uLib::Vtk::vtkObjectsContext::PuppetRemoved, [this](uLib::Vtk::Puppet* p) {
                if (p) {
                    auto panes = this->findChildren<ViewportPane*>();
                    for (auto* pane : panes) {
                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
                            vp->RemovePuppet(*p);
                            vp->Render();
                        }
                    }
                }
            });

            // Add any puppets that were created during m_mainVtkContext's construction to all panes
            auto panes = this->findChildren<ViewportPane*>();
            for (auto* obj : context->GetObjects()) {
                if (auto* p = m_mainVtkContext->GetPuppet(obj)) {
                    for (auto* pane : panes) {
                        if (auto* vp = qobject_cast<uLib::Vtk::QViewport*>(pane->currentViewport())) {
                            vp->AddPuppet(*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() {
    // Placeholder for open logic
}

void MainPanel::onSave() {
    // Placeholder for save logic
}

void MainPanel::onSaveAs() {
    // Placeholder for save as logic
}

void MainPanel::onExit() {
    qApp->quit();
}

void MainPanel::onDarkTheme() {
    StyleManager::applyStyle(qApp, "dark");
}

void MainPanel::onBrightTheme() {
    StyleManager::applyStyle(qApp, "bright");
}

MainPanel::~MainPanel() {}