MainPanel.cpp

Go to the documentation of this file.

#include "Panels/MainPanel.h"
#include "Core/Node.h"
#include "Parsers/ProjectManager.h"
#include "Scenes/BehaviorTreeScene.h"
#include "Utils/AppPreferences.h"
#include "Utils/CustomTabArt.h"
#include "Utils/Logger.h"
#include "Utils/ResourcePath.h"
#include <wx/artprov.h>
#include <wx/filename.h>
#include <wx/menu.h>
#include <wx/statline.h>
#include <wx/textdlg.h>
 
wxBEGIN_EVENT_TABLE(MainPanel, EmberUI::Panel) EVT_AUINOTEBOOK_PAGE_CHANGED(ID_SCENE_NOTEBOOK, MainPanel::OnTabChanged)
    EVT_AUINOTEBOOK_PAGE_CLOSE(ID_SCENE_NOTEBOOK, MainPanel::OnTabClosed)
        EVT_BUTTON(ID_NEW_SCENE_BUTTON, MainPanel::OnNewSceneButton)
            EVT_BUTTON(ID_OVERLAY_BUTTON, MainPanel::OnOverlayButton) wxEND_EVENT_TABLE()
 
                MainPanel::MainPanel(wxWindow *parent)
    : EmberUI::Panel(parent, "MainPanel"), m_activeSceneIndex(-1), m_nextSceneNumber(1) {
    SetTitle("Scene");
    SetPanelType("Scene");
    SetBackgroundColour(wxColour(50, 50, 50)); // Dark like most editors
    DoCreateLayout();                          // Non-virtual: safe to call from constructor
}
 
void MainPanel::CreateLayout() {
    DoCreateLayout(); // Virtual dispatch works when called at runtime (e.g. from Panel::Initialize)
}
 
void MainPanel::DoCreateLayout() {
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    DoCreateToolbar();
 
    m_book = new wxSimplebook(this, wxID_ANY);
 
    m_welcomePanel = CreateWelcomePanel();
    m_book->AddPage(m_welcomePanel, "Welcome");
 
    auto *scenePage = new wxPanel(m_book, wxID_ANY);
    scenePage->SetBackgroundColour(wxColour(50, 50, 50));
    auto *sceneSizer = new wxBoxSizer(wxVERTICAL);
 
    m_sceneNotebook = new wxAuiNotebook(scenePage, ID_SCENE_NOTEBOOK, wxDefaultPosition, wxDefaultSize,
                                        wxAUI_NB_DEFAULT_STYLE | wxAUI_NB_CLOSE_ON_ACTIVE_TAB);
    m_sceneNotebook->SetBackgroundColour(wxColour(50, 50, 50));
    m_sceneNotebook->SetArtProvider(new EmberForge::CustomTabArt());
 
    sceneSizer->Add(m_sceneNotebook, 1, wxEXPAND);
    scenePage->SetSizer(sceneSizer);
 
    m_book->AddPage(scenePage, "Scenes");
 
    sizer->Add(m_toolbar, 0, wxEXPAND | wxALL, 2);
    sizer->Add(m_book, 1, wxEXPAND | wxALL, 5);
 
    SetSizer(sizer);
 
    ShowWelcome();
}
 
