Implemented .NET generator settings

I18N Commander/DataModel/Database/SettingNames.cs

@@ -8,4 +8,6 @@ public static class SettingNames
     public static readonly string DEEPL_SOURCE_CULTURE = "DeepL Source Culture";
     public static readonly string DEEPL_MODE = "DeepL Mode";
     public static readonly string GENERATOR_MODE = "Generator Mode";
+    public static readonly string GENERATOR_DOTNET_ENABLED = "Generator .NET Enabled";
+    public static readonly string GENERATOR_DOTNET_DESTINATION_PATH = "Generator .NET Destination Path";
 }

I18N Commander/Processor/AppSettings.cs

@@ -537,5 +537,153 @@ public static class AppSettings
     
     #endregion
 
+    #region .NET Generator Enabled/Disabled
+    
+    private static bool CACHE_GENERATOR_DOTNET_ENABLED = true;
+    private static bool CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = false;
+    
+    public static async Task<bool> GetGeneratorDotnetEnabled()
+    {
+        // When possible, use the cache:
+        if (CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED)
+            return CACHE_GENERATOR_DOTNET_ENABLED;
+
+        var generatorDotnetEnabled = false;
+        try
+        {
+            // Get the database:
+            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
+
+            // Check, if the setting is already set:
+            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_ENABLED) is { } existingSetting)
+            {
+                generatorDotnetEnabled = existingSetting.BoolValue;
+                return generatorDotnetEnabled;
+            }
+
+            // Does not exist, so create it:
+            var setting = new Setting
+            {
+                Code = SettingNames.GENERATOR_DOTNET_ENABLED,
+                BoolValue = generatorDotnetEnabled,
+            };
+
+            await db.Settings.AddAsync(setting);
+            await db.SaveChangesAsync();
+            return generatorDotnetEnabled;
+        }
+        finally
+        {
+            CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = true;
+            CACHE_GENERATOR_DOTNET_ENABLED = generatorDotnetEnabled;
+        }
+    }
+    
+    public static async Task SetGeneratorDotnetEnabled(bool enabled)
+    {
+        // Update the cache:
+        CACHE_GENERATOR_DOTNET_ENABLED = enabled;
+        CACHE_GENERATOR_DOTNET_ENABLED_IS_LOADED = true;
+        
+        // Get the database:
+        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
+        
+        // Check, if the setting is already set:
+        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_ENABLED) is { } existingSetting)
+        {
+            existingSetting.BoolValue = enabled;
+            await db.SaveChangesAsync();
+        }
+        
+        // Does not exist, so create it:
+        else
+        {
+            var setting = new Setting
+            {
+                Code = SettingNames.GENERATOR_DOTNET_ENABLED,
+                BoolValue = enabled,
+            };
+            
+            await db.Settings.AddAsync(setting);
+            await db.SaveChangesAsync();
+        }
+    }
+
+    #endregion
+
+    #region .NET Generator Destination Path
+    
+    private static string CACHE_GENERATOR_DOTNET_DESTINATION_PATH = string.Empty;
+    private static bool CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = false;
+    
+    public static async Task<string> GetGeneratorDotnetDestinationPath()
+    {
+        // When possible, use the cache:
+        if (CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED)
+            return CACHE_GENERATOR_DOTNET_DESTINATION_PATH;
+
+        var generatorDotnetDestinationPath = string.Empty;
+        try
+        {
+            // Get the database:
+            await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
+
+            // Check, if the setting is already set:
+            if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DESTINATION_PATH) is { } existingSetting)
+            {
+                generatorDotnetDestinationPath = existingSetting.TextValue;
+                return generatorDotnetDestinationPath;
+            }
+
+            // Does not exist, so create it:
+            var setting = new Setting
+            {
+                Code = SettingNames.GENERATOR_DOTNET_DESTINATION_PATH,
+                TextValue = generatorDotnetDestinationPath,
+            };
+
+            await db.Settings.AddAsync(setting);
+            await db.SaveChangesAsync();
+            return generatorDotnetDestinationPath;
+        }
+        finally
+        {
+            CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = true;
+            CACHE_GENERATOR_DOTNET_DESTINATION_PATH = generatorDotnetDestinationPath;
+        }
+    }
+    
+    public static async Task SetGeneratorDotnetDestinationPath(string path)
+    {
+        // Update the cache:
+        CACHE_GENERATOR_DOTNET_DESTINATION_PATH = path;
+        CACHE_GENERATOR_DOTNET_DESTINATION_PATH_IS_LOADED = true;
+        
+        // Get the database:
+        await using var db = ProcessorMeta.ServiceProvider.GetRequiredService<DataContext>();
+        
+        // Check, if the setting is already set:
+        if (await db.Settings.FirstOrDefaultAsync(n => n.Code == SettingNames.GENERATOR_DOTNET_DESTINATION_PATH) is { } existingSetting)
+        {
+            existingSetting.TextValue = path;
+            await db.SaveChangesAsync();
+        }
+        
+        // Does not exist, so create it:
+        else
+        {
+            var setting = new Setting
+            {
+                Code = SettingNames.GENERATOR_DOTNET_DESTINATION_PATH,
+                TextValue = path,
+            };
+            
+            await db.Settings.AddAsync(setting);
+            await db.SaveChangesAsync();
+        }
+    }
+    
+    #endregion
+
     #endregion
 }

