Support for warning for infinite loop, localized errors for new generic HTTP code based errors and IntelliSense compatibility

"Create Music with AI" is made StreamContent instead of GenerateContent to apply infinite loop warning, localized errors are extended for new generic HTTP code based errors and methods are made IntelliSense compatible.

Author: GeniusPilot2016

NeoBleeper/AIGeneratedNBPMLError.cs

@@ -41,6 +41,14 @@ private void ThemeManager_ThemeChanged(object? sender, EventArgs e)
                 }
             }
         }
+
+        /// <summary>
+        /// Applies the current application theme to the control based on user or system settings.
+        /// </summary>
+        /// <remarks>This method updates the control's appearance to match the selected theme. If the
+        /// theme is set to follow the system, the method detects the system's light or dark mode and applies the
+        /// corresponding theme. The method also enables double buffering to improve rendering performance and
+        /// temporarily suspends layout updates to prevent flickering during the theme change.</remarks>
         private void SetTheme()
         {
             this.SuspendLayout(); // Suspend layout to batch updates

NeoBleeper/AboutNeobleeper.cs

@@ -41,6 +41,13 @@ private void ThemeManager_ThemeChanged(object? sender, EventArgs e)
             }
         }
 
+        /// <summary>
+        /// Applies the current application theme to the control based on user or system settings.
+        /// </summary>
+        /// <remarks>This method updates the control's appearance to match the selected theme. If the
+        /// theme is set to follow the system, the method detects the system's light or dark mode and applies the
+        /// corresponding theme. The method temporarily suspends layout and enables double buffering to ensure a smooth
+        /// visual update.</remarks>
         private void SetTheme()
         {
             this.SuspendLayout(); // Suspend layout to batch updates

NeoBleeper/AdvancedSystemSpeakerTest.cs

@@ -27,6 +27,13 @@ private void ThemeManager_ThemeChanged(object? sender, EventArgs e)
             }
         }
 
+        /// <summary>
+        /// Applies the current application theme to the control based on user or system settings.
+        /// </summary>
+        /// <remarks>This method updates the control's appearance to match the selected theme. If the
+        /// theme is set to follow the system, the method detects the system's light or dark mode and applies the
+        /// corresponding theme. The method should be called whenever the theme setting changes to ensure the control
+        /// reflects the correct appearance.</remarks>
         private void SetTheme()
         {
             this.SuspendLayout(); // Suspend layout to batch updates
@@ -76,6 +83,16 @@ private void DarkTheme()
             this.ForeColor = Color.White;
             UIHelper.ApplyCustomTitleBar(this, Color.Black, darkTheme);
         }
+
+        /// <summary>
+        /// Initiates the advanced system speaker test sequence asynchronously, performing a series of diagnostic checks
+        /// and updating the user interface with progress and results.
+        /// </summary>
+        /// <remarks>This method runs multiple hardware and signal tests on the system speaker, including
+        /// electrical feedback, port state stability, and frequency sweep diagnostics. Progress and results are logged
+        /// and displayed to the user. The method is asynchronous and should not be called concurrently. If an error
+        /// occurs during testing, the user interface is updated to indicate the failure and details are
+        /// logged.</remarks>
         private async void StartTest()
         {
             try

NeoBleeper/ClearNoteCommand.cs

@@ -52,6 +52,13 @@ public ClearNoteCommand(ListView listView, int noteIndex, Target target = Target
         }
     }
 
+    /// <summary>
+    /// Clears the text of the note subitem for each item in the list view corresponding to the previously stored
+    /// states.
+    /// </summary>
+    /// <remarks>This method resets the text of the subitem at the specified note index to an empty string for
+    /// all items whose indices are present in the previousStates collection. If a subitem at the note index does not
+    /// exist, it is created. Items with indices outside the valid range of the list view are ignored.</remarks>
     public void Execute()
     {
         foreach (var (Index, _) in previousStates)
@@ -68,6 +75,12 @@ public void Execute()
         }
     }
 
