Preparando los UserControl - PArece que la persistencia funciona

CtrEditor.csproj

@@ -2,13 +2,14 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-    <TargetFramework>net7.0-windows</TargetFramework>
+    <TargetFramework>net8.0-windows8.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <UseWPF>true</UseWPF>
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.77" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Ookii.Dialogs.Wpf" Version="5.0.1" />
   </ItemGroup>

DatosDeTrabajo.cs

@@ -18,6 +18,16 @@ namespace CtrEditor
             CargarImagenes(); // Inicializar la carga de imágenes basada en el directorio persistente
         }
 
+        public string ObtenerPathImagenConExtension(string key, string extension)
+        {
+            if (Imagenes.TryGetValue(key, out string imagePath))
+            {
+                string jsonPath = Path.ChangeExtension(imagePath, extension);
+                return jsonPath;
+            }
+            return null;
+        }
+
         public void CargarImagenes()
         {
             Imagenes.Clear();

MainViewModel.cs

@@ -8,31 +8,127 @@ using System.Threading.Tasks;
 using System.Windows.Controls;
 using System.Windows.Input;
 using Ookii.Dialogs.Wpf;
-using System.Windows.Input;
 using System.Collections.ObjectModel;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
+using static System.Runtime.InteropServices.JavaScript.JSType;
+using System.Windows.Threading;
+using CtrEditor.ObjetosSim;
+using System.IO;
+using System.Windows.Forms;
+using System.Text.Json.Serialization;
+using System.Text.Json;
+using Newtonsoft.Json;
 
 namespace CtrEditor
 {
+
     public class MainViewModel : INotifyPropertyChanged
     {
         public DatosDeTrabajo datosDeTrabajo { get; }
         public ObservableCollection<string> listaImagenes { get; private set; }  // Publicación de las claves del diccionario        
-        private string _selectedImage;
+        public ObservableCollection<TipoSimulable> ListaOsBase { get; } = new ObservableCollection<TipoSimulable>();
+
+        private readonly DispatcherTimer _timerSimulacion;
+
+        public ICommand StartSimulationCommand { get; }
+        public ICommand StopSimulationCommand { get; }
+        public ICommand ItemDoubleClickCommand { get; private set; }
+
 
         // Evento que se dispara cuando se selecciona una nueva imagen
         public event EventHandler<string> ImageSelected;
+        public event EventHandler<TickSimulacionEventArgs> TickSimulacion;
+        public event Action<osBase> OnUserControlSelected;
 
         public MainViewModel()
         {
             OpenWorkDirectoryCommand = new RelayCommand(OpenWorkDirectory);
             datosDeTrabajo = new DatosDeTrabajo();
-            listaImagenes = new ObservableCollection<string>(datosDeTrabajo.Imagenes.Keys);
+
+            InitializeTipoSimulableList();
+
+            ItemDoubleClickCommand = new ParameterizedRelayCommand(ExecuteDoubleClick);
+
+            _timerSimulacion = new DispatcherTimer();
+            _timerSimulacion.Interval = TimeSpan.FromMilliseconds(100); // ajusta el intervalo según sea necesario
+            _timerSimulacion.Tick += OnTickSimulacion;
+
+            StartSimulationCommand = new RelayCommand(StartSimulation);
+            StopSimulationCommand = new RelayCommand(StopSimulation);            
+
+        }
+
+        public void LoadInitialData()
+        {
+            // Suponiendo que "SelectedImage" es una propiedad que al establecerse dispara "ImageSelected"
             directorioTrabajo = EstadoPersistente.Instance.directorio;
         }
 
 
+        private TipoSimulable _selectedItem = null;
+        public TipoSimulable SelectedItem
+        {
+            get => _selectedItem;
+            set
+            {
+                if (_selectedItem != value)
+                {
+                    _selectedItem = value;
+                    OnPropertyChanged(nameof(SelectedItem));  // Notificar que la propiedad ha cambiado
+                }
+            }
+        }
+
+
+        private void ExecuteDoubleClick(object parameter)
+        {
+            if (parameter is TipoSimulable tipoSimulable)
+            {
+                var instance = Activator.CreateInstance(tipoSimulable.Tipo) as osBase;
+                if (instance != null)
+                {                    
+                    ObjetosSimulables.Add(instance);
+                    OnUserControlSelected?.Invoke(instance);
+                }
+            }
+        }
+
+        private void InitializeTipoSimulableList()
+        {
+            var baseType = typeof(osBase);
+            var types = AppDomain.CurrentDomain.GetAssemblies()
+                .SelectMany(assembly => assembly.GetTypes())
+                .Where(type => type.IsSubclassOf(baseType) && !type.IsAbstract);
+
+            foreach (var type in types)
+            {
+                ListaOsBase.Add(new TipoSimulable { Nombre = type.Name, Tipo = type });
+            }
+        }
+
+
+        private void StartSimulation()
+        {
+            _timerSimulacion.Start();
+        }
+
+        private void StopSimulation()
+        {
+            _timerSimulacion.Stop();
+        }
+
+        private void OnTickSimulacion(object sender, EventArgs e)
+        {
+            var args = new TickSimulacionEventArgs();
+            OnTickSimulacion(args);
+        }
+
+        protected virtual void OnTickSimulacion(TickSimulacionEventArgs e)
+        {
+            TickSimulacion?.Invoke(this, e);
+        }
+
         public string directorioTrabajo
         {
             get => EstadoPersistente.Instance.directorio;
@@ -44,27 +140,33 @@ namespace CtrEditor
                     EstadoPersistente.Instance.GuardarEstado();  // Guardar el estado actualizado
                     datosDeTrabajo.CargarImagenes();                    
                     listaImagenes = new ObservableCollection<string>(datosDeTrabajo.Imagenes.Keys);  // Actualizar claves
+                    SelectedImage = null;
+                    if (listaImagenes.FirstOrDefault() != null)
+                        SelectedImage = listaImagenes.FirstOrDefault();
                     OnPropertyChanged(nameof(directorioTrabajo));  // Notificar el cambio de propiedad
                     OnPropertyChanged(nameof(listaImagenes)); // Notificar que la lista de imágenes ha cambiado
                 }
             }
         }
 
+        private string _selectedImage = null;
         public string SelectedImage
         {
             get => _selectedImage;
             set
             {
-                if (_selectedImage != value)
+                if (_selectedImage != value && value != null)
                 {
+                    SaveStateObjetosSimulables();  // Guarda el estado antes de cambiar la imagen
                     _selectedImage = value;
-                    OnPropertyChanged(nameof(SelectedImage));
+                    LoadStateObjetosSimulables();                    
                     ImageSelected?.Invoke(this, datosDeTrabajo.Imagenes[value]); // Dispara el evento con la nueva ruta de imagen
                 }
+                _selectedImage = value;
+                OnPropertyChanged(nameof(SelectedImage));
             }
         }
         
-
         public ICommand OpenWorkDirectoryCommand { get; }
 
         private void OpenWorkDirectory()
@@ -76,6 +178,74 @@ namespace CtrEditor
             }
         }
 
