From 99c98e74a2b3e5d658305893e1389521aebecc83 Mon Sep 17 00:00:00 2001
From: Stone_Red <56473591+Stone-Red-Code@users.noreply.github.com>
Date: Tue, 16 Jun 2026 12:29:04 +0200
Subject: [PATCH] Add Panel, ProgressBar, RadioButton, and Slider UI controls
 and test windows

---
 Processes/DesktopProcess.cs                | 104 ++++++++++++---
 UI/GUI/UIEelements/Controls/Panel.cs       |  24 ++++
 UI/GUI/UIEelements/Controls/ProgressBar.cs |  70 ++++++++++
 UI/GUI/UIEelements/Controls/RadioButton.cs | 103 +++++++++++++++
 UI/GUI/UIEelements/Controls/Slider.cs      | 142 +++++++++++++++++++++
 UI/GUI/Windows/Window.cs                   |  13 +-
 6 files changed, 438 insertions(+), 18 deletions(-)
 create mode 100644 UI/GUI/UIEelements/Controls/Panel.cs
 create mode 100644 UI/GUI/UIEelements/Controls/ProgressBar.cs
 create mode 100644 UI/GUI/UIEelements/Controls/RadioButton.cs
 create mode 100644 UI/GUI/UIEelements/Controls/Slider.cs

diff --git a/Processes/DesktopProcess.cs b/Processes/DesktopProcess.cs
index f53e5b5..1779e03 100644
--- a/Processes/DesktopProcess.cs
+++ b/Processes/DesktopProcess.cs
@@ -3,6 +3,8 @@ using RemSox.UI.GUI.Rendering;
 using RemSox.UI.GUI.UIEelements.Controls;
 using RemSox.UI.GUI.Windows;
 
+using System.Drawing;
+
 namespace RemSox.Processes;
 
 internal class DesktopProcess() : Process("Desktop Manager")
@@ -17,31 +19,30 @@ internal class DesktopProcess() : Process("Desktop Manager")
             isGraphicsInitialized = true;
         }
 
-        // Force existing windows to redraw onto the new canvas renderer
         WindowManager.InvalidateAll();
 
-        // Create a test window for new UI controls
-        Window testWindow = WindowManager.CreateWindow(this, "UI Controls Test", new System.Drawing.Size(200, 180));
+        // Test window 1: interactive controls
+        Window testWindow = WindowManager.CreateWindow(this, "UI Controls", new Size(280, 260));
         testWindow.AutoFlush = true;
 