+    /// <summary>
+    /// Reverts the most recent changes made to the note text in the associated list view items.
+    /// </summary>
+    /// <remarks>Use this method to restore the previous state of note text for all affected items. This
+    /// operation does not raise events or notify listeners of the change. If an item's previous state cannot be
+    /// restored due to an invalid index, that item is skipped.</remarks>
     public void Undo()
     {
         foreach (var (Index, PreviousText) in previousStates)

NeoBleeper/CommandManager.cs

@@ -34,6 +34,13 @@ public CommandManager(Originator originator)
 
     public event EventHandler StateChanged;
 
+    /// <summary>
+    /// Executes the specified command and records it for undo and redo operations.
+    /// </summary>
+    /// <remarks>This method saves the current state before executing the command, enabling the operation to
+    /// be undone or redone later. After execution, the redo history is cleared. If the command is null, an exception
+    /// may be thrown.</remarks>
+    /// <param name="command">The command to execute. Cannot be null.</param>
     public void ExecuteCommand(ICommand command)
     {
         undoMementos.Push(originator.CreateMemento());
@@ -44,6 +51,11 @@ public void ExecuteCommand(ICommand command)
         OnStateChanged();
     }
 
+    /// <summary>
+    /// Clears all undo and redo history, resetting the state tracking to the current state.
+    /// </summary>
+    /// <remarks>After calling this method, all previous undo and redo operations are discarded. The current
+    /// state becomes the new baseline for future undo and redo actions.</remarks>
     public void ClearHistory()
     {
         undoStack.Clear();
@@ -54,6 +66,11 @@ public void ClearHistory()
         OnStateChanged();
     }
 
+    /// <summary>
+    /// Reverses the most recent operation, restoring the previous state if an undo is available.
+    /// </summary>
+    /// <remarks>This method has no effect if there are no operations to undo. After calling this method, the
+    /// state can be redone using the corresponding redo functionality, if available.</remarks>
     public void Undo()
     {
         if (CanUndo)
@@ -67,6 +84,11 @@ public void Undo()
         }
     }
 
+    /// <summary>
+    /// Performs the most recent undone operation, if a redo is available.
+    /// </summary>
+    /// <remarks>Call this method to reapply the last operation that was undone using the undo functionality.
+    /// If there are no operations available to redo, this method has no effect.</remarks>
     public void Redo()
     {
         if (CanRedo)
@@ -80,11 +102,24 @@ public void Redo()
         }
     }
 
+    /// <summary>
+    /// Raises the StateChanged event to notify subscribers of a change in state.
+    /// </summary>
+    /// <remarks>Override this method in a derived class to provide custom logic when the state changes. This
+    /// method invokes the StateChanged event with the current instance as the sender and an empty EventArgs
+    /// object.</remarks>
     protected virtual void OnStateChanged()
     {
         StateChanged?.Invoke(this, EventArgs.Empty);
     }
 
