TabFactory.cpp

Go to the documentation of this file.

#include "Components/TabFactory.h"
#include "App/MainFrame.h"
#include "Tabs/FileExplorerTab.h"
#include "Tabs/ForgeNavigatorTab.h"
#include "Tabs/LogTab.h"
#include "Tabs/PropertiesTab.h"
#include "Utils/Logger.h"
#include "Utils/PerformanceMonitor.h"
 
namespace EmberForge {
 
std::unique_ptr<ITab> TabFactory::CreateTab(TabType type, wxWindow *parent, MainFrame *mainFrame) {
    if (!parent) {
        LOG_ERROR("TabFactory", "Cannot create tab: parent window is null");
        return nullptr;
    }
 
    try {
        switch (type) {
        case TabType::Properties: {
            LOG_INFO("TabFactory", "Creating Properties tab");
            auto tab = std::make_unique<PropertiesTab>(parent, mainFrame);
 
            // If we have a main frame, update its reference and set the selected node
            if (mainFrame) {
                mainFrame->UpdatePropertiesTabReference(tab.get());
            }
 
            return tab;
        }
 
        case TabType::Log: {
            LOG_INFO("TabFactory", "Creating Log tab");
            return std::make_unique<LogTab>(parent);
        }
 
        case TabType::Performance: {
            LOG_INFO("TabFactory", "Creating Performance tab");
            return std::make_unique<EmberForge::PerformancePanel>(parent);
        }
 
        case TabType::FileExplorer: {
            LOG_INFO("TabFactory", "Creating File Explorer tab");
            return std::make_unique<FileExplorerTab>(parent);
        }
 
        case TabType::Navigator: {
            LOG_INFO("TabFactory", "Creating Navigator tab");
            auto tab = std::make_unique<ForgeNavigatorTab>(parent, mainFrame);
 
            if (mainFrame) {
                mainFrame->UpdateNavigatorTabReference(tab.get());
            }
 
            return tab;
        }
 
        default:
            LOG_ERROR("TabFactory", "Unknown tab type requested: " + std::to_string(static_cast<int>(type)));
            return nullptr;
        }
    } catch (const std::exception &e) {
        LOG_ERROR("TabFactory", "Exception while creating tab: " + std::string(e.what()));
        return nullptr;
    } catch (...) {
        LOG_ERROR("TabFactory", "Unknown exception while creating tab");
        return nullptr;
    }
}
 
wxString TabFactory::GetTabDisplayName(TabType type) {
    switch (type) {
    case TabType::Properties:
        return "Properties";
    case TabType::Log:
        return "Log";
    case TabType::Performance:
        return "Performance";
    case TabType::FileExplorer:
        return "File Explorer";
    case TabType::Navigator:
        return "Navigator";
    default:
        return "Unknown Tab";
    }
}
 
wxString TabFactory::GetTabTooltip(TabType type) {
    switch (type) {
    case TabType::Properties:
        return "View and edit object properties";
    case TabType::Log:
        return "View application logs and debug information";
    case TabType::Performance:
        return "Monitor application performance metrics";
    case TabType::FileExplorer:
        return "Browse and manage project files";
    case TabType::Navigator:
        return "Browse trees, navigate node hierarchy, and search across the project";
    default:
        return "Unknown tab type";
    }
}
 
bool TabFactory::AllowMultipleInstances(TabType type) {
    switch (type) {
    case TabType::Properties:
        return false; // Only one properties panel per panel makes sense
    case TabType::Log:
        return false; // Only one log panel per panel makes sense
    case TabType::Performance:
        return false; // Only one performance panel per panel makes sense
    case TabType::FileExplorer:
        return false; // Only one file explorer per panel makes sense
    case TabType::Navigator:
        return false;
    default:
        return false;
    }
}
 
int TabFactory::GetMaxGlobalInstances(TabType type) {
    // Configure the maximum number of instances allowed across ALL panels.
    // Return 0 = unlimited instances
    // Return 1 = single global instance (default for most tabs)
    // Return 2+ = allow that many instances across panels
    switch (type) {
    case TabType::Log:
        return 1; // Only one log output
    case TabType::Performance:
        return 1; // Only one performance monitor
    case TabType::FileExplorer:
        return 1; // Only one file explorer
    case TabType::Properties:
        return 1; // Change to 2 to allow in two panels
    case TabType::Navigator:
        return 1;
    default:
        return 1;
    }
}
 
bool TabFactory::IsTabAllowedInPanel(TabType tabType, PanelType panelType) {
    // Configure which tabs are allowed in which panel types.
    // This provides fine-grained control over tab placement.
    switch (tabType) {
    case TabType::Properties:
        // Properties: only in side panels (left/right)
        return panelType == PanelType::LeftPanel || panelType == PanelType::RightPanel;
 
    case TabType::Log:
        // Log: only in bottom panel
        return panelType == PanelType::BottomPanel;
 
    case TabType::Performance:
        // Performance: only in bottom panel
        return panelType == PanelType::BottomPanel;
 
    case TabType::FileExplorer:
        // File Explorer: only in bottom panel
        return panelType == PanelType::BottomPanel;
 
    case TabType::Navigator:
        return panelType == PanelType::LeftPanel || panelType == PanelType::RightPanel;
 
    default:
        return true;
    }
}
 
std::vector<TabType> TabFactory::GetAvailableTabTypes() {
    return {TabType::Navigator, TabType::Properties, TabType::Log, TabType::Performance, TabType::FileExplorer};
}
 
std::vector<TabType> TabFactory::GetBottomPanelTabTypes() {
    return {TabType::FileExplorer, TabType::Log, TabType::Performance};
}
 
std::vector<TabType> TabFactory::GetSidePanelTabTypes() { return {TabType::Navigator, TabType::Properties}; }
 
std::string TabFactory::TabTypeToString(TabType type) {
    switch (type) {
    case TabType::Properties:
        return "Properties";
    case TabType::Log:
        return "Log";
    case TabType::Performance:
        return "Performance";
    case TabType::FileExplorer:
        return "FileExplorer";
    case TabType::Navigator:
        return "Navigator";
    default:
        return "FileExplorer";
    }
}
 
TabType TabFactory::StringToTabType(const std::string &str) {
    // Migrate deprecated tab types
    if (str == "SceneHierarchy" || str == "TreeSelector")
        return TabType::Navigator;
    if (str == "Tool") // Legacy name for Properties tab
        return TabType::Properties;
    if (str == "Properties")
        return TabType::Properties;
    if (str == "Log")
        return TabType::Log;
    if (str == "Performance")
        return TabType::Performance;
    if (str == "FileExplorer")
        return TabType::FileExplorer;
    if (str == "Navigator")
        return TabType::Navigator;
    return TabType::FileExplorer;
}
 
} // namespace EmberForge