+        // 
+        //  Lista de osBase
+        //
+        private ObservableCollection<osBase> objetosSimulables = new ObservableCollection<osBase>();
+
+        public ObservableCollection<osBase> ObjetosSimulables
+        {
+            get => objetosSimulables;
+            set
+            {
+                if (objetosSimulables != value)
+                {
+                    objetosSimulables = value;
+                    OnPropertyChanged(nameof(ObjetosSimulables));
+                }
+            }
+        }
+
+
+
+        public void SaveStateObjetosSimulables()
+        {
+            if (_selectedImage != null)
+            {
+                var settings = new JsonSerializerSettings
+                {
+                    Formatting = Formatting.Indented,
+                    NullValueHandling = NullValueHandling.Ignore,
+                    TypeNameHandling = TypeNameHandling.Auto
+                };
+                foreach (var obj in objetosSimulables)
+                {
+                    obj.VisualRepresentation = null;
+                }
+                var serializedData = JsonConvert.SerializeObject(objetosSimulables, settings);
+                File.WriteAllText(datosDeTrabajo.ObtenerPathImagenConExtension(_selectedImage, ".json"), serializedData);
+            }
+        }
+
+        public void LoadStateObjetosSimulables()
+        {
+            try
+            {
+                ObjetosSimulables.Clear();
+                if (_selectedImage != null)
+                {
+                    string jsonPath = datosDeTrabajo.ObtenerPathImagenConExtension(_selectedImage, ".json");
+                    if (File.Exists(jsonPath))
+                    {
+                        string jsonString = File.ReadAllText(jsonPath);
+                        var settings = new JsonSerializerSettings
+                        {
+                            TypeNameHandling = TypeNameHandling.Auto,
+                            ObjectCreationHandling = ObjectCreationHandling.Replace,
+                            PreserveReferencesHandling = PreserveReferencesHandling.Objects,
+                            ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor
+                        };
+                        objetosSimulables = JsonConvert.DeserializeObject<ObservableCollection<osBase>>(jsonString, settings);
+
+                        foreach (var obj in objetosSimulables)
+                        {
+                            OnUserControlSelected?.Invoke(obj);
+                        }
+                    }
+                }
+            }
+            catch { /* Consider logging the error or handling it appropriately */ }
+        }
 
         // Implementación de INotifyPropertyChanged...
 
