SceneContainer.cpp

Go to the documentation of this file.

#include "Components/SceneContainer.h"
#include <algorithm>
#include <wx/sizer.h>
 
namespace EmberForge {
namespace ui {
 
// Event table
wxBEGIN_EVENT_TABLE(SceneContainer,
                    wxPanel) EVT_SIZE(SceneContainer::OnSize) EVT_PAINT(SceneContainer::OnPaint) wxEND_EVENT_TABLE()
 
    SceneContainer::SceneContainer(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style)
    : wxPanel(parent, id, pos, size, style), m_maxInactiveScenes(3), m_enableTransitions(true), m_sizer(nullptr) {
    // Create main sizer
    m_sizer = new wxBoxSizer(wxVERTICAL);
    SetSizer(m_sizer);
}
 
SceneContainer::~SceneContainer() { RemoveAllScenes(); }
 
bool SceneContainer::AddScene(std::unique_ptr<IScene> scene, const wxString &name, const wxString &description) {
    if (!scene || name.IsEmpty() || HasScene(name)) {
        return false;
    }
 
    // Get the scene panel
    wxPanel *scenePanel = scene->GetPanel();
    if (!scenePanel) {
        return false;
    }
 
    // Hide initially
    scenePanel->Hide();
 
    // Add to sizer
    m_sizer->Add(scenePanel, 1, wxEXPAND);
 
    // Store scene info
    SceneInfo sceneInfo(std::move(scene), name);
    sceneInfo.description = description;
    m_scenes.emplace(name, std::move(sceneInfo));
 
    // Notify callback
    NotifySceneCreated(name);
 
    return true;
}
 
bool SceneContainer::RemoveScene(const wxString &name) {
    auto it = m_scenes.find(name);
    if (it == m_scenes.end()) {
        return false;
    }
 
    // If this is the active scene, deactivate it
    if (m_activeSceneName == name) {
        if (it->second.scene) {
            it->second.scene->OnDeactivated();
        }
        m_activeSceneName.Clear();
    }
 
    // Notify callback before removal
    NotifySceneDestroyed(name);
 
    // Remove from UI
    wxPanel *scenePanel = it->second.scene->GetPanel();
    if (scenePanel) {
        m_sizer->Detach(scenePanel);
        scenePanel->Destroy();
    }
 
    // Remove from container
    m_scenes.erase(it);
 
    Layout();
    return true;
}
 
void SceneContainer::RemoveAllScenes() {
    // Copy scene names to avoid iterator invalidation
    std::vector<wxString> sceneNames;
    for (const auto &pair : m_scenes) {
        sceneNames.push_back(pair.first);
    }
 
    // Remove all scenes
    for (const auto &name : sceneNames) {
        RemoveScene(name);
    }
}
 
IScene *SceneContainer::GetScene(const wxString &name) const {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        return it->second.scene.get();
    }
    return nullptr;
}
 
IScene *SceneContainer::GetActiveScene() const {
    if (!m_activeSceneName.IsEmpty()) {
        return GetScene(m_activeSceneName);
    }
    return nullptr;
}
 
wxString SceneContainer::GetActiveSceneName() const { return m_activeSceneName; }
 
std::vector<wxString> SceneContainer::GetSceneNames() const {
    std::vector<wxString> names;
    for (const auto &pair : m_scenes) {
        names.push_back(pair.first);
    }
    return names;
}
 
int SceneContainer::GetSceneCount() const { return static_cast<int>(m_scenes.size()); }
 
void SceneContainer::SetSceneDescription(const wxString &name, const wxString &description) {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        it->second.description = description;
    }
}
 
wxString SceneContainer::GetSceneDescription(const wxString &name) const {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        return it->second.description;
    }
    return wxEmptyString;
}
 
void SceneContainer::SetSceneState(const wxString &name, SceneState state) {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        it->second.state = state;
    }
}
 
SceneContainer::SceneState SceneContainer::GetSceneState(const wxString &name) const {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        return it->second.state;
    }
    return SceneState::Inactive;
}
 
void SceneContainer::SetScenePersistent(const wxString &name, bool persistent) {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        it->second.persistent = persistent;
    }
}
 
bool SceneContainer::IsScenePersistent(const wxString &name) const {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        return it->second.persistent;
    }
    return false;
}
 
