blam_ui_editor.hpp

Go to the documentation of this file.

#pragma once
 
#include "components/ui/imgui/imgui.h"
 
#include "components/ui/blam/ui.h"
#include "components/resources/engine_globals/globals.h"
 
class BlamImGuiWindow_BlamUIEditor : public BlamImGuiWindow
{
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:
    BlamImGuiWindow_BlamUIEditor()
    {
        ui_root = Blam::UI::GetUIRoot();
    }
 
    BlamImGuiWindow_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";
                }
 
                if (ImGui::Selectable("ellipse"))
                {
                    selected_widget_type = BlamWidgetType::Basic_Ellipse;
                    widget_type_name = "ellipse";
                }
 
                if (ImGui::Selectable("triangle"))
                {
                    selected_widget_type = BlamWidgetType::Basic_Triangle;
                    widget_type_name = "triangle";
                }
 
                if (ImGui::Selectable("line"))
                {
                    selected_widget_type = BlamWidgetType::Basic_Line;
                    widget_type_name = "line";
                }
 
                if (ImGui::Selectable("vlayout"))
                {
                    selected_widget_type = BlamWidgetType::Group_VLayout;
                    widget_type_name = "vlayout";
                }
 
                if (ImGui::Selectable("hlayout"))
                {
                    selected_widget_type = BlamWidgetType::Group_HLayout;
                    widget_type_name = "hlayout";
                }
 
                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 if (selected_widget_type == BlamWidgetType::Basic_Ellipse)
                    {
                        new_widget = new BlamUIWidget_BasicEllipse(ui_root);
                    }
                    else if (selected_widget_type == BlamWidgetType::Basic_Triangle)
                    {
                        new_widget = new BlamUIWidget_BasicTriangle(ui_root);
                    }
                    else if (selected_widget_type == BlamWidgetType::Basic_Line)
                    {
                        new_widget = new BlamUIWidget_BasicLine(ui_root);
                    }
                    else if (selected_widget_type == BlamWidgetType::Group_VLayout)
                    {
                        new_widget = new BlamUIWidget_VLayoutGroup(ui_root);
                    }
                    else if (selected_widget_type == BlamWidgetType::Group_HLayout)
                    {
 
                    }
                    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 || widget->GetType() == BlamWidgetType::Group_VLayout
                        || widget->GetType() == BlamWidgetType::Group_HLayout)
                    {
                        BlamUIWidget_Group* group_widget = (BlamUIWidget_Group*)widget;
                        group_widget->ShowImGuiEditorWindow();
                    }
                }
            }
        }
    }
};