I18N Commander/UI WinForms/Components/Setting.cs

@@ -434,8 +434,97 @@ public sealed partial class Setting : UserControl
         return new Setting(settingData);
     }
 
+    private static async Task<Setting> ShowGeneratorDotnetEnabledSettingAsync()
+    {
+        var currentSetting = await AppSettings.GetGeneratorDotnetEnabled();
+        
+        var settingData = new SettingUIData(
+            Icon: Icons.icons8_code_512,
+            SettingName: () => "Generator: .NET",
+            ChangeNeedsRestart: false,
+            SettingExplanation: () => "When enabled, .NET translation files are generated. Requires a .NET 6 or newer project.",
+            SettingExplanationLink: () => (string.Empty, string.Empty),
+            SetupDataControl: (changeTrigger) =>
+            {
+                // Set up an checkbox:
+                var checkbox = new CheckBox();
+                checkbox.Checked = currentSetting;
+                checkbox.CheckedChanged += (sender, args) => changeTrigger();
+                checkbox.CheckedChanged += async (sender, args) => await AppSettings.SetGeneratorDotnetEnabled(checkbox.Checked);
+                checkbox.Text = "Enable .NET Generator";
+
+                // Apply the desired layout:
+                checkbox.Dock = DockStyle.Fill;
+                return checkbox;
+            }
+        );
+
+        return new Setting(settingData);
+    }
+
+    private static async Task<Setting> ShowGeneratorDotnetDestinationPathSettingAsync()
+    {
+        var currentSetting = await AppSettings.GetGeneratorDotnetDestinationPath();
+        
+        var settingData = new SettingUIData(
+            Icon: Icons.icons8_code_512,
+            SettingName: () => "Generator: .NET Destination Path",
+            ChangeNeedsRestart: false,
+            SettingExplanation: () => "The destination path for the .NET translation files. You might use environment variables like %USERPROFILE%.",
+            SettingExplanationLink: () => (string.Empty, string.Empty),
+            SetupDataControl: (changeTrigger) =>
+            {
+                // Set up a horizontal layout:
+                var layout = new TableLayoutPanel();
+                layout.ColumnCount = 2;
+                layout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
+                layout.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 66F));
+                layout.RowCount = 1;
+                layout.RowStyles.Add(new RowStyle(SizeType.Percent, 100F));
+                layout.Dock = DockStyle.Fill;
+
+                // Set up a textbox:
+                var textbox = new TextBox();
+                textbox.Text = currentSetting;
+                textbox.TextChanged += (sender, args) => changeTrigger();
+                textbox.TextChanged += async (sender, args) => await AppSettings.SetGeneratorDotnetDestinationPath(textbox.Text);
+                textbox.Dock = DockStyle.Fill;
+                textbox.Margin = new Padding(0, 13, 0, 13);
+                layout.Controls.Add(textbox, 0, 0);
+                
+                // Set up a button:
+                var button = new Button();
+                button.Text = string.Empty;
+                button.Image = Icons.icons8_folder_tree_512;
+                button.FlatStyle = FlatStyle.Flat;
+                button.FlatAppearance.BorderSize = 0;
+                button.BackColor = Color.Empty;
+                button.UseVisualStyleBackColor = true;
+                button.Size = new Size(60, 60);
+                button.Click += (sender, args) =>
+                {
+                    var dialog = new FolderBrowserDialog();
+                    dialog.SelectedPath = textbox.Text;
+                    dialog.InitialDirectory = textbox.Text;
+                    dialog.Description = "Select the destination path for the .NET translation files.";
+                    dialog.ShowNewFolderButton = true;
+                    if (dialog.ShowDialog() == DialogResult.OK)
+                        textbox.Text = dialog.SelectedPath;
+                };
+                button.Dock = DockStyle.Fill;
+                layout.Controls.Add(button, 1, 0);
+                
+                return layout;
+            }
+        );
+        
+        return new Setting(settingData);
+    }
+
     public static IEnumerable<Task<Setting>> GetAllSettings()
     {
+        yield return ShowGeneratorDotnetDestinationPathSettingAsync();
+        yield return ShowGeneratorDotnetEnabledSettingAsync();
         yield return ShowGeneratorModeSettingAsync();
         yield return ShowDeepLSourceCultureSettingAsync();
         foreach (var setting in ShowCultureSettingsAsync())

I18N Commander/UI WinForms/Resources/Icons.Designer.cs

@@ -190,6 +190,16 @@ namespace UI_WinForms.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_folder_tree_512 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_folder_tree_512", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>

I18N Commander/UI WinForms/Resources/Icons.resx

@@ -157,6 +157,9 @@
   <data name="icons8_document_512" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>icons8-document-512.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8_folder_tree_512" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>icons8-folder-tree-512.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8_increase_512" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>icons8-increase-512.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>