I’ve worked on several commercial applications that incorporate scripting languages. Some of these used grammars designed with [Yacc](https://en.wikipedia.org/wiki/Yacc) or [Bison](https://en.wikipedia.org/wiki/GNU_Bison). But writing custom languages is tedious. And convincing users to learn them is hard. Other applications embedded [Visual Basic for Applications](https://en.wikipedia.org/wiki/Visual_Basic_for_Applications). VBA had some great perks, including a form editor and a debugger, but it’s been a _long_ time since third-party integration was [possible](http://summsoft.com/vba/). There’s never been a .NET successor to VBA, and VB6 is now the stuff of [history](https://retool.com/visual-basic) and [nostalgic recreation](https://bandysc.github.io/AvaloniaVisualBasic6/). Today, if you wanted to make your application scriptable, how would you do it? This post explores how to create a simple C# application that uses Python as an embedded scripting language. ## Embedded Python Console Application The first step is to make a proof of concept app. We will start with a minimal Python installation and necessary libraries. ### Installing Embedded Python To ensure our app isn’t dependent on the user’s Python installation, it should have its own dedicated, private Python environment. The first step is to install an embedded version of Python. The [embedded versions](https://docs.python.org/3/using/windows.html#using-python-on-windows) are lightweight and designed to run independently of the system ```PATH```. This makes sense because we don’t want our scripted app to be affected by other Python installs on the machine. We could use [venv](https://docs.python.org/3/library/venv.html) to create an isolated Python environment, but that is better suited for managing separate configurations rather than providing completely standalone setups. We’ll use the [Windows embeddable package (64-bit) of Python 3.11.9](https://www.python.org/downloads/release/python-3119/), the latest embeddable release of Python 3.11. Sticking with 3.11 makes sense, as it’s the most recent version supported by [PyTorch](https://pytorch.org/get-started/locally/). Python is available under the [PSF License](https://docs.python.org/3/license.html), so it should be okay to use from a licensing perspective. We can extract the release somewhere, e.g., ```C:\python-3.11.9```. ### Running Python Code from C# Let’s create a new C# project in [Visual Studio](https://visualstudio.microsoft.com/vs/community/). We can name it ```ConsolePython```. To interact with our embedded Python installation, we’ll use the [Python.NET](https://pythonnet.github.io/) package. This library allows us to call Python from C# and is distributed under the [MIT license](https://github.com/pythonnet/pythonnet/blob/master/LICENSE), making it suitable for use in our application. We can add [Python.NET](https://github.com/pythonnet/pythonnet) to our project using NuGet. To do this, open the Package Manager Console and enter the following command: ```PM> NuGet\Install-Package pythonnet``` Once installed, Python.NET provides a straightforward way to execute Python code. For example, the basic code to run a Python string looks like this: ```editordirect editormode="csharp" Environment.SetEnvironmentVariable("PYTHONNET_PYDLL", @"C:\python-3.11.9\python311.dll"); // Change to point to your dll PythonEngine.Initialize(); using (Py.GIL()) { dynamic pyScope = Py.CreateScope(); string pythonScript = @"print('Hello from python')" pyScope.Exec(pythonScript); } PythonEngine.Shutdown(); ``` As our proof of concept, we can wire up the above code into an app that takes the script and the Python DLL as commandline parameters like: ```ConsolePython.exe

``` The resultant ```program.cs```: ```editordirect editormode="csharp" using Python.Runtime; using System; using System.IO; class ConsolePython { static void Main(string[] args) { // Check if the correct number of arguments were provided if (args.Length != 2) { Console.WriteLine("Usage: ConsolePython.exe

"); return; } string pythonScriptPath = args[0]; string pythonDllPath = args[1]; // Ensure the Python script exists if (!File.Exists(pythonScriptPath)) { Console.WriteLine($"Error: Python script file '{pythonScriptPath}' not found."); return; } // Ensure the Python DLL exists if (!File.Exists(pythonDllPath)) { Console.WriteLine($"Error: Python DLL '{pythonDllPath}' not found."); return; } // Set the environment variable to point to the Python DLL Environment.SetEnvironmentVariable("PYTHONNET_PYDLL", pythonDllPath); // Initialize the Python engine PythonEngine.Initialize(); try { using (Py.GIL()) { dynamic pyScope = Py.CreateScope(); // Read the Python script from the file string pythonScript = File.ReadAllText(pythonScriptPath); // Execute the Python script pyScope.Exec(pythonScript); } } catch (Exception ex) { Console.WriteLine($"Error while executing Python script: {ex.Message}"); } finally { // Because current version of pythonnet uses deprecated BinaryFormatter... this avoids exception on Shutdown... ick AppContext.SetSwitch("System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization", true); // Shut down the Python engine PythonEngine.Shutdown(); } } } ``` We can then save a sample script like ```test.py```: ```editordirect editormode="python" print('Hello from python') ``` and run the program as follows: ```ConsolePython test.py C:\python-3.11.9\python311.dll``` We should get the output in our console like this: ![image](/embeddedpython3.png) Simple, but not super useful. ## Exposing Functionality to the Script Now that we know how to run Python code from C#, it would be nice to expose an API of our application to the Python interpreter. First, let’s make a sample component to expose. We can call it ```AppInterface```: ```editordirect editormode="csharp" public class AppInterface { public AppInterface() { } public int Add(int a, int b) { return a + b; } } ``` Then let’s wire it into our execution code: ```editordirect editormode="csharp" using (Py.GIL()) { dynamic pyScope = Py.CreateScope(); // Create an instance of our helper class var appInterface = new AppInterface(); // Add the helper object to the Python scope with the exposed name pyScope.app = appInterface; // Read the Python script from the file string pythonScript = File.ReadAllText(pythonScriptPath); // Execute the Python script pyScope.Exec(pythonScript); } ``` Finally, let’s make a new test script that uses our mini-API. We can call it ```test2.py```: ```editordirect editormode="python" result = app.Add(5, 3) print(f"5 + 3 = {result}") ``` Now, when we run it, we get the expected result, computed on the C# side: ![image](/embeddedpython5.png) Our proof of concept is complete. ### Adding Packages to Embedded Python It would be helpful to add additional packages so our scripts can do more things. In a standard Python installation, we’d use ```pip install``` to add packages. However, the embedded Python installation doesn’t include ```pip``` by default. Instead we need to set it up manually. Here’s how: * Open up ```python311._pth``` in the main install folder (here ```C:\python-3.11.9\python311._pth```). * Once open, uncomment ```#import site``` to read ```import site```. * Save and close the file. * Download [```get-pip.py```](https://bootstrap.pypa.io/get-pip.py) to the main install folder. * Run ```get-pip.py```: * ```.\python.exe get-pip.py```. * You’ll probably get messaging like: * ```WARNING: The script wheel.exe is installed in 'C:\python-3.11.9\Scripts' which is not on PATH.``` * This is expected and means that ```pip``` is running in the embedded environment without affecting the ```PATH```. With ```pip``` enabled, we can now install any necessary packages by running: ```.\Scripts\pip.exe install ``` For additional details, you can refer to these helpful Stack Overflow discussions: * [Adding packages to Python “embedded” installation for Windows](https://stackoverflow.com/questions/49737721/adding-packages-to-python-embedded-installation-for-windows). * [pip with embedded python](https://stackoverflow.com/questions/42666121/pip-with-embedded-python) ### Scripting Excel Excel provides scripting capabilities through its COM object model, which is the same mechanism used by VBA. To [automate COM objects](https://pbpython.com/windows-com.html) from Python, we can use the [pywin32](https://pypi.org/project/pywin32/) package. While the [Pywin32 Github](https://github.com/mhammond/pywin32) page doesn’t show it, the [pypi.org page](https://pypi.org/project/pywin32/) confirms that ```Pywin32``` is also available under the [PSF License](https://spdx.org/licenses/PSF-2.0.html). To install ```pywin32``` in our embedded Python environment, navigate to the main installation folder and run: ```.\Scripts\pip.exe install pywin32``` After installing, let’s create a new script file named ```exceltext.py```. This script will demonstrate how to automate Excel using ```pywin32```. ```editordirect editormode="python" import win32com.client as pywin32 import ctypes # Display a message box to pause execution and allow viewing the Excel file MessageBox = ctypes.windll.user32.MessageBoxW MessageBox(None, 'Close me to Start Excel!', 'Python Script', 0) # Initialize Excel excel = pywin32.gencache.EnsureDispatch('Excel.Application') excel.Visible = True # Add a new workbook and select the first sheet workbook = excel.Workbooks.Add() sheet = workbook.Sheets(1) # Fill the first 10 rows and 10 columns with a multiplication table for row in range(1, 11): for col in range(1, 11): sheet.Cells(row, col).Value = row * col # Display a message box to pause execution and allow viewing the Excel file MessageBox = ctypes.windll.user32.MessageBoxW MessageBox(None, 'Close me to exit Excel without saving', 'Python Script', 0) # Quit Excel without saving the workbook workbook.Close(SaveChanges=False) excel.Application.Quit() ``` We can execute the script using our C# program with the following command: ```ConsolePython.exe exceltest.py C:\python-3.11.9\python311.dll``` If Microsoft Office is installed, this should open Excel and populate it with a multiplication table: ![image](/embeddedpython4.png) The ```MessageBox``` calls in the script will pause execution until dismissed, after which the script will resume running. ## A Simple GUI Application It’s great that we can expose an API and call COM objects, but if we’re serious about a scripting environment we should have a GUI-based script editor. To set this up, let’s return to Visual Studio and create a new C# ```WinForms``` application. This will serve as the foundation for our script editor. Once the application is set up, we can integrate Python execution capabilities using the Python.NET library to allow scripts to be run directly from the GUI. ### Editor Control To integrate a code editor into the application, we’ll use [AvalonEdit](https://github.com/icsharpcode/AvalonEdit), a WPF control that supports syntax highlighting and is licensed under [MIT](https://github.com/icsharpcode/AvalonEdit/blob/master/LICENSE). It’s available via NuGet, so we can install it with: ```PM> NuGet\Install-Package AvalonEdit``` In addition to serving as the script editor, ```AvalonEdit``` can also be used for the log window. Because ```AvalonEdit``` is a ```WPF``` control and our app is ```WinForms```-based, we need to host it within an ```ElementHost``` control. Depending on the version of Visual Studio, we might also need to add references to various components such as: ```PresentationCore```, ```PresentationFramework```, ```WindowsBase```, and ```WindowsFormsIntegration``` (for ```ElementHost```). For the layout, the client area will use a splitter pane, with the code editor occupying the top section and the log window positioned below. Here’s the basic code to add it to our form: ```editordirect editormode="csharp" using ICSharpCode.AvalonEdit; using ICSharpCode.AvalonEdit.Highlighting; ... private SplitContainer splitContainer; private TextEditor codeEditor; private TextEditor outputLog; private ElementHost upperElementHost; private ElementHost lowerElementHost; ... private void InitializeComponent() { ... splitContainer = new SplitContainer(); upperElementHost = new ElementHost(); lowerElementHost = new ElementHost(); codeEditor = new TextEditor(); outputLog = new TextEditor(); // Set up SplitContainer splitContainer.Dock = DockStyle.Fill; splitContainer.Orientation = Orientation.Horizontal; splitContainer.SplitterDistance = this.Height / 2; // Set up AvalonEdit controls upperElementHost.Dock = DockStyle.Fill; upperElementHost.Child = codeEditor; lowerElementHost.Dock = DockStyle.Fill; lowerElementHost.Child = outputLog; // Configure codeEditor codeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Python"); codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas"); codeEditor.FontSize = 12; codeEditor.ShowLineNumbers = true; // Configure output log outputLog.IsReadOnly = true; outputLog.FontFamily = new System.Windows.Media.FontFamily("Consolas"); outputLog.FontSize = 12; outputLog.ShowLineNumbers = true; // Add controls to SplitContainer splitContainer.Panel1.Controls.Add(upperElementHost); splitContainer.Panel2.Controls.Add(lowerElementHost); // Add controls to Form this.Controls.Add(splitContainer); ... } ``` ### Basic Commands The application should include basic commands for loading scripts, saving scripts, running scripts, and selecting the Python environment. To achieve this, we can add a toolbar to the interface. ```editordirect editormode="csharp" private ToolStrip toolStrip; private void InitializeComponent() { // Initialize components toolStrip = new ToolStrip(); ... // Set up ToolStrip var openButton = new ToolStripButton("Open", null, OpenButton_Click); var saveButton = new ToolStripButton("Save", null, SaveButton_Click); var runButton = new ToolStripButton("Run", null, RunButton_Click); var configButton = new ToolStripButton("Configure Python DLL", null, ConfigButton_Click); toolStrip.Items.Add(openButton); toolStrip.Items.Add(saveButton); toolStrip.Items.Add(runButton); toolStrip.Items.Add(configButton); ... this.Controls.Add(toolStrip); } // Event Handlers private void OpenButton_Click(object sender, EventArgs e) { OpenFile(); } private void SaveButton_Click(object sender, EventArgs e) { SaveFile(); } ... private void OpenFile() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Load(dlg.FileName); } } } private void SaveFile() { using (SaveFileDialog dlg = new SaveFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Save(dlg.FileName); } } } ``` ### Selecting an Installation Since we aren’t specifying the Python DLL on the commandline, we need to provide a user interface for the selection. Once a DLL is chosen, its path can be saved to a local configuration file for future use. In a production application, this could be hardcoded to an installation directory. ```editordirect editormode="csharp" private string configFilePath; private string pythonDllPath; private void ConfigButton_Click(object sender, EventArgs e) { if (ConfigurePythonDll()) { // Inform the user to restart the application for changes to take effect MessageBox.Show("Python DLL path updated. Please restart the application for changes to take effect.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); } } ... private bool ConfigurePythonDll() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python DLL (python*.dll)|python*.dll|All files (*.*)|*.*"; dlg.Title = "Select Python DLL"; if (dlg.ShowDialog() == DialogResult.OK) { pythonDllPath = dlg.FileName; // Save the path to config file try { File.WriteAllText(configFilePath, pythonDllPath); return true; } catch (Exception ex) { MessageBox.Show($"Failed to write config file:\n{ex.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } } else { return false; } } } ``` ### Loading and Unloading the Python Instance We need to start up our Python instance when the app opens, and shut it down when we exit. ```editordirect editormode="csharp" private void MainForm_Load(object sender, EventArgs e) { InitPython(); } protected override void OnFormClosed(FormClosedEventArgs e) { PythonEngine.Shutdown(); base.OnFormClosed(e); } ... private void InitPython() { // Determine the path to the config file configFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config.ini"); // Try to set the Python DLL path from config file pythonDllPath = null; if (File.Exists(configFilePath)) { pythonDllPath = File.ReadAllText(configFilePath).Trim(); } // If the DLL path is invalid, prompt user to select DLL if (string.IsNullOrEmpty(pythonDllPath) || !File.Exists(pythonDllPath)) { if (!ConfigurePythonDll()) { // User canceled DLL selection; exit application MessageBox.Show("Python DLL configuration is required to run the application.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); this.Close(); return; } else { // Config file should now have the new DLL path pythonDllPath = File.ReadAllText(configFilePath).Trim(); } } // Initialize Python Engine try { // Set the Python DLL path for Python.NET Runtime.PythonDLL = pythonDllPath; PythonEngine.Initialize(); PythonEngine.BeginAllowThreads(); } catch (Exception ex) { // Initialization failed; possibly due to invalid DLL MessageBox.Show($"Failed to initialize Python.NET with the selected DLL:\n{ex.Message}", "Initialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); // Clear the invalid DLL path from config try { File.Delete(configFilePath); } catch (Exception ioEx) { MessageBox.Show($"Failed to delete config file:\n{ioEx.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } this.Close(); } } ``` ### Running the Code and Redirecting Output With everything wired together, we can now execute the code. The process involves retrieving the code from the editor and running it. A key difference is that console output is redirected to the log window. If any exceptions occur, they should also be logged. This requires obtaining the exception text from the Task thread that holds the GIL, while ensuring updates to the log window happen on the UI thread. (Note: I haven’t yet experimented with disabling the [GIL](https://www.blog.pythonlibrary.org/2024/03/14/python-3-13-allows-disabling-of-the-gil-subinterpreters/)). ```editordirect editormode="csharp" private void RunButton_Click(object sender, EventArgs e) { RunCode(); } ... private void RunCode() { outputLog.Text = ""; string code = codeEditor.Text; Task.Run(() => { using (Py.GIL()) { dynamic sys = Py.Import("sys"); dynamic io = Py.Import("io"); dynamic stringIO = io.StringIO(); sys.stdout = stringIO; sys.stderr = stringIO; try { dynamic pyScope = Py.CreateScope(); var appInterface = new AppInterface(); pyScope.app = appInterface; pyScope.Exec(code); } catch (PythonException ex) { string oops = ex.ToString(); this.Invoke((Action)(() => { outputLog.AppendText(oops); })); } finally { // Get output string output = stringIO.getvalue().ToString(); this.Invoke((Action)(() => { outputLog.AppendText(output); })); // Reset stdout and stderr sys.stdout = sys.__stdout__; sys.stderr = sys.__stderr__; } } }); } ``` ### Complete First Try Putting it all together, the code to our bare-bones GUI app looks like this: ```editordirect editormode="csharp" using System; using System.IO; using System.Windows.Forms; using System.Windows.Forms.Integration; // For ElementHost using System.Threading.Tasks; // For Tasks using ICSharpCode.AvalonEdit; // AvalonEdit using ICSharpCode.AvalonEdit.Highlighting; using Python.Runtime; // For Python.NET namespace GuiPythonSimple { public partial class MainForm : Form { private ToolStrip toolStrip; private SplitContainer splitContainer; private ElementHost upperElementHost; private ElementHost lowerElementHost; private TextEditor codeEditor; private TextEditor outputLog; private string configFilePath; private string pythonDllPath; public MainForm() { InitializeComponent(); this.Load += MainForm_Load; } private void InitializeComponent() { // Initialize components toolStrip = new ToolStrip(); splitContainer = new SplitContainer(); upperElementHost = new ElementHost(); lowerElementHost = new ElementHost(); codeEditor = new TextEditor(); outputLog = new TextEditor(); // Set up ToolStrip var openButton = new ToolStripButton("Open", null, OpenButton_Click); var saveButton = new ToolStripButton("Save", null, SaveButton_Click); var runButton = new ToolStripButton("Run", null, RunButton_Click); var configButton = new ToolStripButton("Configure Python DLL", null, ConfigButton_Click); toolStrip.Items.Add(openButton); toolStrip.Items.Add(saveButton); toolStrip.Items.Add(runButton); toolStrip.Items.Add(configButton); // Set up SplitContainer splitContainer.Dock = DockStyle.Fill; splitContainer.Orientation = Orientation.Horizontal; splitContainer.SplitterDistance = this.Height / 2; // Set up AvalonEdit controls upperElementHost.Dock = DockStyle.Fill; upperElementHost.Child = codeEditor; lowerElementHost.Dock = DockStyle.Fill; lowerElementHost.Child = outputLog; // Configure codeEditor codeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Python"); codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas"); codeEditor.FontSize = 12; codeEditor.ShowLineNumbers = true; // Configure output log outputLog.IsReadOnly = true; outputLog.FontFamily = new System.Windows.Media.FontFamily("Consolas"); outputLog.FontSize = 12; outputLog.ShowLineNumbers = true; // Add controls to SplitContainer splitContainer.Panel1.Controls.Add(upperElementHost); splitContainer.Panel2.Controls.Add(lowerElementHost); // Add controls to Form this.Controls.Add(splitContainer); this.Controls.Add(toolStrip); // Set Form properties this.Text = "Python Editor"; this.Width = 1000; this.Height = 600; } private void MainForm_Load(object sender, EventArgs e) { InitPython(); } protected override void OnFormClosed(FormClosedEventArgs e) { PythonEngine.Shutdown(); base.OnFormClosed(e); } // Event Handlers private void OpenButton_Click(object sender, EventArgs e) { OpenFile(); } private void SaveButton_Click(object sender, EventArgs e) { SaveFile(); } private void RunButton_Click(object sender, EventArgs e) { RunCode(); } private void ConfigButton_Click(object sender, EventArgs e) { if (ConfigurePythonDll()) { // Inform the user to restart the application for changes to take effect MessageBox.Show("Python DLL path updated. Please restart the application for changes to take effect.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); } } private void OpenFile() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Load(dlg.FileName); } } } private void SaveFile() { using (SaveFileDialog dlg = new SaveFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Save(dlg.FileName); } } } private void RunCode() { outputLog.Text = ""; string code = codeEditor.Text; Task.Run(() => { using (Py.GIL()) { dynamic sys = Py.Import("sys"); dynamic io = Py.Import("io"); dynamic stringIO = io.StringIO(); sys.stdout = stringIO; sys.stderr = stringIO; try { PythonEngine.Exec(code); } catch (PythonException ex) { string oops = ex.ToString(); this.Invoke((Action)(() => { outputLog.AppendText(oops); })); } finally { // Get output string output = stringIO.getvalue().ToString(); this.Invoke((Action)(() => { outputLog.AppendText(output); })); // Reset stdout and stderr sys.stdout = sys.__stdout__; sys.stderr = sys.__stderr__; } } }); } private void InitPython() { // Determine the path to the config file configFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config.ini"); // Try to set the Python DLL path from config file pythonDllPath = null; if (File.Exists(configFilePath)) { pythonDllPath = File.ReadAllText(configFilePath).Trim(); } // If the DLL path is invalid, prompt user to select DLL if (string.IsNullOrEmpty(pythonDllPath) || !File.Exists(pythonDllPath)) { if (!ConfigurePythonDll()) { // User canceled DLL selection; exit application MessageBox.Show("Python DLL configuration is required to run the application.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); this.Close(); return; } else { // Config file should now have the new DLL path pythonDllPath = File.ReadAllText(configFilePath).Trim(); } } // Initialize Python Engine try { // Set the Python DLL path for Python.NET Runtime.PythonDLL = pythonDllPath; PythonEngine.Initialize(); PythonEngine.BeginAllowThreads(); } catch (Exception ex) { // Initialization failed; possibly due to invalid DLL MessageBox.Show($"Failed to initialize Python.NET with the selected DLL:\n{ex.Message}", "Initialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); // Clear the invalid DLL path from config try { File.Delete(configFilePath); } catch (Exception ioEx) { MessageBox.Show($"Failed to delete config file:\n{ioEx.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } this.Close(); } } private bool ConfigurePythonDll() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python DLL (python*.dll)|python*.dll|All files (*.*)|*.*"; dlg.Title = "Select Python DLL"; if (dlg.ShowDialog() == DialogResult.OK) { pythonDllPath = dlg.FileName; // Save the path to config file try { File.WriteAllText(configFilePath, pythonDllPath); return true; } catch (Exception ex) { MessageBox.Show($"Failed to write config file:\n{ex.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } } else { return false; } } } } } ``` We can open the ```test2.py``` script, run it, and observe the output in the log window: ![image](/embeddedpythonGUI1.png) ## Spruce up the GUI Now that we have a GUI proof of concept, let’s fix up some rough edges. ### Ask to Save We can use the ```IsModified``` flag of the ```AvalonEdit``` to track whether the file has been updated. If the file is modified, we can prompt the user to save their changes before closing the application or loading a new file. ```editordirect editormode="csharp" private void InitializeComponent() { ... // Set Form properties this.Text = "Python Editor"; this.Width = 1000; this.Height = 600; this.FormClosing += MainForm_FormClosing; } ... private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { if (codeEditor.IsModified && !AskToSave()) { e.Cancel = true; // This cancels the closing } } private bool AskToSave() { DialogResult result = MessageBox.Show("The file has been modified. Do you want to save changes?", "Save Changes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning); switch (result) { case DialogResult.Yes: if (!SaveFile()) { return false; } break; case DialogResult.Cancel: return false; } return true; } private void OpenButton_Click(object sender, EventArgs e) { if (codeEditor.IsModified && !AskToSave()) { return; } OpenFile(); } ... private void OpenFile() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.IsModified = false; codeEditor.Load(dlg.FileName); } } } private bool SaveFile() { using (SaveFileDialog dlg = new SaveFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Save(dlg.FileName); codeEditor.IsModified = false; } else { return false; } } return true; } ``` ### Update Titlebar It’s useful to display the name of the file being edited and its modified state. We can update the application’s title bar to include the filename and indicate if the file has unsaved changes. ```editordirect editormode="csharp" private string currentFilePath = null; ... private void InitializeComponent() { ... // Configure codeEditor codeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Python"); codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas"); codeEditor.FontSize = 12; codeEditor.ShowLineNumbers = true; codeEditor.TextChanged += CodeEditor_TextChanged; ... } ... private void CodeEditor_TextChanged(object sender, EventArgs e) { codeEditor.Dispatcher.BeginInvoke((Action)(() => { UpdateTitle(); }), System.Windows.Threading.DispatcherPriority.Background); } ... private void OpenFile() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Load(dlg.FileName); currentFilePath = dlg.FileName; codeEditor.IsModified = false; UpdateTitle(); } } } private bool SaveFile() { if (string.IsNullOrEmpty(currentFilePath)) { using (SaveFileDialog dlg = new SaveFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { currentFilePath = dlg.FileName; codeEditor.Save(dlg.FileName); codeEditor.IsModified = false; UpdateTitle(); } else { return false; } } } else { codeEditor.Save(currentFilePath); codeEditor.IsModified = false; UpdateTitle(); } return true; } private void UpdateTitle() { string fileName = string.IsNullOrEmpty(currentFilePath) ? "Untitled" : Path.GetFileName(currentFilePath); this.Text = (codeEditor.IsModified ? "*" : "") + fileName + " - Python Editor"; } ``` ### Find Panel A text editor isn’t complete without find. We can integrate the existing ```SearchPanel``` class to implement this functionality. It’s straightforward to set up: ```editordirect editormode="csharp" using ICSharpCode.AvalonEdit.Search; ... private SearchPanel searchPanel; ... // Configure codeEditor codeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Python"); codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas"); codeEditor.FontSize = 12; codeEditor.ShowLineNumbers = true; codeEditor.TextChanged += CodeEditor_TextChanged; searchPanel = SearchPanel.Install(codeEditor); ``` ### Toolbar Buttons The ```ToolStrip``` feels incomplete without icons. To enhance its appearance, we can use symbols from [Segoe MDL2 Assets](https://learn.microsoft.com/en-us/windows/apps/design/style/segoe-ui-symbol-font) font. This font has been included with Windows 10 for many years, so most computers should have it. This approach is simple and avoids adding image resources to the project: ```editordirect editormode="csharp" private Bitmap CreateIcon(string glyph, Color color, int size = 32) { int bitmapSize = size; float fontSize = size * 1.0f; // Adjust as needed Bitmap bmp = new Bitmap(bitmapSize, bitmapSize); using (Graphics g = Graphics.FromImage(bmp)) { g.Clear(Color.Transparent); using (Font iconFont = new Font("Segoe MDL2 Assets", fontSize, FontStyle.Regular, GraphicsUnit.Pixel)) using (SolidBrush brush = new SolidBrush(color)) { g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; // Measure the size of the glyph SizeF textSize = g.MeasureString(glyph, iconFont); // Calculate position to center the glyph float x = (bitmapSize - textSize.Width) / 2; float y = (bitmapSize - textSize.Height) / 2 + 1; // Draw the glyph onto the bitmap g.DrawString(glyph, iconFont, brush, new PointF(x, y)); } } return bmp; } ... private void InitializeComponent() { ... // Set up ToolStrip var openButton = new ToolStripButton { Text = "Open", Image = CreateIcon("\uE8E5", Color.Goldenrod, 21) }; openButton.Click += OpenButton_Click; var saveButton = new ToolStripButton { Text = "Save", Image = CreateIcon("\uE74E", Color.DeepSkyBlue, 21) }; saveButton.Click += SaveButton_Click; var runButton = new ToolStripButton { Text = "Run", Image = CreateIcon("\uE768", Color.Green, 21) }; runButton.Click += RunButton_Click; var configButton = new ToolStripButton { Text = "Configure", Image = CreateIcon("\uE713", Color.Gray, 21) }; configButton.Click += ConfigButton_Click; toolStrip.Items.Add(openButton); toolStrip.Items.Add(saveButton); toolStrip.Items.Add(runButton); toolStrip.Items.Add(configButton); // Configure the buttons foreach (var item in toolStrip.Items) { if (item is ToolStripButton) { var button = (ToolStripButton)item; button.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText; button.TextImageRelation = TextImageRelation.ImageBeforeText; button.ImageScaling = ToolStripItemImageScaling.None; button.ForeColor = SystemColors.ControlText; } } ... } ``` ### Code Foldings Folding is a feature that allows users to collapse and expand sections of code, improving readability by minimizing visual clutter. Since Python relies on indentation to define blocks of code, we can use this structure to implement folding. ```AvalonEdit``` doesn’t include built-in support for indentation-based folding, but it does allow the creation of custom folding strategies. We can walk the indentation level line-by-line to figure out where to place the foldable sections. A folding region is created when the code detects a decrease in indentation or the end of a block. The code also handles arrays and blocks in a lazy way: ```editordirect editormode="csharp" using ICSharpCode.AvalonEdit.Folding; // For folding using ICSharpCode.AvalonEdit.Document; // For Document ... public static int tabSize = 4; ... private void InitializeComponent() { ... // Initialize folding manager and strategy foldingManager = FoldingManager.Install(codeEditor.TextArea); foldingStrategy = new IndentationFoldingStrategy(); codeEditor.TextChanged += (sender, args) => UpdateFoldings(); } ... private void UpdateFoldings() { if (foldingStrategy != null && foldingManager != null) { foldingStrategy.UpdateFoldings(foldingManager, codeEditor.Document); } } // Folding strategy for indentation public class IndentationFoldingStrategy { public void UpdateFoldings(FoldingManager manager, TextDocument document) { var newFoldings = CreateNewFoldings(document); manager.UpdateFoldings(newFoldings, -1); } public static string ConvertLeadingTabsToSpaces(string input, int spacesPerTab) { if (input == null) return input; // Handle null input string tabReplacement = new string(' ', spacesPerTab); int index = 0; // Find the first non-tab character or end of string while (index < input.Length && input[index] == '\t') { index++; } // Replace only the leading tabs with spaces string leadingTabsConverted = input.Substring(0, index).Replace("\t", tabReplacement); // Combine the converted leading part with the rest of the string return leadingTabsConverted + input.Substring(index); } private IEnumerable CreateNewFoldings(TextDocument document) { var newFoldings = new List(); Stack> startLines = new Stack>(); Stack startIndentationLevels = new Stack(); int previousIndentationLevel = 0; bool inArrayDefinition = false; int arrayStartLine = -1; int arrayNestingLevel = 0; for (int lineNumber = 1; lineNumber <= document.LineCount; lineNumber++) { DocumentLine line = document.GetLineByNumber(lineNumber); string lineText = document.GetText(line).TrimEnd(); // Ignore empty lines if (string.IsNullOrWhiteSpace(lineText)) continue; int currentIndentationLevel = GetIndentationLevel(document.GetText(line)); // Handle block definitions with nesting (arrays and braces) foreach (char c in lineText) { if (c == '[' || c == '{') { if (!inArrayDefinition) { inArrayDefinition = true; arrayStartLine = lineNumber; } arrayNestingLevel++; } else if (c == ']' || c == '}') { arrayNestingLevel--; if (arrayNestingLevel == 0 && inArrayDefinition) { // Close array folding inArrayDefinition = false; if ((lineNumber - arrayStartLine) > 1) { int startOffset = document.GetLineByNumber(arrayStartLine).Offset; int endOffset = line.EndOffset; var name = document.GetText(document.GetLineByNumber(arrayStartLine)).TrimEnd() + "..."; newFoldings.Add(new NewFolding(startOffset, endOffset) { Name = ConvertLeadingTabsToSpaces(name, MainForm.tabSize) }); } } } } // Handle indentation-based folding while (startLines.Count > 0 && currentIndentationLevel <= startLines.Peek().Item2) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; startIndentationLevels.Pop(); int endLine = lineNumber - 1; while (endLine > 1) { string endLineText = document.GetText(document.GetLineByNumber(endLine)).TrimEnd(); if (string.IsNullOrWhiteSpace(endLineText)) endLine--; else break; } if ((lineNumber - startLine) > 2) { var newFolding = new NewFolding(startOffset, document.GetLineByNumber(endLine).EndOffset); newFolding.Name = ConvertLeadingTabsToSpaces(document.GetText(document.GetLineByNumber(startLine)).TrimEnd() + "...", MainForm.tabSize); newFolding.IsDefinition = true; newFoldings.Add(newFolding); } } if (lineText.EndsWith(":")) { // Start a new folding section startLines.Push(new Tuple(lineNumber, currentIndentationLevel)); startIndentationLevels.Push(GetIndentationLevel(document.GetText(line))); } previousIndentationLevel = currentIndentationLevel; } // Close any remaining open foldings while (startLines.Count > 0) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; newFoldings.Add(new NewFolding(startOffset, document.TextLength)); } newFoldings.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset)); return newFoldings; } private int GetIndentationLevel(string lineText) { int indentationLevel = 0; foreach (char c in lineText) { if (c == ' ') indentationLevel++; else if (c == '\t') indentationLevel += MainForm.tabSize; else break; } return indentationLevel; } } ``` ### Complete Improved UI The completed code with these enhancements is as follows: ```editordirect editormode="csharp" using System; using System.IO; using System.Windows.Forms; using System.Windows.Forms.Integration; // For ElementHost using System.Threading.Tasks; // For Tasks using ICSharpCode.AvalonEdit; // AvalonEdit using ICSharpCode.AvalonEdit.Highlighting; using ICSharpCode.AvalonEdit.Document; // For Document using ICSharpCode.AvalonEdit.Search; using ICSharpCode.AvalonEdit.Folding; // For folding using Python.Runtime; // For Python.NET namespace GuiPythonBetter { public partial class MainForm : Form { private ToolStrip toolStrip; private SplitContainer splitContainer; private ElementHost upperElementHost; private ElementHost lowerElementHost; private TextEditor codeEditor; private TextEditor outputLog; private FoldingManager foldingManager; private IndentationFoldingStrategy foldingStrategy; private string configFilePath; private string pythonDllPath; private string currentFilePath = null; private SearchPanel searchPanel; public static int tabSize = 4; public MainForm() { InitializeComponent(); this.Load += MainForm_Load; } private Bitmap CreateIcon(string glyph, Color color, int size = 32) { int bitmapSize = size; float fontSize = size * 1.0f; // Adjust as needed Bitmap bmp = new Bitmap(bitmapSize, bitmapSize); using (Graphics g = Graphics.FromImage(bmp)) { g.Clear(Color.Transparent); using (Font iconFont = new Font("Segoe MDL2 Assets", fontSize, FontStyle.Regular, GraphicsUnit.Pixel)) using (SolidBrush brush = new SolidBrush(color)) { g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; // Measure the size of the glyph SizeF textSize = g.MeasureString(glyph, iconFont); // Calculate position to center the glyph float x = (bitmapSize - textSize.Width) / 2; float y = (bitmapSize - textSize.Height) / 2 + 1; // Draw the glyph onto the bitmap g.DrawString(glyph, iconFont, brush, new PointF(x, y)); } } return bmp; } private void InitializeComponent() { // Initialize components toolStrip = new ToolStrip(); splitContainer = new SplitContainer(); upperElementHost = new ElementHost(); lowerElementHost = new ElementHost(); codeEditor = new TextEditor(); outputLog = new TextEditor(); // Set up ToolStrip var openButton = new ToolStripButton { Text = "Open", Image = CreateIcon("\uE8E5", Color.Goldenrod, 21) }; openButton.Click += OpenButton_Click; var saveButton = new ToolStripButton { Text = "Save", Image = CreateIcon("\uE74E", Color.DeepSkyBlue, 21) }; saveButton.Click += SaveButton_Click; var runButton = new ToolStripButton { Text = "Run", Image = CreateIcon("\uE768", Color.Green, 21) }; runButton.Click += RunButton_Click; var configButton = new ToolStripButton { Text = "Configure", Image = CreateIcon("\uE713", Color.Gray, 21) }; configButton.Click += ConfigButton_Click; toolStrip.Items.Add(openButton); toolStrip.Items.Add(saveButton); toolStrip.Items.Add(runButton); toolStrip.Items.Add(configButton); // Configure the buttons foreach (var item in toolStrip.Items) { if (item is ToolStripButton) { var button = (ToolStripButton)item; button.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText; button.TextImageRelation = TextImageRelation.ImageBeforeText; button.ImageScaling = ToolStripItemImageScaling.None; button.ForeColor = SystemColors.ControlText; } } // Set up SplitContainer splitContainer.Dock = DockStyle.Fill; splitContainer.Orientation = Orientation.Horizontal; splitContainer.SplitterDistance = this.Height / 2; // Set up AvalonEdit controls upperElementHost.Dock = DockStyle.Fill; upperElementHost.Child = codeEditor; lowerElementHost.Dock = DockStyle.Fill; lowerElementHost.Child = outputLog; // Configure codeEditor codeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Python"); codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas"); codeEditor.FontSize = 12; codeEditor.ShowLineNumbers = true; codeEditor.TextChanged += CodeEditor_TextChanged; searchPanel = SearchPanel.Install(codeEditor); // Configure output log outputLog.IsReadOnly = true; outputLog.FontFamily = new System.Windows.Media.FontFamily("Consolas"); outputLog.FontSize = 12; outputLog.ShowLineNumbers = true; // Add controls to SplitContainer splitContainer.Panel1.Controls.Add(upperElementHost); splitContainer.Panel2.Controls.Add(lowerElementHost); // Add controls to Form this.Controls.Add(splitContainer); this.Controls.Add(toolStrip); // Set Form properties this.Text = "Python Editor"; this.Width = 1000; this.Height = 600; UpdateTitle(); this.FormClosing += MainForm_FormClosing; // Initialize folding manager and strategy foldingManager = FoldingManager.Install(codeEditor.TextArea); foldingStrategy = new IndentationFoldingStrategy(); codeEditor.TextChanged += (sender, args) => UpdateFoldings(); } private void MainForm_Load(object sender, EventArgs e) { InitPython(); } protected override void OnFormClosed(FormClosedEventArgs e) { PythonEngine.Shutdown(); base.OnFormClosed(e); } // Event Handlers private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { if (codeEditor.IsModified && !AskToSave()) { e.Cancel = true; // This cancels the closing } } private void CodeEditor_TextChanged(object sender, EventArgs e) { codeEditor.Dispatcher.BeginInvoke((Action)(() => { UpdateTitle(); }), System.Windows.Threading.DispatcherPriority.Background); } private bool AskToSave() { DialogResult result = MessageBox.Show("The file has been modified. Do you want to save changes?", "Save Changes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning); switch (result) { case DialogResult.Yes: if (!SaveFile()) { return false; } break; case DialogResult.Cancel: return false; } return true; } private void OpenButton_Click(object sender, EventArgs e) { if (codeEditor.IsModified && !AskToSave()) { return; } OpenFile(); } private void SaveButton_Click(object sender, EventArgs e) { SaveFile(); } private void RunButton_Click(object sender, EventArgs e) { RunCode(); } private void ConfigButton_Click(object sender, EventArgs e) { if (ConfigurePythonDll()) { // Inform the user to restart the application for changes to take effect MessageBox.Show("Python DLL path updated. Please restart the application for changes to take effect.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); } } private void OpenFile() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Load(dlg.FileName); currentFilePath = dlg.FileName; codeEditor.IsModified = false; UpdateTitle(); } } } private bool SaveFile() { if (string.IsNullOrEmpty(currentFilePath)) { using (SaveFileDialog dlg = new SaveFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { currentFilePath = dlg.FileName; codeEditor.Save(dlg.FileName); codeEditor.IsModified = false; UpdateTitle(); } else { return false; } } } else { codeEditor.Save(currentFilePath); codeEditor.IsModified = false; UpdateTitle(); } return true; } private void UpdateTitle() { string fileName = string.IsNullOrEmpty(currentFilePath) ? "Untitled" : Path.GetFileName(currentFilePath); this.Text = (codeEditor.IsModified ? "*" : "") + fileName + " - Python Editor"; } private void RunCode() { outputLog.Text = ""; string code = codeEditor.Text; Task.Run(() => { using (Py.GIL()) { dynamic sys = Py.Import("sys"); dynamic io = Py.Import("io"); dynamic stringIO = io.StringIO(); sys.stdout = stringIO; sys.stderr = stringIO; try { dynamic pyScope = Py.CreateScope(); var appInterface = new AppInterface(); pyScope.app = appInterface; pyScope.Exec(code); } catch (PythonException ex) { string oops = ex.ToString(); this.Invoke((Action)(() => { outputLog.AppendText(oops); })); } finally { // Get output string output = stringIO.getvalue().ToString(); this.Invoke((Action)(() => { outputLog.AppendText(output); })); // Reset stdout and stderr sys.stdout = sys.__stdout__; sys.stderr = sys.__stderr__; } } }); } private void InitPython() { // Determine the path to the config file configFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config.ini"); // Try to set the Python DLL path from config file pythonDllPath = null; if (File.Exists(configFilePath)) { pythonDllPath = File.ReadAllText(configFilePath).Trim(); } // If the DLL path is invalid, prompt user to select DLL if (string.IsNullOrEmpty(pythonDllPath) || !File.Exists(pythonDllPath)) { if (!ConfigurePythonDll()) { // User canceled DLL selection; exit application MessageBox.Show("Python DLL configuration is required to run the application.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); this.Close(); return; } else { // Config file should now have the new DLL path pythonDllPath = File.ReadAllText(configFilePath).Trim(); } } // Initialize Python Engine try { // Set the Python DLL path for Python.NET Runtime.PythonDLL = pythonDllPath; PythonEngine.Initialize(); PythonEngine.BeginAllowThreads(); } catch (Exception ex) { // Initialization failed; possibly due to invalid DLL MessageBox.Show($"Failed to initialize Python.NET with the selected DLL:\n{ex.Message}", "Initialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); // Clear the invalid DLL path from config try { File.Delete(configFilePath); } catch (Exception ioEx) { MessageBox.Show($"Failed to delete config file:\n{ioEx.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } this.Close(); } } private bool ConfigurePythonDll() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python DLL (python*.dll)|python*.dll|All files (*.*)|*.*"; dlg.Title = "Select Python DLL"; if (dlg.ShowDialog() == DialogResult.OK) { pythonDllPath = dlg.FileName; // Save the path to config file try { File.WriteAllText(configFilePath, pythonDllPath); return true; } catch (Exception ex) { MessageBox.Show($"Failed to write config file:\n{ex.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } } else { return false; } } } private void UpdateFoldings() { if (foldingStrategy != null && foldingManager != null) { foldingStrategy.UpdateFoldings(foldingManager, codeEditor.Document); } } } // Folding strategy for indentation public class IndentationFoldingStrategy { public void UpdateFoldings(FoldingManager manager, TextDocument document) { var newFoldings = CreateNewFoldings(document); manager.UpdateFoldings(newFoldings, -1); } public static string ConvertLeadingTabsToSpaces(string input, int spacesPerTab) { if (input == null) return input; // Handle null input string tabReplacement = new string(' ', spacesPerTab); int index = 0; // Find the first non-tab character or end of string while (index < input.Length && input[index] == '\t') { index++; } // Replace only the leading tabs with spaces string leadingTabsConverted = input.Substring(0, index).Replace("\t", tabReplacement); // Combine the converted leading part with the rest of the string return leadingTabsConverted + input.Substring(index); } private IEnumerable CreateNewFoldings(TextDocument document) { var newFoldings = new List(); Stack> startLines = new Stack>(); Stack startIndentationLevels = new Stack(); int previousIndentationLevel = 0; bool inArrayDefinition = false; int arrayStartLine = -1; int arrayNestingLevel = 0; for (int lineNumber = 1; lineNumber <= document.LineCount; lineNumber++) { DocumentLine line = document.GetLineByNumber(lineNumber); string lineText = document.GetText(line).TrimEnd(); // Ignore empty lines or lines that only contain comments if (string.IsNullOrWhiteSpace(lineText) || lineText.StartsWith("#")) continue; int currentIndentationLevel = GetIndentationLevel(document.GetText(line)); // Handle block definitions with nesting (arrays and braces) foreach (char c in lineText) { if (c == '[' || c == '{') { if (!inArrayDefinition) { inArrayDefinition = true; arrayStartLine = lineNumber; } arrayNestingLevel++; } else if (c == ']' || c == '}') { arrayNestingLevel--; if (arrayNestingLevel == 0 && inArrayDefinition) { // Close array folding inArrayDefinition = false; if ((lineNumber - arrayStartLine) > 1) { int startOffset = document.GetLineByNumber(arrayStartLine).Offset; int endOffset = line.EndOffset; var name = document.GetText(document.GetLineByNumber(arrayStartLine)).TrimEnd() + "..."; newFoldings.Add(new NewFolding(startOffset, endOffset) { Name = ConvertLeadingTabsToSpaces(name, MainForm.tabSize) }); } } } } // Handle indentation-based folding while (startLines.Count > 0 && currentIndentationLevel <= startLines.Peek().Item2) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; startIndentationLevels.Pop(); int endLine = lineNumber - 1; while (endLine > 1) { string endLineText = document.GetText(document.GetLineByNumber(endLine)).TrimEnd(); if (string.IsNullOrWhiteSpace(endLineText)) endLine--; else break; } if ((lineNumber - startLine) > 2) { var newFolding = new NewFolding(startOffset, document.GetLineByNumber(endLine).EndOffset); newFolding.Name = ConvertLeadingTabsToSpaces(document.GetText(document.GetLineByNumber(startLine)).TrimEnd() + "...", MainForm.tabSize); newFolding.IsDefinition = true; newFoldings.Add(newFolding); } } if (lineText.EndsWith(":")) { // Start a new folding section startLines.Push(new Tuple(lineNumber, currentIndentationLevel)); startIndentationLevels.Push(GetIndentationLevel(document.GetText(line))); } previousIndentationLevel = currentIndentationLevel; } // Close any remaining open foldings while (startLines.Count > 0) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; newFoldings.Add(new NewFolding(startOffset, document.TextLength)); } newFoldings.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset)); return newFoldings; } private int GetIndentationLevel(string lineText) { int indentationLevel = 0; foreach (char c in lineText) { if (c == ' ') indentationLevel++; else if (c == '\t') indentationLevel += MainForm.tabSize; else break; } return indentationLevel; } } public class AppInterface { public AppInterface() { } public int Add(int a, int b) { return a + b; } } } ``` The updated app looks like this: ![image](/embeddedpythonGUI1-1.png) ## Interactive Debugging Having a debugger is a must for a scripting application. [pdb](https://docs.python.org/3/library/pdb.html) is a typical Python debugger to use from a commandline. To debug a script such as ```myCode.py```, we typically run: ```python -m pdb myCode.py``` We can integrate this into our GUI by wrapping debugger execution. The following code demonstrates how to enter debug mode for the script currently loaded in the editor: ```editordirect editormode="csharp" // Save the code in the editor to a temporary file string code = codeEditor.Text; tempFilePath = Path.Combine(Path.GetTempPath(), "tempCode.py"); File.WriteAllText(tempFilePath, code); using (Py.GIL()) { // Import pdb and create a Pdb instance with custom stdout dynamic pdb = Py.Import("pdb"); pdbInstance = pdb.Pdb(); // Create an AppInterface instance var appInterface = new AppInterface(); globalLocalDict.SetItem(new PyString("app"), appInterface.ToPython()); // Read and compile the code from the file string codeFromFile = File.ReadAllText(tempFilePath); dynamic builtins = Py.Import("builtins"); dynamic compile = builtins.compile; dynamic codeObject = compile(codeFromFile, tempFilePath, "exec"); // Run the code under pdb control pdbInstance.run(codeObject, globalLocalDict, globalLocalDict); } ``` Although this starts ```pdb```, it doesn’t get us very far. The problem is there’s no way to send commands to ```pdb``` once it’s running. This prevents interaction with the debugger from within the GUI. ### Overriding Standard Input One solution is to override the input stream, allowing us to send ```pdb``` commands programmatically, similar to how they would be entered on the command line. For example: ```editordirect editormode="csharp" private PyInputStream pythonInputStream = new PyInputStream(); // Define a custom input stream to pass input to Python public class PyInputStream { private Queue inputQueue = new Queue(); private ManualResetEvent inputReadyEvent = new ManualResetEvent(false); public void SendInput(string input) { lock (inputQueue) { inputQueue.Enqueue(input); inputReadyEvent.Set(); // Signal that input is available } } // Python expects a readline() method for sys.stdin public string readline() { inputReadyEvent.WaitOne(); // Wait for input to be ready lock (inputQueue) { if (inputQueue.Count > 0) { var input = inputQueue.Dequeue(); inputReadyEvent.Reset(); // Reset the event if no more input is available return input; } } return ""; // Return an empty string if no input is available } } ``` and ```editordirect editormode="csharp" dynamic sys = Py.Import("sys"); sys.stdin = pythonInputStream; ``` We can then send commands to ```pdb``` like: ```editordirect editormode="csharp" pythonInputStream.SendInput("c\n"); // Send 'c' for Continue command ``` ### Debugger Toolbar Buttons Now that we know how to send commands, we can add some buttons for controlling the debugging. We can reuse our code for making icons from a font. ```editordirect editormode="csharp" private ToolStripButton nextButton; private ToolStripButton stepIntoButton; private ToolStripButton stepOutButton; private ToolStripButton continueButton; private ToolStripButton quitButton; private void InitializeComponent() { ... // Debugger buttons for controlling pdb var debugButton = new ToolStripButton("Debug", CreateIcon("\uE768", System.Drawing.Color.Purple, 21), (sender, e) => RunCode(debugMode: true)); toolStrip.Items.Add(debugButton); nextButton = new ToolStripButton("Next", CreateIcon("\uE72A", System.Drawing.Color.Purple, 16), NextButton_Click); stepIntoButton = new ToolStripButton("Step Into", CreateIcon("\uE74B", System.Drawing.Color.Purple, 16), StepIntoButton_Click); stepOutButton = new ToolStripButton("Step Out", CreateIcon("\uE74A", System.Drawing.Color.Purple, 16), StepOutButton_Click); continueButton = new ToolStripButton("Continue", CreateIcon("\uE72A", System.Drawing.Color.Green, 16), ContinueButton_Click); quitButton = new ToolStripButton("Quit", CreateIcon("\uE71A", System.Drawing.Color.Red, 16), QuitButton_Click); // Add the buttons to the toolstrip toolStrip.Items.Add(new ToolStripSeparator()); toolStrip.Items.Add(nextButton); toolStrip.Items.Add(stepIntoButton); toolStrip.Items.Add(stepOutButton); toolStrip.Items.Add(continueButton); toolStrip.Items.Add(quitButton); EnableDebuggerButtons(false); ... } private void NextButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("n\n"); // Send 'n' for Next command } private void StepIntoButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("s\n"); // Send 's' for Step Into command } private void StepOutButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("r\n"); // Send 'r' for Return command } private void ContinueButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("c\n"); // Send 'c' for Continue command } private void QuitButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("q\n"); // Send 'q' for Quit command } private void EnableDebuggerButtons(bool isEnabled) { nextButton.Enabled = isEnabled; stepIntoButton.Enabled = isEnabled; stepOutButton.Enabled = isEnabled; continueButton.Enabled = isEnabled; quitButton.Enabled = isEnabled; } ``` ### Overriding Standard Output Similarly to overriding ```stdin```, we can create an overridden ```stdout``` to capture the script’s output in real time. This approach enables us to display the output dynamically in the log window, rather than waiting until the script finishes execution. ```editordirect editormode="csharp" // Define a custom output stream for real-time Python output public class PyOutputStream { private MainForm _form; public PyOutputStream(MainForm form) { _form = form; } public void write(string output) { _form.Invoke((Action)(() => { _form.outputLog.AppendText(output); // Append output to the log in real time })); } public void flush() { // Implement if needed for flushing buffers } } ``` ### Update RunCode to implement Debug Mode We now have the pieces to complete our new ```RunCode()``` function that supports debug mode. In normal execution, the code runs the script and redirects Python’s ```stdout``` and ```stderr``` to the custom output stream to display real-time output. In debug mode, the code uses ```pdb``` to execute the code under debugger control. Notably, we introduce a separate ```PyPdbOutputStream``` class to keep the debugger output distinct from the script output. A more complete implementation might display these outputs in separate windows. ```editordirect editormode="csharp" private CancellationTokenSource pythonExecutionCancellationTokenSource; private void RunCode(bool debugMode = false) { outputLog.Text = ""; string code = codeEditor.Text; // Initialize the cancellation token source pythonExecutionCancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = pythonExecutionCancellationTokenSource.Token; Task.Run(() => { using (Py.GIL()) { dynamic sys = Py.Import("sys"); // Custom Python stream to capture real-time output dynamic customOutput = new PyOutputStream(this); // Redirect stdout and stderr to the custom output stream sys.stdout = customOutput; sys.stderr = customOutput; sys.stdin = pythonInputStream; try { // Create a dictionary to hold variables PyDict globalLocalDict = new PyDict(); dynamic builtins = Py.Import("builtins"); globalLocalDict.SetItem("__builtins__", builtins); // Create an AppInterface instance and add it to the dictionary var appInterface = new AppInterface(); globalLocalDict.SetItem(new PyString("app"), appInterface.ToPython()); if (debugMode) { // Enable debugger buttons this.Invoke((Action)(() => { EnableDebuggerButtons(true); })); // Save the code to a temporary file tempFilePath = Path.Combine(Path.GetTempPath(), "tempCode.py"); File.WriteAllText(tempFilePath, code); // Import pdb and create a Pdb instance with custom stdout dynamic pdb = Py.Import("pdb"); pdbInstance = pdb.Pdb(); pdbInstance.stdout = new PyPdbOutputStream(); // Redirect pdb's stdout to the bin pdbInstance.prompt = ""; // Suppress the (Pdb) prompt // Read and compile the code from the file string codeFromFile = File.ReadAllText(tempFilePath); dynamic compile = builtins.compile; dynamic codeObject = compile(codeFromFile, tempFilePath, "exec"); // Run the code under pdb control isDebugging = true; pdbInstance.run(codeObject, globalLocalDict, globalLocalDict); // Delete the temporary file after execution File.Delete(tempFilePath); } else { PythonEngine.Exec(code, globalLocalDict, globalLocalDict); } } catch (PythonException ex) { // Log Python runtime exceptions string oops = ex.ToString(); this.Invoke((Action)(() => { outputLog.AppendText(oops); })); } catch (Exception ex) { // Catch any .NET exceptions that occur during the task execution string oops = ex.ToString(); this.Invoke((Action)(() => { outputLog.AppendText($".NET Exception:\n{oops}\n"); })); } finally { isDebugging = false; // Reset the debugging flag // Disable debugger buttons when done this.Invoke((Action)(() => { EnableDebuggerButtons(false); })); // Reset stdout and stderr sys.stdout = sys.__stdout__; sys.stderr = sys.__stderr__; sys.stdin = sys.__stdin__; } } }, cancellationToken); } public class PyPdbOutputStream { public PyPdbOutputStream() { } public void write(string output) { // Do nothing } public void flush() { // Do nothing } } ``` We also don’t want anyone closing our app while we’re debugging: ```editordirect editormode="csharp" private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { if (isDebugging) { MessageBox.Show("Please stop debugging before closing.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); e.Cancel = true; // This cancels the closing return; } if (codeEditor.IsModified && !AskToSave()) { e.Cancel = true; // This cancels the closing } } ``` ### Current Line Indication It’s pretty hard to debug when you don’t know what line you’re on. To address this, let’s implement functionality to highlight the current line. This can be achieved by creating a custom ```IBackgroundRenderer``` for ```AvalonEdit```. The interface for this is straightforward, it takes a line number, as only one line will be highlighted at a time. We also want to scroll that line into view as the highlighted line could be offscreen. ```editordirect editormode="csharp" public class HighlightCurrentLineBackgroundRenderer : ICSharpCode.AvalonEdit.Rendering.IBackgroundRenderer { public int Line { get; set; } public void Draw(ICSharpCode.AvalonEdit.Rendering.TextView textView, DrawingContext drawingContext) { if (Line < 1 || Line > textView.Document.LineCount) return; textView.EnsureVisualLines(); var line = textView.Document.GetLineByNumber(Line); if (line == null) return; foreach (var rect in ICSharpCode.AvalonEdit.Rendering.BackgroundGeometryBuilder.GetRectsForSegment(textView, line)) { drawingContext.DrawRectangle(new SolidColorBrush(Colors.Yellow), null, rect); } } public KnownLayer Layer => KnownLayer.Background; } private HighlightCurrentLineBackgroundRenderer lineHighlighter; public void HighlightCurrentLine(int lineNumber) { if (lineHighlighter == null) { lineHighlighter = new HighlightCurrentLineBackgroundRenderer(); codeEditor.TextArea.TextView.BackgroundRenderers.Add(lineHighlighter); } // Set the line to highlight lineHighlighter.Line = lineNumber; // Ensure visibility codeEditor.ScrollTo(lineNumber, 0); // Redraw the editor to show the highlight codeEditor.TextArea.TextView.InvalidateLayer(KnownLayer.Background); } ``` With the highlighter complete, the next step is determining the current line. When stopped at a line of code, ```pdb``` outputs debug information in the following format: ```> script.py(7)main()``` This indicates that ```pdb``` is paused on line 7 of ```script.py```. To handle this, we can implement parsing logic in our ```PyPdbOutputStream``` class. This parsed information can then be used to call ```HighlightCurrentLine()```. ```editordirect editormode="csharp" using System.Text; // For StringBuilder ... pdbInstance.stdout = new PyPdbOutputStream(this); ... public class PyPdbOutputStream { private MainForm _form; private StringBuilder _buffer = new StringBuilder(); public PyPdbOutputStream(MainForm form) { _form = form; } public void write(string output) { _form.Invoke((Action)(() => { // Append output to buffer _buffer.Append(output); // Check if we have complete lines string bufferContent = _buffer.ToString(); int newLineIndex; while ((newLineIndex = bufferContent.IndexOf('\n')) != -1) { string line = bufferContent.Substring(0, newLineIndex); ParseOutputLine(line); // Remove the parsed line from the buffer _buffer.Remove(0, newLineIndex + 1); bufferContent = _buffer.ToString(); } })); } private void ParseOutputLine(string line) { // Check if the line indicates a pdb line change if (line.StartsWith("> ")) { // Extract the filename and line number // Line format: "> /path/to/file.py(3)()" int startIndex = line.IndexOf('>') + 2; int endIndex = line.IndexOf('(', startIndex); if (endIndex > startIndex) { string filename = line.Substring(startIndex, endIndex - startIndex); // Extract the line number startIndex = endIndex + 1; endIndex = line.IndexOf(')', startIndex); if (endIndex > startIndex) { string lineNumberStr = line.Substring(startIndex, endIndex - startIndex); if (int.TryParse(lineNumberStr, out int lineNumber)) { // Highlight the line in the code editor _form.HighlightCurrentLine(lineNumber); } } } } } public void flush() { // Do nothing } } ``` ### Breakpoints We can implement the GUI part of breakpoints as a custom ```AvalonEdit``` margin. This margin allows users to set or remove breakpoints by clicking next to the line numbers. To visually indicate active breakpoints, we can draw red circles in the margin beside the corresponding lines. On the backend, a ```HashSet``` can be used to store the line numbers with active breakpoints. Additionally, a ```BreakpointChanged``` event can be raised to notify other parts of the application whenever the breakpoint status changes. Some extra directives are required for this functionality, which can get somewhat messy due to overlapping library dependencies. In hindsight, using ```WinForms``` may not have been the best choice. ```editordirect editormode="csharp" using ICSharpCode.AvalonEdit.Editing; // For TextArea using ICSharpCode.AvalonEdit.Rendering; // For TextView using System.Windows.Media; // For ImageSource, Brushes, etc. using System.Windows.Input; ... private BreakpointMargin breakpointMargin; // Define BreakpointChangedEventArgs public class BreakpointChangedEventArgs : EventArgs { public int LineNumber { get; } public bool IsAdded { get; } public BreakpointChangedEventArgs(int lineNumber, bool isAdded) { LineNumber = lineNumber; IsAdded = isAdded; } } public class BreakpointMargin : AbstractMargin { private HashSet breakpoints = new HashSet(); private const double CIRCLE_RADIUS = 8; private const double MARGIN_WIDTH = 20; public event EventHandler BreakpointChanged; public HashSet Breakpoints => breakpoints; public BreakpointMargin() { this.Cursor = System.Windows.Input.Cursors.Hand; } protected override System.Windows.Size MeasureOverride(System.Windows.Size availableSize) { return new System.Windows.Size(MARGIN_WIDTH, availableSize.Height); } protected override void OnRender(DrawingContext drawingContext) { var textView = this.TextView; if (textView == null || !textView.VisualLinesValid) return; // First, draw a slightly darker background for the margin var marginRect = new System.Windows.Rect(0, 0, MARGIN_WIDTH, textView.ActualHeight); drawingContext.DrawRectangle( new SolidColorBrush(System.Windows.Media.Color.FromRgb(240, 240, 240)), null, marginRect ); foreach (var visualLine in textView.VisualLines) { int lineNumber = visualLine.FirstDocumentLine.LineNumber; if (breakpoints.Contains(lineNumber)) { // Calculate proper vertical position double y = visualLine.GetTextLineVisualYPosition(visualLine.TextLines[0], VisualYPosition.TextTop); double lineHeight = visualLine.Height; double circleY = y + (lineHeight / 2) - textView.VerticalOffset; // Draw breakpoint circle drawingContext.DrawEllipse( System.Windows.Media.Brushes.Red, // Fill new System.Windows.Media.Pen(System.Windows.Media.Brushes.DarkRed, 1), // Border new System.Windows.Point(MARGIN_WIDTH / 2, circleY), // Center point CIRCLE_RADIUS - 1, // Width radius CIRCLE_RADIUS - 1 // Height radius ); } } } protected override void OnMouseDown(MouseButtonEventArgs e) { if (e.ChangedButton != MouseButton.Left) return; var textView = this.TextView; if (textView == null) return; var pos = e.GetPosition(textView); pos.Y += textView.VerticalOffset; var visualLine = textView.GetVisualLineFromVisualTop(pos.Y); if (visualLine != null) { ToggleBreakpoint(visualLine.FirstDocumentLine.LineNumber); } } public void ToggleBreakpoint(int lineNumber) { // Toggle breakpoint bool breakpointAdded; if (breakpoints.Contains(lineNumber)) { breakpoints.Remove(lineNumber); breakpointAdded = false; } else { breakpoints.Add(lineNumber); breakpointAdded = true; } InvalidateVisual(); // Raise the event BreakpointChanged?.Invoke(this, new BreakpointChangedEventArgs(lineNumber, breakpointAdded)); } protected override void OnTextViewChanged(TextView oldTextView, TextView newTextView) { if (oldTextView != null) { oldTextView.VisualLinesChanged -= OnVisualLinesChanged; } if (newTextView != null) { newTextView.VisualLinesChanged += OnVisualLinesChanged; } base.OnTextViewChanged(oldTextView, newTextView); } private void OnVisualLinesChanged(object sender, EventArgs e) { InvalidateVisual(); } } ``` Then we can wire the breakpoints in: ```editordirect editormode="csharp" private void InitializeComponent() { ... // Create and add the BreakpointMargin breakpointMargin = new BreakpointMargin(); breakpointMargin.BreakpointChanged += BreakpointMargin_BreakpointChanged; codeEditor.TextArea.LeftMargins.Insert(0, breakpointMargin); codeEditor.TextArea.UpdateLayout(); breakpointMargin.InvalidateVisual(); ... } ... private void BreakpointMargin_BreakpointChanged(object sender, BreakpointChangedEventArgs e) { if (isDebugging) { // Send command to pdb via pythonInputStream string command; if (e.IsAdded) { command = $"break {tempFilePath}:{e.LineNumber}\n"; } else { command = $"clear {tempFilePath}:{e.LineNumber}\n"; } pythonInputStream.SendInput(command); } } ... private void RunCode(bool debugMode = false) { outputLog.Text = ""; string code = codeEditor.Text; var breakpoints = breakpointMargin?.Breakpoints ?? new HashSet(); ... Task.Run(() => { using (Py.GIL()) { ... // Set breakpoints pdbInstance.clear_all_breaks(); foreach (int lineNumber in breakpoints) { pdbInstance.set_break(tempFilePath, lineNumber); } // Read and compile the code from the file string codeFromFile = File.ReadAllText(tempFilePath); dynamic compile = builtins.compile; dynamic codeObject = compile(codeFromFile, tempFilePath, "exec"); // Run the code under pdb control isDebugging = true; pdbInstance.run(codeObject, globalLocalDict, globalLocalDict); ... } ... } ``` ### Keyboard Shortcuts While we’re at it, let’s add some keyboard shortcuts. This makes interacting much more efficient. The ```ToolStripButton``` doesn’t natively support shortcuts, but we can override ```ProcessCmdKey()``` instead: ```editordirect editormode="csharp" protected override bool ProcessCmdKey(ref Message msg, Keys keyData) { switch (keyData) { case Keys.Control | Keys.O: // Ctrl + O for Open OpenButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.S: // Ctrl + S for Save SaveButton_Click(this, EventArgs.Empty); return true; case Keys.F5: // F5 for Debug or Continue if (!isDebugging) RunCode(true); else ContinueButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.F5: // Ctrl + F5 for Run RunCode(); return true; case Keys.Shift | Keys.F5: // Shift + F5 for Stop QuitButton_Click(this, EventArgs.Empty); return true; case Keys.F11: // F11 for Step Into StepIntoButton_Click(this, EventArgs.Empty); return true; case Keys.Shift | Keys.F11: // Shift + F11 for Step Out StepOutButton_Click(this, EventArgs.Empty); return true; case Keys.F10: // F10 for Next NextButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.Shift | Keys.C: // Ctrl + Shift + C for Configure ConfigButton_Click(this, EventArgs.Empty); return true; case Keys.F9: // F9 for Toggle Breakpoint ToggleBreakpointOnCurrentLine(); return true; } return base.ProcessCmdKey(ref msg, keyData); } ... private void ToggleBreakpointOnCurrentLine() { breakpointMargin.ToggleBreakpoint(codeEditor.TextArea.Caret.Line); } ``` ### Variables Window Finally, let’s implement a variables window to display the state of variables as we step through the code. A straightforward approach is to use a ```DataGridView``` for the variables display and introduce a second splitter to divide the lower area between the variables view and the output pane. ```editordirect editormode="csharp" private SplitContainer lowerSplitContainer; private DataGridView variablesGridView; private void InitializeComponent() { // Initialize components ... lowerSplitContainer = new SplitContainer(); variablesGridView = new DataGridView(); ... // Initialize the lower SplitContainer lowerSplitContainer.Dock = DockStyle.Fill; lowerSplitContainer.Orientation = Orientation.Vertical; ... // Configure variables GridView variablesGridView.Dock = DockStyle.Fill; variablesGridView.Columns.Add("Variable", "Variable"); variablesGridView.Columns.Add("Value", "Value"); variablesGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; variablesGridView.ReadOnly = true; variablesGridView.RowHeadersVisible = false; variablesGridView.AllowUserToAddRows = false; variablesGridView.AllowUserToDeleteRows = false; variablesGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; variablesGridView.MultiSelect = false; variablesGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; variablesGridView.BorderStyle = BorderStyle.None; variablesGridView.BackgroundColor = System.Drawing.Color.White; // Add controls to SplitContainers lowerSplitContainer.Panel1.Controls.Add(lowerElementHost); lowerSplitContainer.Panel2.Controls.Add(variablesGridView); splitContainer.Panel1.Controls.Add(upperElementHost); splitContainer.Panel2.Controls.Add(lowerSplitContainer); ... } ``` To populate the variables window, we enumerate the available variables each time the highlighted line is updated. This could be enhanced to allow drilling into variables and modifying their values, but it’s okay for now. ```editordirect editormode="csharp" // Method to update the variables window public void UpdateVariables(Dictionary variables) { variablesGridView.Rows.Clear(); foreach (var kvp in variables) { variablesGridView.Rows.Add(kvp.Key, kvp.Value); } } ... public class PyPdbOutputStream { ... private void ParseOutputLine(string line) { // Check if the line indicates a pdb line change if (line.StartsWith("> ")) { // Extract the filename and line number // Line format: "> /path/to/file.py(3)()" int startIndex = line.IndexOf('>') + 2; int endIndex = line.IndexOf('(', startIndex); if (endIndex > startIndex) { string filename = line.Substring(startIndex, endIndex - startIndex); // Extract the line number startIndex = endIndex + 1; endIndex = line.IndexOf(')', startIndex); if (endIndex > startIndex) { string lineNumberStr = line.Substring(startIndex, endIndex - startIndex); if (int.TryParse(lineNumberStr, out int lineNumber)) { // Highlight the line in the code editor _form.HighlightCurrentLine(lineNumber); // Now, fetch the variables try { using (Py.GIL()) { PyDict localsDict = new PyDict(_form.pdbInstance.curframe.f_locals); Dictionary variables = new Dictionary(); foreach (PyObject key in localsDict.Keys()) { string varName = key.ToString(); PyObject value = localsDict[key]; variables[varName] = value.Repr().ToString(); } // Update variables window _form.UpdateVariables(variables); } } catch (Exception ex) { _form.outputLog.AppendText($"Error fetching variables: {ex.Message}\n"); } } } } } } ... } ... private void RunCode(bool debugMode = false) { ... Task.Run(() => { using (Py.GIL()) { ... finally { isDebugging = false; // Reset the debugging flag this.Invoke((Action)(() => { // Clear the variables window before running the new script variablesGridView.Rows.Clear(); // Disable debugger buttons when done EnableDebuggerButtons(false); })); // Reset stdout and stderr sys.stdout = sys.__stdout__; sys.stderr = sys.__stderr__; sys.stdin = sys.__stdin__; } } }, cancellationToken); } ``` ### Complete Debugger Code The completed code with debugging implemented is as follows: ```editordirect editormode="csharp" using System.Windows.Forms; using System.Windows.Forms.Integration; // For ElementHost using ICSharpCode.AvalonEdit; // AvalonEdit using ICSharpCode.AvalonEdit.Highlighting; using ICSharpCode.AvalonEdit.Search; using ICSharpCode.AvalonEdit.Folding; // For folding using ICSharpCode.AvalonEdit.Document; // For Document using ICSharpCode.AvalonEdit.Editing; // For TextArea using ICSharpCode.AvalonEdit.Rendering; // For TextView using Python.Runtime; // For Python.NET using System.Windows.Media; // For ImageSource, Brushes, etc. using System.Windows.Input; using System.Text; // For StringBuilder namespace GuiPythonDebugger { public partial class MainForm : Form { private ToolStrip toolStrip; private ToolStripButton nextButton; private ToolStripButton stepIntoButton; private ToolStripButton stepOutButton; private ToolStripButton continueButton; private ToolStripButton quitButton; private SplitContainer splitContainer; private ElementHost upperElementHost; private ElementHost lowerElementHost; private TextEditor codeEditor; private TextEditor outputLog; private string configFilePath; private string pythonDllPath; private string currentFilePath = ""; private SearchPanel searchPanel; private FoldingManager foldingManager; private IndentationFoldingStrategy foldingStrategy; public static int tabSize = 4; private BreakpointMargin breakpointMargin; private SplitContainer lowerSplitContainer; private DataGridView variablesGridView; private string tempFilePath; private bool isDebugging = false; private dynamic pdbInstance; public MainForm() { InitializeComponent(); this.Load += MainForm_Load; } private Bitmap CreateIcon(string glyph, System.Drawing.Color color, int size = 32) { int bitmapSize = size; float fontSize = size * 1.0f; // Adjust as needed Bitmap bmp = new Bitmap(bitmapSize, bitmapSize); using (Graphics g = Graphics.FromImage(bmp)) { g.Clear(System.Drawing.Color.Transparent); using (Font iconFont = new Font("Segoe MDL2 Assets", fontSize, FontStyle.Regular, GraphicsUnit.Pixel)) using (SolidBrush brush = new SolidBrush(color)) { g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; // Measure the size of the glyph SizeF textSize = g.MeasureString(glyph, iconFont); // Calculate position to center the glyph float x = (bitmapSize - textSize.Width) / 2; float y = (bitmapSize - textSize.Height) / 2 + 1; // Draw the glyph onto the bitmap g.DrawString(glyph, iconFont, brush, new PointF(x, y)); } } return bmp; } private void InitializeComponent() { // Initialize components toolStrip = new ToolStrip(); splitContainer = new SplitContainer(); lowerSplitContainer = new SplitContainer(); upperElementHost = new ElementHost(); lowerElementHost = new ElementHost(); codeEditor = new TextEditor(); outputLog = new TextEditor(); variablesGridView = new DataGridView(); // Set up ToolStrip var openButton = new ToolStripButton("Open", CreateIcon("\uE8E5", System.Drawing.Color.Goldenrod, 21), OpenButton_Click); var saveButton = new ToolStripButton("Save", CreateIcon("\uE74E", System.Drawing.Color.DeepSkyBlue, 21), SaveButton_Click); var runButton = new ToolStripButton("Run", CreateIcon("\uE768", System.Drawing.Color.Green, 21), RunButton_Click); var configButton = new ToolStripButton("Configure", CreateIcon("\uE713", System.Drawing.Color.Gray, 21), ConfigButton_Click); toolStrip.Items.Add(openButton); toolStrip.Items.Add(saveButton); toolStrip.Items.Add(runButton); toolStrip.Items.Add(configButton); // Debugger buttons for controlling pdb var debugButton = new ToolStripButton("Debug", CreateIcon("\uE768", System.Drawing.Color.Purple, 21), (sender, e) => RunCode(debugMode: true)); toolStrip.Items.Add(debugButton); nextButton = new ToolStripButton("Next", CreateIcon("\uE72A", System.Drawing.Color.Purple, 16), NextButton_Click); stepIntoButton = new ToolStripButton("Step Into", CreateIcon("\uE74B", System.Drawing.Color.Purple, 16), StepIntoButton_Click); stepOutButton = new ToolStripButton("Step Out", CreateIcon("\uE74A", System.Drawing.Color.Purple, 16), StepOutButton_Click); continueButton = new ToolStripButton("Continue", CreateIcon("\uE72A", System.Drawing.Color.Green, 16), ContinueButton_Click); quitButton = new ToolStripButton("Quit", CreateIcon("\uE71A", System.Drawing.Color.Red, 16), QuitButton_Click); // Add the buttons to the toolstrip toolStrip.Items.Add(new ToolStripSeparator()); toolStrip.Items.Add(nextButton); toolStrip.Items.Add(stepIntoButton); toolStrip.Items.Add(stepOutButton); toolStrip.Items.Add(continueButton); toolStrip.Items.Add(quitButton); EnableDebuggerButtons(false); // Configure the buttons foreach (var item in toolStrip.Items) { if (item is ToolStripButton) { var button = (ToolStripButton)item; button.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText; button.TextImageRelation = TextImageRelation.ImageBeforeText; button.ImageScaling = ToolStripItemImageScaling.None; button.ForeColor = SystemColors.ControlText; } } // Set up SplitContainer splitContainer.Dock = DockStyle.Fill; splitContainer.Orientation = Orientation.Horizontal; splitContainer.SplitterDistance = this.Height / 2; // Initialize the lower SplitContainer lowerSplitContainer.Dock = DockStyle.Fill; lowerSplitContainer.Orientation = Orientation.Vertical; // Set up AvalonEdit controls upperElementHost.Dock = DockStyle.Fill; upperElementHost.Child = codeEditor; lowerElementHost.Dock = DockStyle.Fill; lowerElementHost.Child = outputLog; // Configure codeEditor codeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Python"); codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas"); codeEditor.FontSize = 12; codeEditor.ShowLineNumbers = true; codeEditor.TextChanged += CodeEditor_TextChanged; searchPanel = SearchPanel.Install(codeEditor); // Create and add the BreakpointMargin breakpointMargin = new BreakpointMargin(); breakpointMargin.BreakpointChanged += BreakpointMargin_BreakpointChanged; codeEditor.TextArea.LeftMargins.Insert(0, breakpointMargin); codeEditor.TextArea.UpdateLayout(); breakpointMargin.InvalidateVisual(); // Configure output log outputLog.IsReadOnly = true; outputLog.FontFamily = new System.Windows.Media.FontFamily("Consolas"); outputLog.FontSize = 12; outputLog.ShowLineNumbers = true; // Configure variables GridView variablesGridView.Dock = DockStyle.Fill; variablesGridView.Columns.Add("Variable", "Variable"); variablesGridView.Columns.Add("Value", "Value"); variablesGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; variablesGridView.ReadOnly = true; variablesGridView.RowHeadersVisible = false; variablesGridView.AllowUserToAddRows = false; variablesGridView.AllowUserToDeleteRows = false; variablesGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; variablesGridView.MultiSelect = false; variablesGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; variablesGridView.BorderStyle = BorderStyle.None; variablesGridView.BackgroundColor = System.Drawing.Color.White; // Add controls to SplitContainers lowerSplitContainer.Panel1.Controls.Add(lowerElementHost); lowerSplitContainer.Panel2.Controls.Add(variablesGridView); splitContainer.Panel1.Controls.Add(upperElementHost); splitContainer.Panel2.Controls.Add(lowerSplitContainer); // Add controls to Form this.Controls.Add(splitContainer); this.Controls.Add(toolStrip); // Set Form properties this.Text = "Python Editor"; this.Width = 1000; this.Height = 600; UpdateTitle(); this.FormClosing += MainForm_FormClosing; // Initialize folding manager and strategy foldingManager = FoldingManager.Install(codeEditor.TextArea); foldingStrategy = new IndentationFoldingStrategy(); codeEditor.TextChanged += (sender, args) => UpdateFoldings(); } protected override bool ProcessCmdKey(ref Message msg, Keys keyData) { switch (keyData) { case Keys.Control | Keys.O: // Ctrl + O for Open OpenButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.S: // Ctrl + S for Save SaveButton_Click(this, EventArgs.Empty); return true; case Keys.F5: // F5 for Debug or Continue if (!isDebugging) RunCode(true); else ContinueButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.F5: // Ctrl + F5 for Run RunCode(); return true; case Keys.Shift | Keys.F5: // Shift + F5 for Stop QuitButton_Click(this, EventArgs.Empty); return true; case Keys.F11: // F11 for Step Into StepIntoButton_Click(this, EventArgs.Empty); return true; case Keys.Shift | Keys.F11: // Shift + F11 for Step Out StepOutButton_Click(this, EventArgs.Empty); return true; case Keys.F10: // F10 for Next NextButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.Shift | Keys.C: // Ctrl + Shift + C for Configure ConfigButton_Click(this, EventArgs.Empty); return true; case Keys.F9: // F9 for Toggle Breakpoint ToggleBreakpointOnCurrentLine(); return true; } return base.ProcessCmdKey(ref msg, keyData); } private void EnableDebuggerButtons(bool isEnabled) { nextButton.Enabled = isEnabled; stepIntoButton.Enabled = isEnabled; stepOutButton.Enabled = isEnabled; continueButton.Enabled = isEnabled; quitButton.Enabled = isEnabled; } private void MainForm_Load(object sender, EventArgs e) { InitPython(); } protected override void OnFormClosed(FormClosedEventArgs e) { PythonEngine.Shutdown(); base.OnFormClosed(e); } // Event Handlers private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { if (isDebugging) { MessageBox.Show("Please stop debugging before closing.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); e.Cancel = true; // This cancels the closing return; } if (codeEditor.IsModified && !AskToSave()) { e.Cancel = true; // This cancels the closing } } private void CodeEditor_TextChanged(object sender, EventArgs e) { codeEditor.Dispatcher.BeginInvoke((Action)(() => { UpdateTitle(); }), System.Windows.Threading.DispatcherPriority.Background); } private bool AskToSave() { DialogResult result = MessageBox.Show("The file has been modified. Do you want to save changes?", "Save Changes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning); switch (result) { case DialogResult.Yes: if (!SaveFile()) { return false; } break; case DialogResult.Cancel: return false; } return true; } private void OpenButton_Click(object sender, EventArgs e) { if (codeEditor.IsModified && !AskToSave()) { return; } OpenFile(); } private void SaveButton_Click(object sender, EventArgs e) { SaveFile(); } private void RunButton_Click(object sender, EventArgs e) { RunCode(); } private void ConfigButton_Click(object sender, EventArgs e) { if (ConfigurePythonDll()) { // Inform the user to restart the application for changes to take effect MessageBox.Show("Python DLL path updated. Please restart the application for changes to take effect.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); } } private void BreakpointMargin_BreakpointChanged(object sender, BreakpointChangedEventArgs e) { if (isDebugging) { // Send command to pdb via pythonInputStream string command; if (e.IsAdded) { command = $"break {tempFilePath}:{e.LineNumber}\n"; } else { command = $"clear {tempFilePath}:{e.LineNumber}\n"; } pythonInputStream.SendInput(command); } } private void ToggleBreakpointOnCurrentLine() { breakpointMargin.ToggleBreakpoint(codeEditor.TextArea.Caret.Line); } private void OpenFile() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Load(dlg.FileName); currentFilePath = dlg.FileName; codeEditor.IsModified = false; UpdateTitle(); } } } private bool SaveFile() { if (string.IsNullOrEmpty(currentFilePath)) { using (SaveFileDialog dlg = new SaveFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { currentFilePath = dlg.FileName; codeEditor.Save(dlg.FileName); codeEditor.IsModified = false; UpdateTitle(); } else { return false; } } } else { codeEditor.Save(currentFilePath); codeEditor.IsModified = false; UpdateTitle(); } return true; } private void UpdateTitle() { string fileName = string.IsNullOrEmpty(currentFilePath) ? "Untitled" : Path.GetFileName(currentFilePath); this.Text = (codeEditor.IsModified ? "*" : "") + fileName + " - Python Editor"; } // Method to update the variables window public void UpdateVariables(Dictionary variables) { variablesGridView.Rows.Clear(); foreach (var kvp in variables) { variablesGridView.Rows.Add(kvp.Key, kvp.Value); } } private PyInputStream pythonInputStream = new PyInputStream(); // Define a custom input stream to pass input to Python public class PyInputStream { private Queue inputQueue = new Queue(); private ManualResetEvent inputReadyEvent = new ManualResetEvent(false); public void SendInput(string input) { lock (inputQueue) { inputQueue.Enqueue(input); inputReadyEvent.Set(); // Signal that input is available } } // Python expects a readline() method for sys.stdin public string readline() { inputReadyEvent.WaitOne(); // Wait for input to be ready lock (inputQueue) { if (inputQueue.Count > 0) { var input = inputQueue.Dequeue(); inputReadyEvent.Reset(); // Reset the event if no more input is available return input; } } return ""; // Return an empty string if no input is available } } // Define a custom output stream for real-time Python output public class PyOutputStream { private MainForm _form; public PyOutputStream(MainForm form) { _form = form; } public void write(string output) { _form.Invoke((Action)(() => { _form.outputLog.AppendText(output); // Append output to the log in real time })); } public void flush() { // Implement if needed for flushing buffers } } public class PyPdbOutputStream { private MainForm _form; private StringBuilder _buffer = new StringBuilder(); public PyPdbOutputStream(MainForm form) { _form = form; } public void write(string output) { _form.Invoke((Action)(() => { // Append output to buffer _buffer.Append(output); // Check if we have complete lines string bufferContent = _buffer.ToString(); int newLineIndex; while ((newLineIndex = bufferContent.IndexOf('\n')) != -1) { string line = bufferContent.Substring(0, newLineIndex); ParseOutputLine(line); // Remove the parsed line from the buffer _buffer.Remove(0, newLineIndex + 1); bufferContent = _buffer.ToString(); } })); } private void ParseOutputLine(string line) { // Check if the line indicates a pdb line change if (line.StartsWith("> ")) { // Extract the filename and line number // Line format: "> /path/to/file.py(3)()" int startIndex = line.IndexOf('>') + 2; int endIndex = line.IndexOf('(', startIndex); if (endIndex > startIndex) { string filename = line.Substring(startIndex, endIndex - startIndex); // Extract the line number startIndex = endIndex + 1; endIndex = line.IndexOf(')', startIndex); if (endIndex > startIndex) { string lineNumberStr = line.Substring(startIndex, endIndex - startIndex); if (int.TryParse(lineNumberStr, out int lineNumber)) { // Highlight the line in the code editor _form.HighlightCurrentLine(lineNumber); // Now, fetch the variables try { using (Py.GIL()) { PyDict localsDict = new PyDict(_form.pdbInstance.curframe.f_locals); Dictionary variables = new Dictionary(); foreach (PyObject key in localsDict.Keys()) { string varName = key.ToString(); PyObject value = localsDict[key]; variables[varName] = value.Repr().ToString(); } // Update variables window _form.UpdateVariables(variables); } } catch (Exception ex) { _form.outputLog.AppendText($"Error fetching variables: {ex.Message}\n"); } } } } } } public void flush() { // Do nothing } } private void NextButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("n\n"); // Send 'n' for Next command } private void StepIntoButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("s\n"); // Send 's' for Step Into command } private void StepOutButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("r\n"); // Send 'r' for Return command } private void ContinueButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("c\n"); // Send 'c' for Continue command } private void QuitButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("q\n"); // Send 'q' for Quit command } private CancellationTokenSource pythonExecutionCancellationTokenSource; private void RunCode(bool debugMode = false) { outputLog.Text = ""; string code = codeEditor.Text; var breakpoints = breakpointMargin?.Breakpoints ?? new HashSet(); // Initialize the cancellation token source pythonExecutionCancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = pythonExecutionCancellationTokenSource.Token; Task.Run(() => { using (Py.GIL()) { dynamic sys = Py.Import("sys"); // Custom Python stream to capture real-time output dynamic customOutput = new PyOutputStream(this); // Redirect stdout and stderr to the custom output stream sys.stdout = customOutput; sys.stderr = customOutput; sys.stdin = pythonInputStream; try { // Create a dictionary to hold variables PyDict globalLocalDict = new PyDict(); dynamic builtins = Py.Import("builtins"); globalLocalDict.SetItem("__builtins__", builtins); // Create an AppInterface instance and add it to the dictionary var appInterface = new AppInterface(); globalLocalDict.SetItem(new PyString("app"), appInterface.ToPython()); if (debugMode) { // Enable debugger buttons this.Invoke((Action)(() => { EnableDebuggerButtons(true); })); // Save the code to a temporary file tempFilePath = Path.Combine(Path.GetTempPath(), "tempCode.py"); File.WriteAllText(tempFilePath, code); // Import pdb and create a Pdb instance with custom stdout dynamic pdb = Py.Import("pdb"); pdbInstance = pdb.Pdb(); pdbInstance.stdout = new PyPdbOutputStream(this); // Redirect pdb's stdout to the bin pdbInstance.prompt = ""; // Suppress the (Pdb) prompt // Set breakpoints pdbInstance.clear_all_breaks(); foreach (int lineNumber in breakpoints) { pdbInstance.set_break(tempFilePath, lineNumber); } // Read and compile the code from the file string codeFromFile = File.ReadAllText(tempFilePath); dynamic compile = builtins.compile; dynamic codeObject = compile(codeFromFile, tempFilePath, "exec"); // Run the code under pdb control isDebugging = true; pdbInstance.run(codeObject, globalLocalDict, globalLocalDict); // Delete the temporary file after execution File.Delete(tempFilePath); } else { PythonEngine.Exec(code, globalLocalDict, globalLocalDict); } } catch (PythonException ex) { // Log Python runtime exceptions string oops = ex.ToString(); this.Invoke((Action)(() => { outputLog.AppendText($"Python Exception:\n{oops}\n"); })); } catch (Exception ex) { // Catch any .NET exceptions that occur during the task execution string oops = ex.ToString(); this.Invoke((Action)(() => { outputLog.AppendText($".NET Exception:\n{oops}\n"); })); } finally { isDebugging = false; // Reset the debugging flag this.Invoke((Action)(() => { // Clear the variables window before running the new script variablesGridView.Rows.Clear(); // Disable debugger buttons when done EnableDebuggerButtons(false); HighlightCurrentLine(0); })); // Reset stdout and stderr sys.stdout = sys.__stdout__; sys.stderr = sys.__stderr__; sys.stdin = sys.__stdin__; } } }, cancellationToken); } private void InitPython() { // Determine the path to the config file configFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config.ini"); // Try to set the Python DLL path from config file pythonDllPath = null; if (File.Exists(configFilePath)) { pythonDllPath = File.ReadAllText(configFilePath).Trim(); } // If the DLL path is invalid, prompt user to select DLL if (string.IsNullOrEmpty(pythonDllPath) || !File.Exists(pythonDllPath)) { if (!ConfigurePythonDll()) { // User canceled DLL selection; exit application MessageBox.Show("Python DLL configuration is required to run the application.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); this.Close(); return; } else { // Config file should now have the new DLL path pythonDllPath = File.ReadAllText(configFilePath).Trim(); } } // Initialize Python Engine try { // Set the Python DLL path for Python.NET Runtime.PythonDLL = pythonDllPath; PythonEngine.Initialize(); PythonEngine.BeginAllowThreads(); } catch (Exception ex) { // Initialization failed; possibly due to invalid DLL MessageBox.Show($"Failed to initialize Python.NET with the selected DLL:\n{ex.Message}", "Initialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); // Clear the invalid DLL path from config try { File.Delete(configFilePath); } catch (Exception ioEx) { MessageBox.Show($"Failed to delete config file:\n{ioEx.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } this.Close(); } } private bool ConfigurePythonDll() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python DLL (python*.dll)|python*.dll|All files (*.*)|*.*"; dlg.Title = "Select Python DLL"; if (dlg.ShowDialog() == DialogResult.OK) { pythonDllPath = dlg.FileName; // Save the path to config file try { File.WriteAllText(configFilePath, pythonDllPath); return true; } catch (Exception ex) { MessageBox.Show($"Failed to write config file:\n{ex.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } } else { return false; } } } private void UpdateFoldings() { if (foldingStrategy != null && foldingManager != null) { foldingStrategy.UpdateFoldings(foldingManager, codeEditor.Document); } } public class HighlightCurrentLineBackgroundRenderer : ICSharpCode.AvalonEdit.Rendering.IBackgroundRenderer { public int Line { get; set; } public void Draw(ICSharpCode.AvalonEdit.Rendering.TextView textView, DrawingContext drawingContext) { if (Line < 1 || Line > textView.Document.LineCount) return; textView.EnsureVisualLines(); var line = textView.Document.GetLineByNumber(Line); if (line == null) return; foreach (var rect in ICSharpCode.AvalonEdit.Rendering.BackgroundGeometryBuilder.GetRectsForSegment(textView, line)) { drawingContext.DrawRectangle(new SolidColorBrush(Colors.Yellow), null, rect); } } public KnownLayer Layer => KnownLayer.Background; } private HighlightCurrentLineBackgroundRenderer lineHighlighter; public void HighlightCurrentLine(int lineNumber) { if (lineHighlighter == null) { lineHighlighter = new HighlightCurrentLineBackgroundRenderer(); codeEditor.TextArea.TextView.BackgroundRenderers.Add(lineHighlighter); } // Set the line to highlight lineHighlighter.Line = lineNumber; // Ensure visibility codeEditor.ScrollTo(lineNumber, 0); // Redraw the editor to show the highlight codeEditor.TextArea.TextView.InvalidateLayer(KnownLayer.Background); } } // Folding strategy for indentation public class IndentationFoldingStrategy { public void UpdateFoldings(FoldingManager manager, TextDocument document) { var newFoldings = CreateNewFoldings(document); manager.UpdateFoldings(newFoldings, -1); } public static string ConvertLeadingTabsToSpaces(string input, int spacesPerTab) { if (input == null) return input; // Handle null input string tabReplacement = new string(' ', spacesPerTab); int index = 0; // Find the first non-tab character or end of string while (index < input.Length && input[index] == '\t') { index++; } // Replace only the leading tabs with spaces string leadingTabsConverted = input.Substring(0, index).Replace("\t", tabReplacement); // Combine the converted leading part with the rest of the string return leadingTabsConverted + input.Substring(index); } private IEnumerable CreateNewFoldings(TextDocument document) { var newFoldings = new List(); Stack> startLines = new Stack>(); Stack startIndentationLevels = new Stack(); int previousIndentationLevel = 0; bool inArrayDefinition = false; int arrayStartLine = -1; int arrayNestingLevel = 0; for (int lineNumber = 1; lineNumber <= document.LineCount; lineNumber++) { DocumentLine line = document.GetLineByNumber(lineNumber); string lineText = document.GetText(line).TrimEnd(); // Ignore empty lines if (string.IsNullOrWhiteSpace(lineText)) continue; int currentIndentationLevel = GetIndentationLevel(document.GetText(line)); // Handle block definitions with nesting (arrays and braces) foreach (char c in lineText) { if (c == '[' || c == '{') { if (!inArrayDefinition) { inArrayDefinition = true; arrayStartLine = lineNumber; } arrayNestingLevel++; } else if (c == ']' || c == '}') { arrayNestingLevel--; if (arrayNestingLevel == 0 && inArrayDefinition) { // Close array folding inArrayDefinition = false; if ((lineNumber - arrayStartLine) > 1) { int startOffset = document.GetLineByNumber(arrayStartLine).Offset; int endOffset = line.EndOffset; var name = document.GetText(document.GetLineByNumber(arrayStartLine)).TrimEnd() + "..."; newFoldings.Add(new NewFolding(startOffset, endOffset) { Name = ConvertLeadingTabsToSpaces(name, MainForm.tabSize) }); } } } } // Handle indentation-based folding while (startLines.Count > 0 && currentIndentationLevel <= startLines.Peek().Item2) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; startIndentationLevels.Pop(); int endLine = lineNumber - 1; while (endLine > 1) { string endLineText = document.GetText(document.GetLineByNumber(endLine)).TrimEnd(); if (string.IsNullOrWhiteSpace(endLineText)) endLine--; else break; } if ((lineNumber - startLine) > 2) { var newFolding = new NewFolding(startOffset, document.GetLineByNumber(endLine).EndOffset); newFolding.Name = ConvertLeadingTabsToSpaces(document.GetText(document.GetLineByNumber(startLine)).TrimEnd() + "...", MainForm.tabSize); newFolding.IsDefinition = true; newFoldings.Add(newFolding); } } if (lineText.EndsWith(":")) { // Start a new folding section startLines.Push(new Tuple(lineNumber, currentIndentationLevel)); startIndentationLevels.Push(GetIndentationLevel(document.GetText(line))); } previousIndentationLevel = currentIndentationLevel; } // Close any remaining open foldings while (startLines.Count > 0) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; newFoldings.Add(new NewFolding(startOffset, document.TextLength)); } newFoldings.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset)); return newFoldings; } private int GetIndentationLevel(string lineText) { int indentationLevel = 0; foreach (char c in lineText) { if (c == ' ') indentationLevel++; else if (c == '\t') indentationLevel += MainForm.tabSize; else break; } return indentationLevel; } } // Define BreakpointChangedEventArgs public class BreakpointChangedEventArgs : EventArgs { public int LineNumber { get; } public bool IsAdded { get; } public BreakpointChangedEventArgs(int lineNumber, bool isAdded) { LineNumber = lineNumber; IsAdded = isAdded; } } public class BreakpointMargin : AbstractMargin { private HashSet breakpoints = new HashSet(); private const double CIRCLE_RADIUS = 8; private const double MARGIN_WIDTH = 20; public event EventHandler BreakpointChanged; public HashSet Breakpoints => breakpoints; public BreakpointMargin() { this.Cursor = System.Windows.Input.Cursors.Hand; } protected override System.Windows.Size MeasureOverride(System.Windows.Size availableSize) { return new System.Windows.Size(MARGIN_WIDTH, availableSize.Height); } protected override void OnRender(DrawingContext drawingContext) { var textView = this.TextView; if (textView == null || !textView.VisualLinesValid) return; // First, draw a slightly darker background for the margin var marginRect = new System.Windows.Rect(0, 0, MARGIN_WIDTH, textView.ActualHeight); drawingContext.DrawRectangle( new SolidColorBrush(System.Windows.Media.Color.FromRgb(240, 240, 240)), null, marginRect ); foreach (var visualLine in textView.VisualLines) { int lineNumber = visualLine.FirstDocumentLine.LineNumber; if (breakpoints.Contains(lineNumber)) { // Calculate proper vertical position double y = visualLine.GetTextLineVisualYPosition(visualLine.TextLines[0], VisualYPosition.TextTop); double lineHeight = visualLine.Height; double circleY = y + (lineHeight / 2) - textView.VerticalOffset; // Draw breakpoint circle drawingContext.DrawEllipse( System.Windows.Media.Brushes.Red, // Fill new System.Windows.Media.Pen(System.Windows.Media.Brushes.DarkRed, 1), // Border new System.Windows.Point(MARGIN_WIDTH / 2, circleY), // Center point CIRCLE_RADIUS - 1, // Width radius CIRCLE_RADIUS - 1 // Height radius ); } } } protected override void OnMouseDown(MouseButtonEventArgs e) { if (e.ChangedButton != MouseButton.Left) return; var textView = this.TextView; if (textView == null) return; var pos = e.GetPosition(textView); pos.Y += textView.VerticalOffset; var visualLine = textView.GetVisualLineFromVisualTop(pos.Y); if (visualLine != null) { ToggleBreakpoint(visualLine.FirstDocumentLine.LineNumber); } } public void ToggleBreakpoint(int lineNumber) { // Toggle breakpoint bool breakpointAdded; if (breakpoints.Contains(lineNumber)) { breakpoints.Remove(lineNumber); breakpointAdded = false; } else { breakpoints.Add(lineNumber); breakpointAdded = true; } InvalidateVisual(); // Raise the event BreakpointChanged?.Invoke(this, new BreakpointChangedEventArgs(lineNumber, breakpointAdded)); } protected override void OnTextViewChanged(TextView oldTextView, TextView newTextView) { if (oldTextView != null) { oldTextView.VisualLinesChanged -= OnVisualLinesChanged; } if (newTextView != null) { newTextView.VisualLinesChanged += OnVisualLinesChanged; } base.OnTextViewChanged(oldTextView, newTextView); } private void OnVisualLinesChanged(object sender, EventArgs e) { InvalidateVisual(); } } public class AppInterface { public AppInterface() { } public int Add(int a, int b) { return a + b; } } } ``` Here it is in action: we are debugging the addtest.py script from earlier, with a breakpoint set and execution stepped to the next line. ![image](/embeddedpythonGUI1-3.png) ## Editor Features In addition to debugging, we can enhance the editor by adding features like underlining syntax errors and offering code completions as you type. [Jedi](https://jedi.readthedocs.io/en/latest/index.html) is a popular library for code completions. It’s [MIT licensed](https://github.com/davidhalter/jedi?tab=License-1-ov-file#readme), easy to set up, and fits with our goals. The only requirement is installing it into our embedded Python environment: ```.\Scripts\pip.exe install jedi``` The “right” way to do this is probably to integrate with a language service provider that implements a [language server protocol](https://en.wikipedia.org/wiki/Language_Server_Protocol), like [jedi-language-server](https://github.com/pappasam/jedi-language-server) or [pyright](https://github.com/microsoft/pyright). However, to keep things simple and reduce dependencies on the target system, we’re adding ```Jedi``` to the embedded Python installation directly. Hopefully having ```Jedi``` in the same install won’t pose issues for end users. ### Syntax Errors The ```Jedi``` library exposes a function for identifying syntax errors. We pass in the code and ask where the problems are. To visually indicate these errors, we can add squiggles under the identified problems. First let’s get the errors: ```editordirect editormode="csharp" private List<(int line, int column, int untilLine, int untilColumn, string message)> GetSyntaxErrors(string code) { var errors = new List<(int line, int column, int untilLine, int untilColumn, string message)>(); try { using (Py.GIL()) { dynamic jedi = Py.Import("jedi"); dynamic script = jedi.Script(code: code, path: ""); dynamic syntaxErrors = script.get_syntax_errors(); foreach (var error in syntaxErrors) { int line = error.line; int column = error.column; int untilLine = error.until_line; int untilColumn = error.until_column; string message = error.get_message(); errors.Add((line, column, untilLine, untilColumn, message)); } } } catch { } return errors; } ``` With the start and end locations of the syntax errors identified, we can proceed to draw them. To do this, we’ll create another background renderer, designed to draw red squiggles under the problematic sections. A Bezier curve works well for making the squiggle. Additionally, we can implement a ```GetErrorsAtOffset()``` function to expose the errors for use in other parts of the application. ```editordirect editormode="csharp" private SyntaxErrorRenderer syntaxErrorRenderer; ... public class SyntaxErrorRenderer : IBackgroundRenderer { private readonly TextEditor _editor; private readonly List<(int line, int column, int untilLine, int untilColumn, string message)> _errors; public SyntaxErrorRenderer(TextEditor editor) { _editor = editor; _errors = new List<(int, int, int, int, string)>(); } public void SetErrors(List<(int line, int column, int untilLine, int untilColumn, string message)> errors) { _errors.Clear(); _errors.AddRange(errors); _editor.TextArea.TextView.InvalidateLayer(KnownLayer.Background); } public void Draw(TextView textView, DrawingContext drawingContext) { if (_errors.Count == 0) return; try { textView.EnsureVisualLines(); foreach (var error in _errors) { DocumentLine line = textView.Document.GetLineByNumber(error.line); int errorOffset = line.Offset + error.column; int endOffset; if (error.untilLine == error.line) { endOffset = line.Offset + error.untilColumn; } else { DocumentLine endLine = textView.Document.GetLineByNumber(error.untilLine); endOffset = endLine.Offset + error.untilColumn; } foreach (var rect in ICSharpCode.AvalonEdit.Rendering.BackgroundGeometryBuilder.GetRectsForSegment(textView, new TextSegment { StartOffset = errorOffset, EndOffset = endOffset })) { var pen = new System.Windows.Media.Pen(System.Windows.Media.Brushes.Red, 1) { DashStyle = DashStyles.Solid }; double y = rect.Bottom; // Position the squiggle under the text float waveSize = 1.5f; // Adjust wave size for desired effect double start = rect.Left, end = (rect.Right - rect.Left > 12) ? rect.Right : rect.Left + 12; // 12 is font size! var geometry = new StreamGeometry(); using (var context = geometry.Open()) { context.BeginFigure(new System.Windows.Point(rect.Left, y), false, false); bool up = true; // Toggle to create up and down waves for (double x = start; x < end - waveSize * 2; x += waveSize * 2) { double controlY = up ? y + waveSize : y - waveSize; double endX = x + waveSize * 2; context.QuadraticBezierTo(new System.Windows.Point(x + waveSize, controlY), new System.Windows.Point(endX, y), true, true); up = !up; // Alternate wave direction } } geometry.Freeze(); // Freeze the geometry for performance // Draw the squiggly line using the geometry drawingContext.DrawGeometry(null, pen, geometry); } } } catch { // maybe the document has changed since the errors were found. no reason to get in trouble } } public List<(int line, int column, int untilLine, int untilColumn, string message)> GetErrorsAtOffset(int offset) { var result = new List<(int, int, int, int, string)>(); foreach (var error in _errors) { int startOffset = _editor.Document.GetOffset(error.line, error.column); int endOffset = _editor.Document.GetOffset(error.untilLine, error.untilColumn); if (offset >= startOffset && offset <= endOffset) { result.Add(error); } } return result; } public KnownLayer Layer => KnownLayer.Background; } ``` With these pieces put together, we can add mouse handlers to display errors as tooltips. Since our code editor is a ```WPF``` control hosted within a ```WinForms``` application, we need to handle differences in coordinate systems and DPI scaling. This adds some complexity to the ```TextView_MouseHover()``` implementation. ```editordirect editormode="csharp" private ToolTip errorToolTip; ... private void InitializeComponent() { ... // For syntax errors syntaxErrorRenderer = new SyntaxErrorRenderer(codeEditor); codeEditor.TextArea.TextView.BackgroundRenderers.Add(syntaxErrorRenderer); codeEditor.TextArea.TextView.MouseHover += TextView_MouseHover; codeEditor.TextArea.TextView.MouseHoverStopped += TextView_MouseHoverStopped; } ... private async void CodeEditor_TextChanged(object sender, EventArgs e) { // No need to await for this var dontcare = codeEditor.Dispatcher.BeginInvoke((Action)(() => { UpdateTitle(); }), System.Windows.Threading.DispatcherPriority.Background); // Show errors string code = codeEditor.Text; var errors = await Task.Run(() => GetSyntaxErrors(code)); syntaxErrorRenderer.SetErrors(errors); } ... private float GetDpiScale() { using (var graphics = upperElementHost.CreateGraphics()) { return graphics.DpiX / 96f; } } private void TextView_MouseHover(object sender, EventArgs e) { float dpiScale = GetDpiScale(); // Get the mouse position and adjust for DPI var mousePosition = Control.MousePosition; var clientPoint = upperElementHost.PointToClient(mousePosition); // Convert to WPF coordinates with DPI adjustment var wpfPoint = new System.Windows.Point( clientPoint.X / dpiScale, clientPoint.Y / dpiScale); // Transform coordinates relative to TextView wpfPoint = upperElementHost.Child.TransformToDescendant(codeEditor.TextArea.TextView).Transform(wpfPoint); // Add scroll offset wpfPoint.X += codeEditor.TextArea.TextView.ScrollOffset.X; wpfPoint.Y += codeEditor.TextArea.TextView.ScrollOffset.Y; var position = codeEditor.TextArea.TextView.GetPosition(wpfPoint); if (!position.HasValue) return; int offset = codeEditor.Document.GetOffset(position.Value.Line, position.Value.Column); // Get errors at the offset var errorsAtOffset = syntaxErrorRenderer.GetErrorsAtOffset(offset); if (errorsAtOffset != null && errorsAtOffset.Count > 0) { string message = errorsAtOffset[0].message; if (errorToolTip == null) { errorToolTip = new ToolTip(); } // Adjust tooltip position for DPI errorToolTip.Show(message, upperElementHost, (int)(clientPoint.X + (10 * dpiScale)), (int)(clientPoint.Y + (10 * dpiScale))); } else { if (errorToolTip != null) { errorToolTip.Hide(upperElementHost); } } } private void TextView_MouseHoverStopped(object sender, EventArgs e) { if (errorToolTip != null) { errorToolTip.Hide(upperElementHost); } } ``` Now, if there are syntax errors in the code, they are underlined with squiggles. Hovering over the squiggles displays a tooltip explaining the issue. ![image](/embeddedpythonGUI5.png) ### Code Completions We can also use ```Jedi``` to provide code completions. The process is straightforward: pass in the current code and call the ```complete``` method with the caret location to retrieve suggestions. ```editordirect editormode="csharp" private List> GetPythonCompletions(string code, int line, int column) { var completions = new List>(); try { using (Py.GIL()) { // Import jedi directly dynamic jedi = Py.Import("jedi"); // Create a Jedi Script object dynamic script = jedi.Script(code: code, path: ""); // Get completions dynamic jediCompletions = script.complete(line, column); // Process the results foreach (dynamic completion in jediCompletions) { string name = completion.name.ToString(); string type = completion.type.ToString(); string description = completion.description.ToString(); int priority = jediCompletions.index(completion); if (name.StartsWith('_')) continue; completions.Add(Tuple.Create(name, type, description, priority)); } } } catch { // Meh } return completions; } ``` To integrate code completions into the editor, we need to wire them up with the ```AvalonEdit``` control. This is done using the ```ICompletionData``` interface, which we use to provide the completions suggested by ```Jedi```. We can dynamically generate icons to avoid resource dependencies. A simple approach is to draw a circle around the first letter of the type, such as (f) for functions. ```editordirect editormode="csharp" using ICSharpCode.AvalonEdit.CodeCompletion; // For code completion classes using System.Windows.Media.Imaging; // For drawingvisuals ... public class PyCompletionData : ICompletionData { private static readonly Dictionary IconCache = new Dictionary { { "function", CreateBuiltinIcon(Colors.Blue, 'f') }, { "class", CreateBuiltinIcon(Colors.Green, 'c') }, { "module", CreateBuiltinIcon(Colors.Purple, 'm') }, { "instance", CreateBuiltinIcon(Colors.Orange, 'i') }, { "variable", CreateBuiltinIcon(Colors.Red, 'v') }, { "property", CreateBuiltinIcon(Colors.Teal, 'p') }, { "statement", CreateBuiltinIcon(Colors.Brown, 's') }, { "param", CreateBuiltinIcon(Colors.Cyan, 'p') }, { "keyword", CreateBuiltinIcon(Colors.Magenta, 'k') }, { "namespace", CreateBuiltinIcon(Colors.DarkGray, 'n') } }; public PyCompletionData(string text, string type, string description, int priority) { this.Text = text; this.Type = type; this.Description = description; this.Priority = priority; this.Image = GetIconForCompletionType(type); } public ImageSource Image { get; private set; } public string Text { get; private set; } public object Content => this.Text; public object Type { get; private set; } public object Description { get; private set; } public double Priority { get; private set; } public void Complete(TextArea textArea, ISegment completionSegment, EventArgs insertionRequestEventArgs) { int caretOffset = textArea.Caret.Offset; int wordStartOffset = caretOffset; while (wordStartOffset > 0 && char.IsLetterOrDigit(textArea.Document.GetCharAt(wordStartOffset - 1))) { wordStartOffset--; } int lengthToReplace = caretOffset - wordStartOffset; textArea.Document.Replace(wordStartOffset, lengthToReplace, this.Text); } private static ImageSource CreateBuiltinIcon(System.Windows.Media.Color color, char letter) { int size = 16; var drawingVisual = new DrawingVisual(); using (var context = drawingVisual.RenderOpen()) { // Draw a circle context.DrawEllipse(new SolidColorBrush(color), null, new System.Windows.Point(size / 2, size / 2), size / 2, size / 2); // Draw the letter in the middle FormattedText text = new FormattedText( letter.ToString(), System.Globalization.CultureInfo.InvariantCulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Consolas"), size - 6, System.Windows.Media.Brushes.White, VisualTreeHelper.GetDpi(drawingVisual).PixelsPerDip); context.DrawText(text, new System.Windows.Point(size / 2 - text.Width / 2, size / 2 - text.Height / 2)); } var dpi = VisualTreeHelper.GetDpi(drawingVisual); var bitmap = new RenderTargetBitmap((int)(size * dpi.DpiScaleX), (int)(size * dpi.DpiScaleY), dpi.PixelsPerInchX, dpi.PixelsPerInchY, PixelFormats.Pbgra32); bitmap.Render(drawingVisual); return bitmap; } private ImageSource GetIconForCompletionType(string type) { if (IconCache.TryGetValue(type.ToLower(), out var icon)) { return icon; } return null; // No icon for unknown types } } ``` Now, we can wire the ```CompletionWindow``` to the ```AvalonEdit```: ```editordirect editormode="csharp" private CompletionWindow completionWindow; ... private void InitializeComponent() { ... codeEditor.TextArea.TextEntered += TextArea_TextEntered; codeEditor.TextArea.TextEntering += TextArea_TextEntering; ... } ``` The ```CompletionWindow``` is triggered when the user types, using the ```TextArea_TextEntered``` event in the code editor. Simple criteria are defined to open the window, such as entering ```.```, text, ```(```, or a space. Similarly, criteria are established to accept a completion, such as typing the next expected character like ```.```, ```(```, ```[```, or a space. ```editordirect editormode="csharp" private void TextArea_TextEntered(object sender, TextCompositionEventArgs e) { // Trigger completion for certain characters if (e.Text == "." || char.IsLetter(e.Text[0]) || e.Text == "(" || e.Text == "[" || e.Text == " ") { // Cancel previous completion task if it's still running completionCancellationTokenSource?.Cancel(); completionCancellationTokenSource = new CancellationTokenSource(); try { ShowCompletionWindow(); } catch (TaskCanceledException) { // meh } } if (completionWindow != null && completionWindow.CompletionList.ListBox.Items.Count == 0) { completionWindow.Close(); } } private void TextArea_TextEntering(object sender, TextCompositionEventArgs e) { if (e.Text.Length > 0 && completionWindow != null) { char c = e.Text[0]; if (c == '(' || c == '.' || c == '[') { completionWindow.CompletionList.RequestInsertion(e); } } } ``` Finally, the ```ShowCompletionWindow()``` function ties everything together by linking the captured completions to user input. To ensure the HMI remains responsive, we capture the code completions asynchronously. This allows the UI to continue while completions are retrieved in the background. ```editordirect editormode="csharp" private async void ShowCompletionWindow() { if (completionWindow != null) { return; // Completion window is already open } var caret = codeEditor.TextArea.Caret; int offset = caret.Offset; int line = caret.Line; int column = caret.Column - 1; string code = codeEditor.Text; // Use async to fetch completion data without blocking the UI List> completionData = await Task.Run(() => GetPythonCompletions(code, line, column)); if (completionData.Count > 0) { // Sort the completion data by priority (descending) completionData = completionData.OrderBy(item => item.Item4).ToList(); completionWindow = new CompletionWindow(codeEditor.TextArea); IList data = completionWindow.CompletionList.CompletionData; // Create MyCompletionData instances on UI thread foreach (var item in completionData) { data.Add(new PyCompletionData(item.Item1, item.Item2, item.Item3, item.Item4)); } completionWindow.CompletionList.SelectedItem = data[0]; completionWindow.CompletionList.ScrollIntoView(data[0]); // Set the width of the completion window based on the longest item double maxWidth = 0; foreach (var item in data) { FormattedText formattedText = new FormattedText( item.Text, System.Globalization.CultureInfo.CurrentCulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Consolas"), 12, System.Windows.Media.Brushes.Black, VisualTreeHelper.GetDpi(completionWindow).PixelsPerDip); maxWidth = Math.Max(maxWidth, formattedText.Width); } completionWindow.Width = maxWidth + 50; completionWindow.Show(); completionWindow.Closed += (o, args) => completionWindow = null; } } ``` We now have code completions: ![image](/embeddedpythonGUI4.png) ### Function Parameter Completions Building on this framework, it would be great to include function parameter completions. We can achieve this by updating our completions function. The approach is straightforward: if a function signature completion is available, we filter the possible completions to match the parameters of that function. This ensures users receive context-aware suggestions for function arguments. ```editordirect editormode="csharp" private List> GetPythonCompletions(string code, int line, int column) { var completions = new List>(); var completionsFilter = new List>(); try { using (Py.GIL()) { // Import jedi directly dynamic jedi = Py.Import("jedi"); // Create a Jedi Script object dynamic script = jedi.Script(code: code, path: ""); // Get function signatures (if any) dynamic signatures = script.get_signatures(line, column); int i = 1; foreach (dynamic sig in signatures) { // Use the full string representation of the signature string signature = sig.to_string(); // Get the parameters for this signature foreach (dynamic param in sig.GetAttr("params")) { string paramName = param.name.ToString() + '='; string paramDescription = param.to_string(); // Full param representation completionsFilter.Add(Tuple.Create(paramName, "param", paramDescription, i++)); } } // Get completions dynamic jediCompletions = script.complete(line, column); foreach (dynamic completion in jediCompletions) { string name = completion.name.ToString(); int priority = jediCompletions.index(completion); // If completionsFilter has items, only include completions that are also parameters if (completionsFilter.Count > 0) { var filterMatch = completionsFilter.FirstOrDefault(filter => filter.Item1 == name); if (filterMatch != null) { priority = filterMatch.Item4; // Use the priority from the signature } else { continue; // Skip if not in completionsFilter } } string type = completion.type.ToString(); string description = completion.description.ToString(); if (name.StartsWith('_')) continue; completions.Add(Tuple.Create(name, type, description, priority)); } if (jediCompletions.Count() == 0 && completionsFilter.Count() > 0) { completions.AddRange(completionsFilter); } } } catch { // Meh } return completions; } ``` We now have parameter completions: ![image](/embeddedpythonGUI7.png) ### Code Completions for the App Object As it stands, ```Jedi``` cannot provide suggestions for the ```app``` object we expose to the script. This limitation arises because ```Jedi``` lacks interface information about our ```AppInterface``` object. To resolve this, we can create a ```pyi``` stub file to define the interface. For our simple ```AppInterface```, the stub file might look like this: ```editordirect editormode="python" class app: def Add(a: int, b: int) -> int: ... ``` We name the class ```app``` to align with the name we’re using to expose it. The ```...``` syntax indicates to Python that this is a stub. The next step is ensuring this interface is accessible to ```Jedi```. To achieve this, we place the stub file in the Python path. ```editordirect editormode="csharp" // Initialize Python Engine try { // Set the Python DLL path for Python.NET Runtime.PythonDLL = pythonDllPath; PythonEngine.Initialize(); PythonEngine.BeginAllowThreads(); // Add the stub directory to sys.path. This is for code completions of our app object using (Py.GIL()) { dynamic sys = Py.Import("sys"); string stubDirectory = Path.Combine(Path.GetTempPath(), "GUIPython"); dynamic sysPath = sys.path; bool contains = false; foreach (dynamic p in sysPath) { if (p.ToString() == stubDirectory) { contains = true; break; } } if (!contains) { sysPath.insert(0, stubDirectory); } if (!Directory.Exists(stubDirectory)) { Directory.CreateDirectory(stubDirectory); } string stubCode = @" class app: def Add(self, a: int, b: int) -> int: ..."; string stubFileName = Path.Combine(stubDirectory, "app_interface.pyi"); File.WriteAllText(stubFileName, stubCode); } } ``` Then, when we ask ```Jedi``` for suggestions, we hint to ```Jedi``` to reference our stub: ```editordirect editormode="csharp" using (Py.GIL()) { // Import jedi directly dynamic jedi = Py.Import("jedi"); // Prepend the import statement for Jedi's analysis string codeWithImport = "from app_interface import app\n" + code; line++; // Create a Jedi Script object dynamic script = jedi.Script(code: codeWithImport, path: ""); // Get function signatures (if any) dynamic signatures = script.get_signatures(line, column); ... // Get completions dynamic jediCompletions = script.complete(line, column); ... } ``` Now we can get code completions on our interface as well: ![image](/embeddedpythonGUI1-5.png) ## Conclusion Our completed application, such as it is: ```editordirect editormode="csharp" using System.Windows.Forms; using System.Windows.Forms.Integration; // For ElementHost using ICSharpCode.AvalonEdit; // AvalonEdit using ICSharpCode.AvalonEdit.Highlighting; using ICSharpCode.AvalonEdit.Search; using ICSharpCode.AvalonEdit.Folding; // For Folding using ICSharpCode.AvalonEdit.Document; // For Document using ICSharpCode.AvalonEdit.Editing; // For TextArea using ICSharpCode.AvalonEdit.Rendering; // For TextView using ICSharpCode.AvalonEdit.CodeCompletion; // For code completions classes using System.Windows.Media; // For ImageSource, Brushes, etc. using System.Windows.Input; using System.Windows.Media.Imaging; // For Drawing Visuals using System.Text; // For StringBuilder using Python.Runtime; // For Python.NET namespace GuiPythonCompletions { public partial class MainForm : Form { private ToolStrip toolStrip; private ToolStripButton nextButton; private ToolStripButton stepIntoButton; private ToolStripButton stepOutButton; private ToolStripButton continueButton; private ToolStripButton quitButton; private SplitContainer splitContainer; private ElementHost upperElementHost; private ElementHost lowerElementHost; private TextEditor codeEditor; private TextEditor outputLog; private string configFilePath; private string pythonDllPath; private string currentFilePath = ""; private SearchPanel searchPanel; private FoldingManager foldingManager; private IndentationFoldingStrategy foldingStrategy; public static int tabSize = 4; private BreakpointMargin breakpointMargin; private SplitContainer lowerSplitContainer; private DataGridView variablesGridView; private CompletionWindow completionWindow; private SyntaxErrorRenderer syntaxErrorRenderer; private ToolTip errorToolTip; private string tempFilePath; private bool isDebugging = false; private dynamic pdbInstance; public MainForm() { InitializeComponent(); this.Load += MainForm_Load; } private Bitmap CreateIcon(string glyph, System.Drawing.Color color, int size = 32) { int bitmapSize = size; float fontSize = size * 1.0f; // Adjust as needed Bitmap bmp = new Bitmap(bitmapSize, bitmapSize); using (Graphics g = Graphics.FromImage(bmp)) { g.Clear(System.Drawing.Color.Transparent); using (Font iconFont = new Font("Segoe MDL2 Assets", fontSize, FontStyle.Regular, GraphicsUnit.Pixel)) using (SolidBrush brush = new SolidBrush(color)) { g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; // Measure the size of the glyph SizeF textSize = g.MeasureString(glyph, iconFont); // Calculate position to center the glyph float x = (bitmapSize - textSize.Width) / 2; float y = (bitmapSize - textSize.Height) / 2 + 1; // Draw the glyph onto the bitmap g.DrawString(glyph, iconFont, brush, new PointF(x, y)); } } return bmp; } private void InitializeComponent() { // Initialize components toolStrip = new ToolStrip(); splitContainer = new SplitContainer(); lowerSplitContainer = new SplitContainer(); upperElementHost = new ElementHost(); lowerElementHost = new ElementHost(); codeEditor = new TextEditor(); outputLog = new TextEditor(); variablesGridView = new DataGridView(); // Set up ToolStrip var openButton = new ToolStripButton("Open", CreateIcon("\uE8E5", System.Drawing.Color.Goldenrod, 21), OpenButton_Click); var saveButton = new ToolStripButton("Save", CreateIcon("\uE74E", System.Drawing.Color.DeepSkyBlue, 21), SaveButton_Click); var runButton = new ToolStripButton("Run", CreateIcon("\uE768", System.Drawing.Color.Green, 21), RunButton_Click); var configButton = new ToolStripButton("Configure", CreateIcon("\uE713", System.Drawing.Color.Gray, 21), ConfigButton_Click); toolStrip.Items.Add(openButton); toolStrip.Items.Add(saveButton); toolStrip.Items.Add(runButton); toolStrip.Items.Add(configButton); // Debugger buttons for controlling pdb var debugButton = new ToolStripButton("Debug", CreateIcon("\uE768", System.Drawing.Color.Purple, 21), (sender, e) => RunCode(debugMode: true)); toolStrip.Items.Add(debugButton); nextButton = new ToolStripButton("Next", CreateIcon("\uE72A", System.Drawing.Color.Purple, 16), NextButton_Click); stepIntoButton = new ToolStripButton("Step Into", CreateIcon("\uE74B", System.Drawing.Color.Purple, 16), StepIntoButton_Click); stepOutButton = new ToolStripButton("Step Out", CreateIcon("\uE74A", System.Drawing.Color.Purple, 16), StepOutButton_Click); continueButton = new ToolStripButton("Continue", CreateIcon("\uE72A", System.Drawing.Color.Green, 16), ContinueButton_Click); quitButton = new ToolStripButton("Quit", CreateIcon("\uE71A", System.Drawing.Color.Red, 16), QuitButton_Click); // Add the buttons to the toolstrip toolStrip.Items.Add(new ToolStripSeparator()); toolStrip.Items.Add(nextButton); toolStrip.Items.Add(stepIntoButton); toolStrip.Items.Add(stepOutButton); toolStrip.Items.Add(continueButton); toolStrip.Items.Add(quitButton); EnableDebuggerButtons(false); // Configure the buttons foreach (var item in toolStrip.Items) { if (item is ToolStripButton) { var button = (ToolStripButton)item; button.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText; button.TextImageRelation = TextImageRelation.ImageBeforeText; button.ImageScaling = ToolStripItemImageScaling.None; button.ForeColor = SystemColors.ControlText; } } // Set up SplitContainer splitContainer.Dock = DockStyle.Fill; splitContainer.Orientation = Orientation.Horizontal; splitContainer.SplitterDistance = this.Height / 2; // Initialize the lower SplitContainer lowerSplitContainer.Dock = DockStyle.Fill; lowerSplitContainer.Orientation = Orientation.Vertical; // Set up AvalonEdit controls upperElementHost.Dock = DockStyle.Fill; upperElementHost.Child = codeEditor; lowerElementHost.Dock = DockStyle.Fill; lowerElementHost.Child = outputLog; // Configure codeEditor codeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Python"); codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas"); codeEditor.FontSize = 12; codeEditor.ShowLineNumbers = true; codeEditor.TextChanged += CodeEditor_TextChanged; codeEditor.TextArea.TextEntered += TextArea_TextEntered; codeEditor.TextArea.TextEntering += TextArea_TextEntering; searchPanel = SearchPanel.Install(codeEditor); // Create and add the BreakpointMargin breakpointMargin = new BreakpointMargin(); breakpointMargin.BreakpointChanged += BreakpointMargin_BreakpointChanged; codeEditor.TextArea.LeftMargins.Insert(0, breakpointMargin); codeEditor.TextArea.UpdateLayout(); breakpointMargin.InvalidateVisual(); // Configure output log outputLog.IsReadOnly = true; outputLog.FontFamily = new System.Windows.Media.FontFamily("Consolas"); outputLog.FontSize = 12; outputLog.ShowLineNumbers = true; // Configure variables GridView variablesGridView.Dock = DockStyle.Fill; variablesGridView.Columns.Add("Variable", "Variable"); variablesGridView.Columns.Add("Value", "Value"); variablesGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; variablesGridView.ReadOnly = true; variablesGridView.RowHeadersVisible = false; variablesGridView.AllowUserToAddRows = false; variablesGridView.AllowUserToDeleteRows = false; variablesGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect; variablesGridView.MultiSelect = false; variablesGridView.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize; variablesGridView.BorderStyle = BorderStyle.None; variablesGridView.BackgroundColor = System.Drawing.Color.White; // Add controls to SplitContainers lowerSplitContainer.Panel1.Controls.Add(lowerElementHost); lowerSplitContainer.Panel2.Controls.Add(variablesGridView); splitContainer.Panel1.Controls.Add(upperElementHost); splitContainer.Panel2.Controls.Add(lowerSplitContainer); // Add controls to Form this.Controls.Add(splitContainer); this.Controls.Add(toolStrip); // Set Form properties this.Text = "Python Editor"; this.Width = 1000; this.Height = 600; UpdateTitle(); this.FormClosing += MainForm_FormClosing; // Initialize folding manager and strategy foldingManager = FoldingManager.Install(codeEditor.TextArea); foldingStrategy = new IndentationFoldingStrategy(); codeEditor.TextChanged += (sender, args) => UpdateFoldings(); // For syntax errors syntaxErrorRenderer = new SyntaxErrorRenderer(codeEditor); codeEditor.TextArea.TextView.BackgroundRenderers.Add(syntaxErrorRenderer); codeEditor.TextArea.TextView.MouseHover += TextView_MouseHover; codeEditor.TextArea.TextView.MouseHoverStopped += TextView_MouseHoverStopped; } protected override bool ProcessCmdKey(ref Message msg, Keys keyData) { switch (keyData) { case Keys.Control | Keys.O: // Ctrl + O for Open OpenButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.S: // Ctrl + S for Save SaveButton_Click(this, EventArgs.Empty); return true; case Keys.F5: // F5 for Debug or Continue if (!isDebugging) RunCode(true); else ContinueButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.F5: // Ctrl + F5 for Run RunCode(); return true; case Keys.Shift | Keys.F5: // Shift + F5 for Stop QuitButton_Click(this, EventArgs.Empty); return true; case Keys.F11: // F11 for Step Into StepIntoButton_Click(this, EventArgs.Empty); return true; case Keys.Shift | Keys.F11: // Shift + F11 for Step Out StepOutButton_Click(this, EventArgs.Empty); return true; case Keys.F10: // F10 for Next NextButton_Click(this, EventArgs.Empty); return true; case Keys.Control | Keys.Shift | Keys.C: // Ctrl + Shift + C for Configure ConfigButton_Click(this, EventArgs.Empty); return true; case Keys.F9: // F9 for Toggle Breakpoint ToggleBreakpointOnCurrentLine(); return true; } return base.ProcessCmdKey(ref msg, keyData); } private void EnableDebuggerButtons(bool isEnabled) { nextButton.Enabled = isEnabled; stepIntoButton.Enabled = isEnabled; stepOutButton.Enabled = isEnabled; continueButton.Enabled = isEnabled; quitButton.Enabled = isEnabled; } private void MainForm_Load(object sender, EventArgs e) { InitPython(); } protected override void OnFormClosed(FormClosedEventArgs e) { PythonEngine.Shutdown(); base.OnFormClosed(e); } // Event Handlers private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { if (isDebugging) { MessageBox.Show("Please stop debugging before closing.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); e.Cancel = true; // This cancels the closing return; } if (codeEditor.IsModified && AskToSave()) { SaveFile(); } } private async void CodeEditor_TextChanged(object sender, EventArgs e) { // No need to await for this var dontcare = codeEditor.Dispatcher.BeginInvoke((Action)(() => { UpdateTitle(); }), System.Windows.Threading.DispatcherPriority.Background); // Show errors if (!isDebugging) { string code = codeEditor.Text; var errors = await Task.Run(() => GetSyntaxErrors(code)); syntaxErrorRenderer.SetErrors(errors); } } private bool AskToSave() { DialogResult result = MessageBox.Show("The file has been modified. Do you want to save changes?", "Save Changes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning); if (result == DialogResult.Yes) { return true; } else if (result == DialogResult.Cancel) { return false; } return false; } private void OpenButton_Click(object sender, EventArgs e) { if (codeEditor.IsModified && AskToSave()) { SaveFile(); } OpenFile(); } private void SaveButton_Click(object sender, EventArgs e) { SaveFile(); } private void RunButton_Click(object sender, EventArgs e) { RunCode(); } private void ConfigButton_Click(object sender, EventArgs e) { if (ConfigurePythonDll()) { // Inform the user to restart the application for changes to take effect MessageBox.Show("Python DLL path updated. Please restart the application for changes to take effect.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); } } private void BreakpointMargin_BreakpointChanged(object sender, BreakpointChangedEventArgs e) { if (isDebugging) { // Send command to pdb via pythonInputStream string command; if (e.IsAdded) { command = $"break {tempFilePath}:{e.LineNumber}\n"; } else { command = $"clear {tempFilePath}:{e.LineNumber}\n"; } pythonInputStream.SendInput(command); } } private void ToggleBreakpointOnCurrentLine() { breakpointMargin.ToggleBreakpoint(codeEditor.TextArea.Caret.Line); } private CancellationTokenSource completionCancellationTokenSource; private void TextArea_TextEntered(object sender, TextCompositionEventArgs e) { // Trigger completion for certain characters if (e.Text == "." || char.IsLetter(e.Text[0]) || e.Text == "(" || e.Text == "[" || e.Text == " ") { // Cancel previous completion task if it's still running completionCancellationTokenSource?.Cancel(); completionCancellationTokenSource = new CancellationTokenSource(); if (completionWindow != null) { completionWindow.Close(); } try { ShowCompletionWindow(); } catch (TaskCanceledException) { // meh } } else if (completionWindow != null && completionWindow.CompletionList.ListBox.Items.Count == 0) { completionWindow.Close(); } } private void TextArea_TextEntering(object sender, TextCompositionEventArgs e) { if (e.Text.Length > 0 && completionWindow != null) { char c = e.Text[0]; if (c == '(' || c == '.' || c == '[') { completionWindow.CompletionList.RequestInsertion(e); } } } private async void ShowCompletionWindow() { if (completionWindow != null) { return; // Completion window is already open } var caret = codeEditor.TextArea.Caret; int offset = caret.Offset; int line = caret.Line; int column = caret.Column - 1; string code = codeEditor.Text; // Use async to fetch completion data without blocking the UI List> completionData = await Task.Run(() => GetPythonCompletions(code, line, column)); if (completionData.Count > 0) { // Sort the completion data by priority (descending) completionData = completionData.OrderBy(item => item.Item4).ToList(); completionWindow = new CompletionWindow(codeEditor.TextArea); IList data = completionWindow.CompletionList.CompletionData; // Create MyCompletionData instances on UI thread foreach (var item in completionData) { data.Add(new PyCompletionData(item.Item1, item.Item2, item.Item3, item.Item4)); } completionWindow.CompletionList.SelectedItem = data[0]; completionWindow.CompletionList.ScrollIntoView(data[0]); // Set the width of the completion window based on the longest item double maxWidth = 0; foreach (var item in data) { FormattedText formattedText = new FormattedText( item.Text, System.Globalization.CultureInfo.CurrentCulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Consolas"), 12, System.Windows.Media.Brushes.Black, VisualTreeHelper.GetDpi(completionWindow).PixelsPerDip); maxWidth = Math.Max(maxWidth, formattedText.Width); } completionWindow.Width = maxWidth + 50; completionWindow.Show(); completionWindow.Closed += (o, args) => completionWindow = null; } } private List> GetPythonCompletions(string code, int line, int column) { var completions = new List>(); var completionsFilter = new List>(); try { using (Py.GIL()) { // Import jedi directly dynamic jedi = Py.Import("jedi"); // Prepend the import statement for Jedi's analysis string codeWithImport = "from app_interface import app\n" + code; line++; // Create a Jedi Script object dynamic script = jedi.Script(code: codeWithImport, path: ""); // Get function signatures (if any) dynamic signatures = script.get_signatures(line, column); int i = 1; foreach (dynamic sig in signatures) { // Use the full string representation of the signature string signature = sig.to_string(); // Get the parameters for this signature foreach (dynamic param in sig.GetAttr("params")) { string paramName = param.name.ToString() + '='; string paramDescription = param.to_string(); // Full param representation completionsFilter.Add(Tuple.Create(paramName, "param", paramDescription, i++)); } } // Get completions dynamic jediCompletions = script.complete(line, column); foreach (dynamic completion in jediCompletions) { string name = completion.name.ToString(); int priority = jediCompletions.index(completion); // If completionsFilter has items, only include completions that are also parameters if (completionsFilter.Count > 0) { var filterMatch = completionsFilter.FirstOrDefault(filter => filter.Item1 == name); if (filterMatch != null) { priority = filterMatch.Item4; // Use the priority from the signature } else { continue; // Skip if not in completionsFilter } } string type = completion.type.ToString(); string description = completion.description.ToString(); if (name.StartsWith('_')) continue; completions.Add(Tuple.Create(name, type, description, priority)); } if (jediCompletions.Count() == 0 && completionsFilter.Count() > 0) { completions.AddRange(completionsFilter); } } } catch { // Meh } return completions; } public class PyCompletionData : ICompletionData { private static readonly Dictionary IconCache = new Dictionary { { "function", CreateBuiltinIcon(Colors.Blue, 'f') }, { "class", CreateBuiltinIcon(Colors.Green, 'c') }, { "module", CreateBuiltinIcon(Colors.Purple, 'm') }, { "instance", CreateBuiltinIcon(Colors.Orange, 'i') }, { "variable", CreateBuiltinIcon(Colors.Red, 'v') }, { "property", CreateBuiltinIcon(Colors.Teal, 'p') }, { "statement", CreateBuiltinIcon(Colors.Brown, 's') }, { "param", CreateBuiltinIcon(Colors.Cyan, 'p') }, { "keyword", CreateBuiltinIcon(Colors.Magenta, 'k') }, { "namespace", CreateBuiltinIcon(Colors.DarkGray, 'n') } }; public PyCompletionData(string text, string type, string description, int priority) { this.Text = text; this.Type = type; this.Description = description; this.Priority = priority; this.Image = GetIconForCompletionType(type); } public ImageSource Image { get; private set; } public string Text { get; private set; } public object Content => this.Text; public object Type { get; private set; } public object Description { get; private set; } public double Priority { get; private set; } public void Complete(TextArea textArea, ISegment completionSegment, EventArgs insertionRequestEventArgs) { int caretOffset = textArea.Caret.Offset; int wordStartOffset = caretOffset; while (wordStartOffset > 0 && char.IsLetterOrDigit(textArea.Document.GetCharAt(wordStartOffset - 1))) { wordStartOffset--; } int lengthToReplace = caretOffset - wordStartOffset; textArea.Document.Replace(wordStartOffset, lengthToReplace, this.Text); } private static ImageSource CreateBuiltinIcon(System.Windows.Media.Color color, char letter) { int size = 16; var drawingVisual = new DrawingVisual(); using (var context = drawingVisual.RenderOpen()) { // Draw a circle context.DrawEllipse(new SolidColorBrush(color), null, new System.Windows.Point(size / 2, size / 2), size / 2, size / 2); // Draw the letter in the middle FormattedText text = new FormattedText( letter.ToString(), System.Globalization.CultureInfo.InvariantCulture, System.Windows.FlowDirection.LeftToRight, new Typeface("Consolas"), size - 6, System.Windows.Media.Brushes.White, VisualTreeHelper.GetDpi(drawingVisual).PixelsPerDip); context.DrawText(text, new System.Windows.Point(size / 2 - text.Width / 2, size / 2 - text.Height / 2)); } var dpi = VisualTreeHelper.GetDpi(drawingVisual); var bitmap = new RenderTargetBitmap((int)(size * dpi.DpiScaleX), (int)(size * dpi.DpiScaleY), dpi.PixelsPerInchX, dpi.PixelsPerInchY, PixelFormats.Pbgra32); bitmap.Render(drawingVisual); return bitmap; } private ImageSource GetIconForCompletionType(string type) { if (IconCache.TryGetValue(type.ToLower(), out var icon)) { return icon; } return null; // No icon for unknown types } } private List<(int line, int column, int untilLine, int untilColumn, string message)> GetSyntaxErrors(string code) { var errors = new List<(int line, int column, int untilLine, int untilColumn, string message)>(); try { using (Py.GIL()) { dynamic jedi = Py.Import("jedi"); dynamic script = jedi.Script(code: code, path: ""); dynamic syntaxErrors = script.get_syntax_errors(); foreach (var error in syntaxErrors) { int line = error.line; int column = error.column; int untilLine = error.until_line; int untilColumn = error.until_column; string message = error.get_message(); errors.Add((line, column, untilLine, untilColumn, message)); } } } catch { } return errors; } public class SyntaxErrorRenderer : IBackgroundRenderer { private readonly TextEditor _editor; private readonly List<(int line, int column, int untilLine, int untilColumn, string message)> _errors; public SyntaxErrorRenderer(TextEditor editor) { _editor = editor; _errors = new List<(int, int, int, int, string)>(); } public void SetErrors(List<(int line, int column, int untilLine, int untilColumn, string message)> errors) { _errors.Clear(); _errors.AddRange(errors); _editor.TextArea.TextView.InvalidateLayer(KnownLayer.Background); } public void Draw(TextView textView, DrawingContext drawingContext) { if (_errors.Count == 0) return; try { textView.EnsureVisualLines(); int lineCount = textView.Document.LineCount; foreach (var error in _errors) { if (error.line > lineCount) continue; // In case the document changed between getting the errors and displaying them DocumentLine line = textView.Document.GetLineByNumber(error.line); int errorOffset = line.Offset + error.column; int endOffset; if (error.untilLine == error.line) { endOffset = line.Offset + error.untilColumn; } else { if (error.untilLine <= lineCount) { DocumentLine endLine = textView.Document.GetLineByNumber(error.untilLine); endOffset = endLine.Offset + error.untilColumn; } else { endOffset = line.EndOffset; } } foreach (var rect in ICSharpCode.AvalonEdit.Rendering.BackgroundGeometryBuilder.GetRectsForSegment(textView, new TextSegment { StartOffset = errorOffset, EndOffset = endOffset })) { var pen = new System.Windows.Media.Pen(System.Windows.Media.Brushes.Red, 1) { DashStyle = DashStyles.Solid }; double y = rect.Bottom; // Position the squiggle under the text float waveSize = 1.5f; // Adjust wave size for desired effect double start = rect.Left, end = (rect.Right - rect.Left > 12) ? rect.Right : rect.Left + 12; // 12 is font size! var geometry = new StreamGeometry(); using (var context = geometry.Open()) { context.BeginFigure(new System.Windows.Point(rect.Left, y), false, false); bool up = true; // Toggle to create up and down waves for (double x = start; x < end - waveSize * 2; x += waveSize * 2) { double controlY = up ? y + waveSize : y - waveSize; double endX = x + waveSize * 2; context.QuadraticBezierTo(new System.Windows.Point(x + waveSize, controlY), new System.Windows.Point(endX, y), true, true); up = !up; // Alternate wave direction } } geometry.Freeze(); // Freeze the geometry for performance // Draw the squiggly line using the geometry drawingContext.DrawGeometry(null, pen, geometry); } } } catch { // maybe the document has changed since the errors were found. no reason to get in trouble } } public List<(int line, int column, int untilLine, int untilColumn, string message)> GetErrorsAtOffset(int offset) { var result = new List<(int, int, int, int, string)>(); foreach (var error in _errors) { int startOffset = _editor.Document.GetOffset(error.line, error.column); int endOffset = _editor.Document.GetOffset(error.untilLine, error.untilColumn); if (startOffset == endOffset) endOffset++; if (offset >= startOffset && offset <= endOffset) { result.Add(error); } } return result; } public KnownLayer Layer => KnownLayer.Background; } private void OpenFile() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { codeEditor.Load(dlg.FileName); currentFilePath = dlg.FileName; codeEditor.IsModified = false; UpdateTitle(); } } } private void SaveFile() { if (string.IsNullOrEmpty(currentFilePath)) { using (SaveFileDialog dlg = new SaveFileDialog()) { dlg.Filter = "Python files (*.py)|*.py|All files (*.*)|*.*"; if (dlg.ShowDialog() == DialogResult.OK) { currentFilePath = dlg.FileName; codeEditor.Save(dlg.FileName); codeEditor.IsModified = false; UpdateTitle(); } } } else { codeEditor.Save(currentFilePath); codeEditor.IsModified = false; UpdateTitle(); } } private void UpdateTitle() { string fileName = string.IsNullOrEmpty(currentFilePath) ? "Untitled" : Path.GetFileName(currentFilePath); this.Text = (codeEditor.IsModified ? "*" : "") + fileName + " - Python Editor"; } // Method to update the variables window public void UpdateVariables(Dictionary variables) { variablesGridView.Rows.Clear(); foreach (var kvp in variables) { variablesGridView.Rows.Add(kvp.Key, kvp.Value); } } private PyInputStream pythonInputStream = new PyInputStream(); // Define a custom input stream to pass input to Python public class PyInputStream { private Queue inputQueue = new Queue(); private ManualResetEvent inputReadyEvent = new ManualResetEvent(false); // Called when input is sent from the TextBox public void SendInput(string input) { lock (inputQueue) { inputQueue.Enqueue(input); inputReadyEvent.Set(); // Signal that input is available } } // Python expects a readline() method for sys.stdin public string readline() { inputReadyEvent.WaitOne(); // Wait for input to be ready lock (inputQueue) { if (inputQueue.Count > 0) { var input = inputQueue.Dequeue(); inputReadyEvent.Reset(); // Reset the event if no more input is available return input; } } return ""; // Return an empty string if no input is available } } // Define a custom output stream for real-time Python output public class PyOutputStream { private MainForm _form; public PyOutputStream(MainForm form) { _form = form; } public void write(string output) { _form.Invoke((Action)(() => { _form.outputLog.AppendText(output); // Append output to the log in real time })); } public void flush() { // Implement if needed for flushing buffers } } public class PyPdbOutputStream { private MainForm _form; private StringBuilder _buffer = new StringBuilder(); public PyPdbOutputStream(MainForm form) { _form = form; } public void write(string output) { _form.Invoke((Action)(() => { // Append output to buffer _buffer.Append(output); // Check if we have complete lines string bufferContent = _buffer.ToString(); int newLineIndex; while ((newLineIndex = bufferContent.IndexOf('\n')) != -1) { string line = bufferContent.Substring(0, newLineIndex); ParseOutputLine(line); // Remove the parsed line from the buffer _buffer.Remove(0, newLineIndex + 1); bufferContent = _buffer.ToString(); } })); } private void ParseOutputLine(string line) { // Check if the line indicates a pdb line change if (line.StartsWith("> ")) { // Extract the filename and line number // Line format: "> /path/to/file.py(3)()" int startIndex = line.IndexOf('>') + 2; int endIndex = line.IndexOf('(', startIndex); if (endIndex > startIndex) { string filename = line.Substring(startIndex, endIndex - startIndex); // Extract the line number startIndex = endIndex + 1; endIndex = line.IndexOf(')', startIndex); if (endIndex > startIndex) { string lineNumberStr = line.Substring(startIndex, endIndex - startIndex); if (int.TryParse(lineNumberStr, out int lineNumber)) { // Highlight the line in the code editor _form.HighlightCurrentLine(lineNumber); // Now, fetch the variables try { using (Py.GIL()) { PyDict localsDict = new PyDict(_form.pdbInstance.curframe.f_locals); Dictionary variables = new Dictionary(); foreach (PyObject key in localsDict.Keys()) { string varName = key.ToString(); PyObject value = localsDict[key]; variables[varName] = value.Repr().ToString(); } // Update variables window _form.UpdateVariables(variables); } } catch (Exception ex) { _form.outputLog.AppendText($"Error fetching variables: {ex.Message}\n"); } } } } } } public void flush() { // Do nothing } } private void NextButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("n\n"); // Send 'n' for Next command } private void StepIntoButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("s\n"); // Send 's' for Step Into command } private void StepOutButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("r\n"); // Send 'r' for Return command } private void ContinueButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("c\n"); // Send 'c' for Continue command } private void QuitButton_Click(object sender, EventArgs e) { pythonInputStream.SendInput("q\n"); // Send 'q' for Quit command } private float GetDpiScale() { using (var graphics = upperElementHost.CreateGraphics()) { return graphics.DpiX / 96f; } } private void TextView_MouseHover(object sender, EventArgs e) { float dpiScale = GetDpiScale(); // Get the mouse position and adjust for DPI var mousePosition = Control.MousePosition; var clientPoint = upperElementHost.PointToClient(mousePosition); // Convert to WPF coordinates with DPI adjustment var wpfPoint = new System.Windows.Point( clientPoint.X / dpiScale, clientPoint.Y / dpiScale); // Transform coordinates relative to TextView wpfPoint = upperElementHost.Child.TransformToDescendant(codeEditor.TextArea.TextView).Transform(wpfPoint); // Add scroll offset wpfPoint.X += codeEditor.TextArea.TextView.ScrollOffset.X; wpfPoint.Y += codeEditor.TextArea.TextView.ScrollOffset.Y; var position = codeEditor.TextArea.TextView.GetPosition(wpfPoint); if (!position.HasValue) return; int offset = codeEditor.Document.GetOffset(position.Value.Line, position.Value.Column); // Get errors at the offset var errorsAtOffset = syntaxErrorRenderer.GetErrorsAtOffset(offset); if (errorsAtOffset != null && errorsAtOffset.Count > 0) { string message = errorsAtOffset[0].message; if (errorToolTip == null) { errorToolTip = new ToolTip(); } // Adjust tooltip position for DPI errorToolTip.Show(message, upperElementHost, (int)(clientPoint.X + (10 * dpiScale)), (int)(clientPoint.Y + (10 * dpiScale))); } else { if (errorToolTip != null) { errorToolTip.Hide(upperElementHost); } } } private void TextView_MouseHoverStopped(object sender, EventArgs e) { if (errorToolTip != null) { errorToolTip.Hide(upperElementHost); } } private CancellationTokenSource pythonExecutionCancellationTokenSource; private void RunCode(bool debugMode = false) { outputLog.Text = ""; string code = codeEditor.Text; var breakpoints = breakpointMargin?.Breakpoints ?? new HashSet(); // Initialize the cancellation token source pythonExecutionCancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = pythonExecutionCancellationTokenSource.Token; Task.Run(() => { using (Py.GIL()) { dynamic sys = Py.Import("sys"); // Custom Python stream to capture real-time output dynamic customOutput = new PyOutputStream(this); // Redirect stdout and stderr to the custom output stream sys.stdout = customOutput; sys.stderr = customOutput; sys.stdin = pythonInputStream; try { // Create a dictionary to hold variables PyDict globalLocalDict = new PyDict(); dynamic builtins = Py.Import("builtins"); globalLocalDict.SetItem("__builtins__", builtins); // Create an AppInterface instance and add it to the dictionary var appInterface = new AppInterface(); globalLocalDict.SetItem(new PyString("app"), appInterface.ToPython()); if (debugMode) { // Enable debugger buttons this.Invoke((Action)(() => { EnableDebuggerButtons(true); })); // Save the code to a temporary file tempFilePath = Path.Combine(Path.GetTempPath(), "GUIPython", "tempCode.py"); File.WriteAllText(tempFilePath, code); // Import pdb and create a Pdb instance with custom stdout dynamic pdb = Py.Import("pdb"); pdbInstance = pdb.Pdb(); pdbInstance.stdout = new PyPdbOutputStream(this); // Redirect pdb's stdout to the bin pdbInstance.prompt = ""; // Suppress the (Pdb) prompt // Set breakpoints pdbInstance.clear_all_breaks(); foreach (int lineNumber in breakpoints) { pdbInstance.set_break(tempFilePath, lineNumber); } // Read and compile the code from the file string codeFromFile = File.ReadAllText(tempFilePath); dynamic compile = builtins.compile; dynamic codeObject = compile(codeFromFile, tempFilePath, "exec"); // Run the code under pdb control isDebugging = true; pdbInstance.run(codeObject, globalLocalDict, globalLocalDict); // Delete the temporary file after execution File.Delete(tempFilePath); } else { PythonEngine.Exec(code, globalLocalDict, globalLocalDict); } } catch (PythonException ex) { // Log Python runtime exception string error = ex.ToString(); this.BeginInvoke((Action)(() => { outputLog.AppendText($"Python Exception:\n{error}\n"); })); } catch (Exception ex) { // Catch any .NET exceptions that occur during the task execution string error = ex.ToString(); this.BeginInvoke((Action)(() => { outputLog.AppendText($".NET Exception:\n{error}\n"); })); } finally { isDebugging = false; // Reset the debugging flag this.Invoke((Action)(() => { // Clear the variables window before running the new script variablesGridView.Rows.Clear(); // Disable debugger buttons when done EnableDebuggerButtons(false); HighlightCurrentLine(0); })); // Reset stdout and stderr sys.stdout = sys.__stdout__; sys.stderr = sys.__stderr__; sys.stdin = sys.__stdin__; } } }, cancellationToken); } private void InitPython() { // Determine the path to the config file configFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config.ini"); // Try to set the Python DLL path from config file pythonDllPath = null; if (File.Exists(configFilePath)) { pythonDllPath = File.ReadAllText(configFilePath).Trim(); } // If the DLL path is invalid, prompt user to select DLL if (string.IsNullOrEmpty(pythonDllPath) || !File.Exists(pythonDllPath)) { if (!ConfigurePythonDll()) { // User canceled DLL selection; exit application MessageBox.Show("Python DLL configuration is required to run the application.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); this.Close(); return; } else { // Config file should now have the new DLL path pythonDllPath = File.ReadAllText(configFilePath).Trim(); } } // Initialize Python Engine try { // Set the Python DLL path for Python.NET Runtime.PythonDLL = pythonDllPath; PythonEngine.Initialize(); PythonEngine.BeginAllowThreads(); // Add the stub directory to sys.path. This is for code completions of our app object using (Py.GIL()) { dynamic sys = Py.Import("sys"); string stubDirectory = Path.Combine(Path.GetTempPath(), "GUIPython"); dynamic sysPath = sys.path; bool contains = false; foreach (dynamic p in sysPath) { if (p.ToString() == stubDirectory) { contains = true; break; } } if (!contains) { sysPath.insert(0, stubDirectory); } if (!Directory.Exists(stubDirectory)) { Directory.CreateDirectory(stubDirectory); } string stubCode = @" class app: def Add(self, a: int, b: int) -> int: ..."; string stubFileName = Path.Combine(stubDirectory, "app_interface.pyi"); File.WriteAllText(stubFileName, stubCode); } } catch (Exception ex) { // Initialization failed; possibly due to invalid DLL MessageBox.Show($"Failed to initialize Python.NET with the selected DLL:\n{ex.Message}", "Initialization Error", MessageBoxButtons.OK, MessageBoxIcon.Error); // Clear the invalid DLL path from config try { File.Delete(configFilePath); } catch (Exception ioEx) { MessageBox.Show($"Failed to delete config file:\n{ioEx.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } this.Close(); } } private bool ConfigurePythonDll() { using (OpenFileDialog dlg = new OpenFileDialog()) { dlg.Filter = "Python DLL (python*.dll)|python*.dll|All files (*.*)|*.*"; dlg.Title = "Select Python DLL"; if (dlg.ShowDialog() == DialogResult.OK) { pythonDllPath = dlg.FileName; // Save the path to config file try { File.WriteAllText(configFilePath, pythonDllPath); return true; } catch (Exception ex) { MessageBox.Show($"Failed to write config file:\n{ex.Message}", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } } else { return false; } } } private void UpdateFoldings() { if (foldingStrategy != null && foldingManager != null) { foldingStrategy.UpdateFoldings(foldingManager, codeEditor.Document); } } public class HighlightCurrentLineBackgroundRenderer : ICSharpCode.AvalonEdit.Rendering.IBackgroundRenderer { public int Line { get; set; } public void Draw(ICSharpCode.AvalonEdit.Rendering.TextView textView, DrawingContext drawingContext) { if (Line < 1 || Line > textView.Document.LineCount) return; textView.EnsureVisualLines(); var line = textView.Document.GetLineByNumber(Line); if (line == null) return; foreach (var rect in ICSharpCode.AvalonEdit.Rendering.BackgroundGeometryBuilder.GetRectsForSegment(textView, line)) { drawingContext.DrawRectangle(new SolidColorBrush(Colors.Yellow), null, rect); } } public KnownLayer Layer => KnownLayer.Background; } private HighlightCurrentLineBackgroundRenderer lineHighlighter; public void HighlightCurrentLine(int lineNumber) { if (lineHighlighter == null) { lineHighlighter = new HighlightCurrentLineBackgroundRenderer(); codeEditor.TextArea.TextView.BackgroundRenderers.Add(lineHighlighter); } // Set the line to highlight lineHighlighter.Line = lineNumber; // Ensure visibility codeEditor.ScrollTo(lineNumber, 0); // Redraw the editor to show the highlight codeEditor.TextArea.TextView.InvalidateLayer(KnownLayer.Background); } } // Folding strategy for indentation public class IndentationFoldingStrategy { public void UpdateFoldings(FoldingManager manager, TextDocument document) { var newFoldings = CreateNewFoldings(document); manager.UpdateFoldings(newFoldings, -1); } public static string ConvertLeadingTabsToSpaces(string input, int spacesPerTab) { if (input == null) return input; // Handle null input string tabReplacement = new string(' ', spacesPerTab); int index = 0; // Find the first non-tab character or end of string while (index < input.Length && input[index] == '\t') { index++; } // Replace only the leading tabs with spaces string leadingTabsConverted = input.Substring(0, index).Replace("\t", tabReplacement); // Combine the converted leading part with the rest of the string return leadingTabsConverted + input.Substring(index); } private IEnumerable CreateNewFoldings(TextDocument document) { var newFoldings = new List(); Stack> startLines = new Stack>(); Stack startIndentationLevels = new Stack(); int previousIndentationLevel = 0; bool inArrayDefinition = false; int arrayStartLine = -1; int arrayNestingLevel = 0; for (int lineNumber = 1; lineNumber <= document.LineCount; lineNumber++) { DocumentLine line = document.GetLineByNumber(lineNumber); string lineText = document.GetText(line).TrimEnd(); // Ignore empty lines if (string.IsNullOrWhiteSpace(lineText)) continue; int currentIndentationLevel = GetIndentationLevel(document.GetText(line)); // Handle block definitions with nesting (arrays and braces) foreach (char c in lineText) { if (c == '[' || c == '{') { if (!inArrayDefinition) { inArrayDefinition = true; arrayStartLine = lineNumber; } arrayNestingLevel++; } else if (c == ']' || c == '}') { arrayNestingLevel--; if (arrayNestingLevel == 0 && inArrayDefinition) { // Close array folding inArrayDefinition = false; if ((lineNumber - arrayStartLine) > 1) { int startOffset = document.GetLineByNumber(arrayStartLine).Offset; int endOffset = line.EndOffset; var name = document.GetText(document.GetLineByNumber(arrayStartLine)).TrimEnd() + "..."; newFoldings.Add(new NewFolding(startOffset, endOffset) { Name = ConvertLeadingTabsToSpaces(name, MainForm.tabSize) }); } } } } // Handle indentation-based folding while (startLines.Count > 0 && currentIndentationLevel <= startLines.Peek().Item2) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; startIndentationLevels.Pop(); int endLine = lineNumber - 1; while (endLine > 1) { string endLineText = document.GetText(document.GetLineByNumber(endLine)).TrimEnd(); if (string.IsNullOrWhiteSpace(endLineText)) endLine--; else break; } if ((lineNumber - startLine) > 2) { var newFolding = new NewFolding(startOffset, document.GetLineByNumber(endLine).EndOffset); newFolding.Name = ConvertLeadingTabsToSpaces(document.GetText(document.GetLineByNumber(startLine)).TrimEnd() + "...", MainForm.tabSize); newFolding.IsDefinition = true; newFoldings.Add(newFolding); } } if (lineText.EndsWith(":")) { // Start a new folding section startLines.Push(new Tuple(lineNumber, currentIndentationLevel)); startIndentationLevels.Push(GetIndentationLevel(document.GetText(line))); } previousIndentationLevel = currentIndentationLevel; } // Close any remaining open foldings while (startLines.Count > 0) { var entry = startLines.Pop(); int startLine = entry.Item1; int startOffset = document.GetLineByNumber(startLine).Offset; newFoldings.Add(new NewFolding(startOffset, document.TextLength)); } newFoldings.Sort((a, b) => a.StartOffset.CompareTo(b.StartOffset)); return newFoldings; } private int GetIndentationLevel(string lineText) { int indentationLevel = 0; foreach (char c in lineText) { if (c == ' ') indentationLevel++; else if (c == '\t') indentationLevel += MainForm.tabSize; else break; } return indentationLevel; } } // Define BreakpointChangedEventArgs public class BreakpointChangedEventArgs : EventArgs { public int LineNumber { get; } public bool IsAdded { get; } public BreakpointChangedEventArgs(int lineNumber, bool isAdded) { LineNumber = lineNumber; IsAdded = isAdded; } } public class BreakpointMargin : AbstractMargin { private HashSet breakpoints = new HashSet(); private const double CIRCLE_RADIUS = 8; private const double MARGIN_WIDTH = 20; public event EventHandler BreakpointChanged; public HashSet Breakpoints => breakpoints; public BreakpointMargin() { this.Cursor = System.Windows.Input.Cursors.Hand; } protected override System.Windows.Size MeasureOverride(System.Windows.Size availableSize) { return new System.Windows.Size(MARGIN_WIDTH, availableSize.Height); } protected override void OnRender(DrawingContext drawingContext) { var textView = this.TextView; if (textView == null || !textView.VisualLinesValid) return; // First, draw a slightly darker background for the margin var marginRect = new System.Windows.Rect(0, 0, MARGIN_WIDTH, textView.ActualHeight); drawingContext.DrawRectangle( new SolidColorBrush(System.Windows.Media.Color.FromRgb(240, 240, 240)), null, marginRect ); foreach (var visualLine in textView.VisualLines) { int lineNumber = visualLine.FirstDocumentLine.LineNumber; if (breakpoints.Contains(lineNumber)) { // Calculate proper vertical position double y = visualLine.GetTextLineVisualYPosition(visualLine.TextLines[0], VisualYPosition.TextTop); double lineHeight = visualLine.Height; double circleY = y + (lineHeight / 2) - textView.VerticalOffset; // Draw breakpoint circle drawingContext.DrawEllipse( System.Windows.Media.Brushes.Red, // Fill new System.Windows.Media.Pen(System.Windows.Media.Brushes.DarkRed, 1), // Border new System.Windows.Point(MARGIN_WIDTH / 2, circleY), // Center point CIRCLE_RADIUS - 1, // Width radius CIRCLE_RADIUS - 1 // Height radius ); } } } protected override void OnMouseDown(MouseButtonEventArgs e) { if (e.ChangedButton != MouseButton.Left) return; var textView = this.TextView; if (textView == null) return; var pos = e.GetPosition(textView); pos.Y += textView.VerticalOffset; var visualLine = textView.GetVisualLineFromVisualTop(pos.Y); if (visualLine != null) { ToggleBreakpoint(visualLine.FirstDocumentLine.LineNumber); } } public void ToggleBreakpoint(int lineNumber) { // Toggle breakpoint bool breakpointAdded; if (breakpoints.Contains(lineNumber)) { breakpoints.Remove(lineNumber); breakpointAdded = false; } else { breakpoints.Add(lineNumber); breakpointAdded = true; } InvalidateVisual(); // Raise the event BreakpointChanged?.Invoke(this, new BreakpointChangedEventArgs(lineNumber, breakpointAdded)); } protected override void OnTextViewChanged(TextView oldTextView, TextView newTextView) { if (oldTextView != null) { oldTextView.VisualLinesChanged -= OnVisualLinesChanged; } if (newTextView != null) { newTextView.VisualLinesChanged += OnVisualLinesChanged; } base.OnTextViewChanged(oldTextView, newTextView); } private void OnVisualLinesChanged(object sender, EventArgs e) { InvalidateVisual(); } } public class AppInterface { public AppInterface() { } public int Add(int a, int b) { return a + b; } } } ``` It’s not perfect, but we have a start to a C# application that uses Python as an embedded scripting language. Some steps to make this more complete include: * Implement projects * Add editing and member viewing to variables window * Use a customizable docking window framework * Improve code completion performance * Ignore syntax errors for the current word * Don’t suggest keywords in code completions * Add support for identifying undeclared variables * Add some type of GUI form designer * Add an about box with disclosures Another time.

Embedding Python