C-under-WinForm

CODE:
using System.Collections.Generic;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using WealthLab.WPF;

// The following code requires at least C# version 13.

namespace WLExtensions;

/// <summary>
///     Minimal, bare-bones WL9 (8) client extension used as a starting point ("template") for building
///     new Wealth-Lab 9 (8) client extensions. It registers a single menu item under the extension's menu
///     and shows a singleton child window (<see cref="ExtensionWindow" />) when activated.
///     Copy/rename this class (and its companion window class) as the basis for a new extension.
/// </summary>
public sealed class ClientExtensionTemplate : WL8ClientExtensionBase
{
    // name of the extension as shown in WL9; adjust for your extension's name
    private const string ExtensionName = "Extension Template";

    // The resource path of the glyph/icon shown next to the extension's menu item and on its
    // child window title bar. Re-using an existing embedded resource avoids having to add a
    // new image asset just for this extension.
    // Here, the candlestick glyph from the WealthLab.Candlesticks.WPF assembly is used,
    // but you can add your own image to your extension project and reference it here instead.
    public const string ImageSourceName = "WealthLab.Candlesticks.WPF.Glyphs.Candlesticks.png";

    // Display name for the extension as shown in the WL9 client's Extensions list/UI.
    public override string Name => ExtensionName;

    /// <summary>
    ///     Builds the list of menu items WL9 should display for this extension (e.g., under the
    ///     Extensions menu). Called by the host application when it needs to populate the menu.
    /// </summary>
    /// <returns>A list containing the single menu item that opens/activates the extension window.</returns>
    public override List<MenuItem> GetMenuItems()
    {
        var mi = new List<MenuItem>();

        // CreateExtensionMenuItem (inherited from WL8ClientExtensionBase) builds a properly
        // styled MenuItem with the given caption and glyph. The click handler opens (or brings
        // to the front) the singleton extension window rather than creating a new one each time.
        var mni = CreateExtensionMenuItem("Extension Template",
            GlyphManager.GetImageSource(ImageSourceName, this),
            (_, _) => { ExtensionWindow.GetCreateExtensionWindow(); });

        mi.Add(mni);
        return mi;
    }

    /// <summary>
    ///     Returns the child window associated with this extension. WL9 calls this (e.g., when
    ///     restoring a saved workspace/layout) with a token identifying which window to recreate.
    ///     Since this template only has one window, the token is ignored and the singleton
    ///     <see cref="ExtensionWindow" /> instance is always returned/created.
    /// </summary>
    /// <param name="token">
    ///     Identifier of the requested child window (unused here since there is only one for this sample
    ///     template).
    /// </param>
    public override ChildWindow GetChildWindow(string token) => ExtensionWindow.GetCreateExtensionWindow();
}

/// <summary>
///     The single child window ("panel") shown by <see cref="ClientExtensionTemplate" />. Implemented as
///     a lazily created singleton so that activating the extension's menu item repeatedly reuses the
///     same window instance instead of spawning duplicates. Replace <see cref="BuildContent" /> with
///     real UI construction when adapting this template for an actual extension.
/// </summary>
public sealed class ExtensionWindow : ChildWindow
{
    // title shown on the window's title bar; adjust for your extension's window title
    private const string ExtensionTitle = "Extension Template";

    // Synchronizes creation/teardown of the singleton MyWindow instance across threads.
    private static readonly Lock WindowLock = new();

    // Private constructor forces all instantiation through GetCreateExtensionWindow(),
    // guaranteeing the singleton pattern is respected.
    private ExtensionWindow()
    {
        BuildContent();
    }

    // Root layout panel that holds the window's UI content.
    private Grid MyContent { get; set; }

    // Backing field for the single live instance of this window; null when no window is open.
    private static ExtensionWindow ExtensionChildWindow { get; set; }

