SolidShineUi 2.0.1

SolidShineUi UI Library

This is a library containing controls and windows for WPF .NET programs (many new, some a replacement of built-in controls). This library also contains helper classes and functions to customize the UI and provide other various bits of additional functionality. I use this for all of my modern software projects, and hopefully it will be of use to you as well!

This library is created and maintained by JaykeBird (Jayke R. Huempfner). While a large majority of the code and functionality was built by me, I did reuse some code created by others. Please see the credits on my website for more details (linked below).

The entire library is available under the MIT License. ( )

View more details about this library at my website, jaykebird.com.

Included

Basic Windows

• ThemedWindow - a basic WPF window, with the SsuiTheme property added in
• FlatWindow - drop-in replacement for a WPF window, with a flat appearance and additional functionality

Dialogs

• ColorPickerDialog - a WPF dialog for selecting colors, either from swatches, using sliders, or from an image or color palette file
• FontSelectDialog - a WPF dialog that allows the user to select a font, as well as other properties like size and style
• MessageDialog - a MessageBox dialog in the FlatWindow/SSUI style, with additional functions and buttons (similar to the Windows TaskDialog)
• StringInputDialog - a WPF dialog to allow users to input a string, similar to the input dialog JOptionPane from Java's Swing library
• MultilineStringInputDialog - similar to the StringInputDialog, but allows users to include multiple lines of text
• LinearGradientEditorDialog - found in SolidShineUi.PropertyList.Dialogs, allows you to edit a LinearGradientBrush
• RadialGradientEditorDialog - found in SolidShineUi.PropertyList.Dialogs, allows you to edit a RadialGradientBrush

Controls

• CheckBox - a box that can be checked; it is larger than the standard WPF CheckBox and offers more customization
• ClickSelectTextBox - a TextBox, that automatically selects all the text within when you click on it
• ContentControlWithMenu - displays some UI elements on one side, and then a menu on the other side (or below)
• ContextMenu - a context menu with a flat style to match the rest of the library
• DoubleSpinner - also known as a NumericUpDown; select a number by typing it in, clicking up or down, or entering in a math expression
• EnumComboBox - a ComboBox pre-filled with the values of an enumerator
• FileSelect - select one or more files, via the Browse button or drag-and-drop
• FlatButton - a flat-styled button with a lot of customization options (including toggle-button functions)
• FlatRepeatButton - similar to the WPF RepeatButton, but with the appearance of the FlatButton, and a few extra fine-control options
• IntegerSpinner - the same as the DoubleSpinner, but only allows integer values (and can display hex numbers)
• LinkTextBlock - a TextBlock that acts as a hyperlink
• LongSpinner - the same as the IntegerSpinner, but stores numbers as a long (for larger values)
• Menu - a menu bar and menu with a flat, colored style
• MenuButton - a flat-styled button that opens a menu when you click on it
• ParticleEmitter - generate a bunch of 2-D particles for your app, to add some sparkles or motion
• PositionSelect - select a 2-D coordinate between (0,0) and (1,1) (use PointMultiplerConverter to use with a larger range)
• PropertyList - view and edit the properties of any WPF control or C# object
• SelectPanel - a powerful panel to easily manage a list and select items from it
• SelectableItem - a type of SelectableUserControl, use to display items in SelectPanel
• SplitButton - a button that can display content and also a menu with more options
• StringSpinner - similar to the DomainUpDown control in Windows Forms. allows users to select a value from a list of strings
• TabControl - a flat-styled tab control, where each tab has a title, icon, and close button
• TimeSpinner - a spinner that allows users to enter in a time value (supports any TimeSpan value, or TimeOnly in .NET 6+)

Other Classes

• ArithmeticParser - parse math expressions ("(5+4)/2") quickly and easily. Available separately as well
• AutoCompleteBehavior - adds basic auto-complete behavior to text boxes. Available separately as well
• BindableChild - allows you to use WPF binding for a control's Child property (such as the WPF Border control)
• BrushFactory - easy and convenient way to create various brushes
• BrushSerializer - convert solid color or gradient brushes to a short string that can be stored or transferred (and then later deserialized)
• ColorPaletteFileReader - load a list of colors from various color palette file formats
• ColorScheme - a palette/scheme of colors to use throughout your UI. Used in Solid Shine UI 1.x, new projects should use SsuiAppTheme
• ColorsHelper - contains various methods for interacting with colors and color spaces
• ImageColorPicker - select colors from an image, used in the ColorPickerDialog
• IKeyAction - represents an action that can occur when a keyboard shortcut is pressed (such as CommandKeyAction and RoutedEventKeyAction)
• KeyboardShortcut - represents a single keyboard shortcut (and the action to take when it is pressed)
• KeyboardShortcutHandler - a helper class that can be added to any WPF window to add keyboard shortcut support
• KeyboardShortcutsIo - a helper class to load/save keyboard shortcut settings to/from a file
• KeyRegistry - represents a list of keyboard shortcuts currently set, and the actions to take when a shortcut is pressed
• SelectableCollection - an extension on ObservableCollection, with additional functions/properties for selecting items in the collection
• SelectableUserControl - the base class from which you can create your own controls to use with a SelectPanel (or implement IClickSelectableControl)
• SubKeyRegistry - when combined with a master KeyRegistry, allows you to create layers of keyboard shortcuts in more complex apps
• SsuiTheme - a scheme of colors and brushes to use in particular SSUI controls (or controls that inherit from ThemedControl)
• SsuiAppTheme - a scheme of colors and brushes to use throughout your whole UI; has the ability to set an accent theme too
• SsuiThemes - a collection of pre-made SsuiAppTheme objects that you can quickly apply to your app
• TabItem - a tab to use with the TabControl
• TransformSerializer - convert a WPF Transform object to a short string that can be stored or transferred (and then later deserialized)
• WildcardMatch - match file names/paths (or any text) using wildcard characters like * and ?. Available separately as well

