MainWindow.axaml.cs

using System;
using System.IO;
using System.Linq;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Media;
using Avalonia.Layout;
using Avalonia.Markup.Xaml;
using Avalonia.Controls.Shapes;
using System.Threading.Tasks;
using Avalonia.Threading;
using Avalonia.Media.Imaging;

namespace AvaloniaApplicationtest1
{
    public partial class MainWindow : Window
    {
        private Window _calculatorWindowInstance = null;

        private ThermoEOSWindow _ThermoEOSWindowInstance = null;
        private ModelBuilderWindow _ModelBuilderWindowInstance = null;
        private ModelSolverWindow _ModelSolverWindowInstance = null;
        private PIDControllerWindow _PIDControllerWindowInstance = null;
        private OPCConnectorWindow _OPCConnectorWindowInstance = null;
        private AIOptimizerWindow _AIOptimizerWindowInstance = null;

        private DispatcherTimer _timer;
        private DispatcherTimer _imageUpdateTimer;
        private const string ImageFolderPath = @"C:\Users\ljh\Desktop\气象图"; // 图片文件夹路径

        public MainWindow()
        {
            InitializeComponent();
            if (this.FindControl<Grid>("DynamicGrid") != null)
            {
                Console.WriteLine("DynamicGrid is initialized.");
                PopulateGridWithRectangles(this.FindControl<Grid>("DynamicGrid"));

            }
            else
            {
                Console.WriteLine("DynamicGrid is not initialized.");
            }

            // 初始化定时器
            InitializeTimer();
            SystemTimeTextBlock = this.FindControl<TextBlock>("SystemTimeTextBlock");
            // 初始化图片更新功能
            InitializeImageUpdateTimer();

        }

        private void InitializeComponent()
        {
            AvaloniaXamlLoader.Load(this);
        }

        // *************************************************** Timer ***************************************************//
        private void InitializeTimer()
        {
            _timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(1) };
            _timer.Tick += UpdateSystemTime;
            _timer.Start();

            // 立即更新一次时间
            UpdateSystemTime(null, EventArgs.Empty);
        }

        private void UpdateSystemTime(object sender, EventArgs e)
        {
            if (SystemTimeTextBlock != null)
            {
                string currentTime = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss");
                SystemTimeTextBlock.Text = currentTime;
                Console.WriteLine($"Current Time: {currentTime}");
            }
        }

        // *************************************************** Image Update Timer ***************************************************//
        // 初始化图片更新定时器
        private void InitializeImageUpdateTimer()
        {
            _imageUpdateTimer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMinutes(30) // 每 30 分钟触发一次
            };
            _imageUpdateTimer.Tick += UpdateWeatherImage;
            _imageUpdateTimer.Start();