    /// <summary>
    ///     Constructs the window's visual content. This template just creates an empty <see cref="Grid" />
    ///     anchored to the top of the window with a small margin; real extensions should add controls
    ///     to <see cref="MyContent" /> here (or build a more elaborate layout).
    ///     If your extension doesn't want to use the extension child window then you can
    ///     simply not add anything to Content.
    /// </summary>
    private void BuildContent()
    {
        // example: make a grid...
        MyContent = new Grid
        {
            VerticalAlignment = VerticalAlignment.Top,
            Margin = new Thickness(10)
        };

        // add a couple of rows and columns to the grid as an example; real extensions would add more controls here
        var rowDef = new RowDefinition {Height = new GridLength(1, GridUnitType.Star)};
        MyContent.RowDefinitions.Add(rowDef);
        var colDef = new ColumnDefinition {Width = new GridLength(1, GridUnitType.Star)};
        MyContent.ColumnDefinitions.Add(colDef);
        Content = MyContent;
    }

    /// <summary>
    ///     Returns the existing extension window if one is already open, otherwise creates it,
    ///     and wires up cleanup so the singleton reference is cleared when the window is closed.
    ///     Thread-safe via <see cref="WindowLock" />.
    ///     Also, you can create other resources like System.Windows.Window, etc. here if you want to have a more complex
    ///     extension with multiple windows.
    /// </summary>
    /// <returns>The singleton <see cref="ExtensionWindow" /> instance, creating it on the first call.</returns>
    public static ExtensionWindow GetCreateExtensionWindow()
    {
        lock (WindowLock)
        {
            // Reuse the existing window if it's already open rather than creating a second one.
            if (ExtensionChildWindow != null)
            {
                return ExtensionChildWindow;
            }

            var window = new ExtensionWindow();

            // Ask the WL9 client host to display this window as an MDI child, with the given
            // title and glyph icon (matching the icon used on the extension's menu item).
            WLClientHost.Instance.ShowExtensionChildWindow(window, ExtensionTitle,
                GlyphManager.GetImageSource(ClientExtensionTemplate.ImageSourceName));

            // NaN width/height tells the MDI host to auto-size the window to its content
            // rather than using a fixed size.
            window.MyMDIChild.Width = double.NaN;
            window.MyMDIChild.Height = double.NaN;

            // When the user closes the window, clear the singleton reference so the next
            // menu click creates a fresh window instead of reusing a disposed one.
            window.MyMDIChild.Closing += (_, _) =>
            {
                lock (WindowLock)
                {
                    ExtensionChildWindow = null;
                }
            };
            ExtensionChildWindow = window;

            // you could also create other windows here if you want to have a more complex extension with multiple windows,
            // like create a System.Windows.Window...
            // OtherWindow = new Window(); // presume OtherWindow is a static property of type Window
        }

        return ExtensionChildWindow;
    }
}

QUOTE:
I don't think there's really any need to create a ChildWindow if you don't need one.

QUOTE:
No... that doesn't work. After all, I need to create at least one `MenuItem` to launch the window.
`GetMenuItems()` references `WL8ClientExtensionBase`.
And as I understand it, that requires WPF.

CODE:
    Application.Current.Dispatcher.Invoke(() =>
    {
        var form = new MyWinFormsWindow(); // or store the form in an property
        form.Show();
    });

CODE:

    public class WLAppMenu : WL8ClientExtensionBase
    {
        private static wlMainWindow? mainWindow;

        public override string Name => "WLAppForm";

        public override List<System.Windows.Controls.MenuItem> GetMenuItems()
        {
            var menuItem = new System.Windows.Controls.MenuItem { Header = "WLAppForm öffnen" };
            menuItem.Click += MenuItem_Click;
            return new List<System.Windows.Controls.MenuItem> { menuItem };
        }

        private void MenuItem_Click(object sender, RoutedEventArgs e)
        {
            if (mainWindow == null || mainWindow.IsDisposed)
            {
                WindowsFormsHost.EnableWindowsFormsInterop();
                mainWindow = new wlMainWindow();
                mainWindow.Show();
            }
            else
                mainWindow.Activate();
        }
    }