Add sequences for simple common menu properties

src/ObjLoading/Parsing/Menu/Domain/CommonMenuDef.h

@@ -4,6 +4,7 @@
 #include <vector>
 
 #include "CommonItemDef.h"
+#include "CommonMenuTypes.h"
 
 namespace menu
 {
@@ -11,9 +12,35 @@ namespace menu
     {
     public:
         std::string m_name;
+        CommonRect m_rect;
+        int m_style;
+        int m_border;
+        double m_border_size;
+        CommonColor m_back_color;
+        CommonColor m_fore_color;
+        CommonColor m_border_color;
+        CommonColor m_focus_color;
+        std::string m_background;
+        int m_owner_draw;
+        int m_owner_draw_flags;
+        std::string m_sound_loop;
+        double m_fade_clamp;
+        int m_fade_cycle;
+        double m_fade_amount;
+        double m_fade_in_amount;
+        double m_blur_radius;
+        std::string m_allowed_binding;
+
         bool m_full_screen;
         bool m_screen_space;
         bool m_decoration;
+        bool m_out_of_bounds_click;
+        bool m_popup;
+        bool m_legacy_split_screen_scale;
+        bool m_hidden_during_scope;
+        bool m_hidden_during_flashbang;
+        bool m_hidden_during_ui;
+        bool m_text_only_focus;
 
         std::vector<std::unique_ptr<CommonItemDef>> m_items;
     };

src/ObjLoading/Parsing/Menu/Domain/CommonMenuTypes.h

@@ -13,4 +13,14 @@ namespace menu
         };
         double array[4];
     };
+
+    struct CommonRect
+    {
+        double x;
+        double y;
+        double w;
+        double h;
+        int horizontalAlign;
+        int verticalAlign;
+    };
 }

src/ObjLoading/Parsing/Menu/Sequence/Properties/MenuPropertySequences.cpp

@@ -1,26 +1,42 @@
 #include "MenuPropertySequences.h"
 
 #include "GenericBoolPropertySequence.h"
+#include "GenericColorPropertySequence.h"
+#include "GenericFloatingPointPropertySequence.h"
+#include "GenericIntPropertySequence.h"
 #include "GenericKeywordPropertySequence.h"
 #include "GenericStringPropertySequence.h"
 #include "Parsing/Menu/MenuMatcherFactory.h"
+#include "Parsing/Menu/Domain/CommonMenuTypes.h"
 
 using namespace menu;
 
 namespace menu::menu_properties
 {
-    class SequenceFullScreen final : public MenuFileParser::sequence_t
+    class SequenceRect final : public MenuFileParser::sequence_t
     {
-        static constexpr auto CAPTURE_VALUE = 1;
+        static constexpr auto CAPTURE_X = 1;
+        static constexpr auto CAPTURE_Y = 2;
+        static constexpr auto CAPTURE_W = 3;
+        static constexpr auto CAPTURE_H = 4;
+        static constexpr auto CAPTURE_ALIGN_HORIZONTAL = 5;
+        static constexpr auto CAPTURE_ALIGN_VERTICAL = 6;
 
     public:
-        SequenceFullScreen()
+        SequenceRect()
         {
             const MenuMatcherFactory create(this);
 
             AddMatchers({
-                create.KeywordIgnoreCase("fullscreen"),
+                create.KeywordIgnoreCase("rect"),
-                create.Numeric().Capture(CAPTURE_VALUE)
+                create.Numeric().Capture(CAPTURE_X),
+                create.Numeric().Capture(CAPTURE_Y),
+                create.Numeric().Capture(CAPTURE_W),
+                create.Numeric().Capture(CAPTURE_H),
+                create.Optional(create.And({
+                    create.Integer().Capture(CAPTURE_ALIGN_HORIZONTAL),
+                    create.Integer().Capture(CAPTURE_ALIGN_VERTICAL)
+                }))
             });
         }
 
@@ -29,8 +45,22 @@ namespace menu::menu_properties
         {
             assert(state->m_current_menu);
 
-            const auto value = MenuMatcherFactory::TokenNumericIntValue(result.NextCapture(CAPTURE_VALUE));
+            CommonRect rect
-            state->m_current_menu->m_full_screen = value > 0;
+            {
+                MenuMatcherFactory::TokenNumericFloatingPointValue(result.NextCapture(CAPTURE_X)),
+                MenuMatcherFactory::TokenNumericFloatingPointValue(result.NextCapture(CAPTURE_Y)),
+                MenuMatcherFactory::TokenNumericFloatingPointValue(result.NextCapture(CAPTURE_W)),
+                MenuMatcherFactory::TokenNumericFloatingPointValue(result.NextCapture(CAPTURE_H)),
+                0, 0
+            };
+
+            if (result.HasNextCapture(CAPTURE_ALIGN_HORIZONTAL) && result.HasNextCapture(CAPTURE_ALIGN_VERTICAL))
+            {
+                rect.horizontalAlign = result.NextCapture(CAPTURE_ALIGN_HORIZONTAL).IntegerValue();
+                rect.verticalAlign = result.NextCapture(CAPTURE_ALIGN_VERTICAL).IntegerValue();
+            }
+
+            state->m_current_menu->m_rect = rect;
         }
     };
 }