            // 立即加载一次图片
            UpdateWeatherImage(null, EventArgs.Empty);
        }

        // 更新图片逻辑
        private void UpdateWeatherImage(object sender, EventArgs e)
        {
            try
            {
                if (Directory.Exists(ImageFolderPath))
                {
                    // 获取文件夹内最新的图片文件
                    var latestImageFile = Directory.GetFiles(ImageFolderPath, "*.jpg")
                        .Concat(Directory.GetFiles(ImageFolderPath, "*.png"))
                        .Concat(Directory.GetFiles(ImageFolderPath, "*.bmp"))
                        .OrderByDescending(File.GetLastWriteTime)
                        .FirstOrDefault();

                    if (!string.IsNullOrEmpty(latestImageFile) && File.Exists(latestImageFile))
                    {
                        // 加载图片到 Image 控件
                        var bitmap = new Bitmap(latestImageFile);
                        var weatherImage = this.FindControl<Image>("WeatherImage");
                        if (weatherImage != null)
                        {
                            weatherImage.Source = bitmap;
                            Console.WriteLine($"Updated image: {latestImageFile}");
                        }
                    }
                    else
                    {
                        Console.WriteLine("No image files found in the specified folder.");
                    }
                }
                else
                {
                    Console.WriteLine($"Directory does not exist: {ImageFolderPath}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error updating image: {ex.Message}");
            }
        }

        // ************************************************** Calculator_Click **************************************************//
        private void Calculator_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            if (_calculatorWindowInstance == null || !_calculatorWindowInstance.IsVisible)
            {
                _calculatorWindowInstance = new CalculatorWindow
                {
                    Width = 720,
                    Height = 480,
                    Title = "Calculator",
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };
                _calculatorWindowInstance.Show(this);

                _calculatorWindowInstance.Closed += (s, ev) =>
                {
                    _calculatorWindowInstance = null;
                };
            }
            else
            {
                if (_calculatorWindowInstance.WindowState == WindowState.Minimized)
                {
                    _calculatorWindowInstance.WindowState = WindowState.Normal;
                }
                _calculatorWindowInstance.Activate();
            }
        }

        // ************************************************** ThermoEOS_Click **************************************************//
        private async void ThermoEOS_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            if (_ThermoEOSWindowInstance == null || !_ThermoEOSWindowInstance.IsVisible)
            {
                _ThermoEOSWindowInstance = new ThermoEOSWindow
                {
                    Width = 1080,
                    Height = 720,
                    Title = "ThermoEOS",
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };
                _ThermoEOSWindowInstance.Show(this);

                _ThermoEOSWindowInstance.Closed += (s, ev) =>
                {
                    _ThermoEOSWindowInstance = null;
                };
            }
            else
            {
                if (_ThermoEOSWindowInstance.WindowState == WindowState.Minimized)
                {
                    _ThermoEOSWindowInstance.WindowState = WindowState.Normal;
                }
                _ThermoEOSWindowInstance.Activate();
            }

            await Task.Run(() => PerformCalculation("ThermoEOS", 1));
        }



        // ************************************************** ModelBuilder_Click **************************************************//
        private async void ModelBuilder_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            if (_ModelBuilderWindowInstance == null || !_ModelBuilderWindowInstance.IsVisible)
            {
                _ModelBuilderWindowInstance = new ModelBuilderWindow
                {
                    Width = 1080,
                    Height = 720,
                    Title = "ModelBuilder",
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };
                _ModelBuilderWindowInstance.Show(this);

                _ModelBuilderWindowInstance.Closed += (s, ev) =>
                {
                    _ModelBuilderWindowInstance = null;
                };
            }
            else
            {
                if (_ModelBuilderWindowInstance.WindowState == WindowState.Minimized)
                {
                    _ModelBuilderWindowInstance.WindowState = WindowState.Normal;
                }
                _ModelBuilderWindowInstance.Activate();
            }

            await Task.Run(() => PerformCalculation("ModelBuilder", 1));
        }


        // ************************************************** ModelSolver_Click **************************************************//
        private async void ModelSolver_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            if (_ModelSolverWindowInstance == null || !_ModelSolverWindowInstance.IsVisible)
            {
                _ModelSolverWindowInstance = new ModelSolverWindow
                {
                    Width = 1080,
                    Height = 720,
                    Title = "ModelSolver",
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };
                _ModelSolverWindowInstance.Show(this);
                _ModelSolverWindowInstance.Closed += (s, ev) =>
                {
                    _ModelSolverWindowInstance = null;
                };
            }
            else
            {
                if (_ModelSolverWindowInstance.WindowState == WindowState.Minimized)
                {
                    _ModelSolverWindowInstance.WindowState = WindowState.Normal;
                }
                _ModelSolverWindowInstance.Activate();
            }
            await Task.Run(() => PerformCalculation("ModelSolver", 2));
        }
        



        // ************************************************** PIDController_Click **************************************************//
        private async void PIDController_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            if (_PIDControllerWindowInstance == null || !_PIDControllerWindowInstance.IsVisible)
            {
                _PIDControllerWindowInstance = new PIDControllerWindow
                {
                    Width = 1080,
                    Height = 720,
                    Title = "PIDController",
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };
                _PIDControllerWindowInstance.Show(this);
                _PIDControllerWindowInstance.Closed += (s, ev) =>
                {
                    _PIDControllerWindowInstance = null;
                };
            }
            else
            {
                if (_PIDControllerWindowInstance.WindowState == WindowState.Minimized)
                {
                    _PIDControllerWindowInstance.WindowState = WindowState.Normal;
                }
                _PIDControllerWindowInstance.Activate();
            }
            
            await Task.Run(() => PerformCalculation("PIDController", 3));
        }

        // ************************************************** OPCConnector_Click **************************************************//
        private async void OPCConnector_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            if (_OPCConnectorWindowInstance == null || !_OPCConnectorWindowInstance.IsVisible)
            {
                _OPCConnectorWindowInstance = new OPCConnectorWindow
                {
                    Width = 1080,
                    Height = 720,
                    Title = "OPCConnector",
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };
                _OPCConnectorWindowInstance.Show(this);
                _OPCConnectorWindowInstance.Closed += (s, ev) =>
                {
                    _OPCConnectorWindowInstance = null;
                };
            }
            else
            {
                if (_OPCConnectorWindowInstance.WindowState == WindowState.Minimized)
                {
                    _OPCConnectorWindowInstance.WindowState = WindowState.Normal;
                }
                _OPCConnectorWindowInstance.Activate();
            }
            await Task.Run(() => PerformCalculation("OPCConnector", 4));
        }

        // ************************************************** AIOptimizer_Click **************************************************//
        private async void AIOptimizer_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
        {
            if (_AIOptimizerWindowInstance == null || !_AIOptimizerWindowInstance.IsVisible)
            {
                _AIOptimizerWindowInstance = new AIOptimizerWindow
                {
                    Width = 1080,
                    Height = 720,
                    Title = "AIOptimizer",
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };
                _AIOptimizerWindowInstance.Show(this);
                _AIOptimizerWindowInstance.Closed += (s, ev) =>
                {
                    _AIOptimizerWindowInstance = null;
                };
            }
            else
            {
                if (_AIOptimizerWindowInstance.WindowState == WindowState.Minimized)
                {
                    _AIOptimizerWindowInstance.WindowState = WindowState.Normal;
                }
                _AIOptimizerWindowInstance.Activate();
            }
            await Task.Run(() => PerformCalculation("AIOptimizer", 5));
        }

        private void PerformCalculation(string taskName, int coreIndex)
        {
            Console.WriteLine($"{taskName} 开始在核心 {coreIndex} 上运行...");
            for (int i = 0; i < 1000000000; i++)
            {
                // 简单的循环，模拟计算工作负载
            }
            Console.WriteLine($"{taskName} 在核心 {coreIndex} 上完成！");
        }






        // ***************************************************  DynamicGrid ***************************************************//
        private void PopulateGridWithRectangles(Grid grid)
        {
            Random random = new Random();

            int rowCount = grid.RowDefinitions.Count;
            int columnCount = grid.ColumnDefinitions.Count;

            for (int row = 0; row < rowCount; row++)
            {
                for (int col = 0; col < columnCount; col++)
                {
                    if (grid.Children.FirstOrDefault(c => Grid.GetRow(c) == row && Grid.GetColumn(c) == col) != null)
                        continue;

                    // 正确引用 Rectangle 类
                    var rectangle = new Rectangle
                    {
                        Fill = GetRandomColorBrush(random),
                        Width = double.NaN,
                        Height = double.NaN,
                        HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Stretch,
                        VerticalAlignment = Avalonia.Layout.VerticalAlignment.Stretch
                    };

                    Grid.SetRow(rectangle, row);
                    Grid.SetColumn(rectangle, col);

                    grid.Children.Add(rectangle);
                }
            }
        }

        private SolidColorBrush GetRandomColorBrush(Random random)
        {
            byte r = (byte)random.Next(256);
            byte g = (byte)random.Next(256);
            byte b = (byte)random.Next(256);
            return new SolidColorBrush(Color.FromRgb(r, g, b));
        }
    }
}