wxPanel *MainPanel::CreateWelcomePanel() {
    const wxColour bgColour(42, 42, 42);
    const wxColour btnNormal(60, 60, 60);
    const wxColour btnHover(80, 80, 80);
    const wxColour btnPressed(45, 45, 45);
    const wxColour entryNormal(50, 50, 50);
    const wxColour entryHover(65, 65, 65);
    const wxColour entryPressed(40, 40, 40);
 
    auto *panel = new wxPanel(m_book, wxID_ANY);
    panel->SetBackgroundColour(bgColour);
 
    auto *rootSizer = new wxBoxSizer(wxVERTICAL);
    rootSizer->AddStretchSpacer(1);
 
    auto *centerSizer = new wxBoxSizer(wxVERTICAL);
 
    // --- Action Buttons ---
    auto bindButtonHighlight = [=](wxButton *btn) {
        btn->Bind(wxEVT_ENTER_WINDOW, [btn, btnHover](wxMouseEvent &e) {
            btn->SetBackgroundColour(btnHover);
            btn->Refresh();
            e.Skip();
        });
        btn->Bind(wxEVT_LEAVE_WINDOW, [btn, btnNormal](wxMouseEvent &e) {
            btn->SetBackgroundColour(btnNormal);
            btn->Refresh();
            e.Skip();
        });
        btn->Bind(wxEVT_LEFT_DOWN, [btn, btnPressed](wxMouseEvent &e) {
            btn->SetBackgroundColour(btnPressed);
            btn->Refresh();
            e.Skip();
        });
        btn->Bind(wxEVT_LEFT_UP, [btn, btnHover](wxMouseEvent &e) {
            btn->SetBackgroundColour(btnHover);
            btn->Refresh();
            e.Skip();
        });
    };
 
    auto makeButton = [&](wxPanel *parent, const wxString &label) -> wxButton * {
        auto *btn = new wxButton(parent, wxID_ANY, label, wxDefaultPosition, wxSize(220, 36));
        btn->SetBackgroundColour(btnNormal);
        btn->SetForegroundColour(wxColour(210, 210, 210));
        btn->SetFont(wxFont(11, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        btn->SetCursor(wxCursor(wxCURSOR_HAND));
        bindButtonHighlight(btn);
        return btn;
    };
 
    auto *newProjectBtn = makeButton(panel, "New Project");
    centerSizer->Add(newProjectBtn, 0, wxALIGN_CENTER_HORIZONTAL);
 
    auto *openProjectBtn = makeButton(panel, "Open Project");
    centerSizer->Add(openProjectBtn, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 6);
 
    auto *docsBtn = makeButton(panel, "Documentation");
    centerSizer->Add(docsBtn, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 6);
 
    newProjectBtn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        if (m_welcomeActionCallback)
            m_welcomeActionCallback("new_project", "");
    });
    openProjectBtn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        if (m_welcomeActionCallback)
            m_welcomeActionCallback("open_project", "");
    });
    docsBtn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        if (m_welcomeActionCallback)
            m_welcomeActionCallback("docs", "");
    });
 
    centerSizer->AddSpacer(30);
 
    // --- Recent Projects ---
    auto *recentHeader = new wxStaticText(panel, wxID_ANY, "Recent Projects");
    recentHeader->SetForegroundColour(wxColour(180, 180, 180));
    recentHeader->SetFont(wxFont(12, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
    centerSizer->Add(recentHeader, 0, wxALIGN_CENTER_HORIZONTAL);
 
    auto *line = new wxStaticLine(panel, wxID_ANY, wxDefaultPosition, wxSize(300, 1));
    centerSizer->Add(line, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP | wxBOTTOM, 6);
 
    const auto &recentProjects = EmberCore::ProjectManager::GetInstance().GetRecentProjects();
 
    if (recentProjects.empty()) {
        auto *emptyLabel = new wxStaticText(panel, wxID_ANY, "No recent projects");
        emptyLabel->SetForegroundColour(wxColour(100, 100, 100));
        emptyLabel->SetFont(wxFont(10, wxFONTFAMILY_SWISS, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_NORMAL));
        centerSizer->Add(emptyLabel, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 4);
    } else {
        auto bindEntryHighlight = [=](wxPanel *ep) {
            ep->Bind(wxEVT_ENTER_WINDOW, [ep, entryHover](wxMouseEvent &e) {
                ep->SetBackgroundColour(entryHover);
                ep->Refresh();
                e.Skip();
            });
            ep->Bind(wxEVT_LEAVE_WINDOW, [ep, entryNormal](wxMouseEvent &e) {
                ep->SetBackgroundColour(entryNormal);
                ep->Refresh();
                e.Skip();
            });
            ep->Bind(wxEVT_LEFT_DOWN, [ep, entryPressed](wxMouseEvent &e) {
                ep->SetBackgroundColour(entryPressed);
                ep->Refresh();
                e.Skip();
            });
            ep->Bind(wxEVT_LEFT_UP, [ep, entryHover](wxMouseEvent &e) {
                ep->SetBackgroundColour(entryHover);
                ep->Refresh();
                e.Skip();
            });
        };
 
        for (const auto &projectPath : recentProjects) {
            wxFileName fn(wxString::FromUTF8(projectPath));
            wxString projectName = fn.GetName();
            wxString displayPath = fn.GetFullPath();
 
            auto *entryPanel = new wxPanel(panel, wxID_ANY);
            entryPanel->SetBackgroundColour(entryNormal);
            entryPanel->SetMinSize(wxSize(400, -1));
 
            auto *entrySizer = new wxBoxSizer(wxVERTICAL);
 
            auto *nameLabel = new wxStaticText(entryPanel, wxID_ANY, projectName);
            nameLabel->SetForegroundColour(wxColour(100, 180, 255));
            nameLabel->SetFont(wxFont(11, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
            entrySizer->Add(nameLabel, 0, wxLEFT | wxTOP, 6);
 
            auto *pathLabel = new wxStaticText(entryPanel, wxID_ANY, displayPath);
            pathLabel->SetForegroundColour(wxColour(120, 120, 120));
            pathLabel->SetFont(wxFont(8, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
            entrySizer->Add(pathLabel, 0, wxLEFT | wxBOTTOM, 6);
 
            entryPanel->SetSizer(entrySizer);
 
            std::string path = projectPath;
            entryPanel->SetCursor(wxCursor(wxCURSOR_HAND));
            nameLabel->SetCursor(wxCursor(wxCURSOR_HAND));
            pathLabel->SetCursor(wxCursor(wxCURSOR_HAND));
 
            bindEntryHighlight(entryPanel);
 
            auto clickHandler = [this, path](wxMouseEvent &e) {
                if (m_welcomeActionCallback)
                    m_welcomeActionCallback("open_recent", path);
                e.Skip();
            };
            entryPanel->Bind(wxEVT_LEFT_UP, clickHandler);
            nameLabel->Bind(wxEVT_LEFT_UP, clickHandler);
            pathLabel->Bind(wxEVT_LEFT_UP, clickHandler);
 
            // Forward mouse enter/leave from child labels so the panel highlights properly
            nameLabel->Bind(wxEVT_ENTER_WINDOW, [entryPanel, entryHover](wxMouseEvent &e) {
                entryPanel->SetBackgroundColour(entryHover);
                entryPanel->Refresh();
                e.Skip();
            });
            nameLabel->Bind(wxEVT_LEAVE_WINDOW, [entryPanel, entryNormal](wxMouseEvent &e) {
                wxPoint pos = entryPanel->ScreenToClient(wxGetMousePosition());
                if (!entryPanel->GetRect().Contains(entryPanel->GetPosition() + pos))
                    entryPanel->SetBackgroundColour(entryNormal);
                entryPanel->Refresh();
                e.Skip();
            });
            pathLabel->Bind(wxEVT_ENTER_WINDOW, [entryPanel, entryHover](wxMouseEvent &e) {
                entryPanel->SetBackgroundColour(entryHover);
                entryPanel->Refresh();
                e.Skip();
            });
            pathLabel->Bind(wxEVT_LEAVE_WINDOW, [entryPanel, entryNormal](wxMouseEvent &e) {
                wxPoint pos = entryPanel->ScreenToClient(wxGetMousePosition());
                if (!entryPanel->GetRect().Contains(entryPanel->GetPosition() + pos))
                    entryPanel->SetBackgroundColour(entryNormal);
                entryPanel->Refresh();
                e.Skip();
            });
 
            centerSizer->Add(entryPanel, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 4);
        }
    }
 
    rootSizer->Add(centerSizer, 0, wxALIGN_CENTER_HORIZONTAL);
    rootSizer->AddStretchSpacer(1);
 
    // Version label anchored bottom-right
    auto *versionLabel = new wxStaticText(panel, wxID_ANY, "v1.0.0");
    versionLabel->SetForegroundColour(wxColour(100, 100, 100));
    versionLabel->SetFont(wxFont(9, wxFONTFAMILY_SWISS, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_NORMAL));
    rootSizer->Add(versionLabel, 0, wxALIGN_RIGHT | wxRIGHT | wxBOTTOM, 10);
 
    panel->SetSizer(rootSizer);
    return panel;
}
 
void MainPanel::ShowWelcome() {
    if (m_book) {
        m_book->SetSelection(0);
    }
    if (m_toolbar) {
        m_toolbar->Hide();
        Layout();
    }
}
 
void MainPanel::ShowScenes() {
    if (m_book) {
        m_book->SetSelection(1);
    }
    if (m_toolbar) {
        m_toolbar->Show();
        Layout();
    }
}
 
void MainPanel::CreateToolbar() {
    DoCreateToolbar(); // Virtual dispatch works when called at runtime
}
 
void MainPanel::DoCreateToolbar() {
    m_toolbar =
        new wxToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_HORIZONTAL | wxTB_FLAT | wxTB_NODIVIDER);
    m_toolbar->SetBackgroundColour(wxColour(60, 60, 60));
    m_toolbar->SetToolBitmapSize(wxSize(22, 22));
 
    wxString resPath = EmberForge::ResourcePath::GetDir("buttons");
 
    wxBitmap newNormal(resPath + "new_scene/NewScene_Normal_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap newHovered(resPath + "new_scene/NewScene_Hovered_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap newPressed(resPath + "new_scene/NewScene_Pressed_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap newDisabled(resPath + "new_scene/NewScene_Disabled_22.png", wxBITMAP_TYPE_PNG);
 
    auto *newSceneBtn = new wxBitmapButton(m_toolbar, ID_NEW_SCENE_BUTTON, newNormal, wxDefaultPosition, wxSize(32, 32),
                                           wxBORDER_NONE | wxBU_EXACTFIT);
    newSceneBtn->SetBitmapHover(newHovered);
    newSceneBtn->SetBitmapPressed(newPressed);
    newSceneBtn->SetBitmapDisabled(newDisabled);
    newSceneBtn->SetToolTip("Create a new empty behavior tree scene");
    m_toolbar->AddControl(newSceneBtn);
 
    wxBitmap ovNormal(resPath + "overlay/Overlay_Normal_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap ovHovered(resPath + "overlay/Overlay_Hovered_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap ovPressed(resPath + "overlay/Overlay_Pressed_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap ovDisabled(resPath + "overlay/Overlay_Disabled_22.png", wxBITMAP_TYPE_PNG);
 
    auto *overlayBtn = new wxBitmapButton(m_toolbar, ID_OVERLAY_BUTTON, ovPressed, wxDefaultPosition, wxSize(32, 32),
                                          wxBORDER_NONE | wxBU_EXACTFIT);
    overlayBtn->SetBitmapHover(ovHovered);
    overlayBtn->SetBitmapPressed(ovPressed);
    overlayBtn->SetBitmapDisabled(ovDisabled);
    overlayBtn->SetToolTip("Overlay settings");
    m_toolbar->AddControl(overlayBtn);
 
    m_toolbar->Realize();
 
    UpdateOverlayButtonState();
}
 
int MainPanel::AddScene(std::unique_ptr<IScene> scene) {
    if (!scene)
        return -1;
 
    // Check scene limit from preferences
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    int maxScenes = prefs.GetMainPanelSettings().maxScenes;
 
    if (maxScenes > 0 && static_cast<int>(m_scenes.size()) >= maxScenes) {
        wxMessageBox(
            wxString::Format("Maximum number of scenes (%d) reached.\nClose some scenes before creating new ones.",
                             maxScenes),
            "Scene Limit Reached", wxOK | wxICON_WARNING);
        return -1;
    }
 
    // Add the scene's panel to the notebook
    int index = m_sceneNotebook->GetPageCount();
    m_sceneNotebook->AddPage(scene->GetPanel(), scene->GetTitle(), true); // true = make active
 
    // Store the scene
    m_scenes.push_back(std::move(scene));
 
    // If this is the first scene, make it active
    if (m_scenes.size() == 1) {
        m_activeSceneIndex = 0;
        m_scenes[0]->OnActivated();
    } else {
        // Update active scene index to the new scene
        m_activeSceneIndex = index;
        m_scenes[m_activeSceneIndex]->OnActivated();
    }
 
    return index;
}
 
int MainPanel::InsertScene(int insertIdx, std::unique_ptr<IScene> scene) {
    if (!scene)
        return -1;
 
    if (insertIdx < 0)
        insertIdx = 0;
    if (insertIdx > static_cast<int>(m_scenes.size()))
        insertIdx = static_cast<int>(m_scenes.size());
 
    m_sceneNotebook->InsertPage(insertIdx, scene->GetPanel(), scene->GetTitle(), false);
    m_scenes.insert(m_scenes.begin() + insertIdx, std::move(scene));
 
    if (m_activeSceneIndex >= insertIdx)
        m_activeSceneIndex++;
 
    return insertIdx;
}
 
bool MainPanel::RemoveScene(int index, bool force) {
    if (index < 0 || index >= static_cast<int>(m_scenes.size())) {
        return false;
    }
 
    if (!force && m_scenes[index]->HasUnsavedChanges()) {
        wxMessageDialog dialog(
            this, wxString::Format("Scene '%s' has unsaved changes. Close anyway?", m_scenes[index]->GetTitle()),
            "Unsaved Changes", wxYES_NO | wxICON_QUESTION);
        if (dialog.ShowModal() != wxID_YES) {
            return false;
        }
    }
 
    std::unique_ptr<IScene> sceneToRemove = std::move(m_scenes[index]);
 
    if (index == m_activeSceneIndex) {
        sceneToRemove->OnDeactivated();
    }
 
    m_scenes.erase(m_scenes.begin() + index);
 
    if (m_scenes.empty()) {
        m_activeSceneIndex = -1;
    } else if (index == m_activeSceneIndex) {
        if (index >= static_cast<int>(m_scenes.size())) {
            m_activeSceneIndex = static_cast<int>(m_scenes.size()) - 1;
        } else {
            m_activeSceneIndex = index;
        }
        if (m_activeSceneIndex >= 0) {
            m_scenes[m_activeSceneIndex]->OnActivated();
        }
    } else if (index < m_activeSceneIndex) {
        m_activeSceneIndex--;
    }
 
    // Destroy the scene object FIRST while its child widgets are still alive,
    // so the destructor can safely clear callbacks on those widgets.
    sceneToRemove.reset();
 
    // Now remove the notebook page, which destroys the (already-cleaned-up) widgets.
    m_sceneNotebook->DeletePage(index);
 
    return true;
}
 
IScene *MainPanel::GetActiveScene() const {
    if (m_activeSceneIndex >= 0 && m_activeSceneIndex < static_cast<int>(m_scenes.size())) {
        return m_scenes[m_activeSceneIndex].get();
    }
    return nullptr;
}
 
IScene *MainPanel::GetScene(int index) const {
    if (index >= 0 && index < static_cast<int>(m_scenes.size())) {
        return m_scenes[index].get();
    }
    return nullptr;
}
 
bool MainPanel::SetActiveScene(int index) {
    if (index < 0 || index >= static_cast<int>(m_scenes.size())) {
        return false;
    }
 
    if (index == m_activeSceneIndex) {
        return true; // Already active
    }
 
    // Deactivate current scene
    if (m_activeSceneIndex >= 0 && m_activeSceneIndex < static_cast<int>(m_scenes.size())) {
        m_scenes[m_activeSceneIndex]->OnDeactivated();
    }
 
    // Set new active scene
    m_activeSceneIndex = index;
    m_sceneNotebook->SetSelection(index);
    m_scenes[m_activeSceneIndex]->OnActivated();
 
    return true;
}
 
int MainPanel::CreateNewScene() {
    // Create a new empty behavior tree scene
    wxString title = GenerateSceneTitle();
    auto newScene = std::make_unique<BehaviorTreeScene>(m_sceneNotebook, title);
 
    // Add the scene to the panel
    int index = AddScene(std::move(newScene));
 
    // Only log if scene was successfully added
    if (index != -1) {
        LOG_INFO("MainPanel", "Created new scene: " + std::string(title.mb_str()));
    }
 
    return index;
}
 
wxString MainPanel::GenerateSceneTitle() const {
    wxString title;
    bool titleExists = false;
 
    do {
        title = wxString::Format("Scene %d", m_nextSceneNumber);
        titleExists = false;
 
        // Check if title already exists
        for (const auto &scene : m_scenes) {
            if (scene->GetTitle() == title) {
                titleExists = true;
                break;
            }
        }
 
        if (titleExists) {
            const_cast<MainPanel *>(this)->m_nextSceneNumber++;
        }
    } while (titleExists);
 
    const_cast<MainPanel *>(this)->m_nextSceneNumber++;
    return title;
}
 
bool MainPanel::SceneTitleExists(const wxString &title) const {
    for (const auto &scene : m_scenes) {
        if (scene->GetTitle() == title) {
            return true;
        }
    }
    return false;
}
 
int MainPanel::CreateNewScene(const wxString &customTitle) {
    // Create a new empty behavior tree scene with custom title
    auto newScene = std::make_unique<BehaviorTreeScene>(m_sceneNotebook, customTitle);
 
    // Add the scene to the panel
    int index = AddScene(std::move(newScene));
 
    // Only log if scene was successfully added
    if (index != -1) {
        LOG_INFO("MainPanel", "Created new scene: " + std::string(customTitle.mb_str()));
    }
 
    return index;
}
 
void MainPanel::UpdateActiveSceneTitle(const wxString &newTitle) {
    if (m_activeSceneIndex < 0 || m_activeSceneIndex >= static_cast<int>(m_scenes.size())) {
        return;
    }
 
    // Update the scene's internal title
    auto *behaviorTreeScene = dynamic_cast<BehaviorTreeScene *>(m_scenes[m_activeSceneIndex].get());
    if (behaviorTreeScene) {
        behaviorTreeScene->SetTitle(newTitle);
    }
 
    // Update the notebook tab text
    m_sceneNotebook->SetPageText(m_activeSceneIndex, newTitle);
 
    LOG_INFO("MainPanel", "Updated scene title to: " + std::string(newTitle.mb_str()));
}
 
void MainPanel::OnTabChanged(wxAuiNotebookEvent &event) {
    if (m_isClosingTab) {
        event.Skip();
        return;
    }
 
    int newIndex = event.GetSelection();
 
    // Deactivate current scene
    if (m_activeSceneIndex >= 0 && m_activeSceneIndex < static_cast<int>(m_scenes.size())) {
        m_scenes[m_activeSceneIndex]->OnDeactivated();
    }
 
    // Activate new scene
    m_activeSceneIndex = newIndex;
    IScene *newScene = nullptr;
    if (m_activeSceneIndex >= 0 && m_activeSceneIndex < static_cast<int>(m_scenes.size())) {
        m_scenes[m_activeSceneIndex]->OnActivated();
        newScene = m_scenes[m_activeSceneIndex].get();
    }
 
    // Notify listeners about scene change
    if (m_sceneChangedCallback) {
        m_sceneChangedCallback(newScene, m_activeSceneIndex);
    }
 
    event.Skip();
}
 
void MainPanel::OnNewSceneButton(wxCommandEvent &event) {
    // Show dialog to get scene name from user
    wxTextEntryDialog dialog(this, "Enter a name for the new scene:", "New Scene", GenerateSceneTitle());
 
    if (dialog.ShowModal() == wxID_OK) {
        wxString sceneName = dialog.GetValue().Trim();
 
        // Validate the scene name
        if (sceneName.IsEmpty()) {
            wxMessageBox("Scene name cannot be empty!", "Invalid Name", wxOK | wxICON_WARNING, this);
            return;
        }
 
        // Check if name already exists
        if (SceneTitleExists(sceneName)) {
            wxMessageBox(
                wxString::Format("A scene named '%s' already exists!\nPlease choose a different name.", sceneName),
                "Duplicate Name", wxOK | wxICON_WARNING, this);
            return;
        }
 
        // Create the scene with the custom name
        CreateNewScene(sceneName);
    }
}
 
void MainPanel::OnTabClosed(wxAuiNotebookEvent &event) {
    int index = event.GetSelection();
 
    if (index < 0 || index >= static_cast<int>(m_scenes.size())) {
        wxLogError("Invalid tab close index: %d (have %zu scenes)", index, m_scenes.size());
        event.Veto();
        return;
    }
 
    if (!m_scenes[index]->IsClosable()) {
        event.Veto();
        return;
    }
 
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    auto closeConfirmMode = prefs.GetMainPanelSettings().closeConfirmation;
 
    bool shouldAsk = false;
    wxString message;
 
    if (closeConfirmMode == EmberForge::AppPreferences::CloseConfirmationMode::AlwaysAsk) {
        shouldAsk = true;
        if (m_scenes[index]->HasUnsavedChanges()) {
            message = wxString::Format("Scene '%s' has unsaved changes. Close anyway?", m_scenes[index]->GetTitle());
        } else {
            message = wxString::Format("Close scene '%s'?", m_scenes[index]->GetTitle());
        }
    } else if (closeConfirmMode == EmberForge::AppPreferences::CloseConfirmationMode::AskIfUnsaved) {
        if (m_scenes[index]->HasUnsavedChanges()) {
            shouldAsk = true;
            message = wxString::Format("Scene '%s' has unsaved changes. Close anyway?", m_scenes[index]->GetTitle());
        }
    }
 
    if (shouldAsk) {
        wxMessageDialog dialog(this, message, "Close Scene", wxYES_NO | wxICON_QUESTION);
        if (dialog.ShowModal() != wxID_YES) {
            event.Veto();
            return;
        }
    }
 
    m_isClosingTab = true;
 
    std::unique_ptr<IScene> sceneToCleanup = std::move(m_scenes[index]);
 
    if (index == m_activeSceneIndex) {
        sceneToCleanup->OnDeactivated();
    }
 
    m_scenes.erase(m_scenes.begin() + index);
 
    if (m_scenes.empty()) {
        m_activeSceneIndex = -1;
    } else if (index == m_activeSceneIndex) {
        if (index >= static_cast<int>(m_scenes.size())) {
            m_activeSceneIndex = static_cast<int>(m_scenes.size()) - 1;
        } else {
            m_activeSceneIndex = index;
        }
    } else if (index < m_activeSceneIndex) {
        m_activeSceneIndex--;
    }
 
    sceneToCleanup.reset();
 
    m_isClosingTab = false;
 
    if (m_activeSceneIndex >= 0 && m_activeSceneIndex < static_cast<int>(m_scenes.size())) {
        m_scenes[m_activeSceneIndex]->OnActivated();
        if (m_sceneChangedCallback) {
            m_sceneChangedCallback(m_scenes[m_activeSceneIndex].get(), m_activeSceneIndex);
        }
    } else if (m_sceneChangedCallback) {
        m_sceneChangedCallback(nullptr, -1);
    }
}
 
void MainPanel::ApplyCanvasBackgroundColor(const wxColour &color) {
    // Apply to all existing scenes
    for (auto &scene : m_scenes) {
        if (scene) {
            BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(scene.get());
            if (btScene) {
                btScene->SetCanvasBackgroundColor(color);
            }
        }
    }
}
 
void MainPanel::SwitchToNextScene() {
    if (m_scenes.empty() || !m_sceneNotebook)
        return;
 
    int currentSelection = m_sceneNotebook->GetSelection();
    int nextSelection = (currentSelection + 1) % m_sceneNotebook->GetPageCount();
    m_sceneNotebook->SetSelection(nextSelection);
}
 
void MainPanel::SwitchToPreviousScene() {
    if (m_scenes.empty() || !m_sceneNotebook)
        return;
 
    int currentSelection = m_sceneNotebook->GetSelection();
    int pageCount = m_sceneNotebook->GetPageCount();
    int prevSelection = (currentSelection - 1 + pageCount) % pageCount;
    m_sceneNotebook->SetSelection(prevSelection);
}
 
void MainPanel::OnOverlayButton(wxCommandEvent &) {
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    auto &mainPanel = prefs.GetMainPanelSettings();
    auto &btView = prefs.GetBehaviorTreeViewSettings();
 
    wxMenu menu;
 
    menu.Append(ID_OVERLAY_SHOW_ALL, "Show All");
    menu.Append(ID_OVERLAY_HIDE_ALL, "Hide All");
    menu.AppendSeparator();
 
    menu.AppendCheckItem(ID_OVERLAY_GRID, "Show Grid")->Check(mainPanel.showGrid);
    menu.AppendCheckItem(ID_OVERLAY_MINIMAP, "Show Minimap")->Check(mainPanel.showMinimap);
    menu.AppendCheckItem(ID_OVERLAY_BREADCRUMB, "Show Breadcrumb")->Check(mainPanel.showCanvasBreadcrumb);
    menu.AppendSeparator();
 
    menu.AppendCheckItem(ID_OVERLAY_COORDINATE, "Show Coordinate Info")->Check(btView.showCoordinateInfo);
    menu.AppendCheckItem(ID_OVERLAY_SELECTED_NODE, "Show Selected Node Info")->Check(btView.showSelectedNodeInfo);
    menu.AppendCheckItem(ID_OVERLAY_TREE_INFO, "Show Tree Info")->Check(btView.showTreeInfo);
    menu.AppendCheckItem(ID_OVERLAY_FPS, "Show FPS Counter")->Check(btView.showFPS);
    menu.AppendCheckItem(ID_OVERLAY_CONTROLS_HELP, "Show Controls Help")->Check(btView.showControlsHelp);
 
    menu.Bind(wxEVT_MENU, &MainPanel::OnOverlayMenuItem, this);
    PopupMenu(&menu);
}
 
void MainPanel::OnOverlayMenuItem(wxCommandEvent &event) {
    auto &prefMgr = EmberForge::AppPreferencesManager::GetInstance();
    auto &prefs = prefMgr.GetPreferences();
    auto &mp = prefs.GetMainPanelSettings();
    auto &btv = prefs.GetBehaviorTreeViewSettings();
 
    int id = event.GetId();
 
    if (id == ID_OVERLAY_SHOW_ALL || id == ID_OVERLAY_HIDE_ALL) {
        bool val = (id == ID_OVERLAY_SHOW_ALL);
        mp.showGrid = val;
        mp.showMinimap = val;
        mp.showCanvasBreadcrumb = val;
        btv.showCoordinateInfo = val;
        btv.showSelectedNodeInfo = val;
        btv.showTreeInfo = val;
        btv.showFPS = val;
        btv.showControlsHelp = val;
    } else if (id == ID_OVERLAY_GRID) {
        mp.showGrid = !mp.showGrid;
    } else if (id == ID_OVERLAY_MINIMAP) {
        mp.showMinimap = !mp.showMinimap;
    } else if (id == ID_OVERLAY_BREADCRUMB) {
        mp.showCanvasBreadcrumb = !mp.showCanvasBreadcrumb;
    } else if (id == ID_OVERLAY_COORDINATE) {
        btv.showCoordinateInfo = !btv.showCoordinateInfo;
    } else if (id == ID_OVERLAY_SELECTED_NODE) {
        btv.showSelectedNodeInfo = !btv.showSelectedNodeInfo;
    } else if (id == ID_OVERLAY_TREE_INFO) {
        btv.showTreeInfo = !btv.showTreeInfo;
    } else if (id == ID_OVERLAY_FPS) {
        btv.showFPS = !btv.showFPS;
    } else if (id == ID_OVERLAY_CONTROLS_HELP) {
        btv.showControlsHelp = !btv.showControlsHelp;
    }
 
    ApplyOverlayToActiveCanvas();
    UpdateOverlayButtonState();
 
    std::string configPath = EmberForge::AppPreferences::GetDefaultConfigPath();
    prefs.SaveToFile(configPath);
}
 
void MainPanel::ApplyOverlayToActiveCanvas() {
    IScene *scene = GetActiveScene();
    if (!scene)
        return;
 
    auto *btScene = dynamic_cast<BehaviorTreeScene *>(scene);
    if (!btScene)
        return;
 
    auto *canvas = btScene->GetTreeVisualization();
    if (!canvas)
        return;
 
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mp = prefs.GetMainPanelSettings();
 
    canvas->SetShowGrid(mp.showGrid);
    canvas->SetShowMinimap(mp.showMinimap);
    canvas->SetShowBreadcrumb(mp.showCanvasBreadcrumb);
    canvas->Refresh();
}
 
void MainPanel::UpdateOverlayButtonState() {
    if (!m_toolbar)
        return;
 
    auto *win = m_toolbar->FindWindow(ID_OVERLAY_BUTTON);
    if (!win)
        return;
 
    auto *btn = dynamic_cast<wxBitmapButton *>(win);
    if (!btn)
        return;
 
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mp = prefs.GetMainPanelSettings();
    const auto &btv = prefs.GetBehaviorTreeViewSettings();
 
    bool anyOn = mp.showGrid || mp.showMinimap || mp.showCanvasBreadcrumb || btv.showCoordinateInfo ||
                 btv.showSelectedNodeInfo || btv.showTreeInfo || btv.showFPS || btv.showControlsHelp;
 
    wxString resPath = EmberForge::ResourcePath::GetDir("buttons");
    if (anyOn) {
        btn->SetBitmap(wxBitmap(resPath + "overlay/Overlay_Pressed_22.png", wxBITMAP_TYPE_PNG));
    } else {
        btn->SetBitmap(wxBitmap(resPath + "overlay/Overlay_Normal_22.png", wxBITMAP_TYPE_PNG));
    }
}