bool SceneContainer::SwitchToScene(const wxString &name, TransitionType transition) {
    if (!HasScene(name) || !CanSwitchScene(name)) {
        return false;
    }
 
    wxString previousScene = m_activeSceneName;
 
    // Deactivate current scene
    if (!previousScene.IsEmpty()) {
        IScene *currentScene = GetScene(previousScene);
        if (currentScene) {
            currentScene->OnDeactivated();
            SetSceneState(previousScene, SceneState::Inactive);
            HideScene(previousScene);
            NotifySceneDeactivated(previousScene);
        }
    }
 
    // Activate new scene
    IScene *newScene = GetScene(name);
    if (newScene) {
        SetSceneState(name, SceneState::Active);
        m_activeSceneName = name;
        newScene->OnActivated();
        ShowScene(name);
        NotifySceneActivated(name);
 
        // Perform transition if enabled
        if (m_enableTransitions && !previousScene.IsEmpty()) {
            PerformTransition(previousScene, name, transition);
        }
 
        Layout();
        return true;
    }
 
    return false;
}
 
bool SceneContainer::SwitchToScene(IScene *scene, TransitionType transition) {
    for (const auto &pair : m_scenes) {
        if (pair.second.scene.get() == scene) {
            return SwitchToScene(pair.first, transition);
        }
    }
    return false;
}
 
bool SceneContainer::HasScene(const wxString &name) const { return m_scenes.find(name) != m_scenes.end(); }
 
void SceneContainer::RefreshScene(const wxString &name) {
    IScene *scene = GetScene(name);
    if (scene) {
        scene->Refresh();
    }
}
 
void SceneContainer::RefreshActiveScene() {
    if (!m_activeSceneName.IsEmpty()) {
        RefreshScene(m_activeSceneName);
    }
}
 
void SceneContainer::RefreshAllScenes() {
    for (const auto &pair : m_scenes) {
        if (pair.second.scene) {
            pair.second.scene->Refresh();
        }
    }
}
 
bool SceneContainer::CanSwitchScene(const wxString &name) {
    auto it = m_scenes.find(name);
    if (it == m_scenes.end()) {
        return false;
    }
 
    SceneState state = it->second.state;
    return state != SceneState::Loading && state != SceneState::Error;
}
 
void SceneContainer::SetSceneActivatedCallback(SceneActivatedCallback callback) { m_sceneActivatedCallback = callback; }
 
void SceneContainer::SetSceneDeactivatedCallback(SceneDeactivatedCallback callback) {
    m_sceneDeactivatedCallback = callback;
}
 
void SceneContainer::SetSceneCreatedCallback(SceneCreatedCallback callback) { m_sceneCreatedCallback = callback; }
 
void SceneContainer::SetSceneDestroyedCallback(SceneDestroyedCallback callback) { m_sceneDestroyedCallback = callback; }
 
void SceneContainer::SetSceneUserData(const wxString &name, void *userData) {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        it->second.userData = userData;
    }
}
 
void *SceneContainer::GetSceneUserData(const wxString &name) const {
    auto it = m_scenes.find(name);
    if (it != m_scenes.end()) {
        return it->second.userData;
    }
    return nullptr;
}
 
void SceneContainer::SetSceneSize(const wxString &name, const wxSize &size) {
    IScene *scene = GetScene(name);
    if (scene) {
        wxPanel *scenePanel = scene->GetPanel();
        if (scenePanel) {
            scenePanel->SetSize(size);
        }
    }
}
 
wxSize SceneContainer::GetSceneSize(const wxString &name) const {
    IScene *scene = GetScene(name);
    if (scene) {
        wxPanel *scenePanel = scene->GetPanel();
        if (scenePanel) {
            return scenePanel->GetSize();
        }
    }
    return wxDefaultSize;
}
 
void SceneContainer::FitSceneToContainer(const wxString &name) {
    IScene *scene = GetScene(name);
    if (scene) {
        wxPanel *scenePanel = scene->GetPanel();
        if (scenePanel) {
            scenePanel->SetSize(GetClientSize());
        }
    }
}
 
void SceneContainer::FitActiveSceneToContainer() {
    if (!m_activeSceneName.IsEmpty()) {
        FitSceneToContainer(m_activeSceneName);
    }
}
 
