blam_ui_editor.hpp

Go to the documentation of this file.

#pragma once
 
#include "../../debug_ui.h"
 
#include "components/ui/blam/ui.h"
#include "components/resources/engine_globals/globals.h"
 
namespace Blam::DebugUI::Windows
{
    class BlamUIEditor : public Blam::DebugUI::ImGUIDrawingGroup
    {
    private:
        int active_widget_index = -1;
 
        bool show_add_widget_dialog = false;
        bool add_widget_to_group = false;
        BlamWidgetType selected_widget_type = BlamWidgetType::Basic_Rectangle;
        std::string widget_type_name = "rectangle";
 
        BlamUIWidget_Group* ui_root = nullptr;
 
    public:
        BlamUIEditor()
        {
            ui_root = Blam::UI::GetUIRoot();
        }
 
        BlamUIEditor(BlamUIWidget_Group* _ui_root)
        {
            ui_root = _ui_root;
        }
 
        void ShowAddPrimitivePopup()
        {
            ImGui::OpenPopup("Add Widget");
            if (ImGui::BeginPopupModal("Add Widget", &show_add_widget_dialog))
            {
                if (ImGui::BeginCombo("widget type", widget_type_name.c_str()))
                {
                    if (ImGui::Selectable("basic_rectangle"))
                    {
                        selected_widget_type = BlamWidgetType::Basic_Rectangle;
                        widget_type_name = "basic_rectangle";
                    }
 
                    //if (ImGui::Selectable("basic_ellipse"))
                    //{
                    //  selected_widget_type = BlamWidgetType::Basic_Ellipse;
                    //  widget_type_name = "basic_ellipse";
                    //}
 
                    if (ImGui::Selectable("group"))
                    {
                        selected_widget_type = BlamWidgetType::Group;
                        widget_type_name = "group";
                    }
 
                    if (ImGui::Selectable("text"))
                    {
                        selected_widget_type = BlamWidgetType::Text;
                        widget_type_name = "text";
                    }
 
                    ImGui::EndCombo();
                }
 
                if (ImGui::Button("OK"))
                {
                    if (Blam::UI::GetUIRoot())
                    {
                        BlamUIWidget* new_widget = nullptr;
 
                        if (selected_widget_type == BlamWidgetType::Basic_Rectangle)
                        {
                            new_widget = new BlamUIWidget_BasicRectangle(ui_root);
                        }
                        else if (selected_widget_type == BlamWidgetType::Group)
                        {
                            new_widget = new BlamUIWidget_Group(ui_root);
                        }
                        else if (selected_widget_type == BlamWidgetType::Text)
                        {
                            new_widget = new BlamUIWidget_Text(ui_root);
                        }
                        else
                        {
                            // unimplemented widget type
                        }
 
                        if (new_widget)
                        {
                            ui_root->children.push_back(new_widget);
                        }
                        else
                        {
                            // failed to create new ui widget
                        }
                    }
 
                    show_add_widget_dialog = false;
                }
 
                ImGui::SameLine();
 
                if (ImGui::Button("Cancel"))
                {
                    show_add_widget_dialog = false;
                }
 
                ImGui::EndPopup();
            }
        }
 