+    /// <summary>
+    /// Determines whether the current state matches the initial state with no undo or redo operations pending.
+    /// </summary>
+    /// <remarks>Use this method to check if all changes have been undone and the object is in its original
+    /// state. This can be useful for enabling or disabling reset or save functionality in user interfaces.</remarks>
+    /// <returns>true if the state is unchanged from its initial value and both the undo and redo stacks are empty; otherwise,
+    /// false.</returns>
     public bool IsAtInitialState()
     {
         return undoStack.Count == 0 && redoStack.Count == 0 && originator.CreateMemento().Equals(initialMemento);

NeoBleeper/ControlExtensions.cs

@@ -20,6 +20,14 @@ namespace NeoBleeper
 {
     public static class ControlExtensions
     {
+        /// <summary>
+        /// Enables or disables double buffering for the specified control to reduce flicker during repaint operations.
+        /// </summary>
+        /// <remarks>Double buffering can improve rendering performance and visual quality for controls
+        /// that experience flickering during redraws. Not all controls support double buffering, and enabling it may
+        /// have no effect on some controls.</remarks>
+        /// <param name="control">The control for which to set double buffering. Cannot be null.</param>
+        /// <param name="enabled">true to enable double buffering; otherwise, false.</param>
         public static void DoubleBuffering(this Control control, bool enabled)
         {
             var method = typeof(Control).GetMethod("SetStyle", BindingFlags.Instance | BindingFlags.NonPublic);

NeoBleeper/ConvertToBeepCommandForLinux.cs

@@ -55,19 +55,13 @@ private void ThemeManager_ThemeChanged(object? sender, EventArgs e)
             }
         }
 
-        protected override void WndProc(ref Message m)
-        {
-            const int WM_SETTINGCHANGE = 0x001A;
-            base.WndProc(ref m);
-
-            if (m.Msg == WM_SETTINGCHANGE)
-            {
-                if (Settings1.Default.theme == 0 && (darkTheme != SystemThemeUtility.IsDarkTheme()))
-                {
-                    SetTheme();
-                }
-            }
-        }
+        /// <summary>
+        /// Applies the current application theme to the form based on user or system preferences.
+        /// </summary>
+        /// <remarks>This method selects and applies a light or dark theme according to the application's
+        /// theme settings. If the theme is set to follow the system, the method detects the system's current theme and
+        /// applies the corresponding style. The method also ensures that UI updates are performed efficiently and that
+        /// the form is refreshed to reflect the new theme.</remarks>
         private void SetTheme()
         {
             this.SuspendLayout(); // Suspend layout to batch updates
@@ -131,8 +125,21 @@ private void buttonCopyBeepCommandToClipboard_Click(object sender, EventArgs e)
             Toast.ShowToast(this, Resources.MessageConvertedBeepCommandCopied, 2000);
         }
 
+
         StringBuilder beepCommandBuilder = new StringBuilder();
         int elapsedElementTime = 0; // Equivalent of Stopwatch.ElapsedMilliseconds for text based timing
+
+        /// <summary>
+        /// Parses a music project string and generates a formatted beep command sequence representing the extracted
+        /// notes.
+        /// </summary>
+        /// <remarks>The returned beep command sequence encodes the timing and pitch information for each
+        /// note as specified in the input music project. The method applies default values for certain settings if they
+        /// are missing from the input. The output can be used as input to a beep-compatible audio tool or command-line
+        /// utility.</remarks>
+        /// <param name="musicString">A string containing the serialized music project data to parse for note extraction. Cannot be null.</param>
+        /// <returns>A string containing the formatted beep command sequence for the extracted notes. Returns an empty string if
+        /// no notes are found or if the input is invalid.</returns>
         private String ExtractNotes(string musicString)
         {
             List<NoteInfo> notes = new List<NoteInfo>();
@@ -202,16 +209,36 @@ private String ExtractNotes(string musicString)
                 if (silence > 0)
                 {
                     // Pass endOfLine so that last element doesn't get a trailing -n
-                    beepCommandBuilder.Append(createDelay(silence, endOfLine).duration);
+                    beepCommandBuilder.Append(CreateDelay(silence, endOfLine).duration);
                 }
 
             }
             string rawOutput = beepCommandBuilder.ToString();
             string trimmedOutput = rawOutput.TrimEnd();
             return trimmedOutput;
         }
+
+        /// <summary>
+        /// Inserts one or more musical notes into the beep command sequence, specifying which notes to play, their
+        /// order, and duration.
+        /// </summary>
+        /// <remarks>The order and alternation of notes depend on the current playback mode. Only notes
+        /// marked to be played and with non-empty names are included. If no notes are selected, a delay of the
+        /// specified length is inserted instead.</remarks>
+        /// <param name="note1">The name of the first note to include in the sequence. Can be null or empty if not used.</param>
+        /// <param name="note2">The name of the second note to include in the sequence. Can be null or empty if not used.</param>
+        /// <param name="note3">The name of the third note to include in the sequence. Can be null or empty if not used.</param>
+        /// <param name="note4">The name of the fourth note to include in the sequence. Can be null or empty if not used.</param>
+        /// <param name="playNote1">true to play the note specified by note1; otherwise, false.</param>
+        /// <param name="playNote2">true to play the note specified by note2; otherwise, false.</param>
+        /// <param name="playNote3">true to play the note specified by note3; otherwise, false.</param>
+        /// <param name="playNote4">true to play the note specified by note4; otherwise, false.</param>
+        /// <param name="length">The total duration, in milliseconds, for which the notes should be played. Must be a positive integer.</param>
+        /// <param name="endOfLine">true to indicate that this is the last note or group of notes in the line; otherwise, false. The default is
+        /// false.</param>
+        /// <returns>The total elapsed time, in milliseconds, for the inserted notes or delay.</returns>
         private int insert_note_to_beep_command(String note1, String note2, String note3, String note4,
-bool playNote1, bool playNote2, bool playNote3, bool playNote4, int length, bool endOfLine = false) // Play note in a line
+        bool playNote1, bool playNote2, bool playNote3, bool playNote4, int length, bool endOfLine = false) // Play note in a line
         {
             int elapsedTime = 0;
             double note1Frequency = 0, note2Frequency = 0, note3Frequency = 0, note4Frequency = 0;
@@ -355,7 +382,7 @@ private int insert_note_to_beep_command(String note1, String note2, String note3
                         }
                         else
                         {
-                            generatedBeepCommand = createDelay(remainingLength, endOfLine).duration;
+                            generatedBeepCommand = CreateDelay(remainingLength, endOfLine).duration;
                             beepCommandBuilder.Append(generatedBeepCommand + Environment.NewLine);
                             remainingLength = 0;
                             break;
@@ -370,11 +397,26 @@ private int insert_note_to_beep_command(String note1, String note2, String note3
             }
             else
             {
-                beepCommandBuilder.Append(createDelay(length, endOfLine).duration);
+                beepCommandBuilder.Append(CreateDelay(length, endOfLine).duration);
                 return length;
             }
             return elapsedTime;
         }
+
+        /// <summary>
+        /// Creates a command-line argument string representing a beep with the specified frequency and duration, and
+        /// calculates the total duration including any required delays.
+        /// </summary>
+        /// <remarks>If the specified frequency matches a known resonant frequency, it is incremented by 1
+        /// Hz to prevent potential playback issues. When nonStopping is false, an extra delay is added to ensure the
+        /// beep plays correctly.</remarks>
+        /// <param name="frequency">The frequency of the beep, in hertz. If the value matches a known resonant frequency, it is automatically
+        /// adjusted to avoid issues.</param>
+        /// <param name="duration">The duration of the beep, in milliseconds. Must be a non-negative integer.</param>
+        /// <param name="endOfLine">true if the beep is at the end of a line and should not be followed by a new beep; otherwise, false.</param>
+        /// <param name="nonStopping">true to omit the additional delay and stop sequence after the beep; otherwise, false. The default is false.</param>
+        /// <returns>A tuple containing the constructed command-line argument string for the beep and the total duration in
+        /// milliseconds, including any additional delay if applicable.</returns>
         private (string frequencyAndLength, int totalDuration) CreateFrequencyAndDurationDuo(int frequency, int duration, bool endOfLine, bool nonStopping = false)
         {
             if (probableResonantFrequencies.Contains(frequency))
@@ -393,7 +435,14 @@ private int insert_note_to_beep_command(String note1, String note2, String note3
             }
             return (result, nonStopping ? duration : duration + 5);
         }
-        private (string duration, int totalDuration) createDelay(int duration, bool endOfLine)
+
+        /// <summary>
+        /// Creates a delay command string and returns the corresponding duration information.
+        /// </summary>
+        /// <param name="duration">The length of the delay, in milliseconds. Must be a non-negative integer.</param>
+        /// <param name="endOfLine">true to indicate the delay is at the end of a line; otherwise, false to start a new beep after the delay.</param>
+        /// <returns>A tuple containing the delay command string and the total duration in milliseconds.</returns>
+        private (string duration, int totalDuration) CreateDelay(int duration, bool endOfLine)
         {
             string result = $" -f 0 -l 0 -D {duration}"; // Add delay
             if (!endOfLine)
@@ -402,6 +451,14 @@ private int insert_note_to_beep_command(String note1, String note2, String note3
             }
             return (result, duration);
         }
+
+        /// <summary>
+        /// Deserializes an XML representation of a NeoBleeper project file from the specified string reader.
+        /// </summary>
+        /// <param name="stringReader">A StringReader containing the XML data to deserialize. Must not be null and must contain a valid XML
+        /// representation of a NeoBleeper project file.</param>
+        /// <returns>A NeoBleeperProjectFile object deserialized from the XML data, or null if the XML does not represent a valid
+        /// NeoBleeper project file.</returns>
         private NBPMLFile.NeoBleeperProjectFile? DeserializeXMLFromString(StringReader stringReader)
         {
             System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(NBPMLFile.NeoBleeperProjectFile));