@@ -84,6 +254,20 @@ namespace CtrEditor
         {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
         }
+
+
+    }
+
+    public class TipoSimulable
+    {
+        public string Nombre { get; set; }
+        public Type Tipo { get; set; }
+    }
+
+    public class TickSimulacionEventArgs : EventArgs
+    {
+        // Aquí puedes agregar propiedades o campos para pasar información adicional
+        // en el evento TickSimulacion
     }
 
 }

MainWindow.xaml

@@ -1,6 +1,8 @@
 <Window x:Class="CtrEditor.MainWindow"
+        xmlns:ctreditor="clr-namespace:CtrEditor" 
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:ctreditor="clr-namespace:CtrEditor" 
+        xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Height="450" Width="800"
         ResizeMode="CanResize" Title="{Binding directorioTrabajo}">
 
@@ -13,8 +15,8 @@
         <Menu VerticalAlignment="Top" HorizontalAlignment="Stretch">
             <MenuItem Header="Projecto">
                 <MenuItem Header="Abrir Directorio de trabajo" Command="{Binding OpenWorkDirectoryCommand}" />
-                <MenuItem Header="Iniciar Simulacion" Command="{Binding RunSimCommand}" />
+                <MenuItem Header="Iniciar Simulacion" Command="{Binding StartSimulationCommand}" />
-                <MenuItem Header="Detenet Simulacion" Command="{Binding StopSimCommand}" />
+                <MenuItem Header="Detenet Simulacion" Command="{Binding StopSimulationCommand}" />
                 <MenuItem Header="Guardar" Command="{Binding SaveCommand}" />
                 <MenuItem Header="Salir" Command="{Binding ExitCommand}" />
             </MenuItem>
@@ -23,9 +25,9 @@
         <Grid Margin="0,20,0,0">
             <!-- Margen superior para el menú -->
             <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*" MinWidth="100"/>
-                <ColumnDefinition Width="2*"/>
+                <ColumnDefinition Width="4*" MinWidth="200"/>
-                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*" MinWidth="100"/>
             </Grid.ColumnDefinitions>
 
             <!-- Primera Columna -->
@@ -35,25 +37,21 @@
                     <RowDefinition Height="1*"/>
                 </Grid.RowDefinitions>
                 <ListBox x:Name="ListaImagenes" Grid.Row="0"  Margin="5" ItemsSource="{Binding listaImagenes}" SelectedItem="{Binding SelectedImage}" />
-                <ListBox x:Name="ListaFunciones" Grid.Row="1" Margin="5"/>
+                <ListBox x:Name="ListaFunciones" Grid.Row="1" Margin="5" ItemsSource="{Binding ListaOsBase}" DisplayMemberPath="Nombre" SelectedItem="{Binding SelectedItem}">
+                    <i:Interaction.Triggers>
+                        <i:EventTrigger EventName="MouseDoubleClick">
+                            <i:InvokeCommandAction Command="{Binding ItemDoubleClickCommand}" CommandParameter="{Binding SelectedItem}"/>
+                        </i:EventTrigger>
+                    </i:Interaction.Triggers>
+                </ListBox>
             </Grid>
+            <!-- GridSplitter -->
+            <GridSplitter Grid.Column="0" Grid.Row="0" HorizontalAlignment="Right" Width="5" Background="LightGray" />
 
             <!-- Segunda Columna -->
             <Grid Grid.Column="1">