@@ -60,4 +90,101 @@ void MenuPropertySequences::AddSequences(FeatureLevel featureLevel)
     {
         state->m_current_menu->m_decoration = true;
     }));
+    AddSequence(std::make_unique<SequenceRect>());
+    AddSequence(std::make_unique<GenericIntPropertySequence>("style", [](const MenuFileParserState* state, const int value)
+    {
+        state->m_current_menu->m_style = value;
+    }));
+    AddSequence(std::make_unique<GenericIntPropertySequence>("border", [](const MenuFileParserState* state, const int value)
+    {
+        state->m_current_menu->m_border = value;
+    }));
+    AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("borderSize", [](const MenuFileParserState* state, const double value)
+    {
+        state->m_current_menu->m_border_size = value;
+    }));
+    AddSequence(std::make_unique<GenericColorPropertySequence>("backcolor", [](const MenuFileParserState* state, const CommonColor value)
+    {
+        state->m_current_menu->m_back_color = value;
+    }));
+    AddSequence(std::make_unique<GenericColorPropertySequence>("forecolor", [](const MenuFileParserState* state, const CommonColor value)
+    {
+        state->m_current_menu->m_fore_color = value;
+    }));
+    AddSequence(std::make_unique<GenericColorPropertySequence>("bordercolor", [](const MenuFileParserState* state, const CommonColor value)
+    {
+        state->m_current_menu->m_border_color = value;
+    }));
+    AddSequence(std::make_unique<GenericColorPropertySequence>("focuscolor", [](const MenuFileParserState* state, const CommonColor value)
+    {
+        state->m_current_menu->m_focus_color = value;
+    }));
+    AddSequence(std::make_unique<GenericStringPropertySequence>("background", [](const MenuFileParserState* state, const std::string& value)
+    {
+        state->m_current_menu->m_background = value;
+    }));
+    AddSequence(std::make_unique<GenericIntPropertySequence>("ownerdraw", [](const MenuFileParserState* state, const int value)
+    {
+        state->m_current_menu->m_owner_draw = value;
+    }));
+    AddSequence(std::make_unique<GenericIntPropertySequence>("ownerdrawFlag", [](const MenuFileParserState* state, const int value)
+    {
+        state->m_current_menu->m_owner_draw_flags |= value;
+    }));
+    AddSequence(std::make_unique<GenericKeywordPropertySequence>("outOfBoundsClick", [](const MenuFileParserState* state)
+    {
+        state->m_current_menu->m_out_of_bounds_click = true;
+    }));
+    AddSequence(std::make_unique<GenericStringPropertySequence>("soundLoop", [](const MenuFileParserState* state, const std::string& value)
+    {
+        state->m_current_menu->m_sound_loop = value;
+    }));
+    AddSequence(std::make_unique<GenericKeywordPropertySequence>("popup", [](const MenuFileParserState* state)
+    {
+        state->m_current_menu->m_popup = true;
+    }));
+    AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeClamp", [](const MenuFileParserState* state, const double value)
+    {
+        state->m_current_menu->m_fade_clamp = value;
+    }));
+    AddSequence(std::make_unique<GenericIntPropertySequence>("fadeCycle", [](const MenuFileParserState* state, const int value)
+    {
+        state->m_current_menu->m_fade_cycle = value;
+    }));
+    AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeAmount", [](const MenuFileParserState* state, const double value)
+    {
+        state->m_current_menu->m_fade_amount = value;
+    }));
+    AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeInAmount", [](const MenuFileParserState* state, const double value)
+    {
+        state->m_current_menu->m_fade_in_amount = value;
+    }));
+    AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("blurWorld", [](const MenuFileParserState* state, const double value)
+    {
+        state->m_current_menu->m_blur_radius = value;
+    }));
+    AddSequence(std::make_unique<GenericKeywordPropertySequence>("legacySplitScreenScale", [](const MenuFileParserState* state)
+    {
+        state->m_current_menu->m_legacy_split_screen_scale = true;
+    }));
+    AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringScope", [](const MenuFileParserState* state)
+    {
+        state->m_current_menu->m_hidden_during_scope = true;
+    }));
+    AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringFlashbang", [](const MenuFileParserState* state)
+    {
+        state->m_current_menu->m_hidden_during_flashbang = true;
+    }));
+    AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringUI", [](const MenuFileParserState* state)
+    {
+        state->m_current_menu->m_hidden_during_ui = true;
+    }));
+    AddSequence(std::make_unique<GenericStringPropertySequence>("allowedBinding", [](const MenuFileParserState* state, const std::string& value)
+    {
+        state->m_current_menu->m_allowed_binding = value;
+    }));
+    AddSequence(std::make_unique<GenericKeywordPropertySequence>("textOnlyFocus", [](const MenuFileParserState* state)
+    {
+        state->m_current_menu->m_text_only_focus = true;
+    }));
 }