-        Button button = testWindow.CreateUIElement<UI.GUI.UIEelements.Controls.Button>(b =>
+        Button button = testWindow.CreateUIElement<Button>(b =>
         {
-            b.Position = new System.Drawing.Point(20, 30);
-            b.Size = new System.Drawing.Size(200, 30);
+            b.Position = new Point(20, 30);
+            b.Size = new Size(240, 25);
             b.Text = "Click Me";
-            b.BackgroundColor = System.Drawing.Color.LightBlue;
+            b.BackgroundColor = Color.LightBlue;
         });
 
         button.OnClick += (s, e) =>
         {
             button.Text = "Clicked!";
-            button.BackgroundColor = System.Drawing.Color.LightGreen;
+            button.BackgroundColor = Color.LightGreen;
         };
 
-        CheckBox check = testWindow.CreateUIElement<UI.GUI.UIEelements.Controls.CheckBox>(c =>
+        CheckBox check = testWindow.CreateUIElement<CheckBox>(c =>
         {
-            c.Position = new System.Drawing.Point(20, 80);
-            c.Size = new System.Drawing.Size(200, 30);
+            c.Position = new Point(20, 65);
+            c.Size = new Size(240, 20);
             c.Text = "Check Me";
             c.IsChecked = true;
         });
@@ -51,12 +52,85 @@ internal class DesktopProcess() : Process("Desktop Manager")
             check.Text = check.IsChecked ? "Checked!" : "Unchecked!";
         };
 
-        _ = testWindow.CreateUIElement<UI.GUI.UIEelements.Shapes.Line>(l =>
+        RadioButton radio = testWindow.CreateUIElement<RadioButton>(r =>
         {
-            l.Position = new System.Drawing.Point(20, 130);
-            l.EndPosition = new System.Drawing.Point(180, 130);
-            l.Color = System.Drawing.Color.Red;
+            r.Position = new Point(20, 95);
+            r.Size = new Size(240, 20);
+            r.Text = "Radio Option";
+            r.IsChecked = true;
         });
+
+        Slider slider = testWindow.CreateUIElement<Slider>(s =>
+        {
+            s.Position = new Point(20, 130);
+            s.Size = new Size(240, 24);
+            s.BackgroundColor = Color.SteelBlue;
+            s.Value = 60;
+        });
+
+        ProgressBar progress = testWindow.CreateUIElement<ProgressBar>(p =>
+        {
+            p.Position = new Point(20, 170);
+            p.Size = new Size(240, 20);
+            p.BackgroundColor = Color.DimGray;
+            p.FillColor = Color.LimeGreen;
+            p.Value = 60;
+        });
+
+        slider.OnValueChanged += (_, _) =>
+        {
+            progress.Value = slider.Value;
+        };
+
+        // Test window 2: shapes and panel
+        Window shapesWin = WindowManager.CreateWindow(this, "Shapes & Panel", new Size(200, 220));
+        shapesWin.AutoFlush = true;
+
+        _ = shapesWin.CreateUIElement<Panel>(p =>
+        {
+            p.Position = new Point(10, 25);
+            p.Size = new Size(180, 80);
+            p.BackgroundColor = Color.FromArgb(48, 48, 48);
+        });
+
+        _ = shapesWin.CreateUIElement<UI.GUI.UIEelements.Shapes.Circle>(c =>
+        {
+            c.Position = new Point(20, 35);
+            c.Radius = 10;
+            c.Color = Color.Coral;
+        });
+
+        _ = shapesWin.CreateUIElement<UI.GUI.UIEelements.Shapes.Rectangle>(r =>
+        {
+            r.Position = new Point(60, 35);
+            r.Size = new Size(50, 30);
+            r.Color = Color.CornflowerBlue;
+            r.IsFilled = true;
+        });
+
+        _ = shapesWin.CreateUIElement<UI.GUI.UIEelements.Shapes.Text>(t =>
+        {
+            t.Position = new Point(10, 120);
+            t.Content = "Hello from the desktop!";
+            t.Color = Color.White;
+            t.FontSize = 14;
+        });
+
+        _ = shapesWin.CreateUIElement<UI.GUI.UIEelements.Shapes.Line>(l =>
+        {
+            l.Position = new Point(10, 150);
+            l.EndPosition = new Point(180, 180);
+            l.Color = Color.Orange;
+        });
+
+        CheckBox shapesCheck = shapesWin.CreateUIElement<CheckBox>(c =>
+        {
+            c.Position = new Point(10, 185);
+            c.Size = new Size(180, 20);
+            c.Text = "Toggle";
+        });
+
+        shapesCheck.OnCheckedChanged += (_, _) => { };
     }
 
     internal override void Tick()
diff --git a/UI/GUI/UIEelements/Controls/Panel.cs b/UI/GUI/UIEelements/Controls/Panel.cs
new file mode 100644
index 0000000..6d12353
--- /dev/null
+++ b/UI/GUI/UIEelements/Controls/Panel.cs
@@ -0,0 +1,24 @@
+using RemSox.UI.GUI.Rendering;
+
+using System.Drawing;
+
+namespace RemSox.UI.GUI.UIEelements.Controls;
+
+public class Panel() : Control("Panel")
+{
+    public override IEnumerable<RenderCommand> ToPrimitives(int windowId)
+    {
+        yield return new RenderCommand
+        {
+            WindowId = windowId,
+            ElementId = PrimitiveId(0),
+            Type = RenderCommandType.DrawFilledRect,
+            Position = Position,
+            Properties = new Dictionary<string, object?>
+            {
+                ["Color"] = BackgroundColor,
+                ["Size"] = Size,
+            }
+        };
+    }
+}
diff --git a/UI/GUI/UIEelements/Controls/ProgressBar.cs b/UI/GUI/UIEelements/Controls/ProgressBar.cs
new file mode 100644
index 0000000..24b0386
--- /dev/null
+++ b/UI/GUI/UIEelements/Controls/ProgressBar.cs
@@ -0,0 +1,70 @@
+using RemSox.UI.GUI.Rendering;
+
+using System.Drawing;
+
+namespace RemSox.UI.GUI.UIEelements.Controls;
+
+public class ProgressBar() : Control("ProgressBar")
+{
+    public int Value
+    {
+        get;
+        set => SetProperty(nameof(Value), ref field, value);
+    }
+
+    public Color FillColor
+    {
+        get;
+        set => SetProperty(nameof(FillColor), ref field, value);
+    } = Color.Green;
+
+    public override IEnumerable<RenderCommand> ToPrimitives(int windowId)
+    {
+        // Background
+        yield return new RenderCommand
+        {
+            WindowId = windowId,
+            ElementId = PrimitiveId(0),
+            Type = RenderCommandType.DrawFilledRect,
+            Position = Position,
+            Properties = new Dictionary<string, object?>
+            {
+                ["Color"] = BackgroundColor,
+                ["Size"] = Size,
+            }
+        };
+
+        // Fill
+        int fillWidth = Size.Width * Math.Clamp(Value, 0, 100) / 100;
+
+        if (fillWidth > 0)
+        {
+            yield return new RenderCommand
+            {
+                WindowId = windowId,
+                ElementId = PrimitiveId(1),
+                Type = RenderCommandType.DrawFilledRect,
+                Position = Position,
+                Properties = new Dictionary<string, object?>
+                {
+                    ["Color"] = FillColor,
+                    ["Size"] = new Size(fillWidth, Size.Height),
+                }
+            };
+        }
+
+        // Border
+        yield return new RenderCommand
+        {
+            WindowId = windowId,
+            ElementId = PrimitiveId(2),
+            Type = RenderCommandType.DrawRectBorder,
+            Position = Position,
+            Properties = new Dictionary<string, object?>
+            {
+                ["Color"] = Color.DarkGray,
+                ["Size"] = Size,
+            }
+        };
+    }
+}
diff --git a/UI/GUI/UIEelements/Controls/RadioButton.cs b/UI/GUI/UIEelements/Controls/RadioButton.cs
new file mode 100644
index 0000000..8719e2e
--- /dev/null
+++ b/UI/GUI/UIEelements/Controls/RadioButton.cs
@@ -0,0 +1,103 @@
+using RemSox.UI.GUI.Rendering;
+
+using System.Drawing;
+
+namespace RemSox.UI.GUI.UIEelements.Controls;
+
+public class RadioButton() : Control("RadioButton")
+{
+    public event EventHandler? OnCheckedChanged;
+
+    public bool IsChecked
+    {
+        get;
+        set
+        {
+            SetProperty(nameof(IsChecked), ref field, value);
+            OnCheckedChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    public string Text
+    {
+        get;
+        set => SetProperty(nameof(Text), ref field, value);
+    } = string.Empty;
+
+    public Color TextColor
+    {
+        get;
+        set => SetProperty(nameof(TextColor), ref field, value);
+    } = Color.White;
+
+    public override IEnumerable<RenderCommand> ToPrimitives(int windowId)
+    {
+        int diameter = Size.Height;
+        int radius = diameter / 2;
+        Point center = new(Position.X + radius, Position.Y + radius);
+
+        // Outer circle
+        yield return new RenderCommand
+        {
+            WindowId = windowId,
+            ElementId = PrimitiveId(0),
+            Type = RenderCommandType.DrawCircle,
+            Position = new Point(center.X - radius, center.Y - radius),
+            Properties = new Dictionary<string, object?>
+            {
+                ["Color"] = Color.DarkGray,
+                ["Radius"] = radius,
+            }
+        };
+
+        // Inner fill when checked
+        if (IsChecked)
+        {
+            int innerRadius = radius - 3;
+            if (innerRadius > 0)
+            {
+                yield return new RenderCommand
+                {
+                    WindowId = windowId,
+                    ElementId = PrimitiveId(1),
+                    Type = RenderCommandType.DrawFilledCircle,
+                    Position = new Point(center.X - innerRadius, center.Y - innerRadius),
+                    Properties = new Dictionary<string, object?>
+                    {
+                        ["Color"] = Color.Black,
+                        ["Radius"] = innerRadius,
+                    }
+                };
+            }
+        }
+
+        // Label text
+        if (!string.IsNullOrEmpty(Text))
+        {
+            int textX = Position.X + diameter + 5;
+            int textY = Position.Y + (Size.Height / 2) - 8;
+
+            yield return new RenderCommand
+            {
+                WindowId = windowId,
+                ElementId = PrimitiveId(2),
+                Type = RenderCommandType.DrawText,
+                Position = new Point(textX, textY),
+                Properties = new Dictionary<string, object?>
+                {
+                    ["Color"] = TextColor,
+                    ["Content"] = Text,
+                    ["FontSize"] = Size.Height,
+                }
+            };
+        }
+    }
+
+    public override void HandleMouseEvent(MouseEvent mouseEvent)
+    {
+        if (mouseEvent.Type == MouseEventType.ButtonDown && mouseEvent.Button == MouseButton.Left)
+        {
+            IsChecked = true;
+        }
+    }
+}
diff --git a/UI/GUI/UIEelements/Controls/Slider.cs b/UI/GUI/UIEelements/Controls/Slider.cs
new file mode 100644
index 0000000..0085943
--- /dev/null
+++ b/UI/GUI/UIEelements/Controls/Slider.cs
@@ -0,0 +1,142 @@
+using RemSox.UI.GUI.Rendering;
+
+using System.Drawing;
+
+namespace RemSox.UI.GUI.UIEelements.Controls;
+
+public class Slider() : Control("Slider")
+{
+    public event EventHandler? OnValueChanged;
+
+    public int MinValue
+    {
+        get;
+        set => SetProperty(nameof(MinValue), ref field, value);
+    }
+
+    public int MaxValue
+    {
+        get;
+        set => SetProperty(nameof(MaxValue), ref field, value);
+    } = 100;
+
+    public int Value
+    {
+        get;
+        set
+        {
+            int clamped = Math.Clamp(value, MinValue, MaxValue);
+            SetProperty(nameof(Value), ref field, clamped);
+            if (Value == clamped)
+            {
+                OnValueChanged?.Invoke(this, EventArgs.Empty);
+            }
+        }
+    }
+
+    public Color ThumbColor
+    {
+        get;
+        set => SetProperty(nameof(ThumbColor), ref field, value);
+    } = Color.LightGray;
+
+    public override IEnumerable<RenderCommand> ToPrimitives(int windowId)
+    {
+        int trackHeight = 4;
+        int trackY = Position.Y + (Size.Height / 2) - (trackHeight / 2);
+
+        // Track background
+        yield return new RenderCommand
+        {
+            WindowId = windowId,
+            ElementId = PrimitiveId(0),
+            Type = RenderCommandType.DrawFilledRect,
+            Position = new Point(Position.X, trackY),
+            Properties = new Dictionary<string, object?>
+            {
+                ["Color"] = Color.DimGray,
+                ["Size"] = new Size(Size.Width, trackHeight),
+            }
+        };
+
+        // Filled portion
+        int range = MaxValue - MinValue;
+        int fillWidth = range > 0 ? Size.Width * (Value - MinValue) / range : 0;
+
+        if (fillWidth > 0)
+        {
+            yield return new RenderCommand
+            {
+                WindowId = windowId,
+                ElementId = PrimitiveId(1),
+                Type = RenderCommandType.DrawFilledRect,
+                Position = new Point(Position.X, trackY),
+                Properties = new Dictionary<string, object?>
+                {
+                    ["Color"] = BackgroundColor,
+                    ["Size"] = new Size(fillWidth, trackHeight),
+                }
+            };
+        }
+
+        // Thumb (centered at the fill edge)
+        int thumbSize = Size.Height;
+        int thumbX = fillWidth - (thumbSize / 2);
+        int thumbY = Position.Y;
+
+        yield return new RenderCommand
+        {
+            WindowId = windowId,
+            ElementId = PrimitiveId(2),
+            Type = RenderCommandType.DrawFilledCircle,
+            Position = new Point(Position.X + thumbX, thumbY),
+            Properties = new Dictionary<string, object?>
+            {
+                ["Color"] = ThumbColor,
+                ["Radius"] = thumbSize / 2,
+            }
+        };
+
+        // Thumb border
+        yield return new RenderCommand
+        {
+            WindowId = windowId,
+            ElementId = PrimitiveId(3),
+            Type = RenderCommandType.DrawCircle,
+            Position = new Point(Position.X + thumbX, thumbY),
+            Properties = new Dictionary<string, object?>
+            {
+                ["Color"] = Color.DarkGray,
+                ["Radius"] = thumbSize / 2,
+            }
+        };
+    }
+
+    private bool isDragging;
+
+    public override void HandleMouseEvent(MouseEvent mouseEvent)
+    {
+        if (mouseEvent.Type == MouseEventType.ButtonDown && mouseEvent.Button == MouseButton.Left)
+        {
+            isDragging = true;
+            SetValueFromX(mouseEvent.X);
+        }
+        else if (mouseEvent.Type == MouseEventType.Move && isDragging)
+        {
+            SetValueFromX(mouseEvent.X);
+        }
+        else if (mouseEvent.Type == MouseEventType.ButtonUp && mouseEvent.Button == MouseButton.Left)
+        {
+            isDragging = false;
+        }
+    }
+
+    private void SetValueFromX(int windowX)
+    {
+        int localX = windowX - Position.X;
+        int range = MaxValue - MinValue;
+        Value = range > 0
+            ? MinValue + (localX * range / Size.Width)
+            : MinValue;
+    }
+}
diff --git a/UI/GUI/Windows/Window.cs b/UI/GUI/Windows/Window.cs
index 9509468..3e2f109 100644
--- a/UI/GUI/Windows/Window.cs
+++ b/UI/GUI/Windows/Window.cs
@@ -64,6 +64,7 @@ public sealed class Window(string title, int processId, int id, IRenderSource re
     private readonly Dictionary<int, UIElement> uiElements = [];
     private readonly Dictionary<int, Control> controls = [];
     private Control? focusedControl = null;
+    private Control? capturedControl = null;
 
     private int nextUIElementId = 1;
 
@@ -354,13 +355,19 @@ public sealed class Window(string title, int processId, int id, IRenderSource re
 
         Point local = new(mouseEvent.X - Position.X, mouseEvent.Y - Position.Y);
 
-        Control? target = HitTestControl(local);
-
         if (mouseEvent.Type == MouseEventType.ButtonDown && mouseEvent.Button == MouseButton.Left)
         {
-            focusedControl = target;
+            capturedControl = HitTestControl(local);
+            focusedControl = capturedControl;
         }
 
+        if (mouseEvent.Type == MouseEventType.ButtonUp && mouseEvent.Button == MouseButton.Left)
+        {
+            capturedControl = null;
+        }
+
+        Control? target = capturedControl ?? HitTestControl(local);
+
         if (target is null)
         {
             return;