PropertiesTab.cpp

Go to the documentation of this file.

#include "Tabs/PropertiesTab.h"
#include "App/MainFrame.h"
#include "Utils/AppPreferences.h"
#include "Utils/Logger.h"
 
wxBEGIN_EVENT_TABLE(PropertiesTab, EmberUI::PropertiesTabBase)
    EVT_PG_CHANGED(wxID_ANY, PropertiesTab::OnPropertyChanged)
        EVT_PG_CHANGING(wxID_ANY, PropertiesTab::OnPropertyChanging) wxEND_EVENT_TABLE()
 
            PropertiesTab::PropertiesTab(wxWindow *parent, MainFrame *mainFrame)
    : PropertiesTabBase(parent), m_node(nullptr), m_mainFrame(mainFrame) {
    SetSelectionHighlightColor(EmberForge::AppPreferencesManager::GetAccentColor());
    InitLayout();
}
 
void PropertiesTab::OnClosed() {
    if (m_mainFrame) {
        m_mainFrame->OnPropertiesTabClosed();
    }
}
 
void PropertiesTab::OnNodeCleared() { m_node = nullptr; }
 
void PropertiesTab::CreateContentLayout(wxPanel *contentPanel) {
    SetupPropertyGrid(contentPanel);
 
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
    sizer->Add(m_propertyGrid, 1, wxEXPAND | wxALL, 5);
    contentPanel->SetSizer(sizer);
}
 
void PropertiesTab::SetSelectedNode(EmberCore::Node *node) {
    m_node = node;
    m_selectedNode = nullptr;
 
    if (node) {
        LOG_INFO("Properties",
                 wxString::Format("Selected node: %s (ID: %zu)", node->GetName(), node->GetId()).ToStdString());
        m_propertyGrid->Clear();
        PopulateProperties();
        m_propertyGrid->Refresh();
        m_stack->ChangeSelection(1);
    } else {
        ClearSelection();
    }
}
 
void PropertiesTab::PopulateProperties() {
    if (!m_node || !m_propertyGrid)
        return;
 
    // Basic properties category
    m_propertyGrid->Append(new wxPropertyCategory("Basic Properties"));
 
    auto nameProp = new wxStringProperty("Name", "name", m_node->GetName());
    nameProp->SetClientData(reinterpret_cast<void *>(PROP_NODE_NAME));
    m_propertyGrid->Append(nameProp);
 
    auto idProp = new wxUIntProperty("ID", "id", static_cast<unsigned int>(m_node->GetId()));
    idProp->SetClientData(reinterpret_cast<void *>(PROP_NODE_ID));
    idProp->ChangeFlag(wxPGPropertyFlags::ReadOnly, true);
    m_propertyGrid->Append(idProp);
 
    auto typeProp = new wxStringProperty("Type", "type", GetNodeTypeDisplayName(m_node->GetType()));
    typeProp->SetClientData(reinterpret_cast<void *>(PROP_NODE_TYPE));
    typeProp->ChangeFlag(wxPGPropertyFlags::ReadOnly, true);
    m_propertyGrid->Append(typeProp);
 
    AddVisualProperties();
    AddNodePortAttributes();
    AddNodeCustomAttributes();
}
 
void PropertiesTab::AddVisualProperties() {
    if (!m_node)
        return;
 
    m_propertyGrid->Append(new wxPropertyCategory("Visual Properties"));
 
    auto childrenVisibleProp = new wxBoolProperty("Children Visible", "children_visible", m_node->AreChildrenVisible());
    childrenVisibleProp->SetClientData(reinterpret_cast<void *>(PROP_NODE_CHILDREN_VISIBLE));
    m_propertyGrid->Append(childrenVisibleProp);
}
 
bool PropertiesTab::IsPortValue(const std::string &value) {
    if (value.size() < 3)
        return false;
    if (value.front() == '{' && value.back() == '}')
        return true;
    if (value.size() >= 4 && value[0] == '$' && value[1] == '{' && value.back() == '}')
        return true;
    return false;
}
 
void PropertiesTab::AddNodePortAttributes() {
    if (!m_node)
        return;
 
    const auto &attributes = m_node->GetAllAttributes();
    bool headerAdded = false;
    int propId = PROP_CUSTOM_ATTRIBUTES_START;
 
    for (const auto &pair : attributes) {
        if (!IsPortValue(pair.second))
            continue;
 
        if (!headerAdded) {
            m_propertyGrid->Append(new wxPropertyCategory("Ports"));
            headerAdded = true;
        }
 
        auto portProp = new wxStringProperty(pair.first, wxString::Format("attr_%s", pair.first), pair.second);
        portProp->SetClientData(reinterpret_cast<void *>(propId++));
        m_propertyGrid->Append(portProp);
    }
}
 
void PropertiesTab::AddNodeCustomAttributes() {
    if (!m_node)
        return;
 
    const auto &attributes = m_node->GetAllAttributes();
    bool headerAdded = false;
    int propId = PROP_CUSTOM_ATTRIBUTES_START + 500;
 
    for (const auto &pair : attributes) {
        if (IsPortValue(pair.second))
            continue;
 
        if (!headerAdded) {
            m_propertyGrid->Append(new wxPropertyCategory("Attributes"));
            headerAdded = true;
        }
 
        auto attrProp = new wxStringProperty(pair.first, wxString::Format("attr_%s", pair.first), pair.second);
        attrProp->SetClientData(reinterpret_cast<void *>(propId++));
        m_propertyGrid->Append(attrProp);
    }
}
 
wxString PropertiesTab::GetNodeTypeDisplayName(EmberCore::Node::Type type) const {
    switch (type) {
    case EmberCore::Node::Type::Control:
        return "Control";
    case EmberCore::Node::Type::Action:
        return "Action";
    case EmberCore::Node::Type::Condition:
        return "Condition";
    case EmberCore::Node::Type::Decorator:
        return "Decorator";
    case EmberCore::Node::Type::BehaviorTree:
        return "BehaviorTree";
    case EmberCore::Node::Type::None:
        return "None";
    default:
        return "Unknown";
    }
}
 
void PropertiesTab::OnPropertyChanged(wxPropertyGridEvent &event) {
    if (!m_node)
        return;
 
    wxPGProperty *prop = event.GetProperty();
    if (!prop)
        return;
 
    int propId = reinterpret_cast<intptr_t>(prop->GetClientData());
    wxVariant value = prop->GetValue();
 
    LOG_INFO("Properties",
             wxString::Format("Property changed: %s = %s", prop->GetName(), value.GetString()).ToStdString());
 
    switch (propId) {
    case PROP_NODE_NAME:
        m_node->SetName(value.GetString().ToStdString());
        break;
 
    case PROP_NODE_CHILDREN_VISIBLE:
        m_node->SetChildrenVisible(value.GetBool());
        break;
 
    default:
        if (propId >= PROP_CUSTOM_ATTRIBUTES_START) {
            wxString attrName = prop->GetName();
            m_node->SetAttribute(attrName.ToStdString(), value.GetString().ToStdString());
        }
        break;
    }
}
 
void PropertiesTab::OnPropertyChanging(wxPropertyGridEvent &event) {
    wxPGProperty *prop = event.GetProperty();
    if (!prop)
        return;
}