-                <Grid.RowDefinitions>
-                    <RowDefinition Height="Auto"/>
-                    <!-- Espacio para el menú -->
-                    <RowDefinition Height="*"/>
-                    <!-- Espacio restante para el Canvas -->
-                </Grid.RowDefinitions>
-
-                <Menu Grid.Row="0" Height="20" VerticalAlignment="Top">
-                    <MenuItem Header="Nuevo"/>
-                    <MenuItem Header="Eliminar"/>
-                </Menu>
-
                 <ScrollViewer x:Name="ImagenEnTrabajoScrollViewer" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto" PanningMode="Both">
-                    <Canvas x:Name="ImagenEnTrabajoCanvas" Margin="200">
+                    <Canvas x:Name="ImagenEnTrabajoCanvas" Margin="20">
                         <!-- El Margin puede ser ajustado según el espacio adicional que quieras proporcionar -->
                         <Canvas.LayoutTransform>
                             <ScaleTransform ScaleX="1" ScaleY="1"/>
@@ -62,6 +60,8 @@
                 </ScrollViewer>
             </Grid>
 
+            <!-- GridSplitter -->
+            <GridSplitter Grid.Column="1" Grid.Row="0" HorizontalAlignment="Right" Width="5" Background="LightGray" />
 
             <!-- Tercera Columna -->
             <Grid Grid.Column="2">

MainWindow.xaml.cs

@@ -8,6 +8,7 @@ using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using System.Windows.Navigation;
 using System.Windows.Shapes;
+using CtrEditor.ObjetosSim;
 
 namespace CtrEditor
 {
@@ -35,8 +36,57 @@ namespace CtrEditor
             if (DataContext is MainViewModel viewModel)
             {
                 viewModel.ImageSelected += ViewModel_ImageSelected;
+                viewModel.TickSimulacion += MainViewModel_TickSimulacion;
+                viewModel.OnUserControlSelected += AgregarUserControl;
+                viewModel?.LoadInitialData(); // Carga la primera imagen por defecto una vez cargada la ventana principal
             }
         }