bool SceneContainer::SerializeState(wxString &data) const {
    // Simple serialization - can be enhanced later
    data = wxString::Format("scenes:%d,active:%s", GetSceneCount(), m_activeSceneName);
    return true;
}
 
bool SceneContainer::DeserializeState(const wxString &data) {
    // Simple deserialization - can be enhanced later
    return true;
}
 
void SceneContainer::SuspendInactiveScenes() {
    for (auto &pair : m_scenes) {
        if (pair.first != m_activeSceneName && pair.second.state != SceneState::Suspended) {
            // Mark as suspended (no actual suspend method in interface)
            pair.second.state = SceneState::Suspended;
        }
    }
}
 
void SceneContainer::ResumeAllScenes() {
    for (auto &pair : m_scenes) {
        if (pair.second.state == SceneState::Suspended) {
            // Mark as inactive (no actual resume method in interface)
            pair.second.state = SceneState::Inactive;
        }
    }
}
 
void SceneContainer::SetMaxInactiveScenes(int maxScenes) { m_maxInactiveScenes = maxScenes; }
 
int SceneContainer::GetMaxInactiveScenes() const { return m_maxInactiveScenes; }
 
// Event handlers
void SceneContainer::OnSize(wxSizeEvent &event) {
    FitActiveSceneToContainer();
    event.Skip();
}
 
void SceneContainer::OnPaint(wxPaintEvent &event) {
    wxPaintDC dc(this);
    // Custom painting can be added here
}
 
// Helper methods
void SceneContainer::UpdateSceneLayout() {
    Layout();
    Refresh();
}
 
void SceneContainer::ShowScene(const wxString &name) {
    IScene *scene = GetScene(name);
    if (scene) {
        wxPanel *scenePanel = scene->GetPanel();
        if (scenePanel) {
            scenePanel->Show();
        }
    }
}
 
void SceneContainer::HideScene(const wxString &name) {
    IScene *scene = GetScene(name);
    if (scene) {
        wxPanel *scenePanel = scene->GetPanel();
        if (scenePanel) {
            scenePanel->Hide();
        }
    }
}
 
bool SceneContainer::ValidateSceneName(const wxString &name) const {
    return !name.IsEmpty() && name.Find('/') == wxNOT_FOUND;
}
 
void SceneContainer::NotifySceneActivated(const wxString &name) {
    if (m_sceneActivatedCallback) {
        IScene *scene = GetScene(name);
        if (scene) {
            m_sceneActivatedCallback(scene, name);
        }
    }
}
 
void SceneContainer::NotifySceneDeactivated(const wxString &name) {
    if (m_sceneDeactivatedCallback) {
        IScene *scene = GetScene(name);
        if (scene) {
            m_sceneDeactivatedCallback(scene, name);
        }
    }
}
 
void SceneContainer::NotifySceneCreated(const wxString &name) {
    if (m_sceneCreatedCallback) {
        IScene *scene = GetScene(name);
        if (scene) {
            m_sceneCreatedCallback(scene, name);
        }
    }
}
 
void SceneContainer::NotifySceneDestroyed(const wxString &name) {
    if (m_sceneDestroyedCallback) {
        IScene *scene = GetScene(name);
        if (scene) {
            m_sceneDestroyedCallback(scene, name);
        }
    }
}
 
void SceneContainer::PerformTransition(const wxString &fromScene, const wxString &toScene, TransitionType transition) {
    switch (transition) {
    case TransitionType::Fade:
        FadeTransition(fromScene, toScene);
        break;
    case TransitionType::Slide:
        SlideTransition(fromScene, toScene);
        break;
    case TransitionType::Custom:
        // Custom transition implementation
        break;
    case TransitionType::Immediate:
    default:
        // No transition effect
        break;
    }
}
 
void SceneContainer::FadeTransition(const wxString &fromScene, const wxString &toScene) {
    // Simple fade implementation - can be enhanced with proper animation
    // This is a placeholder for future animation framework
}
 
void SceneContainer::SlideTransition(const wxString &fromScene, const wxString &toScene) {
    // Simple slide implementation - can be enhanced with proper animation
    // This is a placeholder for future animation framework
}
 
} // namespace ui
} // namespace EmberForge