WPF XAML Converters

SolidShineUi also includes a lot of WPF XAML converters. See the Value Converters wiki page for the full list and how to use them.

Use it now

The library is available on NuGet, or you can download the binaries directly from here on GitHub.

Getting set up

After you get the library from a location listed above, you can add a reference to SolidShineUi in your C# and XAML files.

    xmlns:flat="clr-namespace:SolidShineUi;assembly=SolidShineUi"

using SolidShineUi;

After that, you can start using the controls listed above!

You can use just the one or two controls you need, or you can rebuild existing UIs or design all-new UIs with the Solid Shine UI controls. You can also use these alongside the standard WPF controls with no changes in their appearance or behavior.

You can build and run the SsuiSample app included in this repo as an example to get started with or to see the capabilities of the library.

Documentation is available on the wiki here on GitHub.

Adding/using SsuiTheme

If you're building your application's UI with many of my controls/windows (or almost entirely from these controls/windows), it's recommended that you set up a SsuiTheme that all the windows can access. Almost all window and control classes in Solid Shine UI includes a SsuiTheme property, which you can use with WPF's binding features.

There could be a number of ways to set this up, but the way I personally use and I recommend to others is to place a static SsuiAppTheme property in your App.xaml.cs file:

    // the app theme can be based on any color; here, we'll use green
    // there's also pre-made themes available in the SolidShineUi.SsuiThemes class
    public static SsuiAppTheme AppTheme { get; set; } = new SsuiAppTheme(Colors.Green);