+
+        private void AgregarUserControl(osBase NuevoOS)
+        {
+            if (NuevoOS != null)
+            {
+                if (NuevoOS.VisualRepresentation is null)
+                {
+                    UserControl userControl = UserControlFactory.GetControlForType(NuevoOS.GetType());
+                    NuevoOS.VisualRepresentation = userControl;
+
+                    if (!NuevoOS.Inicializado) // Aun no fue inicializado
+                    {
+                        // Obtiene el área visible del ScrollViewer
+                        var visibleWidth = ImagenEnTrabajoScrollViewer.ViewportWidth;
+                        var visibleHeight = ImagenEnTrabajoScrollViewer.ViewportHeight;
+
+                        // Obtiene la posición actual del desplazamiento
+                        var offsetX = ImagenEnTrabajoScrollViewer.HorizontalOffset;
+                        var offsetY = ImagenEnTrabajoScrollViewer.VerticalOffset;
+
+                        // Calcula el centro visible del Canvas
+                        double centerX = offsetX + visibleWidth / 2;
+                        double centerY = offsetY + visibleHeight / 2;
+
+                        // Ajusta la posición del UserControl para que esté centrado en el área visible
+                        double left = centerX - (userControl.ActualWidth / 2);
+                        double top = centerY - (userControl.ActualHeight / 2);
+
+                        // Establece la posición del UserControl
+                        Canvas.SetLeft(userControl, left);
+                        Canvas.SetTop(userControl, top);
+
+                        NuevoOS.x = left;
+                        NuevoOS.y = top;
+
+                        NuevoOS.Inicializado = true;
+                    }
+
+                    // Añade el UserControl al Canvas
+                    ImagenEnTrabajoCanvas.Children.Add(userControl);
+                }
+            }
+        }
+
+
+
         private void ViewModel_ImageSelected(object sender, string imagePath)
         {
             LoadImageToCanvas(imagePath);
@@ -58,7 +108,7 @@ namespace CtrEditor
             // Elimina solo los ROIs, no la imagen de fondo
             for (int i = ImagenEnTrabajoCanvas.Children.Count - 1; i >= 0; i--)
             {
-                if (ImagenEnTrabajoCanvas.Children[i] is Rectangle)
+                if (ImagenEnTrabajoCanvas.Children[i] is not Image)
                 {
                     ImagenEnTrabajoCanvas.Children.RemoveAt(i);
                 }
@@ -139,6 +189,20 @@ namespace CtrEditor
             e.Handled = true; // Evita el procesamiento adicional del evento
         }
 
+        private void MainViewModel_TickSimulacion(object sender, TickSimulacionEventArgs e)
+        {
+            // aquí puedes agregar la lógica para actualizar tus UserControl
+            // en el ImagenEnTrabajoCanvas
+            foreach (var child in ImagenEnTrabajoCanvas.Children)
+            {
+                if (child is osBase uc)
+                {
+                    // llama al método Update de cada UserControl
+                    uc.Update();
+                }
+            }
+        }
+
         private void MainWindow_Closed(object sender, EventArgs e)
         {
             if (DataContext is MainViewModel viewModel)

ObjetoSimuladoPack.xaml

@@ -1,6 +0,0 @@
-<UserControl x:Class="CtrEditor.ObjetoSimuladoPack"
-             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             Width="200" Height="150">
-    <Border Background="Gray" CornerRadius="2" Height="10" Width="10"/>
-</UserControl>

ObjetoSimuladoPack.xaml.cs

@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
-
-namespace CtrEditor
-{
-    /// <summary>
-    /// Interaction logic for ObjetoSimuladoPack.xaml
-    /// </summary>
-    public partial class ObjetoSimuladoPack : UserControl
-    {
-        public ObjetoSimuladoPack()
-        {
-            InitializeComponent();
-        }
-    }
-
-}

ObjetosSim/UserControlFactory.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+
+namespace CtrEditor.ObjetosSim
+{
+    public static class UserControlFactory
+    {
+        public static UserControl GetControlForType(Type tipoObjeto)
+        {
+            if (tipoObjeto == typeof(osBotella))
+                return new ucBotella();
+            if (tipoObjeto == typeof(osTransporteTTop))
+                return new ucTransporteTTop();
+
+            // Puedes añadir más condiciones para otros tipos
+
+
+            return null;
+        }
+    }
+
+}

ObjetosSim/osBase.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+
+namespace CtrEditor.ObjetosSim
+{
+
+    public interface IosBase
+    {
+        string Nombre { get; }
+        void Update();        
+    }
+
+
+    public abstract class osBase : IosBase
+    {
+        private UserControl? _visualRepresentation = null;
+
+        [JsonIgnore]
+        public UserControl? VisualRepresentation
+        {
+            get => _visualRepresentation;
+            set => _visualRepresentation = value;
+        }
+
+        // Método para inicializar la representación visual, si es necesario        
+        //public void InitializeVisualRepresentation()
+        //{
+        //    // Suponiendo que existe un método estático para obtener el UserControl adecuado            
+        //    _visualRepresentation = UserControlFactory.GetControlForType(this.GetType());
+        //}
+        public string Nombre => "Base";
+        public abstract void Update();
+        public bool Inicializado = false;
+        public double x { get; set; }
+        public double y { get; set; }
+
+
+    }
+}

ObjetosSim/ucBotella.xaml

@@ -1,6 +1,5 @@
-<UserControl x:Class="CtrEditor.ObjetoSimuladoBotella"
+<UserControl x:Class="CtrEditor.ObjetosSim.ucBotella"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
-             Width="100" Height="300">
     <Border Background="Brown" CornerRadius="10" Height="10" Width="10"/>
 </UserControl>

ObjetosSim/ucBotella.xaml.cs

@@ -13,17 +13,30 @@ using System.Windows.Media.Imaging;
 using System.Windows.Navigation;
 using System.Windows.Shapes;
 
-namespace CtrEditor
+namespace CtrEditor.ObjetosSim
 {
     /// <summary>
-    /// Interaction logic for ObjetoSimuladoBotella.xaml
+    /// Interaction logic for ucBotella.xaml
     /// </summary>
-    public partial class ObjetoSimuladoBotella : UserControl
+    /// 
+    
+    public class osBotella : osBase
     {
-        public ObjetoSimuladoBotella()
+        public double diametro { get; set; }
+        // Otros datos y métodos relevantes para la simulación
+
+        public new string Nombre => "Botella";
+        public override void Update()
+        {
+            // implementation of Update method
+        }
+    }
+
+    public partial class ucBotella : UserControl
+    {
+        public ucBotella()
         {
             InitializeComponent();
         }
     }
-
 }

ObjetosSim/ucTransporteTTop.xaml

@@ -0,0 +1,9 @@
+<UserControl x:Class="CtrEditor.ObjetosSim.ucTransporteTTop"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:CtrEditor"
+             mc:Ignorable="d" >
+    <Rectangle HorizontalAlignment="Left" Height="10" Margin="0,0,0,0" Stroke="Black" VerticalAlignment="Top" Width="100"/>
+</UserControl>

ObjetosSim/ucTransporteTTop.xaml.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace CtrEditor.ObjetosSim
+{
+    /// <summary>
+    /// Interaction logic for ucTransporteTTop.xaml
+    /// </summary>
+    /// 
+    
+    public class osTransporteTTop : osBase
+    {
+        public double diametro { get; set; }
+        // Otros datos y métodos relevantes para la simulación
+
+        public new string Nombre => "Transporte TTOP";
+        public override void Update()
+        {
+            // implementation of Update method
+        }
+    }
+
+    public partial class ucTransporteTTop : UserControl
+    {
+        public ucTransporteTTop()
+        {
+            InitializeComponent();
+        }
+    }
+}

RelayCommand.cs

@@ -39,4 +39,37 @@ namespace CtrEditor
             CommandManager.InvalidateRequerySuggested();
         }
     }
