SAL.Windows 1.2.11

SAL.Windows

SAL.Windows is a .NET library that provides a plugin-based architecture for developing extensible Windows Forms applications. It's part of the SAL (Software Abstraction Layer) framework that enables modular and flexible application development.

Features

• Plugin-based Architecture: Build applications using modular, reusable plugins
• Multiple UI Support: Works with various interface types (MDI/SDI/Dialog/VS IDE integration)
• Centralized Settings Management: Flexible storage of user settings and configurations
• Dynamic Module Loading: Load required modules based on user roles or server requirements
• Interface Abstraction: Common interfaces for Windows Forms controls and menus
• Cross-platform Compatibility: Supports .NET Framework 3.5 and .NET Standard 2.0

Architecture Overview

The SAL architecture consists of three main components:

1. Application Host: The main application that implements one of the supported interfaces
2. SAL Host: Core component managing plugin communication and loading
3. Plugins: Modular components that provide specific functionality

Plugin System

The architecture is built around the IPlugin interface, allowing plugins to:

• Extend or use other modules
• Access code from other plugins without recompilation
• Save and restore control states between sessions
• Integrate easily with existing applications
• Use standard WinForms UserControl or WPF components

Host Types

SAL supports multiple host types:

• MDI Applications
  1. Flatbed.MDI
  2. Flatbed.MDI (Avalon)
• Dialog-based Applications
  1. Flatbed.Dialog
  2. Flatbed.Dialog (Lite)
• Visual Studio Integration (EnvDTE)
• Windows Services
  1. Flatbed.Service
• ASP.NET Applications

Getting Started

Basic Plugin Implementation

public class Plugin : IPlugin, IPluginSettings<PluginSettings>
{
    private readonly IHost _host;
    private PluginSettings _settings;

    public Plugin(IHost host)
    {
        _host = host;
    }

    public PluginSettings Settings
    {
        get
        {
            if(_settings == null)
            {
                _settings = new PluginSettings(this);
                _host.Plugins.Settings(this).LoadAssemblyParameters(_settings);
            }
            return _settings;
        }
    }
}

Adding UI Elements

IHostWindows host = this.Host as IHostWindows;
if(host != null)
{
    IMenuItem menuTools = host.MainMenu.FindMenuItem("Tools");
    if(menuTools != null)
    {
        var newMenuItem = menuTools.Create("New Feature");
        newMenuItem.Name = "tsmiToolsNewFeature";
        newMenuItem.Click += OnNewFeatureClick;
        menuTools.Items.Insert(0, newMenuItem);
    }
}

Creating Windows

IWindow window = hostWindows.Windows.CreateWindow(
    plugin: this,
    formType: typeof(MyUserControl).ToString(),
    searchForOpened: false,
    showHint: DockState.DockLeft
);

Adding menus and toolbars

public class MyPlugin : IPlugin
{
    private IMenuItem _pluginMenuItem;
    internal IHost Host { get; }

    /// <summary>It's allowed to launch the plugin with any host, and at startup - the plugin decides how to start</summary>
    public MyPlugin(IHost host)
        => this.Host = host;

    Boolean IPlugin.OnConnection(ConnectMode mode)
    {
        IHostWindows host = this.Host as IHostWindows;
        if(host != null)
        {
            IMenuItem menuTools = host.MainMenu.FindMenuItem("Tools");
            if(menuTools != null)
            {
                _pluginMenuItem = menuTools.Create("Menu Item Name");
                _pluginMenuItem.Name = "tsmiToolsPluginMenuItem";
                _pluginMenuItem.Click += new EventHandler(_pluginMenuItem_Click);
                menuTools.Items.Insert(0, _pluginMenuItem);
                return true;
            }
        }
        return false;
    }

    Boolean IPlugin.OnDisconnection(DisconnectMode mode)
    {
        if(this._pluginMenuItem != null)
            this.HostWindows.MainMenu.Items.Remove(this._pluginMenuItem);
        return true;
    }
}

Opening window (UI should be inherited from UserControl class)

public class MyPlugin : IPlugin
{
    private IHostWindows HostWindows { get; private set; }

    /// <summary>Creating an instance of this plugin is only possible in a host that implements the IHostWindows interface (Constructor is optional and works as IoC)</summary>
    public MyPlugin(IHostWindows host)
        => this.HostWindows = host;

    Boolean IPlugin.OnConnection(ConnectMode mode)
    {
        this.HostWindows.Plugins.PluginsLoaded += (sender, e) => this.CreateWindow(typeof(PanelMyWindowControl).ToString(), true);
        return true;
    }

    Boolean IPlugin.OnDisconnection(DisconnectMode mode)
        => true;

    private IWindow CreateWindow(String typeName, Boolean searchForOpened, Object args = null)
        => this.HostWindows.Windows.CreateWindow(this, typeName, searchForOpened, DockState.DockLeft, args);
}

Receiving objects IWindow and IPlugin in the opened window.

public partial class PanelMyWindowControl : UserControl
{
    private IWindow Window { get { return (IWindow)base.Parent; } }
    private MyPlugin Plugin { get { return (MyPlugin)this.Window.Plugin; } }

    protected override void OnCreateControl()
    {
        this.Window.Caption = "I want cookie";

        base.OnCreateControl();
    }

}

Core Components

SAL.Flatbed

• Base assembly containing core interfaces
• Minimal set of abstractions for plugins and hosts
• Platform-independent functionality

SAL.Windows

• Windows Forms and WPF specific implementation
• UI component interfaces
• Menu and toolbar abstractions
• Window management

Plugin Architecture

Plugin Lifecycle

1. Loading: Plugins are discovered and loaded from configured locations
2. Provider Resolution: Settings and plugin providers are initialized
3. Kernel Plugin Detection: System identifies and initializes kernel plugins
4. Plugin Initialization: Remaining plugins are initialized with dependencies

Plugin Communication

• Inter-plugin communication through public methods, properties, and events
• Host communication via IHost interface and its extensions
• Settings management through IPluginSettings interface

Configuration

Settings Management

// Loading data
using(Stream stream = plugin.Host.Plugins.Settings(plugin).LoadAssemblyBlob("config.xml"))
{
    if(stream != null)
        // Process configuration
}

// Saving data
using(MemoryStream stream = new MemoryStream())
{
    // Write configuration
    plugin.Host.Plugins.Settings(plugin).SaveAssemblyBlob("config.xml", stream);
}

Compatibility

• .NET Framework 3.5
• .NET Standard 2.0

Contributing

Contributions are welcome. Please ensure your changes maintain compatibility with the supported .NET versions.