(If you're planning to offer customization and/or storing the SsuiAppTheme in your settings, make sure to use SerializableSsuiTheme to store the SsuiAppTheme data in your settings file. You can create one by using AppTheme.ToSerializableObject().)

You can create a SsuiAppTheme based upon any base color you want to use (such as your app's branding color), or you can use SsuiThemes.CreateLightTheme() or SsuiThemes.CreateDarkTheme() for more standard light or dark themes, or even SsuiThemes.SystemTheme for a more standard Windows-looking theme. High-contrast color schemes are also built-in in the SsuiThemes class. You can also start from scratch and custom set each value if you'd like, too (including using gradients!).

From there, you can use a ThemedWindow (drop-in replacement of the standard WPF window), which contains a SsuiTheme property that all the child Solid Shine UI controls can bind to. Change the Window to be a ThemedWindow on the XAML side:

<flat:ThemedWindow x:Class="MyApp.MyWindow" x:Name="window"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:flat="clr-namespace:SolidShineUi;assembly=SolidShineUi"
        mc:Ignorable="d" Title="My Window" >
   
   
   <flat:IntegerSpinner MinValue="0" />
   
</flat:ThemedWindow>

And in the C# side, set the window's SsuiTheme property, and it'll set it for all the child SSUI-themed controls too.

using System;
using System.Windows;
using SolidShineUi; // <--- don't forget the reference to SolidShineUi

namespace MyApp
{

    public partial class MyWindow : ThemedWindow // <--- make sure to update this to be a ThemedWindow too
    {
    
        public MyWindow()
        {
            InitializeComponent();
            
            SsuiTheme = App.AppTheme; // <--- this sets up the color scheme for the window
        }
        
        // the rest of your code-behind as normal   
    }
}

Solid Shine UI also includes another window class called FlatWindow, which has all the features of a standard WPF window, but with a custom title bar and a custom appearance (and with it, a few extra features and options about what to put into the title bar). It is a drop-in replacement if you want to use FlatWindow instead of ThemedWindow.

If you're building your own controls, they can also use SsuiTheme by having them inherit from ThemedControl, ThemedContentControl, or ThemedUserControl. Make sure to then override the OnApplySsuiTheme method to set your control's appearance based upon the SsuiTheme's values. Use this to get started:

    /// <inheritdoc/>
    protected override void OnApplySsuiTheme(SsuiTheme ssuiTheme, bool useLightBorder = false, bool useAccentTheme = false)
    {
        base.OnApplySsuiTheme(ssuiTheme, useLightBorder, useAccentTheme);

        if (useAccentTheme && ssuiTheme is SsuiAppTheme ssuiAppTheme)
        {
            ApplyTheme(ssuiAppTheme.AccentTheme);
        }
        else
        {
            ApplyTheme(ssuiTheme);
        }

        void ApplyTheme(SsuiTheme theme)
        {
            // update your appearance and properties in here
                
            // use ApplyThemeBinding() to bind the properties so that changing the value in the SsuiTheme automatically updates this control:
            ApplyThemeBinding(ForegroundProperty, SsuiTheme.ForegroundProperty, theme);
            ApplyThemeBinding(BackgroundProperty, SsuiTheme.PanelBackgroundProperty, theme);

            // note that "theme" can be null; ApplyThemeBinding handles that and also handles the ThemeValueExclude property
        }
    }

If you want to customize the appearance of specific controls while still using SsuiTheme, you can either look into using an accent theme (see below) or set that control's ThemeValueExclude property to make sure that your brushes don't get overwritten by the SsuiTheme:

    <flat:FlatButton Content="My Button" x:Name="btn1" Background="Orchid" BorderBrush="Purple" ThemeValueExclude="Background,BorderBrush" />

For storing your SsuiAppTheme in a settings file or cache, get a serializable version of it using the ToSerializableObject method.

From here, you should be on your way!

View the wiki page on SsuiTheme and themed controls for more info on using SsuiAppTheme.

Accent theme

The SsuiAppTheme class allows you to set an accent theme that you can use in any SSUI-themed control.

    // we'll use Green as the main color, and Yellow as the accent color
    public static SsuiAppTheme AppTheme { get; set; } = new SsuiAppTheme(Colors.Green, Colors.Yellow);

From there, you can set UseAccentTheme on any control to have them use the accent theme's colors/brushes instead.

    <flat:FlatButton Content="My Button 2" x:Name="btn2" UseAccentTheme="true" />

There is also a subitem theme that you can set in SsuiAppTheme, if you want the Menu, ContextMenu, and SelectPanel controls to use that for its child items instead. Make sure to also set the UseSubitemThemeWith... properties in the SsuiAppTheme to set which types of controls to use the subitem theme with.

ColorScheme

Versions prior to 2.0 don't have SsuiTheme, and instead use ColorScheme. The basic idea is the same, but I'd recommend everyone use 2.0 and start using SsuiTheme instead.

The old ColorScheme class had names for its properties that didn't have the best descriptions for what they were used for, and was limited to only using solid colors.

Keyboard shortcuts

One part of Solid Shine UI is a keyboard shortcut handling system that I built.

While WPF has its own method of handling keyboard shortcuts (via InputBindings), my system is a bit more flexible and customizable, and these customizations can also be saved to/loaded from a XML file. However, my system is not an easy drop-in replacement, and has the drawback that it mostly needs to be set up in C#, rather than being doable in XAML.

To get started with my keyboard shortcut handling system, I recommend looking at the Adding Keyboard Support file for a step-by-step process and other notes and remarks.

Coming Soon

Version 2.0 is here! See the release page for more info on all the new stuff in there. Up next will be version 2.1, coming in 2026 or 2027. Don't be surprised if don't see much activity on the main branch for some periods of time, as I'll be using sub-branches to develop various features, including an upcoming Ribbon control!

View the roadmap for more details on my plans.

Building/Testing

To build this library you will need:

• .NET Framework developer tools/targeting packs (4.6.1 through 4.8.1)
• latest .NET Core SDK
• (for the Avalonia version, I'd also recommend installing the latest Avalonia UI extension for your IDE)

I recommend using Visual Studio 2026 (or the latest version) for this library. When opened up, you should be able to just build and run the library (to build the .NET Framework versions, you may need to have the individual components for .NET Framework targeting packs installed).

Included is the SsuiSample program, which is useful for demonstrating the library and its functions. I also use this to test the library and its controls. Feel free to use SsuiSample as a basis for your implementations.

Notes

If you receive this message (SourceRoot items must include at least one top-level (not nested) item when DeterministicSourcePaths is true) when trying to debug, make sure you have Visual Studio set to the Debug configuration, and not the Release configuration (this is the drop-down to the left of the Start button, or you can access it via Build > Configuration Manager... and set the active configuration there).

License

This library is released under the MIT License.

Credits/Usage

For credits/attribution for when you use the library, please use one of the credit blocks below:

Developed/compiled by Jayke R. Huempfner (JaykeBird)

https://jaykebird.com/software/ssui

Contains work by Manuel Schweigert, Pete Laker, Steve Lautenschlager, Richard Moss (Cyotek Ltd.), Warren Galyen (Mechanika Design), Yassine (Stopbyte), Hector Pulido, Sebastien Lambla, Nimgoble, H.A. Sullivan, and ControlzEx (batzen and punker76). See website for more details.

Licensed under MIT License

Developed by Jayke R. Huempfner (JaykeBird), other contributors

https://jaykebird.com/software/ssui

Licensed under MIT License. See website for more details.

The full credits are available on the Credits page on my website.