+    public class ParameterizedRelayCommand : ICommand
+    {
+        private readonly Action<object> _execute;
+        private readonly Predicate<object> _canExecute;
+
+        public ParameterizedRelayCommand(Action<object> execute, Predicate<object> canExecute = null)
+        {
+            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
+            _canExecute = canExecute;
+        }
+
+        public bool CanExecute(object parameter)
+        {
+            return _canExecute == null || _canExecute(parameter);
+        }
+
+        public void Execute(object parameter)
+        {
+            _execute(parameter);
+        }
+
+        public event EventHandler CanExecuteChanged
+        {
+            add { CommandManager.RequerySuggested += value; }
+            remove { CommandManager.RequerySuggested -= value; }
+        }
+
+        public void RaiseCanExecuteChanged()
+        {
+            CommandManager.InvalidateRequerySuggested();
+        }
+    }
+
 }

estadoPersistente.cs

@@ -3,9 +3,9 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using Newtonsoft.Json;
 using System;
 using System.IO;
+using System.Text.Json;
 
 namespace CtrEditor
 {
@@ -28,9 +28,14 @@ namespace CtrEditor
         }
 
         // Constructor privado para evitar la instanciación externa
-        private EstadoPersistente()
+        public EstadoPersistente()
+        {            
+        }
+
+        private EstadoPersistente Inizializar()
         {
             _strDirectorioTrabajo = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+            return this;
         }
 
         // Propiedad pública estática para acceder a la instancia
@@ -47,21 +52,34 @@ namespace CtrEditor
         }
 
         // Método para guardar el estado en un archivo JSON
+
+
         public void GuardarEstado()
         {
-            string json = JsonConvert.SerializeObject(this);
+            var options = new JsonSerializerOptions
+            {
+                WriteIndented = true // para una salida JSON formateada legiblemente
+            };
+            string json = JsonSerializer.Serialize(this, options);
             File.WriteAllText(_filePath, json);
         }
 
+
         // Método estático para cargar el estado desde un archivo JSON
         private static EstadoPersistente CargarEstado()
+        {
+            try
             {
                 if (File.Exists(_filePath))
                 {
                     string json = File.ReadAllText(_filePath);
-                return JsonConvert.DeserializeObject<EstadoPersistente>(json);
+                    return JsonSerializer.Deserialize<EstadoPersistente>(json);
+                }                
+                return new EstadoPersistente().Inizializar(); // Devuelve una nueva instancia si no existe el archivo
+            } catch
+            {
+                return new EstadoPersistente().Inizializar(); // Devuelve una nueva instancia si no existe el archivo
             }
-            return new EstadoPersistente(); // Devuelve una nueva instancia si no existe el archivo
         }
     }