        void Draw()
        {
            if (!ui_root)
            {
                ui_root = Blam::UI::GetUIRoot();
            }
 
            if (show)
            {
                std::string window_title = "";
                
                if (ui_root)
                {
                    window_title = "Blam UI Editor (context: " + ui_root->display_name + ")";
                }
                else
                {
                    window_title = "Blam UI Editor (no root available, root was nullptr)";
                }
 
                if (ImGui::Begin(window_title.c_str(), &show))
                {
                    if (ui_root)
                    {
                        if (ImGui::Button("add widget"))
                        {
                            show_add_widget_dialog = true;
                        }
 
                        if (active_widget_index >= 0 && active_widget_index < ui_root->children.size())
                        {
                            ImGui::SameLine();
 
                            if (ImGui::Button("remove widget"))
                            {
                                BlamUIWidget* widget_to_remove = ui_root->children.at(active_widget_index);
                                ui_root->children.erase(ui_root->children.begin() + active_widget_index);
                                delete widget_to_remove;
 
                                active_widget_index = -1;
                            }
 
                            if ((active_widget_index - 1) >= 0)
                            {
                                ImGui::SameLine();
 
                                if (ImGui::Button("move widget up"))
                                {
                                    int new_pos = active_widget_index - 1;
 
                                    BlamUIWidget* widget_to_move = ui_root->children.at(active_widget_index);
                                    ui_root->children.erase(ui_root->children.begin() + active_widget_index);
 
                                    ui_root->children.insert(ui_root->children.begin() + new_pos, widget_to_move);
 
                                    active_widget_index--;
                                }
                            }
 
                            if ((active_widget_index + 1) < ui_root->children.size())
                            {
                                ImGui::SameLine();
 
                                if (ImGui::Button("move widget down"))
                                {
                                    int new_pos = active_widget_index + 1;
 
                                    BlamUIWidget* widget_to_move = ui_root->children.at(active_widget_index);
                                    ui_root->children.erase(ui_root->children.begin() + active_widget_index);
 
                                    ui_root->children.insert(ui_root->children.begin() + new_pos, widget_to_move);
 
                                    active_widget_index++;
                                }
                            }
                        }
 
                        ImGui::Separator();
 
                        ImGui::Columns(2);
 
                        ImGui::SetColumnWidth(0, (200.0f * *Blam::Globals::GetGlobalAsFloat("ui_scale_factor")));
 
                        if (ImGui::ListBoxHeader("", ImVec2(ImGui::GetColumnWidth() - 15, -1)))
                        {
                            for (int i = 0; i < ui_root->children.size(); i++)
                            {
                                BlamUIWidget* widget = ui_root->children.at(i);
                                std::string selectable_item_name = std::to_string(i) + ": " + widget->display_name;
                                bool is_active_item = false;
 
                                if (i == active_widget_index)
                                {
                                    is_active_item = true;
                                }
 
                                if (ImGui::Selectable(selectable_item_name.c_str(), is_active_item))
                                {
                                    active_widget_index = i;
                                }
 
                                if (ImGui::IsItemHovered())
                                {
                                    ImGui::BeginTooltip();
                                    ImGui::PushTextWrapPos(450.0f);
                                    ImGui::Text("widget information");
                                    ImGui::Separator();
 
                                    std::string display_name = "display name: " + widget->display_name;
                                    std::string description = "description: " + widget->description;
                                    std::string index = "index: " + std::to_string(i);
 
                                    ImGui::Text(display_name.c_str());
                                    ImGui::Text(description.c_str());
                                    ImGui::Text(index.c_str());
 
                                    ImGui::PopTextWrapPos();
                                    ImGui::EndTooltip();
                                }
                            }
 
                            ImGui::ListBoxFooter();
                        }
 
                        ImGui::NextColumn();
 
                        if (active_widget_index < 0)
                        {
                            ImGui::Text("select a widget to modify");
                        }
                        else if (active_widget_index > ui_root->children.size())
                        {
                            std::string message = "selected index " + std::to_string(active_widget_index) +
                                " was too high (max is " + std::to_string(ui_root->children.size()) + ")";
 
                            ImGui::Text(message.c_str());
                        }
                        else
                        {
                            BlamUIWidget* widget = ui_root->children.at(active_widget_index);
 
                            if (ImGui::BeginTabBar("widget_editor_tabs"))
                            {
                                if (ImGui::BeginTabItem("widget information"))
                                {
                                    std::string display_name = "display name: " + widget->display_name;
                                    std::string description = "description: " + widget->description;
                                    std::string index = "index: " + std::to_string(active_widget_index);
 
                                    ImGui::Text(display_name.c_str());
                                    ImGui::Text(description.c_str());
                                    ImGui::Text(index.c_str());
 
                                    ImGui::EndTabItem();
                                }
 
                                if (ImGui::BeginTabItem("widget properties"))
                                {
                                    widget->ShowImGuiPropertyEditor();
 
                                    ImGui::EndTabItem();
                                }
 
 
                                ImGui::EndTabBar();
                            }
                        }
                    }
                }
                ImGui::End();
 
                if (show_add_widget_dialog)
                {
                    ShowAddPrimitivePopup();
                }
 
                if (ui_root)
                {
                    for (int i = 0; i < ui_root->children.size(); i++)
                    {
                        BlamUIWidget* widget = ui_root->children.at(i);
 
                        if (widget->GetType() == BlamWidgetType::Group)
                        {
                            BlamUIWidget_Group* group_widget = (BlamUIWidget_Group*)widget;
                            group_widget->ShowImGuiEditorWindow();
                        }
                    }
                }
            }
        }
    };
}