Program.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Threading;
using GalaxyUI.UIElement;

namespace GalaxyUI
{
    /// <summary>
    /// Entry point for the GalaxyUI framework
    /// </summary>
    public static class Galaxy
    {
        private static bool _initialized = false;
        private static List<Window> _windows = new List<Window>();

        /// <summary>
        /// Initializes the GalaxyUI framework
        /// </summary>

        static void Main(string[] args)
        {
            try
            {
                // Initialize the GalaxyUI framework
                Galaxy.Initialize();


                // Add UI elements to the window (assuming Window has methods to add elements)
                // Example (implementation would depend on the UIElement namespace):
                 Button button = new Button();
                 button.Text = "Click Me";


                // Show the window

                // Start the application event loop
                // This will block until all windows are closed
                Galaxy.Run();

                Console.WriteLine("Application has exited gracefully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
        }

        public static void Initialize()
        {
            if (_initialized)
                return;

            HyperDimension.Initialize();
            ThemeManager.Initialize();

            _initialized = true;
            Console.WriteLine("GalaxyUI initialized successfully!");
        }

        /// <summary>
        /// Starts the application event loop
        /// </summary>
        public static void Run()
        {
            if (!_initialized)
                throw new InvalidOperationException("GalaxyUI must be initialized before calling Run()");

            // Start the message pump
            MessagePump.Start();

            // Wait until all windows are closed
            while (_windows.Count > 0)
            {
                Thread.Sleep(10);
            }
        }

        /// <summary>
        /// Registers a window with the framework
        /// </summary>
        internal static void RegisterWindow(Window window)
        {
            _windows.Add(window);
        }

        /// <summary>
        /// Unregisters a window from the framework
        /// </summary>
        internal static void UnregisterWindow(Window window)
        {
            _windows.Remove(window);
        }
    }

    /// <summary>
    /// Core rendering engine for GalaxyUI
    /// </summary>
    public static class HyperDimension
    {
        private static bool _initialized = false;

        internal static void Initialize()
        {
            if (_initialized)
                return;

            // Initialize DirectX or OpenGL bindings here
            NativeRenderingEngine.Initialize();

            _initialized = true;
        }

        /// <summary>
        /// Creates a rendering context for a window
        /// </summary>
        internal static RenderContext CreateContext(IntPtr windowHandle)
        {
            return new RenderContext(windowHandle);
        }
    }

    /// <summary>
    /// Native rendering operations using platform API calls
    /// </summary>
    internal static class NativeRenderingEngine
    {
        [DllImport("user32.dll")]
        private static extern IntPtr GetDC(IntPtr hWnd);

        [DllImport("user32.dll")]
        private static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);

        [DllImport("gdi32.dll")]
        private static extern IntPtr CreateCompatibleDC(IntPtr hDC);

        [DllImport("gdi32.dll")]
        private static extern IntPtr CreateCompatibleBitmap(IntPtr hDC, int nWidth, int nHeight);

        [DllImport("gdi32.dll")]
        private static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);

        [DllImport("gdi32.dll")]
        private static extern bool DeleteObject(IntPtr hObject);

        [DllImport("gdi32.dll")]
        private static extern bool DeleteDC(IntPtr hDC);

        internal static void Initialize()
        {
            // Initialize any necessary native resources
        }

        internal static IntPtr GetDeviceContext(IntPtr windowHandle)
        {
            return GetDC(windowHandle);
        }

        internal static void ReleaseDeviceContext(IntPtr windowHandle, IntPtr deviceContext)
        {
            ReleaseDC(windowHandle, deviceContext);
        }

        internal static IntPtr CreateBackBuffer(IntPtr deviceContext, int width, int height)
        {
            IntPtr memoryDC = CreateCompatibleDC(deviceContext);
            IntPtr bitmap = CreateCompatibleBitmap(deviceContext, width, height);
            SelectObject(memoryDC, bitmap);
            DeleteObject(bitmap);
            return memoryDC;
        }

        internal static void DeleteBackBuffer(IntPtr backBuffer)
        {
            DeleteDC(backBuffer);
        }
    }

    /// <summary>
    /// Rendering context for a specific window
    /// </summary>
    public class RenderContext
    {
        private IntPtr _windowHandle;
        private IntPtr _deviceContext;
        private IntPtr _backBuffer;
        private Size _size;

        internal RenderContext(IntPtr windowHandle)
        {
            _windowHandle = windowHandle;
            _deviceContext = NativeRenderingEngine.GetDeviceContext(windowHandle);
            _size = new Size(800, 600); // Default size
            _backBuffer = NativeRenderingEngine.CreateBackBuffer(_deviceContext, _size.Width, _size.Height);
        }

        public void Resize(int width, int height)
        {
            _size = new Size(width, height);

            // Recreate back buffer with new size
            if (_backBuffer != IntPtr.Zero)
                NativeRenderingEngine.DeleteBackBuffer(_backBuffer);

            _backBuffer = NativeRenderingEngine.CreateBackBuffer(_deviceContext, width, height);
        }

        public void BeginDraw()
        {
            // Clear the back buffer to prepare for drawing
        }

        public void EndDraw()
        {
            // Swap buffers to present the rendered content
        }

        internal void Dispose()
        {
            if (_backBuffer != IntPtr.Zero)
            {
                NativeRenderingEngine.DeleteBackBuffer(_backBuffer);
                _backBuffer = IntPtr.Zero;
            }

            if (_deviceContext != IntPtr.Zero)
            {
                NativeRenderingEngine.ReleaseDeviceContext(_windowHandle, _deviceContext);
                _deviceContext = IntPtr.Zero;
            }
        }
    }

    /// <summary>
    /// Handles OS-specific message processing
    /// </summary>
    internal static class MessagePump
    {
        private static bool _running = false;
        private static Thread _messageThread;

        internal static void Start()
        {
            if (_running)
                return;

            _running = true;
            _messageThread = new Thread(ProcessMessages);
            _messageThread.Start();
        }

        internal static void Stop()
        {
            _running = false;
            _messageThread.Join();
        }

        private static void ProcessMessages()
        {
            while (_running)
            {
                // Process Windows messages
                // This is a simplified version; a real implementation would use PInvoke to GetMessage/TranslateMessage/DispatchMessage
                Thread.Sleep(10);
            }
        }
    }

    /// <summary>
    /// Manages application themes
    /// </summary>
    public static class ThemeManager
    {
        private static Theme _currentTheme;

        internal static void Initialize()
        {
            _currentTheme = Theme.Dark; // Default theme
        }

        public static Theme CurrentTheme
        {
            get { return _currentTheme; }
            set { _currentTheme = value; OnThemeChanged(); }
        }

        public static event EventHandler ThemeChanged;

        private static void OnThemeChanged()
        {
            ThemeChanged?.Invoke(null, EventArgs.Empty);
        }
    }

    /// <summary>
    /// Application theme
    /// </summary>
    public enum Theme
    {
        Light,
        Dark,
        Custom
    }


}