├── icon.png
├── .gitignore
├── packages.config
├── Views
    ├── SettingsView.xaml.cs
    ├── Common.cs
    ├── FullscreenSettingsView.cs
    ├── SettingsView.xaml
    └── FullscreenSettingsView.xaml
├── ThemeOptions.csproj.user
├── Controls
    ├── CommandControl.xaml
    ├── GamepadAltControl.xaml
    ├── out_of_order
    │   ├── CommandControl_TriggerActions.cs.txt
    │   ├── CommandControl_SendEvent.cs..txt
    │   └── CommandControl_UpdateOneTimeBind.cs.txt
    ├── CommandControl_BeginStoryboard.cs
    ├── CommandControl_Toggle.cs
    ├── CommandControl.xaml.cs
    ├── CommandControl_MainMenuCommands.cs
    ├── CommandControl_TouchTag.cs
    ├── CommandControl_ChangeProperty.cs
    ├── CommandControl_GameControllerHold.cs
    └── GamepadAltControl.xaml.cs
├── App.xaml
├── Localization
    ├── en_US.xaml
    └── ru_RU.xaml
├── extension.yaml
├── Models
    ├── MinimalVersion.cs
    ├── Extensions.cs
    ├── Preset.cs
    ├── DynamicProperties.cs
    ├── Options.cs
    ├── GamepadState.cs
    ├── Variable.cs
    ├── Theme.cs
    ├── Presets.cs
    ├── Variables.cs
    └── SettingsViewModel.cs
├── AssemblyInfo.cs
├── LICENSE
├── Tools
    ├── DisplayAspectRatio.cs
    ├── VersionComparer.cs
    ├── GetFakeModel.cs
    ├── DynamicEventHandler.cs
    └── Gamepad.cs
├── Tests
    ├── Tools
    │   └── VersionComparer.cs
    ├── Tests.csproj
    └── Models
    │   ├── VariablesToObjectsCast.test.cs
    │   └── VariableValuesSearization.test.cs
├── Converters
    ├── VisibilityToBoolean.cs
    ├── DurationToDouble.cs
    └── DurationToString.cs
├── .vscode
    ├── settings.json
    ├── launch.json
    └── tasks.json
├── ThemeOptions.sln
├── ThemeOptions.csproj
├── Localization.cs
├── ThemeOptions.yaml
└── ThemeOptions.cs


/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ashpynov/ThemeOptions/HEAD/icon.png


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /.vs
2 | /bin
3 | /obj
4 | /packages
5 | Properties/launchSettings.json
6 | /.idea
7 | Tests/bin/
8 | Tests/obj/
9 | 


--------------------------------------------------------------------------------
/packages.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <packages>
3 |   <package id="PlayniteSDK" version="6.12.0" targetFramework="net462" />
4 | </packages>


--------------------------------------------------------------------------------
/Views/SettingsView.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows.Controls;
 2 | using System.Windows.Markup;
 3 | 
 4 | namespace ThemeOptions.Views
 5 | {
 6 |     public partial class SettingsView : UserControl
 7 |     {
 8 |         public SettingsView()
 9 |         {
10 |             ((IComponentConnector)this).InitializeComponent();
11 |         }
12 |     }
13 | }


--------------------------------------------------------------------------------
/ThemeOptions.csproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
4 |     <DebuggerFlavor>ProjectDebugger</DebuggerFlavor>
5 |   </PropertyGroup>
6 |   <PropertyGroup>
7 |     <ActiveDebugProfile>Fullscreen</ActiveDebugProfile>
8 |   </PropertyGroup>
9 | </Project>


--------------------------------------------------------------------------------
/Controls/CommandControl.xaml:
--------------------------------------------------------------------------------
 1 | <PluginUserControl x:Class="ThemeOptions.Controls.CommandControl"
 2 |     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 5 |     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 6 |     xmlns:local="clr-namespace:ThemeOptions.Controls"
 7 |     mc:Ignorable="d"
 8 |     d:DataContext="{d:DesignInstance Type=local:CommandControl}"
 9 | >
10 | 
11 | </PluginUserControl>


--------------------------------------------------------------------------------
/App.xaml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 4 |     <Application.Resources>
 5 |         <ResourceDictionary>
 6 |             <Style x:Key="BaseTextBlockStyle" TargetType="TextBlock" />
 7 |             <ResourceDictionary.MergedDictionaries>                
 8 |                 <ResourceDictionary Source="Localization/en_US.xaml" />
 9 |             </ResourceDictionary.MergedDictionaries>
10 |         </ResourceDictionary>
11 |     </Application.Resources>
12 | </Application>


--------------------------------------------------------------------------------
/Localization/en_US.xaml:
--------------------------------------------------------------------------------
1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
2 |                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
3 |                     xmlns:sys="clr-namespace:System;assembly=mscorlib">
4 |     <sys:String x:Key="LOCThemeOptionsSettingsMenu">Theme Options</sys:String>
5 |     <sys:String x:Key="LOCThemeOptionsSettingsChooseTheme">Choose theme to set options:</sys:String>
6 |     <sys:String x:Key="LOCThemeOptionsSettingsPresets">Presets</sys:String>
7 |     <sys:String x:Key="LOCThemeOptionsSettingsVariables">Variables</sys:String>
8 | 
9 | </ResourceDictionary>


--------------------------------------------------------------------------------
/Localization/ru_RU.xaml:
--------------------------------------------------------------------------------
1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
2 |                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
3 |                     xmlns:sys="clr-namespace:System;assembly=mscorlib">
4 |     <sys:String x:Key="LOCThemeOptionsSettingsMenu">Настройки темы</sys:String>
5 |     <sys:String x:Key="LOCThemeOptionsSettingsChooseTheme">Выберите тему для настройки:</sys:String>
6 |     <sys:String x:Key="LOCThemeOptionsSettingsPresets">Предустановки</sys:String>
7 |     <sys:String x:Key="LOCThemeOptionsSettingsVariables">Настройки</sys:String>
8 | 
9 | </ResourceDictionary>


--------------------------------------------------------------------------------
/Controls/GamepadAltControl.xaml:
--------------------------------------------------------------------------------
 1 | <PluginUserControl x:Class="ThemeOptions.Controls.GamepadAltControl"
 2 |     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 5 |     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 6 |     xmlns:local="clr-namespace:ThemeOptions.Controls"
 7 |     mc:Ignorable="d"
 8 |     d:DataContext="{d:DesignInstance Type=local:GamepadAltControl}"
 9 |     Tag="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType=Control, AncestorLevel=1}, Path=Tag}"
10 | >
11 | 
12 | </PluginUserControl>


--------------------------------------------------------------------------------
/extension.yaml:
--------------------------------------------------------------------------------
 1 | Id: ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef
 2 | Name: Theme Options
 3 | Author: Artem Shpynov, Jono
 4 | Version: 0.32
 5 | Module: ThemeOptions.dll
 6 | Type: GenericPlugin
 7 | Icon: icon.png
 8 | Links:
 9 |     - Name: Github
10 |       Url: https://github.com/ashpynov/ThemeOptions
11 |     - Name: License
12 |       Url: https://github.com/ashpynov/ThemeOptions/LICENSE
13 |     - Name: Support(Discord)
14 |       Url: https://discord.com/channels/365863063296933888/808419165311467630
15 |     - Name: Bug tracker
16 |       Url: https://github.com/ashpynov/ThemeOptions/issues
17 |     - Name: Ko-fi for Tips
18 |       Url: https://ko-fi.com/ashpynov
19 |     - Name: Boosty for Tips
20 |       Url: https://boosty.to/ashpynov/donate


--------------------------------------------------------------------------------
/Models/MinimalVersion.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.IO;
 3 | using System.Reflection;
 4 | using Playnite.SDK.Data;
 5 | using ThemeOptions.Tools;
 6 | 
 7 | namespace ThemeOptions.Models
 8 | {
 9 |     public class MinimalVersion: Dictionary<string, object>
10 |     {
11 |         static private string GetPluginVersion()
12 |         {
13 |             string pluginManifestFile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Extension.yaml");
14 |             var info = Serialization.FromYamlFile<Dictionary<string, object>>(pluginManifestFile);
15 |             return info["Version"].ToString();
16 |         }
17 |         static public string PluginVersion = GetPluginVersion();
18 | 
19 |         public new object this[string version]
20 |         {
21 |             get => VersionComparer.MinimalVersion(version, PluginVersion);
22 |             set { }
23 |         }
24 |     }
25 | }


--------------------------------------------------------------------------------
/Controls/out_of_order/CommandControl_TriggerActions.cs.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | using Playnite.SDK;
 3 | using System.Linq;
 4 | using System.Reflection;
 5 | using System.Windows;
 6 | using Behaviors = Microsoft.Xaml.Behaviors;
 7 | 
 8 | namespace ThemeOptions.Controls
 9 | {
10 | 
11 |     public partial class CommandControl
12 |     {
13 |         public RelayCommand<object> TriggerActions => new RelayCommand<object>((o) =>
14 |         {
15 |             if (o is Behaviors.TriggerAction[] actions)
16 |             {
17 |                 foreach( var a in actions.ToArray())
18 |                 {
19 |                     a.Attach(FindName("ThemeOptions_Command") as DependencyObject);
20 |                     MethodInfo CallInvokeMethod = a.GetType().GetMethod("Invoke", BindingFlags.NonPublic | BindingFlags.Instance);
21 |                     CallInvokeMethod.Invoke(a, new object[] {a}); // This will call the internal method
22 |                     a.Detach();
23 |                 }
24 |             }
25 |         });
26 |     }
27 | }


--------------------------------------------------------------------------------
/Models/Extensions.cs:
--------------------------------------------------------------------------------
 1 | using Playnite.SDK;
 2 | using Playnite.SDK.Data;
 3 | using System;
 4 | using System.Collections.Generic;
 5 | using System.IO;
 6 | using System.Linq;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | 
10 | namespace ThemeOptions.Models
11 | {
12 |     public class Extensions
13 |     {
14 |         private static readonly ILogger logger = LogManager.GetLogger();
15 |         public List<string> Required { get; set; }
16 |         public List<string> Recommended { get; set; }
17 |         static public Extensions FromFile(string path)
18 |         {
19 |             if (!File.Exists(path)) return null;
20 | 
21 |             try
22 |             {
23 |                 var res = Serialization.FromYamlFile<Extensions>(path);
24 |                 return res;
25 |             }
26 |             catch (Exception e)
27 |             {
28 |                 logger.Error($"Error loading theme option file {path}: \n{e.Message}");
29 |                 return null;
30 |             }
31 |         }
32 | 
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | 
 9 | // Setting ComVisible to false makes the types in this assembly not visible
10 | // to COM components.  If you need to access a type in this assembly from
11 | // COM, set the ComVisible attribute to true on that type.
12 | [assembly: ComVisible(false)]
13 | 
14 | // The following GUID is for the ID of the typelib if this project is exposed to COM
15 | [assembly: Guid("904cbf3b-573f-48f8-9642-0a09d05c64ef")]
16 | 
17 | // Version information for an assembly consists of the following four values:
18 | //
19 | //      Major Version
20 | //      Minor Version
21 | //      Build Number
22 | //      Revision
23 | //
24 | // You can specify all the values or you can default the Build and Revision Numbers
25 | // by using the '*' as shown below:
26 | // [assembly: AssemblyVersion("1.0.*")]
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Artem Shptynov
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Tools/DisplayAspectRatio.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Linq;
 3 | 
 4 | namespace ThemeOptions.Tools
 5 | {
 6 |     public class DisplayAspectRatio
 7 |     {
 8 |         private struct AspectRatio
 9 |         {
10 |             public double Width;
11 |             public double Height;
12 |             public AspectRatio(int width, int height)
13 |             {
14 |                 Width = width;
15 |                 Height = height;
16 |             }
17 | 
18 |             public string Name => $"dsp{Width}{Height}";
19 |             public double Ratio => Width / Height;
20 |         }
21 |         private static readonly AspectRatio[] commonRatios =
22 |         {
23 |             new AspectRatio(4, 3),
24 |             new AspectRatio(16, 9),
25 |             new AspectRatio(16, 10),
26 |             new AspectRatio(21, 9),
27 |             new AspectRatio(19, 10),
28 |             new AspectRatio(32, 9)
29 |         };
30 | 
31 |         public static string GetAspectRatio(double width, double height)
32 |         {
33 |             double ratio = width / height;
34 |             return commonRatios.OrderBy(c => Math.Abs(ratio - c.Ratio)).First().Name;
35 |         }
36 |     }
37 | }


--------------------------------------------------------------------------------
/Tools/VersionComparer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace ThemeOptions.Tools
 4 | {
 5 |     public class VersionComparer
 6 |     {
 7 |         public static int CompareVersions(string version1, string version2)
 8 |         {
 9 |             // Split the version strings into arrays of integers
10 |             var v1 = Array.ConvertAll(version1.Split('.'), int.Parse);
11 |             var v2 = Array.ConvertAll(version2.Split('.'), int.Parse);
12 | 
13 |             // Compare each part of the version
14 |             for (int i = 0; i < Math.Max(v1.Length, v2.Length); i++)
15 |             {
16 |                 int part1 = i < v1.Length ? v1[i] : 0;
17 |                 int part2 = i < v2.Length ? v2[i] : 0;
18 | 
19 |                 if (part1 > part2)
20 |                     return 1; // version1 is greater
21 |                 if (part1 < part2)
22 |                     return -1; // version1 is lower
23 |             }
24 | 
25 |             return 0; // versions are equal
26 |         }
27 | 
28 |         public static bool MinimalVersion(string minVersion, string actualVersion)
29 |         {
30 |             return CompareVersions( minVersion, actualVersion) <= 0;
31 |         }
32 |     }
33 | }


--------------------------------------------------------------------------------
/Controls/out_of_order/CommandControl_SendEvent.cs..txt:
--------------------------------------------------------------------------------
 1 | 
 2 | using Playnite.SDK;
 3 | using System.Windows;
 4 | using System.Windows.Controls;
 5 | 
 6 | namespace ThemeOptions.Controls
 7 | {
 8 | 
 9 |     public partial class CommandControl
10 |     {
11 |         public static readonly RoutedEvent ThemeOptions_CommandEvent = EventManager.RegisterRoutedEvent(
12 |             "ThemeOptions_Command", RoutingStrategy.Direct, typeof(RoutedEventHandler), typeof(CommandControl));
13 | 
14 |         public event RoutedEventHandler ThemeOptions_Command
15 |         {
16 |             add { AddHandler(ThemeOptions_CommandEvent, value); }
17 |             remove { RemoveHandler(ThemeOptions_CommandEvent, value); }
18 |         }
19 | 
20 |         public void RaiseThemeOptions_CommandEvent(Control targetControl)
21 |         {
22 |             RoutedEventArgs newEventArgs = new RoutedEventArgs(ThemeOptions_CommandEvent, targetControl );
23 |             RaiseEvent(newEventArgs);
24 |         }
25 | 
26 |         public RelayCommand<object> SendEvent => new RelayCommand<object>(o =>
27 |         {
28 |             if (((o as Control) ?? FindName(o as string)) is Control control )
29 |             {
30 |                 RaiseThemeOptions_CommandEvent(control);
31 |             }
32 |         });
33 |     }
34 | }


--------------------------------------------------------------------------------
/Controls/CommandControl_BeginStoryboard.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using Playnite.SDK;
 3 | using System.Windows.Media.Animation;
 4 | 
 5 | namespace ThemeOptions.Controls
 6 | {
 7 | 
 8 |     public partial class CommandControl
 9 |     {
10 |          /********************************************************************************************************
11 |           BeginStoryboard Command implementation
12 |          ********************************************************
13 |             @Name: Content.BeginStoryboard
14 |             @Parameter: Storyboard to be triggered
15 | 
16 |             Just trigger Storyboard
17 | 
18 |             xmlns:pin="clr-namespace:Playnite.Input;assembly=Playnite"
19 | 
20 |             ...
21 | 
22 |             <Grid.InputBindings>
23 |                 <pin:GameControllerInputBinding
24 |                     Button="LeftShoulder"
25 |                     Command="{Binding Content.TouchTag, ElementName=ThemeOptions_Command}"
26 |                     CommandParameter="{StaticResource SwipeLeft}"/>
27 |             </Grid.InputBindings>
28 | 
29 |         ********************************************************************************************************/
30 | 
31 | 
32 |         public new RelayCommand<object> BeginStoryboard => new RelayCommand<object>((o) => (o as Storyboard)?.Begin());
33 |     }
34 | }


--------------------------------------------------------------------------------
/Tests/Tools/VersionComparer.cs:
--------------------------------------------------------------------------------
 1 | using ThemeOptions.Tools;
 2 | //using NUnit.Framework;
 3 | using Microsoft.VisualStudio.TestTools.UnitTesting;
 4 | using System;
 5 | using System.Windows;
 6 | using System.Collections.Generic;
 7 | 
 8 | namespace Tests.Tools
 9 | {
10 |     [TestClass]
11 |     public class VersionComparerTest
12 |     {
13 |         [TestMethod]
14 |         [DataRow("0.1", "0.1.0", 0)]
15 |         [DataRow("0.18", "0.1", 1)]
16 |         [DataRow("0.18", "0.19", -1)]
17 |         [DataRow("0.1", "0.1.1", -1)]
18 |         public void VersionCompareTest(string version1, string version2, int expected)
19 |         {
20 |             Assert.AreEqual(expected, VersionComparer.CompareVersions(version1,version2) );
21 |         }
22 | 
23 |         [TestMethod]
24 |         [DataRow("0.16", "0.1.0", false)]
25 |         [DataRow("0.16", "0.1", false)]
26 |         [DataRow("0.16", "0.2", false)]
27 |         [DataRow("0.16", "0.16", true)]
28 |         [DataRow("0.16", "0.16.1", true)]
29 |         [DataRow("0.16.1", "0.16", false)]
30 |         [DataRow("0.16.10", "0.16.1", false)]
31 |         public void MinimumVersionTest(string minVersion, string actualVersion, bool expected)
32 |         {
33 |             Assert.AreEqual(expected, VersionComparer.MinimalVersion(minVersion,actualVersion) );
34 |         }
35 |     }
36 | }


--------------------------------------------------------------------------------
/Converters/VisibilityToBoolean.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace ThemeOptions.Converters
 7 | {
 8 |     public class VisibilityToBooleanConverter : IValueConverter
 9 |     {
10 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
11 |         {
12 |             if (value is Visibility visibility)
13 |             {
14 |                 return visibility == Visibility.Visible;
15 |             }
16 |             else if (value is string visibilityString)
17 |             {
18 |                 return visibilityString.Equals("Visible", StringComparison.OrdinalIgnoreCase);
19 |             }
20 |             return false;
21 |         }
22 | 
23 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
24 |         {
25 |             if (value is bool isVisible)
26 |             {
27 |                 return isVisible ? Visibility.Visible : Visibility.Collapsed;
28 |             }
29 |             else if (value is string boolString)
30 |             {
31 |                 return boolString.Equals("True", StringComparison.OrdinalIgnoreCase) ? Visibility.Visible : Visibility.Collapsed;
32 |             }
33 |             return Visibility.Collapsed;
34 |         }
35 |     }
36 | }


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "logViewer.watch": [
 3 |         "c:\\tools\\playnite\\*.log"
 4 |     ],
 5 |     "dotnetAcquisitionExtension.enableTelemetry": false,
 6 |     "dotnetAcquisitionExtension.enablePreviewFeatures": true,
 7 |     "omnisharp.useModernNet": false,
 8 |     "csharp.inlayHints.enableInlayHintsForImplicitObjectCreation": false,
 9 |     "csharp.inlayHints.enableInlayHintsForImplicitVariableTypes": false,
10 |     "csharp.inlayHints.enableInlayHintsForLambdaParameterTypes": false,
11 |     "csharp.inlayHints.enableInlayHintsForTypes": false,
12 |     "dotnet.inlayHints.enableInlayHintsForIndexerParameters": true,
13 |     "dotnet.inlayHints.enableInlayHintsForLiteralParameters": true,
14 |     "dotnet.inlayHints.enableInlayHintsForObjectCreationParameters": true,
15 |     "dotnet.inlayHints.enableInlayHintsForOtherParameters": true,
16 |     "dotnet.inlayHints.enableInlayHintsForParameters": true,
17 |     "dotnet.inlayHints.suppressInlayHintsForParametersThatDifferOnlyBySuffix": false,
18 |     "csharp.debug.justMyCode": false,
19 |     "csharp.debug.logging.diagnosticsLog.debugEngineAPITracing": "all",
20 |     "csharp.debug.logging.diagnosticsLog.debugRuntimeEventTracing": true,
21 |     "csharp.debug.symbolOptions.searchMicrosoftSymbolServer": false,
22 |     "csharp.debug.symbolOptions.searchNuGetOrgSymbolServer": false,
23 |     "dotnet.typeMembers.propertyGenerationBehavior": "preferAutoProperties",
24 |     "dotnet-test-explorer.testProjectPath": "**/*Tests.csproj"
25 | }


--------------------------------------------------------------------------------
/Models/Preset.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | 
 5 | using Playnite.SDK.Data;
 6 | 
 7 | 
 8 | namespace ThemeOptions.Models
 9 | {
10 |     public class Preset
11 |     {
12 | #pragma warning disable 0649
13 |         public string Id { get; set; }
14 |         public string Name { get; set; }
15 |         public string LocKey { get; set; }
16 |         public string Preview { get; set; }
17 |         public Presets Presets { get; set; }
18 |         public List<string> Files { get; set; }
19 |         public VariablesValues Constants { get; set; }
20 | 
21 |         [DontSerialize]
22 |         public bool NeedRestart { get; set; } = false;
23 | 
24 | #pragma warning restore 0649
25 | 
26 |         [DontSerialize]
27 |         public List<Preset> OptionsList { get
28 |             {
29 |                 var list = Presets.Values.ToList();
30 |                 if (list.FirstOrDefault(p => p.Id.ToLower().EndsWith("default")) == null)
31 |                 {
32 |                     list.Insert(0, new Preset() { Id = "default", Name = "Default" });
33 |                 }
34 |                 return list;
35 |             }
36 |         }
37 | 
38 |         [DontSerialize]
39 | 
40 |         private Preset defaultOption { get => OptionsList.FirstOrDefault(p => p.Id.ToLower().EndsWith("default")); }
41 | 
42 |         private Preset selected;
43 |         public Preset Selected
44 |         {
45 |             get => selected ?? defaultOption;
46 |             set { selected = value; }
47 |         }
48 |     }
49 | }


--------------------------------------------------------------------------------
/ThemeOptions.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.28307.1267
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ThemeOptions", "ThemeOptions.csproj", "{4FDF1E89-5BC3-4C72-8FDA-0D580E7A5D5F}"
 7 | EndProject
 8 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj", "{53367B10-02EE-4A45-8B00-40BE2FD8B09A}"
 9 | EndProject
10 | Global
11 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
12 | 		Debug|Any CPU = Debug|Any CPU
13 | 		Release|Any CPU = Release|Any CPU
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{4FDF1E89-5BC3-4C72-8FDA-0D580E7A5D5F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
17 | 		{4FDF1E89-5BC3-4C72-8FDA-0D580E7A5D5F}.Debug|Any CPU.Build.0 = Debug|Any CPU
18 | 		{4FDF1E89-5BC3-4C72-8FDA-0D580E7A5D5F}.Release|Any CPU.ActiveCfg = Release|Any CPU
19 | 		{4FDF1E89-5BC3-4C72-8FDA-0D580E7A5D5F}.Release|Any CPU.Build.0 = Release|Any CPU
20 | 		{53367B10-02EE-4A45-8B00-40BE2FD8B09A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
21 | 		{53367B10-02EE-4A45-8B00-40BE2FD8B09A}.Debug|Any CPU.Build.0 = Debug|Any CPU
22 | 		{53367B10-02EE-4A45-8B00-40BE2FD8B09A}.Release|Any CPU.ActiveCfg = Release|Any CPU
23 | 		{53367B10-02EE-4A45-8B00-40BE2FD8B09A}.Release|Any CPU.Build.0 = Release|Any CPU
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {620DAE38-0360-4A4F-A05E-7FE07CD0E592}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/Tools/GetFakeModel.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Reflection;
 4 | using System.Threading;
 5 | using System.Windows;
 6 | using System.Windows.Automation;
 7 | 
 8 | namespace ThemeOptions.Tools
 9 | {
10 |     public class FakeWindow
11 |     {
12 |         public static dynamic GetModel(string factoryName, string modelName)
13 |         {
14 | 
15 |             Assembly playnite = Assembly.LoadFrom(Path.Combine( AppDomain.CurrentDomain.BaseDirectory, "playnite.dll"));
16 | 
17 |             Type windowBaseType = playnite.GetType("Playnite.Controls.WindowBase");
18 |             var windowsBase = Activator.CreateInstance(windowBaseType);
19 | 
20 |             Assembly assembly = Application.Current.GetType().Assembly;
21 | 
22 |             Type fakeFactoryType = assembly.GetType(factoryName);
23 |             var fakeFactory = Activator.CreateInstance(fakeFactoryType);
24 | 
25 |             PropertyInfo windowProperty = fakeFactoryType.BaseType.GetProperty("Window", BindingFlags.Public | BindingFlags.Instance);
26 |             windowProperty.GetSetMethod(true).Invoke(fakeFactory, new[] { windowsBase });
27 | 
28 |             PropertyInfo initFinishedEventProperty = fakeFactoryType.BaseType.GetProperty("initFinishedEvent", BindingFlags.NonPublic | BindingFlags.Instance);
29 |             AutoResetEvent initFinishedEvent = initFinishedEventProperty.GetValue(fakeFactory) as AutoResetEvent;
30 | 
31 |             initFinishedEvent.Set();
32 | 
33 |             Type fakeModelType = assembly.GetType(modelName);
34 |             return Activator.CreateInstance(fakeModelType, new[] { fakeFactory,  Application.Current.MainWindow.DataContext});
35 |         }
36 |     }
37 | }


--------------------------------------------------------------------------------
/Models/DynamicProperties.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections;
 2 | using System.Collections.Generic;
 3 | using System.ComponentModel;
 4 | using System.Linq;
 5 | using System.Runtime.InteropServices;
 6 | 
 7 | namespace ThemeOptions.Models
 8 | {
 9 |     public class DynamicProperties : Dictionary<string, object>, INotifyPropertyChanged
10 |     {
11 | 
12 |         public event PropertyChangedEventHandler PropertyChanged;
13 | 
14 |         public DynamicProperties() {}
15 | 
16 |         public new object this[string propertyName]
17 |         {
18 |             get
19 |             {
20 |                 TryGetValue(propertyName, out var value);
21 |                 return value;
22 |             }
23 |             set
24 |             {
25 |                 base[propertyName] = value;
26 |                 OnPropertyChanged(propertyName);
27 |             }
28 |         }
29 | 
30 |         public DynamicProperties Update(VariablesValues variables) => Update(variables.ToDynamicProperties());
31 | 
32 |         public DynamicProperties Update(DynamicProperties properties)
33 |         {
34 |             foreach(var v in properties)
35 |             {
36 |                 if (this[v.Key] != v.Value)
37 |                 {
38 |                     this[v.Key] = v.Value;
39 |                 }
40 |             }
41 | 
42 |             var toRemove = Keys.Where( k => !properties.Keys.Contains(k)).ToList();
43 | 
44 |             foreach (var k in toRemove)
45 |             {
46 |                 Remove(k);
47 |                 OnPropertyChanged(k);
48 |             }
49 | 
50 |             return this;
51 |         }
52 | 
53 |         protected void OnPropertyChanged(string propertyName)
54 |         {
55 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
56 |         }
57 |     }
58 | 
59 | }


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "configurations": [
 3 | 
 4 |         {
 5 |             "name": "Debug Desktop",
 6 |             "type": "clr",
 7 |             "request": "launch",
 8 |             "preLaunchTask": "build debug64",
 9 |             "program": "C:\\Tools\\Playnite\\Playnite.DesktopApp.exe",
10 |             "args": [],
11 |             "cwd": "${workspaceFolder}",
12 |             "stopAtEntry": false,
13 |             "console": "internalConsole",
14 |             "logging": {
15 |                 "programOutput": true,
16 |                 "moduleLoad": false,
17 |                 "processExit": false
18 |             }
19 |         },
20 |         {
21 |             "name": "Debug Fullscreen",
22 |             "type": "clr",
23 |             "request": "launch",
24 |             "preLaunchTask": "build debug64",
25 |             "program": "C:\\Tools\\Playnite\\Playnite.FullscreenApp.exe",
26 |             "args": [],
27 |             "cwd": "${workspaceFolder}",
28 |             "stopAtEntry": false,
29 |             "console": "internalConsole",
30 |             "logging": {
31 |                 "programOutput": true,
32 |                 "moduleLoad": false,
33 |                 "processExit": false
34 |             }
35 |         },
36 |         {
37 |             "name": "MSTest Launch",
38 |             "type": "clr",
39 |             "request": "launch",
40 |             "preLaunchTask": "build tests",
41 |             "program": "C:/Program Files/Microsoft Visual Studio/2022/Community/Common7/IDE/Extensions/TestPlatform/vstest.console.exe",
42 |             "args": [
43 |                 "${workspaceFolder}/Tests/bin/Debug/net4.6.2/Tests.dll"
44 |             ],
45 |             "cwd": "${workspaceFolder}",
46 |             "stopAtEntry": false,
47 |             "console": "internalConsole"
48 |         }
49 | 
50 |     ]
51 | }


--------------------------------------------------------------------------------
/Tests/Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |     <PropertyGroup>
 4 |         <TargetFramework>net4.6.2</TargetFramework>
 5 |         <IsPackable>false</IsPackable>
 6 |         <IsTestProject>true</IsTestProject>
 7 |         <DefineConstants>DEBUG;NET462;TRACE</DefineConstants>
 8 |         <DebugType>portable</DebugType>
 9 |         <PlatformTarget>x64</PlatformTarget>
10 |     </PropertyGroup>
11 |     <!-- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
12 |         <DefineConstants>DEBUG;NET462;TRACE</DefineConstants>
13 |         <DebugType>portable</DebugType>
14 |         <PlatformTarget>x64</PlatformTarget>
15 |     </PropertyGroup>
16 |     <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
17 |         <DebugType>portable</DebugType>
18 |         <PlatformTarget>x86</PlatformTarget>
19 |     </PropertyGroup> -->
20 | 
21 |      <ItemGroup>
22 |         <PackageReference Include="MSTest.TestAdapter" Version="3.7.0" />
23 |         <PackageReference Include="MSTest.TestFramework" Version="3.7.0" />
24 |         <ProjectReference Include="../ThemeOptions.csproj" />
25 |         <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
26 |         <PackageReference Include="coverlet.collector" Version="6.0.0" />
27 |         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
28 |     </ItemGroup>
29 | 
30 |     <!-- <ItemGroup>
31 |         <None Include="Views\FulscreenSettingsViewTemplate.xaml">
32 |             <Generator></Generator>
33 |         </None>
34 |         <Page Remove="bin\Debug\net462\Views\FulscreenSettingsViewTemplate.xaml" />
35 |         <Compile Remove="FulscreenSettingsViewTemplate.xaml" />
36 |     </ItemGroup> -->
37 | 
38 | 
39 | 
40 |     <ItemGroup>
41 |         <Reference Include="Playnite.SDK" />
42 |     </ItemGroup>
43 | 
44 | </Project>


--------------------------------------------------------------------------------
/Controls/CommandControl_Toggle.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using Playnite.SDK;
 3 | using System.Reflection;
 4 | using System.Windows;
 5 | using System.Windows.Data;
 6 | using System.Windows.Input;
 7 | 
 8 | namespace ThemeOptions.Controls
 9 | {
10 |     public partial class CommandControl
11 |     {
12 |         /********************************************************************************************************
13 |           Toggle Command implementation
14 |          ********************************************************
15 |             @Name: Content.Toggle
16 |             @Parameter: FrameworkElement or NameOf on which button press/toggle will be called
17 | 
18 |             Currently it will:
19 |                call specified control command (if command exist)
20 |             or toggle IsChecked of specified control (if command exists)
21 | 
22 |         ********************************************************************************************************/
23 | 
24 |         public RelayCommand<object> Toggle => new RelayCommand<object>(o =>
25 |         {
26 |             if (((o as FrameworkElement) ?? FindName(o as string)) is FrameworkElement control)
27 |             {
28 |                 var type = control.GetType();
29 |                 if (type.GetProperty("Command") is PropertyInfo cp && cp.GetValue(control) is ICommand command )
30 |                 {
31 |                     var parameter = type.GetProperty("Command")?.GetValue(control);
32 |                     if (command.CanExecute(parameter))
33 |                     {
34 |                         command.Execute(parameter);
35 |                     }
36 |                 }
37 |                 else if (type.GetProperty("IsChecked") is PropertyInfo isCheckedProp && isCheckedProp.GetValue(control) is bool isChecked)
38 |                 {
39 |                     isCheckedProp.SetValue(control, !isChecked);
40 |                 }
41 |             }
42 |         });
43 |     }
44 | }


--------------------------------------------------------------------------------
/Converters/DurationToDouble.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows.Data;
 3 | using System.Windows.Markup;
 4 | using System.Globalization;
 5 | using System.Windows;
 6 | 
 7 | namespace ThemeOptions.Converters
 8 | {
 9 |     public class DurationToDouble : MarkupExtension, IValueConverter
10 |     {
11 |         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
12 |         {
13 |             TimeSpan timeSpan;
14 |             if (value is string strValue)
15 |             {
16 |                 timeSpan = TimeSpan.Parse(strValue);
17 |             }
18 |             else if (value is Duration durationValue && durationValue.HasTimeSpan)
19 |             {
20 |                 timeSpan = durationValue.TimeSpan;
21 |             }
22 |             else if (value is TimeSpan tsValue)
23 |             {
24 |                 timeSpan = tsValue;
25 |             }
26 |             else
27 |             {
28 |                 throw new NotSupportedException();
29 |             }
30 |             return timeSpan.TotalSeconds;
31 |         }
32 |         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
33 |         {
34 | 
35 |             double seconds = 0;
36 |             if (value is string strValue)
37 |             {
38 |                 seconds = double.Parse(strValue, CultureInfo.InvariantCulture);
39 |             }
40 |             else if (value is double doubleValue)
41 |             {
42 |                 seconds = doubleValue;
43 |             }
44 |             else
45 |             {
46 |                 throw new NotSupportedException();
47 |             }
48 |             return new Duration(TimeSpan.FromSeconds(seconds));
49 |         }
50 | 
51 |         public override object ProvideValue(IServiceProvider serviceProvider)
52 |         {
53 |             return this;
54 |         }
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/Converters/DurationToString.cs:
--------------------------------------------------------------------------------
 1 | using Playnite.SDK;
 2 | using System;
 3 | using System.Windows.Data;
 4 | using System.Windows.Markup;
 5 | using System.Globalization;
 6 | using System.Windows;
 7 | 
 8 | namespace ThemeOptions.Converters
 9 | {
10 |     public class DurationToString : MarkupExtension, IValueConverter
11 |     {
12 |         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
13 |         {
14 |             TimeSpan timeSpan;
15 |             if (value is Duration durationValue && durationValue.HasTimeSpan)
16 |             {
17 |                 timeSpan = durationValue.TimeSpan;
18 |             }
19 |             else if (value is string strValue)
20 |             {
21 |                 timeSpan = TimeSpan.Parse(strValue);
22 |             }
23 |             else if (value is TimeSpan tsValue)
24 |             {
25 |                 timeSpan = tsValue;
26 |             }
27 |             else
28 |             {
29 |                 throw new NotSupportedException();
30 |             }
31 | 
32 |             int totalHours = (int)timeSpan.TotalHours;
33 |             string hours = totalHours > 0 ? totalHours.ToString() + ":" : "";
34 |             string ms = timeSpan.Milliseconds > 0 ? timeSpan.ToString(@"\.FFFFFF") : "";
35 |             return hours + timeSpan.ToString(@"mm\:ss") + ms;
36 |         }
37 |         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
38 |         {
39 |             if (value is string strValue)
40 |             {
41 |                 return new Duration(TimeSpan.FromSeconds(double.Parse(strValue, CultureInfo.InvariantCulture)));
42 |             }
43 |             else
44 |             {
45 |                 throw new NotSupportedException();
46 |             }
47 | 
48 |         }
49 | 
50 |         public override object ProvideValue(IServiceProvider serviceProvider)
51 |         {
52 |             return this;
53 |         }
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "version": "2.0.0",
 3 |     "tasks": [
 4 |         {
 5 |             "label": "build debug64",
 6 |             "command": "dotnet",
 7 |             "type": "process",
 8 |             "args": [
 9 |                 "build",
10 |                 "${workspaceFolder}/ThemeOptions.csproj",
11 |                 "/property:GenerateFullPaths=true",
12 |                 "/consoleloggerparameters:NoSummary;ForceNoAlign",
13 |                 "-c",
14 |                 "Debug64"
15 |             ],
16 |             "problemMatcher": "$msCompile",
17 |             "group": {
18 |                 "kind": "build",
19 |                 "isDefault": true
20 |             }
21 |         },
22 |         {
23 |             "label": "build tests",
24 |             "command": "dotnet",
25 |             "type": "process",
26 |             "args": [
27 |                 "build",
28 |                 "${workspaceFolder}/Tests/Tests.csproj"
29 |             ],
30 |             "problemMatcher": "$msCompile",
31 | 
32 |         },
33 |         {
34 |             "label": "build release",
35 |             "command": "dotnet",
36 |             "type": "process",
37 |             "args": [
38 |                 "build",
39 |                 "${workspaceFolder}/ThemeOptions.csproj",
40 |                 "/property:GenerateFullPaths=true",
41 |                 "/consoleloggerparameters:NoSummary;ForceNoAlign",
42 |                 "-c",
43 |                 "Release"
44 |             ],
45 |             "problemMatcher": "$msCompile"
46 |         },
47 |         {
48 |             "label": "pack",
49 |             "command": "C:\\Tools\\Playnite\\Toolbox.exe",
50 |             "type": "process",
51 |             "args": [
52 |                 "pack",
53 |                 "${workspaceFolder}\\bin\\Release\\net4.6.2",
54 |                 "${workspaceFolder}\\bin\\Package"
55 |             ],
56 |             "problemMatcher": "$msCompile",
57 |             "dependsOn": [
58 |                 "build release"
59 |             ]
60 |         }
61 |     ]
62 | }


--------------------------------------------------------------------------------
/Tools/DynamicEventHandler.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Reflection;
 4 | using System.Reflection.Emit;
 5 | 
 6 | namespace ThemeOptions.Tools
 7 | {
 8 |     class DynamicEventHandler
 9 |     {
10 |         static public Delegate AddEventHandler(dynamic eventOwner, string eventName, object methodOwner, string methodName)
11 |         {
12 |             EventInfo eventInfo = eventOwner.GetType().GetEvent(eventName);
13 |             Type delegateType = eventInfo.EventHandlerType;
14 |             MethodInfo invokeMethod = delegateType.GetMethod("Invoke");
15 | 
16 |             // Get the parameter types from the Invoke method
17 |             ParameterInfo[] parameters = invokeMethod.GetParameters();
18 |             Type[] parameterTypes = new Type[parameters.Length + 1];
19 |             parameterTypes[0] = methodOwner.GetType();
20 |             for (int i = 1; i < parameters.Length + 1; i++)
21 |             {
22 |                 parameterTypes[i] = parameters[i - 1].ParameterType;
23 |             }
24 | 
25 |             // Create the dynamic method
26 |             DynamicMethod dynamicMethod = new DynamicMethod(
27 |                 $"{eventName}DynamicHandler",
28 |                 null,
29 |                 parameterTypes,
30 |                 typeof(Gamepad).Module,
31 |                 true);
32 | 
33 | 
34 |             // Get an ILGenerator and emit the IL for the dynamic method
35 |             ILGenerator il = dynamicMethod.GetILGenerator();
36 | 
37 |             il.Emit(OpCodes.Ldarg_0);
38 |             il.Emit(OpCodes.Ldarg_1);
39 |             il.Emit(OpCodes.Ldarg_2);
40 |             il.Emit(OpCodes.Call, methodOwner.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic));
41 |             il.Emit(OpCodes.Ret);
42 | 
43 | 
44 |             // Create the delegate
45 |             Delegate handler = dynamicMethod.CreateDelegate(delegateType, methodOwner);
46 | 
47 |             // Add the event handler
48 |             eventInfo.AddEventHandler(eventOwner, handler);
49 |             return handler;
50 |         }
51 |     }
52 | }


--------------------------------------------------------------------------------
/Controls/CommandControl.xaml.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using System;
 3 | using System.ComponentModel;
 4 | using System.Runtime.CompilerServices;
 5 | using System.Windows;
 6 | using Playnite.SDK;
 7 | using Playnite.SDK.Controls;
 8 | using ThemeOptions.Models;
 9 | 
10 | namespace ThemeOptions.Controls
11 | {
12 |     public partial class CommandControl : PluginUserControl, INotifyPropertyChanged
13 |     {
14 |         private static readonly ILogger Logger = LogManager.GetLogger();
15 | 
16 |         public CommandControl()
17 |         {
18 |             Application.Current.Deactivated += OnApplicationDeactivate;
19 |             Application.Current.Activated += OnApplicationActivate;
20 |             if (ThemeOptions.PlayniteAPI.ApplicationInfo.Mode == ApplicationMode.Fullscreen)
21 |             {
22 |                 ThemeOptions.PlayniteAPI.Dialogs.GetCurrentAppWindow().SizeChanged += (o, e) =>
23 |                 {
24 |                     ThemeOptions.Settings.UpdateAspectRatio();
25 |                 };
26 |             }
27 |         }
28 | 
29 |         private void OnApplicationDeactivate(object sender, EventArgs e)
30 |         {
31 |             IsActive = false;
32 |         }
33 | 
34 |         private void OnApplicationActivate(object sender, EventArgs e)
35 |         {
36 |             IsActive = true;
37 |         }
38 | 
39 |         private bool isActive = true;
40 |         public bool IsActive
41 |         {
42 |             get => isActive;
43 |             set => SetValue(ref isActive, value);
44 |         }
45 | 
46 |         public DynamicProperties Options { get => ThemeOptions.Settings.Settings.Options; }
47 |         public event PropertyChangedEventHandler PropertyChanged;
48 | 
49 |         private void OnPropertyChanged([CallerMemberName] string propertyName = null)
50 |         {
51 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
52 |         }
53 |         protected void SetValue<T>(ref T property, T value, [CallerMemberName] string propertyName = null)
54 |         {
55 |             property = value;
56 |             OnPropertyChanged(propertyName);
57 |         }
58 |     }
59 | }


--------------------------------------------------------------------------------
/ThemeOptions.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |     <PropertyGroup>
 3 |         <OutputType>Library</OutputType>
 4 |         <TargetFramework>net4.6.2</TargetFramework>
 5 |         <UseWPF>true</UseWPF>
 6 |     </PropertyGroup>
 7 |         <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug64|AnyCPU'">
 8 |         <DefineConstants>DEBUG;NET462;TRACE</DefineConstants>
 9 |         <DebugType>portable</DebugType>
10 |         <PlatformTarget>x64</PlatformTarget>
11 |     </PropertyGroup>
12 |     <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
13 |         <DefineConstants>DEBUG;NET462;TRACE</DefineConstants>
14 |         <DebugType>portable</DebugType>
15 |         <PlatformTarget>x86</PlatformTarget>
16 |     </PropertyGroup>
17 |     <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
18 |         <DebugType>portable</DebugType>
19 |         <PlatformTarget>x86</PlatformTarget>
20 |     </PropertyGroup>
21 |     <ItemGroup>
22 |         <ApplicationDefinition Remove="App.xaml" />
23 |     </ItemGroup>
24 |     <ItemGroup>
25 |         <PackageReference Include="PlayniteSDK" Version="6.12.0" />
26 |         <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
27 |         <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.3" />
28 |     </ItemGroup>
29 |     <ItemGroup>
30 |         <None Include="extension.yaml">
31 |             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
32 |         </None>
33 |         <None Include="packages.config" />
34 |     </ItemGroup>
35 |     <ItemGroup>
36 |         <None Include="Localization/*.*">
37 |             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
38 |         </None>
39 |     </ItemGroup>
40 | 
41 |     <ItemGroup>
42 |         <Compile Remove="Tests\**" />
43 |         <None Remove="Tests\**" />
44 |         <Page Remove="Tests\**" />
45 |     </ItemGroup>
46 | 
47 |     <ItemGroup>
48 |         <None Include="icon.png">
49 |             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
50 |         </None>
51 |     </ItemGroup>
52 | 
53 |     <ItemGroup>
54 |         <Resource Include="Views\FullscreenSettingsView.xaml" />
55 |     </ItemGroup>
56 | 
57 | </Project>


--------------------------------------------------------------------------------
/Localization.cs:
--------------------------------------------------------------------------------
 1 | using Playnite.SDK;
 2 | using System;
 3 | using System.IO;
 4 | using System.Windows;
 5 | using System.Windows.Markup;
 6 | 
 7 | namespace ThemeOptions
 8 | {
 9 | 
10 |     //based on code from lacro59 from
11 |     //https://github.com/Lacro59/playnite-plugincommon/blob/master/Localization.cs
12 |     //
13 |     public class Localization
14 |     {
15 |         private static readonly ILogger Logger = LogManager.GetLogger();
16 | 
17 |         public static void Load(string folder, string language = "en_US")
18 |         {
19 |             var dictionaries = Application.Current.Resources.MergedDictionaries;
20 | 
21 |             ResourceDictionary res = LoadDictionary(folder, language);
22 |             if (res != null)
23 |             {
24 |                 dictionaries.Add(res);
25 |             }
26 |         }
27 | 
28 |         public static ResourceDictionary LoadDictionary(string folder, string language = "en_US")
29 |         {
30 |             var langFile = Path.Combine(folder, "Localization", language + ".xaml");
31 | 
32 |             // Load localization
33 |             if (File.Exists(langFile))
34 |             {
35 |                 ResourceDictionary res;
36 |                 try
37 |                 {
38 |                     using (var stream = new StreamReader(langFile))
39 |                     {
40 |                         res = (ResourceDictionary)XamlReader.Load(stream.BaseStream);
41 |                         res.Source = new Uri(langFile, UriKind.Absolute);
42 |                     }
43 | 
44 |                     foreach (var key in res.Keys)
45 |                     {
46 |                         if (res[key] is string locString && string.IsNullOrEmpty(locString))
47 |                         {
48 |                             res.Remove(key);
49 |                         }
50 |                     }
51 |                     return res;
52 |                 }
53 |                 catch (Exception ex)
54 |                 {
55 |                     Logger.Error(ex, $"Failed to parse localization file {langFile}.");
56 |                 }
57 |             }
58 |             else
59 |             {
60 |                 Logger.Warn($"File {langFile} not found.");
61 |             }
62 | 
63 |             return null;
64 |         }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/Models/Options.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Collections.Generic;
 4 | using Playnite.SDK;
 5 | using Playnite.SDK.Data;
 6 | using System.Windows;
 7 | 
 8 | 
 9 | namespace ThemeOptions.Models
10 | {
11 |     public class DictNoCase<TValue> : Dictionary<string, TValue>
12 |     {
13 |         public DictNoCase() : base(StringComparer.OrdinalIgnoreCase) { }
14 |     }
15 | 
16 |     public class Options
17 |     {
18 |         public Presets Presets { get; set; }
19 |         public Variables Variables { get; set; }
20 | 
21 |         private static readonly ILogger logger = LogManager.GetLogger();
22 |         static public Options FromFile(string path)
23 |         {
24 |             if (!File.Exists(path)) return null;
25 | 
26 |             try
27 |             {
28 |                 var res = Serialization.FromYamlFile<Options>(path);
29 |                 res?.Presets?.PostLoad(Path.GetDirectoryName(path));
30 |                 return res;
31 |             }
32 |             catch (Exception e)
33 |             {
34 |                 logger.Error($"Error loading theme option file {path}: \n{e.Message}");
35 |                 return null;
36 |             }
37 |         }
38 |         public void Translate(string themePath, string language)
39 |         {
40 |             ResourceDictionary locale = language != "en_US" ? Localization.LoadDictionary(themePath, language) : null;
41 |             if (locale == null) return;
42 |             if (Variables?.Count > 0)
43 |             {
44 |                 foreach (var v in Variables)
45 |                 {
46 |                     if (v.Value.LocKey != null && locale.Contains(v.Value.LocKey) )
47 |                     {
48 |                         v.Value.Title = locale[v.Value.LocKey] as string;
49 |                     }
50 |                 }
51 |             }
52 |             if (Presets?.Count > 0)
53 |             {
54 |                 Presets.Enumerate().ForEach(p => {
55 |                     if (p.Value.LocKey != null && locale.Contains(p.Value.LocKey))
56 |                     {
57 |                         p.Value.Name = locale[p.Value.LocKey] as string;
58 |                     }
59 |                 });
60 |             }
61 |         }
62 |     }
63 | }


--------------------------------------------------------------------------------
/Models/GamepadState.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.ComponentModel;
 3 | using ThemeOptions.Tools;
 4 | 
 5 | namespace ThemeOptions.Models
 6 | {
 7 |     public class GamepadState: Dictionary<string, bool>, INotifyPropertyChanged
 8 |     {
 9 |         Gamepad _gamepad;
10 | 
11 |         private bool IsPressed(string button)
12 |         {
13 |             if (_gamepad == null)
14 |             {
15 |                 _gamepad = new Gamepad();
16 |                 Gamepad.ButtonChanged += (o, e) => OnPropertyChanged(e.ToString());
17 |             }
18 |             return _gamepad.IsPressed(button);
19 |         }
20 | 
21 |         public GamepadState()
22 |         {
23 |         }
24 |         public event PropertyChangedEventHandler PropertyChanged;
25 | 
26 |         protected void OnPropertyChanged(string propertyName)
27 |         {
28 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
29 |         }
30 | 
31 |         public bool Start { get => IsPressed("Start"); }
32 |         public bool Menu { get => IsPressed("Start"); }
33 |         public bool Back { get => IsPressed("Back"); }
34 |         public bool View { get => IsPressed("Back"); }
35 |         public bool LeftStick { get => IsPressed("LeftStick"); }
36 |         public bool RightStick { get => IsPressed("RightStick"); }
37 |         public bool LeftShoulder { get => IsPressed("LeftShoulder"); }
38 |         public bool RightShoulder { get => IsPressed("RightShoulder"); }
39 |         public bool Guide { get => IsPressed("Guide"); }
40 |         public bool A { get => IsPressed("A"); }
41 |         public bool B { get => IsPressed("B"); }
42 |         public bool X { get => IsPressed("X"); }
43 |         public bool Y { get => IsPressed("Y"); }
44 |         public bool DPadLeft { get => IsPressed("DPadLeft"); }
45 |         public bool DPadRight { get => IsPressed("DPadRight"); }
46 |         public bool DPadUp { get => IsPressed("DPadUp"); }
47 |         public bool DPadDown { get => IsPressed("DPadDown"); }
48 |         public bool TriggerLeft { get => IsPressed("TriggerLeft"); }
49 |         public bool TriggerRight { get => IsPressed("TriggerRight"); }
50 |         public bool LeftStickLeft { get => IsPressed("LeftStickLeft"); }
51 |         public bool LeftStickRight { get => IsPressed("LeftStickRight"); }
52 |         public bool LeftStickUp { get => IsPressed("LeftStickUp"); }
53 |         public bool LeftStickDown { get => IsPressed("LeftStickDown"); }
54 |         public bool RightStickLeft { get => IsPressed("RightStickLeft"); }
55 |         public bool RightStickRight { get => IsPressed("RightStickRight"); }
56 |         public bool RightStickUp { get => IsPressed("RightStickUp"); }
57 |         public bool RightStickDown { get => IsPressed("RightStickDown"); }
58 |     }
59 | }


--------------------------------------------------------------------------------
/Controls/CommandControl_MainMenuCommands.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using Playnite.SDK;
 3 | using System;
 4 | using System.IO;
 5 | using System.Reflection;
 6 | using System.Threading;
 7 | using System.Windows;
 8 | using System.Windows.Media.Animation;
 9 | using ThemeOptions.Tools;
10 | 
11 | namespace ThemeOptions.Controls
12 | {
13 | 
14 |     public partial class CommandControl
15 |     {
16 | 
17 |         public class MainMenuCommands
18 |         {
19 |             const string MainMenuWindowFactory = "Playnite.FullscreenApp.Windows.MainMenuWindowFactory";
20 |             const string MainMenuModel = "Playnite.FullscreenApp.ViewModels.MainMenuViewModel";
21 | 
22 |             dynamic FakeModel() => FakeWindow.GetModel( MainMenuWindowFactory, MainMenuModel);
23 |             public RelayCommand CloseCommand => new RelayCommand(() => FakeModel().CloseCommand.Execute());
24 |             public RelayCommand ExitCommand => new RelayCommand(() => FakeModel().ExitCommand.Execute());
25 |             public RelayCommand SwitchToDesktopCommand => new RelayCommand(() => FakeModel().SwitchToDesktopCommand.Execute());
26 |             public RelayCommand OpenSettingsCommand => new RelayCommand(() => FakeModel().OpenSettingsCommand.Execute());
27 |             public RelayCommand SelectRandomGameCommand => new RelayCommand(() => FakeModel().SelectRandomGameCommand.Execute());
28 |             public RelayCommand OpenPatreonCommand => new RelayCommand(() => FakeModel().OpenPatreonCommand.Execute());
29 |             public RelayCommand OpenKofiCommand => new RelayCommand(() => FakeModel().OpenKofiCommand.Execute());
30 |             public RelayCommand ShutdownSystemCommand => new RelayCommand(() => FakeModel().ShutdownSystemCommand.Execute());
31 |             public RelayCommand HibernateSystemCommand => new RelayCommand(() => FakeModel().HibernateSystemCommand.Execute());
32 |             public RelayCommand SleepSystemCommand => new RelayCommand(() => FakeModel().SleepSystemCommand.Execute());
33 |             public RelayCommand RestartSystemCommand => new RelayCommand(() => FakeModel().RestartSystemCommand.Execute());
34 |             public RelayCommand LockSystemCommand => new RelayCommand(() => FakeModel().LockSystemCommand.Execute());
35 |             public RelayCommand LogoutUserCommand => new RelayCommand(() => FakeModel().LogoutUserCommand.Execute());
36 |             public RelayCommand OpenClientsCommand => new RelayCommand(() => FakeModel().OpenClientsCommand.Execute());
37 |             public RelayCommand OpenToolsCommand => new RelayCommand(() => FakeModel().OpenToolsCommand.Execute());
38 |             public RelayCommand OpenExtensionsCommand => new RelayCommand(() => FakeModel().OpenExtensionsCommand.Execute());
39 |             public RelayCommand UpdateGamesCommand => new RelayCommand(() => FakeModel().UpdateGamesCommand.Execute());
40 |             public RelayCommand CancelProgressCommand => new RelayCommand(() => FakeModel().CancelProgressCommand.Execute());
41 |             public RelayCommand OpenHelpCommand => new RelayCommand(() => FakeModel().OpenHelpCommand.Execute());
42 |             public RelayCommand MinimizeCommand => new RelayCommand(() => FakeModel().MinimizeCommand.Execute());
43 |         }
44 |         public MainMenuCommands MainMenu { get; } = new MainMenuCommands();
45 | 
46 |     }
47 | }


--------------------------------------------------------------------------------
/Views/Common.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Windows;
 3 | using System.Windows.Controls;
 4 | 
 5 | using Playnite.SDK;
 6 | 
 7 | using ThemeOptions.Models;
 8 | 
 9 | namespace ThemeOptions.Views
10 | {
11 | 
12 |     public class VariablePanelItemsDataTemplateSelector : DataTemplateSelector
13 |     {
14 |         public override DataTemplate
15 |             SelectTemplate(object item, DependencyObject container)
16 |         {
17 |             FrameworkElement element = container as FrameworkElement;
18 | 
19 |             if (element != null && item != null && item is Variable && (item as Variable).Type != null )
20 |             {
21 |                 try
22 |                 {
23 |                     var variable = item as Variable;
24 |                     var type = variable.Type.ToUpper();
25 |                     if (new List<string>{ "DOUBLE", "INT32","CORNERRADIUS" }.Contains(type) && variable.Slider != null)
26 |                     {
27 |                         return element.FindResource("SLIDER_PanelTemplate") as DataTemplate;
28 |                     }
29 |                     else if (new List<string>{ "DURATION", "TIMESPAN" }.Contains(type) && variable.Slider != null)
30 |                     {
31 |                         return element.FindResource("DURATION_PanelTemplate") as DataTemplate;
32 |                     }
33 |                     else
34 |                     {
35 |                         return element.FindResource(type + "_PanelTemplate") as DataTemplate;
36 |                     }
37 |                 }
38 |                 catch
39 |                 {
40 |                     return null;
41 |                 }
42 |             }
43 |             else if (element != null && item != null && item is Preset)
44 |             {
45 |                 return element.FindResource("PRESET_PanelTemplate") as DataTemplate;
46 |             }
47 | 
48 |             return null;
49 |         }
50 |     }
51 |     public static class FocusHelper
52 |     {
53 |         public static readonly DependencyProperty IsFocusedProperty =
54 |             DependencyProperty.RegisterAttached("IsFocused", typeof(bool), typeof(FocusHelper), new UIPropertyMetadata(false, OnIsFocusedPropertyChanged));
55 | 
56 |         public static bool GetIsFocused(DependencyObject obj)
57 |         {
58 |             return (bool)obj.GetValue(IsFocusedProperty);
59 |         }
60 | 
61 |         public static void SetIsFocused(DependencyObject obj, bool value)
62 |         {
63 |             obj.SetValue(IsFocusedProperty, value);
64 |         }
65 | 
66 |         private static void OnIsFocusedPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
67 |         {
68 |             var preset = (d as ComboBoxItem).DataContext as Preset;
69 |             ThemeOptions.Settings.UpdatePreview(preset?.Preview, (bool)e.NewValue);
70 |         }
71 |     }
72 |     public class Commands
73 |     {
74 |         public static RelayCommand<object> ResetToDefault { get; } = new RelayCommand<object>((sender) =>
75 |         {
76 |             Variable v = sender as Variable;
77 |             v.Value = v.Default;
78 |         });
79 | 
80 |         public static RelayCommand<object> TextInputCommand { get; } = new RelayCommand<object>((sender) => FullscreenSettingsView.TextInput(sender as Variable));
81 |     }
82 | }


--------------------------------------------------------------------------------
/Models/Variable.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.ComponentModel;
  3 | using System.Runtime.CompilerServices;
  4 | using System.Globalization;
  5 | using System.Runtime.InteropServices;
  6 | using System.Security.Cryptography.X509Certificates;
  7 | using System.Windows.Automation;
  8 | using Playnite.SDK.Data;
  9 | using System.Windows;
 10 | using System.Windows.Controls;
 11 | 
 12 | namespace ThemeOptions.Models
 13 | {
 14 |     public class VariableValue: INotifyPropertyChanged
 15 |     {
 16 |         public event PropertyChangedEventHandler PropertyChanged;
 17 | 
 18 |         private string _value;
 19 | 
 20 |         public string Type { get; set; }
 21 |         public string Value { get => _value;
 22 |         set
 23 |         {
 24 |             _value = value;
 25 |             OnPropertyChanged();
 26 |         }}
 27 |         protected void OnPropertyChanged([CallerMemberName] string name = null)
 28 |         {
 29 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
 30 |         }
 31 |     }
 32 | 
 33 |     public class Slider
 34 |     {
 35 | 
 36 |         static private double ToDouble(string str) =>  str.Contains(":") ? TimeSpan.Parse(str).TotalSeconds : double.Parse(str, CultureInfo.InvariantCulture);
 37 |         static private string ToStr(double val) => val.ToString(CultureInfo.InvariantCulture);
 38 | 
 39 |         private double min;
 40 |         public string Min { get => ToStr(min); set { min = ToDouble(value); } }
 41 | 
 42 |         private double max;
 43 |         public string Max { get => ToStr(max); set { max = ToDouble(value); } }
 44 | 
 45 |         private double step;
 46 |         public string Step { get => ToStr(step); set { step = ToDouble(value); } }
 47 | 
 48 |         private double small;
 49 |         public string SmallChange { get => ToStr(small!= 0 ? small : step); set {  small = ToDouble(value); } }
 50 | 
 51 |         private double large;
 52 |         public string LargeChange
 53 |         {
 54 |             get
 55 |             {
 56 |                 if (large != 0) return ToStr(large);
 57 |                 var count = (max - min) / step;
 58 |                 var scale = (int)(count / 10) + (count%10 > 0 ? 1 : 0);
 59 |                 return ToStr(step * scale);
 60 |             }
 61 |             set
 62 |             {
 63 |                 large = ToDouble(value);
 64 |             }
 65 |         }
 66 |     }
 67 | 
 68 |     public class Variable : VariableValue
 69 |     {
 70 |         public new string Value { get => base.Value ?? Default; set => base.Value = value; }
 71 | 
 72 |         [DontSerialize]
 73 |         public string Title { get; set; }
 74 |         [DontSerialize]
 75 |         public string LocKey { get; set; }
 76 |         [DontSerialize]
 77 |         public string Default { get; set; }
 78 |         [DontSerialize]
 79 |         public string Description { get; set; }
 80 |         [DontSerialize]
 81 |         public string Preview{ get; set; }
 82 |         [DontSerialize]
 83 |         public Slider Slider { get; set; }
 84 | 
 85 |         [DontSerialize]
 86 |         public string TitleStyle { get; set; }
 87 | 
 88 |         [DontSerialize]
 89 |         public string Style { get; set; }
 90 | 
 91 |         [DontSerialize]
 92 |         public Style TextBlockStyle { get => Application.Current.FindResource(TitleStyle ?? "SettingsSectionText") as Style; }
 93 | 
 94 |         [DontSerialize]
 95 |         public Style DockPanelStyle { get => Style != null ? Application.Current.FindResource(Style) as Style : null ?? new Style(typeof(DockPanel)); }
 96 | 
 97 |         [DontSerialize]
 98 |         public bool NeedRestart { get; set; } = false;
 99 |     }
100 | }


--------------------------------------------------------------------------------
/Controls/CommandControl_TouchTag.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using Playnite.SDK;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace ThemeOptions.Controls
 7 | {
 8 |     public partial class CommandControl
 9 |     {
10 |         /********************************************************************************************************
11 |           TouchTag Command implementation
12 |          ********************************************************
13 |             @Name: Content.TouchTag
14 |             @Parameter: FrameworkElement or NameOf on which TargetUpdated will be called
15 | 
16 |             To use it  - you have refer to object with 'Tag' field binded to something and NotifyOnTargetUpdated=true
17 |             If it does not - Tag field binding will be created or update
18 |             During triggering - value of tag is not chaned
19 | 
20 |             Latter you may handle TargetUpdated Event using Behaviors:
21 | 
22 |             xmlns:pin="clr-namespace:Playnite.Input;assembly=Playnite"
23 |             xmlns:Behaviors="clr-namespace:Microsoft.Xaml.Behaviors;assembly=Microsoft.Xaml.Behaviors"
24 |             xmlns:BehaviorsCore="clr-namespace:Microsoft.Xaml.Behaviors.Core;assembly=Microsoft.Xaml.Behaviors"
25 |             xmlns:BehaviorsMedia="clr-namespace:Microsoft.Xaml.Behaviors.Media;assembly=Microsoft.Xaml.Behaviors"
26 | 
27 |             ...
28 | 
29 |             <Grid.InputBindings>
30 |                 <pin:GameControllerInputBinding
31 |                     Button="LeftShoulder"
32 |                     Command="{Binding Content.TouchTag, ElementName=ThemeOptions_Command}"
33 |                     CommandParameter="{Binding ElementName=FILTER_Left}"/>
34 |             </Grid.InputBindings>
35 | 
36 |             ...
37 | 
38 |             <ContentControl x:Name="FILTER_Left" Visibility="Collapsed">
39 |                 <Behaviors:Interaction.Triggers>
40 |                     <Behaviors:EventTrigger EventName="TargetUpdated" >
41 |                         <BehaviorsCore:ChangePropertyAction
42 |                             TargetObject="{Binding ElementName=FILTER_PreviousName}"
43 |                             PropertyName="Text" Value="{Binding ActiveFilterPreset.Name}"
44 |                         />
45 |                         <BehaviorsMedia:ControlStoryboardAction
46 |                             Storyboard="{StaticResource SwipeLeft}"
47 |                             ControlStoryboardOption="Play"
48 |                         />
49 |                         <Behaviors:InvokeCommandAction Command="{Binding PrevFilterViewCommand}" />
50 |                     </Behaviors:EventTrigger>
51 |                 </Behaviors:Interaction.Triggers>
52 |             </ContentControl>
53 | 
54 | 
55 |         ********************************************************************************************************/
56 | 
57 |         public RelayCommand<object> TouchTag => new RelayCommand<object>(o =>
58 |         {
59 |             if (((o as FrameworkElement) ?? FindName(o as string)) is FrameworkElement obj)
60 |             {
61 | 
62 |                 BindingExpression bindingExpression = BindingOperations.GetBindingExpression(obj, TagProperty);
63 | 
64 |                 if (bindingExpression == null )
65 |                 {
66 |                     Binding binding = new Binding()
67 |                     {
68 |                         NotifyOnTargetUpdated = true
69 |                     };
70 |                     bindingExpression = BindingOperations.SetBinding(obj, TagProperty, binding) as BindingExpression;
71 |                 }
72 |                 else if (bindingExpression.ParentBinding.NotifyOnTargetUpdated == false)
73 |                 {
74 |                     bindingExpression.ParentBinding.NotifyOnTargetUpdated = true;
75 |                 }
76 |                 bindingExpression.UpdateTarget();
77 |             }
78 |         });
79 |     }
80 | }


--------------------------------------------------------------------------------
/Models/Theme.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Collections.Generic;
  4 | 
  5 | using System.Linq;
  6 | 
  7 | using Playnite.SDK;
  8 | using Playnite.SDK.Data;
  9 | 
 10 | namespace ThemeOptions.Models
 11 | {
 12 |     public class Theme
 13 |     {
 14 |         public string Id { get; set; }
 15 |         public string Name { get; set; }
 16 |         public string Path { get; set; }
 17 |         public Options Options { get; set; }
 18 | 
 19 |         public Extensions Extensions { get; set; }
 20 | 
 21 |         public List<Preset> PresetList { get => Options.Presets?.Values.ToList() ?? new List<Preset>(); }
 22 |         public List<Variable> VariablesList { get => Options.Variables?.Values.ToList() ?? new List<Variable>(); }
 23 |         public IEnumerable<object> SettingsList
 24 |         {
 25 |             get => PresetList.Cast<object>().Concat(VariablesList.Cast<object>()).ToList();
 26 |         }
 27 | 
 28 |         private static readonly ILogger logger = LogManager.GetLogger();
 29 |         public static Theme FromFile(string path)
 30 |         {
 31 |             if (path == null)
 32 |             {
 33 |                 return null;
 34 |             }
 35 | 
 36 |             path = path.EndsWith("theme.yaml") ? path : System.IO.Path.Combine(path, "theme.yaml");
 37 | 
 38 |             if (!File.Exists(path))
 39 |             {
 40 |                 return null;
 41 |             }
 42 | 
 43 |             try
 44 |             {
 45 |                 var theme = Serialization.FromYamlFile<Theme>(path);
 46 |                 theme.Path =  System.IO.Path.GetDirectoryName(path);
 47 |                 theme.Options = Options.FromFile(System.IO.Path.Combine(theme.Path, "options.yaml"));
 48 |                 theme.Extensions = Extensions.FromFile(System.IO.Path.Combine(theme.Path, "extensions.yaml"));
 49 |                 return theme;
 50 |             }
 51 |             catch (Exception e)
 52 |             {
 53 |                 logger.Error($"Error loading theme {path}: \n{e.Message}");
 54 |                 return null;
 55 |             }
 56 |         }
 57 |         public static Theme FromId(string id)
 58 |         {
 59 |             return FromFile(GetThemePath(id));
 60 |         }
 61 | 
 62 |         private static string GetThemePath(string id)
 63 |         {
 64 |             var theme = FindTheme(id);
 65 |             return theme?.Path;
 66 |         }
 67 |         public static IEnumerable<Theme> EnumThemes()
 68 |         {
 69 |             var themesRoot = new List<string>();
 70 |             if (!ThemeOptions.PlayniteAPI.ApplicationInfo.IsPortable)
 71 |             {
 72 |                 themesRoot.Add(ThemeOptions.PlayniteAPI.Paths.ConfigurationPath);
 73 |             }
 74 | 
 75 |             themesRoot.AddMissing(ThemeOptions.PlayniteAPI.Paths.ApplicationPath);
 76 | 
 77 |             var modes = new List<string> { "Fullscreen", "Desktop" };
 78 | 
 79 |             foreach (var root in themesRoot)
 80 |             {
 81 |                 foreach (var mode in modes)
 82 |                 {
 83 |                     var themesFolder = System.IO.Path.Combine(root, "Themes", mode);
 84 |                     if (Directory.Exists(themesFolder))
 85 |                     {
 86 |                         foreach (var themePath in Directory.EnumerateDirectories(themesFolder))
 87 |                         {
 88 |                             Theme theme = Theme.FromFile(System.IO.Path.Combine(themePath, "theme.yaml"));
 89 |                             if (theme != null && theme.Options != null) yield return theme;
 90 |                         }
 91 |                     }
 92 |                 }
 93 |             }
 94 |         }
 95 |         private static Theme FindTheme(string themeId) => EnumThemes().FirstOrDefault(theme => theme.Id == themeId);
 96 | 
 97 |         public void TranslateOptions()
 98 |         {
 99 |             Options?.Translate(Path, ThemeOptions.PlayniteAPI.ApplicationSettings.Language);
100 |         }
101 |     }
102 | }


--------------------------------------------------------------------------------
/Controls/CommandControl_ChangeProperty.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | using Playnite.SDK;
 3 | using System;
 4 | using System.ComponentModel;
 5 | using System.Reflection;
 6 | using System.Text.RegularExpressions;
 7 | using System.Windows;
 8 | 
 9 | namespace ThemeOptions.Controls
10 | {
11 | 
12 |     public partial class CommandControl
13 |     {
14 |          /********************************************************************************************************
15 |           ChangeProperty Command implementation
16 | 
17 |           CommandParameter: [Setter ElementName=element_x_name, Property=property_name, Value=value]
18 | 
19 |          ********************************************************/
20 | 
21 |         public RelayCommand<object> ChangeProperty => new RelayCommand<object>((o) => ChangePropertyCommand(o));
22 |         public class CustomSetter
23 |         {
24 |             static public bool TryParse(string value, out CustomSetter result)
25 |             {
26 |                 result = null;
27 |                 if (string.IsNullOrEmpty(value))
28 |                 {
29 |                     return false;
30 |                 }
31 | 
32 |                 var regex = new Regex(@"\[\s*(?<CommandName>\w+)(?:\s+ElementName\s*=\s*(?<ElementName>\w+))?(?:,\s*Property\s*=\s*(?<Property>\w+))?(?:,\s*Value\s*=\s*(?<Value>\w+))?\s*\]");
33 |                 var match = regex.Match(value);
34 |                 if (match.Success && match.Groups["CommandName"].Value == "Setter")
35 |                 {
36 |                     result = new CustomSetter(
37 |                         match.Groups["ElementName"].Value,
38 |                         match.Groups["Property"].Value,
39 |                         match.Groups["Value"].Value
40 |                     );
41 |                     return true;
42 |                 }
43 |                 return false;
44 |             }
45 |             public string ElementName;
46 |             public string Property;
47 |             public string Value;
48 | 
49 |             public CustomSetter(string elementName, string property, string value)
50 |             {
51 |                 ElementName = elementName;
52 |                 Property = property;
53 |                 Value = value;
54 |             }
55 |         }
56 | 
57 |         void ChangePropertyCommand(object o)
58 |         {
59 |             if (CustomSetter.TryParse(o as string, out CustomSetter setter))
60 |             {
61 |                 if (FindName(setter.ElementName) is DependencyObject element)
62 |                 {
63 |                     if (element.GetType().GetProperty(setter.Property, BindingFlags.Public | BindingFlags.Instance) is PropertyInfo property)
64 |                     {
65 |                         try
66 |                         {
67 |                             var converter = TypeDescriptor.GetConverter(property.PropertyType);
68 |                             if (converter != null && converter.CanConvertFrom(typeof(string)))
69 |                             {
70 |                                 property.SetValue(element, converter.ConvertFromString(setter.Value));
71 |                             }
72 |                             else
73 |                             {
74 |                                 Logger.Error($"Cant convert Element {setter.ElementName} {setter.Property} from string");
75 |                             }
76 |                         }
77 |                         catch (Exception e)
78 |                         {
79 |                             Logger.Error($"Cant set Element {setter.ElementName} {setter.Property} property: {e.InnerException?.Message ?? e.Message}");
80 |                         }
81 |                     }
82 |                     else
83 |                     {
84 |                         Logger.Error($"Element {setter.ElementName} has no {setter.Property} property");
85 |                     }
86 |                 }
87 |                 else
88 |                 {
89 |                     Logger.Error($"Cant find Element with name {setter.ElementName}");
90 |                 }
91 |             }
92 |             else
93 |             {
94 |                 Logger.Error($"ChangeProperty CommandParameter should match format: [Setter ElementName=element_x_name, Property=property_name, Value=value]");
95 |             }
96 |         }
97 | 
98 |     }
99 | }


--------------------------------------------------------------------------------
/Models/Presets.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Collections.Generic;
  4 | 
  5 | 
  6 | 
  7 | namespace ThemeOptions.Models
  8 | {
  9 |     using PresetPair = KeyValuePair<string, Preset>;
 10 |     public class Presets : DictNoCase<Preset>
 11 |     {
 12 |         /*  Gets end suboption node by dot delemeted path  */
 13 |         public Preset GetItem(string path, Func<Preset, bool> callback = null)
 14 |         {
 15 |             if (string.IsNullOrEmpty(path)) return null;
 16 |             Presets suboptions = this;
 17 |             Preset option = null;
 18 |             foreach (var p in path.Split('.'))
 19 |             {
 20 |                 option = suboptions?.Get(p);
 21 |                 suboptions = option?.Presets;
 22 |                 if (option == null || callback?.Invoke(option) == false)
 23 |                     break;
 24 |             }
 25 |             return option;
 26 |         }
 27 | 
 28 |         /* Get list of files to loaded by commas options */
 29 |         public List<string> GetResourceFiles(List<string> presets)
 30 |         {
 31 |             List<string> paths = new List<string>();
 32 |             foreach (var p in presets)
 33 |             {
 34 |                 GetItem(p.Trim(), (option) =>
 35 |                 {
 36 |                     if (option?.Files != null)
 37 |                     {
 38 |                         paths.RemoveAll(f => option.Files.Contains(f));
 39 |                         paths.AddRange(option.Files);
 40 |                     }
 41 |                     return true;
 42 |                 });
 43 |             }
 44 |             return paths;
 45 |         }
 46 | 
 47 | 
 48 |         public VariablesValues GetConstants(List<string> presets)
 49 |         {
 50 |             VariablesValues variables= new VariablesValues();
 51 | 
 52 |             foreach (var p in presets ?? new List<string>())
 53 |             {
 54 |                 GetItem(p.Trim(), (option) =>
 55 |                 {
 56 |                     if (option?.Constants != null)
 57 |                     {
 58 |                         foreach (var c in option.Constants)
 59 |                             variables[c.Key] = c.Value;
 60 |                     }
 61 |                     return true;
 62 |                 });
 63 |             }
 64 |             return variables;
 65 |         }
 66 | 
 67 |         public void PostLoad(string themePath)
 68 |         {
 69 |             List<Preset> toProcess = new List<Preset>();
 70 | 
 71 |             void ProcessSubPresets( string rootId, Presets presets, List<Preset> outList)
 72 |             {
 73 |                 if (presets == null) return;
 74 | 
 75 |                 foreach(var k in presets.Keys)
 76 |                 {
 77 |                     if (presets[k].Id == null)
 78 |                     {
 79 |                         presets[k].Id = rootId != null ? $"{rootId}.{k}" : k;
 80 |                     }
 81 |                     if (presets[k].Preview != null)
 82 |                     {
 83 |                         var imagePath = Path.Combine(themePath, presets[k].Preview);
 84 |                         presets[k].Preview = File.Exists(imagePath) ? imagePath : null;
 85 |                     }
 86 | 
 87 |                     outList.Add(presets[k]);
 88 |                 }
 89 |             }
 90 | 
 91 |             ProcessSubPresets(null, this, toProcess);
 92 | 
 93 |             for (int index = 0; index < toProcess.Count; index++)
 94 |             {
 95 |                 ProcessSubPresets(toProcess[index].Id, toProcess[index].Presets, toProcess);
 96 |             }
 97 |         }
 98 | 
 99 |         public IEnumerable<PresetPair>Enumerate()
100 |         {
101 |             Queue<PresetPair> toProcess = new Queue<PresetPair>();
102 | 
103 |             if (this != null )
104 |                 foreach(var p in this)
105 |                     toProcess.Enqueue(p);
106 | 
107 |             while (toProcess.Count > 0)
108 |             {
109 |                 PresetPair preset = toProcess.Dequeue();
110 |                 if (preset.Value.Presets != null)
111 |                     foreach(var p in preset.Value.Presets)
112 |                         toProcess.Enqueue(p);
113 | 
114 |                 yield return preset;
115 |             }
116 |         }
117 |     }
118 | }


--------------------------------------------------------------------------------
/Tests/Models/VariablesToObjectsCast.test.cs:
--------------------------------------------------------------------------------
 1 | using ThemeOptions.Models;
 2 | //using NUnit.Framework;
 3 | using Microsoft.VisualStudio.TestTools.UnitTesting;
 4 | using System;
 5 | using System.Windows;
 6 | using System.Collections.Generic;
 7 | 
 8 | namespace Tests.Models
 9 | {
10 |     [TestClass]
11 |     public class VariablesToObjectsCast
12 |     {
13 |         [TestMethod]
14 |         [DataRow("string", "value1", "value1")]
15 |         [DataRow("String", "value2", "value2")]
16 |         public void ToString(string typeName, string value, object expected)
17 |         {
18 |             VariableValue variable =  new Variable() { Type = typeName, Value = value };
19 |             object actual = VariablesValues.CastToObject(variable);
20 |             Assert.AreEqual(expected, actual);
21 |         }
22 | 
23 |         [TestMethod]
24 |         [DataRow("boolean", "True", true)]
25 |         [DataRow("Boolean", "true", true)]
26 |         [DataRow("Boolean", "False", false)]
27 |         [DataRow("Boolean", "Any", false)]
28 |         public void ToBoolean(string typeName, string value, object expected)
29 |         {
30 |             VariableValue variable =  new Variable() { Type = typeName, Value = value };
31 |             object actual = VariablesValues.CastToObject(variable);
32 |             Assert.AreEqual(expected, actual);
33 |         }
34 | 
35 |         [TestMethod]
36 |         [DataRow("unknown", "555", null)]
37 |         [DataRow("Int32", "555", 555)]
38 |         [DataRow("Int32", "-358", -358)]
39 |         [DataRow("Int32", "2A", 0)]
40 |         [DataRow("Double", "45", 45.0)]
41 |         [DataRow("Double", "98.78", 98.78)]
42 |         [DataRow("Double", "-89.45", -89.45)]
43 |         [DataRow("Double", "4f5", double.NaN)]
44 |         public void ToNumbers(string typeName, string value, object expected)
45 |         {
46 |             VariableValue variable =  new Variable() { Type = typeName, Value = value };
47 |             object actual = VariablesValues.CastToObject(variable);
48 |             Assert.AreEqual(expected, actual);
49 |         }
50 | 
51 |         [TestMethod]
52 |         [DataRow("Thickness", "1,2,3,4", 1,2,3,4)]
53 |         [DataRow("Thickness", "5", 5,5,5,5)]
54 |         [DataRow("Thickness", "5,6", 0,0,0,0)]
55 |         public void ToThickness(string typeName, string value, double left, double top, double right, double bottom)
56 |         {
57 |             VariableValue variable =  new Variable() { Type = typeName, Value = value };
58 |             object actual = VariablesValues.CastToObject(variable);
59 |             Assert.AreEqual(new Thickness(left, top, right, bottom), actual);
60 |         }
61 | 
62 |         [TestMethod]
63 |         [DataRow("CornerRadius", "1,2,3,4", 1,2,3,4)]
64 |         [DataRow("CornerRadius", "1,2,3.3,4", 1,2,3.3,4)]
65 |         [DataRow("CornerRadius", "5.1", 5.1,5.1,5.1,5.1)]
66 |         [DataRow("CornerRadius", "5,6", 0,0,0,0)]
67 |         public void ToCornerRadius(string typeName, string value, double left, double top, double right , double bottom)
68 |         {
69 |             VariableValue variable =  new Variable() { Type = typeName, Value = value };
70 |             object actual = VariablesValues.CastToObject(variable);
71 |             Assert.AreEqual(new CornerRadius(left, top, right, bottom), actual);
72 |         }
73 | 
74 |         [TestMethod]
75 |         [DataRow("Visibility", "Visible", Visibility.Visible)]
76 |         [DataRow("Visibility", "visible", Visibility.Visible)]
77 |         [DataRow("Visibility", "Collapsed", Visibility.Collapsed)]
78 |         [DataRow("Visibility", "Other", Visibility.Collapsed)]
79 |         public void ToVisibility(string typeName, string value, Visibility expected)
80 |         {
81 |             VariableValue variable =  new Variable() { Type = typeName, Value = value };
82 |             object actual = VariablesValues.CastToObject(variable);
83 |             Assert.AreEqual(expected, actual);
84 |         }
85 | 
86 |         [TestMethod]
87 |         [DataRow("TimeSpan", "00:00:12", 0, 0, 12, 0)]
88 |         [DataRow("TimeSpan", "00:00:34.56", 0, 0, 34, 560)]
89 |         [DataRow("TimeSpan", "aa", 0, 0, 0, 0)]
90 |         public void ToTimeSpan(string typeName, string value, int hh, int mm, int ss, int ms)
91 |         {
92 |             VariableValue variable =  new Variable() { Type = typeName, Value = value };
93 |             object actual = VariablesValues.CastToObject(variable);
94 |             Assert.AreEqual(new TimeSpan(0, hh,mm,ss, ms), actual);
95 |         }
96 |     }
97 | }


--------------------------------------------------------------------------------
/Controls/CommandControl_GameControllerHold.cs:
--------------------------------------------------------------------------------
 1 | using Playnite.SDK;
 2 | using System;
 3 | using System.Reflection;
 4 | using System.Windows.Controls;
 5 | using System.Windows.Data;
 6 | using System.Windows.Input;
 7 | using ThemeOptions.Tools;
 8 | 
 9 | namespace ThemeOptions.Controls
10 | {
11 |     public partial class CommandControl
12 |     {
13 |         /********************************************************************************************************
14 |           Command to Assign action on Gamepad longPress button
15 |          ********************************************************
16 |             @Name: Content.GameControllerHoldCommand
17 |             @Parameter: Array of 2 Buttons to handle command on Short and Long press
18 | 
19 |             Warning: Usage of commands require to use Binding Proxy (from Playnite namespace)
20 | 
21 |             <Grid.Resources>
22 |                 <p:BindingProxy x:Key="MAIN_Commands" Data="{Binding}" />
23 |                 <p:BindingProxy x:Key="THEMEOPTIONS_Commands" Data="{Binding Content, ElementName=ThemeOptions_Command}" />
24 |             </Grid.Resources>
25 |             <Grid.InputBindings>
26 |                 <pin:GameControllerInputBinding
27 |                     Button="Back"
28 |                     Command="{Binding Content.GameControllerHoldCommand, ElementName=ThemeOptions_Command}">
29 |                     <pin:GameControllerInputBinding.CommandParameter>
30 |                         <x:Array Type="{x:Type Button}">
31 |                             <Button
32 |                                 Command="{Binding Data.OpenMainMenuCommand, Source={StaticResource MAIN_Commands}}"
33 |                             />
34 |                             <Button
35 |                                 Command="{Binding Data.TouchTag, Source={StaticResource THEMEOPTIONS_Commands}}"
36 |                                 CommandParameter="FILTER_Show"/>
37 |                         </x:Array>
38 |                     </pin:GameControllerInputBinding.CommandParameter>
39 |                 </pin:GameControllerInputBinding>
40 |             <Grid.InputBindings>
41 | 
42 |         ********************************************************************************************************/
43 |         public RelayCommand<object> GameControllerHoldCommand => new RelayCommand<object>(o =>
44 |         {
45 |             if (o is Button[] buttons && buttons.Length == 2 )
46 |             {
47 |                 new Gamepad().LongPressCommand(buttons[0]?.Command, buttons[1]?.Command, buttons[0]?.CommandParameter, buttons[1]?.CommandParameter);
48 |             }
49 |         });
50 | 
51 |         /********************************************************************************************************
52 |           Command to Assign action on Gamepad short press (on release) button
53 |           Action occurs only on short click (on release) button
54 |           it is required if you are going to use some button as 'modifier' on hold and  same time to keep ability
55 |           to use it also on short press
56 |           e.g. 'Options' button to open menu, but 'Options + View' as Switch to
57 |          ********************************************************
58 |             @Name: Content.GameControllerShortCommand
59 |             @Parameter: Command to be called on Short press or Button object as Command and CommandParameter holder
60 | 
61 |             <Grid.Resources>
62 |                 <p:BindingProxy x:Key="MAIN_Commands" Data="{Binding}" />
63 |                 <p:BindingProxy x:Key="THEMEOPTIONS_Commands" Data="{Binding Content, ElementName=ThemeOptions_Command}" />
64 |             </Grid.Resources>
65 |             <Grid.InputBindings>
66 |                 <pin:GameControllerInputBinding
67 |                     Button="Back"
68 |                     Command="{Binding Data.OpenMainMenuCommand, Source={StaticResource MAIN_Commands}}"
69 |                     CommandParameter="{Binding Data.TouchTag, Source={StaticResource THEMEOPTIONS_Commands}}" />
70 |                 </pin:GameControllerInputBinding>
71 |             <Grid.InputBindings>
72 | 
73 |         ********************************************************************************************************/
74 |         public RelayCommand<object> GameControllerAltCommand => new RelayCommand<object>(o =>
75 |         {
76 |             if (o is ICommand command )
77 |             {
78 |                 new Gamepad().LongPressCommand(command, null, null, null);
79 |             }
80 |             else if (o is Button button)
81 |             {
82 |                 new Gamepad().LongPressCommand(button.Command, null, button.CommandParameter, null);
83 |             }
84 |         });
85 |     }
86 | }


--------------------------------------------------------------------------------
/Controls/GamepadAltControl.xaml.cs:
--------------------------------------------------------------------------------
  1 | 
  2 | using System;
  3 | using System.ComponentModel;
  4 | using System.Windows;
  5 | using System.Windows.Controls;
  6 | using System.Windows.Input;
  7 | using System.Windows.Markup;
  8 | using System.Windows.Media;
  9 | using System.Windows.Threading;
 10 | using Playnite.SDK;
 11 | using Playnite.SDK.Controls;
 12 | using Playnite.SDK.Events;
 13 | using ThemeOptions.Tools;
 14 | 
 15 | namespace ThemeOptions.Controls
 16 | {
 17 |     public partial class GamepadAltControl : PluginUserControl
 18 |     {
 19 |         public Gamepad controller;
 20 | 
 21 |         private static readonly ILogger Logger = LogManager.GetLogger();
 22 |         private readonly bool suppressDefaults;
 23 |         private readonly bool global;
 24 | 
 25 |         InputBindingCollection actualBindings;
 26 |         public new InputBindingCollection InputBindings
 27 |         {
 28 |              set
 29 |              {
 30 |                 if (value != actualBindings)
 31 |                 {
 32 |                     (Parent as ContentControl).InputBindings.Clear();
 33 |                     (Parent as ContentControl).InputBindings.AddRange(value);
 34 |                     actualBindings = value;
 35 |                     Logger.Debug("Binding is changed");
 36 |                 }
 37 |              }
 38 |         }
 39 | 
 40 |         static GamepadAltControl()
 41 |         {
 42 |             TagProperty.OverrideMetadata(typeof(GamepadAltControl), new FrameworkPropertyMetadata(null, OnTagChanged));
 43 |         }
 44 | 
 45 |         public GamepadAltControl(bool suppressDefaults = false, bool global = false)
 46 |         {
 47 |             this.suppressDefaults = suppressDefaults;
 48 |             this.global = global;
 49 | 
 50 |             ((IComponentConnector)this).InitializeComponent();
 51 |             DataContext = this;
 52 |             controller = new Gamepad();
 53 | 
 54 |             Gamepad.ButtonDown += OnButtonDown;
 55 | 
 56 |             dynamic model = Application.Current.MainWindow.DataContext;
 57 |             if (model != null && model.GetType().Name == "FullscreenAppViewModel")
 58 |             {
 59 |                 (model.AppSettings.Fullscreen as INotifyPropertyChanged).PropertyChanged += (o, e) =>
 60 |                 {
 61 |                     if (e.PropertyName == "EnableGameControllerSupport")
 62 |                     {
 63 |                         UpdateAltProcessing();
 64 |                     }
 65 |                 };
 66 |                 (model.App as INotifyPropertyChanged).PropertyChanged += (o, e) =>
 67 |                 {
 68 |                     if (e.PropertyName == "IsActive")
 69 |                     {
 70 |                         UpdateAltProcessing();
 71 |                     }
 72 |                 };
 73 |                 EventManager.RegisterClassHandler(
 74 |                     typeof(UIElement),
 75 |                     Keyboard.GotKeyboardFocusEvent,
 76 |                         new KeyboardFocusChangedEventHandler((sender, args) =>
 77 |                     {
 78 |                         UpdateAltProcessing();
 79 |                     })
 80 |                 );
 81 | 
 82 |             }
 83 |         }
 84 | 
 85 |         bool _scheduled = false;
 86 |         void UpdateAltProcessing()
 87 |         {
 88 |             if (!_scheduled)
 89 |             {
 90 |                 _scheduled = true;
 91 |                 Application.Current.Dispatcher.BeginInvoke(new Action(() =>
 92 |                 {
 93 |                     _scheduled = false;
 94 |                     DoUpdateAltProcessing();
 95 |                 }), DispatcherPriority.DataBind);
 96 |             }
 97 |         }
 98 |         void DoUpdateAltProcessing()
 99 |         {
100 |             bool active = Tag?.ToString()?.Equals("True", StringComparison.OrdinalIgnoreCase) ?? false;
101 |             if (Tag is InputBindingCollection collection)
102 |             {
103 |                 active = true;
104 |                 InputBindings = collection;
105 |             }
106 |             controller.AltProcessing = active && (global || IsParentFocused(this));
107 |         }
108 | 
109 |         private static void OnTagChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
110 |         {
111 |             if (dependencyObject is GamepadAltControl gamepadAltControl)
112 |             {
113 |                 gamepadAltControl.UpdateAltProcessing();
114 |             }
115 |         }
116 | 
117 |         private void OnButtonDown(object o, ControllerInput button)
118 |         {
119 |             if (controller.AltProcessing)
120 |             {
121 |                 foreach (var binding in (Parent as ContentControl).InputBindings)
122 |                 {
123 |                     if (binding.GetType().Name == "GameControllerInputBinding")
124 |                     {
125 |                         dynamic gamePadBinding = binding;
126 |                         if (gamePadBinding.Button.ToString().Equals(button.ToString()))
127 |                         {
128 | 
129 |                             if (gamePadBinding.Command?.CanExecute(gamePadBinding.CommandParameter) == true)
130 |                             {
131 |                                 gamePadBinding.Command?.Execute(gamePadBinding.CommandParameter);
132 |                             }
133 |                             return;
134 |                         }
135 |                     }
136 |                 }
137 |                 // button not found, default processing
138 |                 if (!suppressDefaults)
139 |                 {
140 |                     controller.DefaultProcess(button.ToString(), pressed: true);
141 |                 }
142 |             }
143 |         }
144 | 
145 | 
146 |         static bool IsParentFocused(DependencyObject current)
147 |         {
148 |             var parent = VisualTreeHelper.GetParent(current);
149 |             if (parent == null)
150 |             {
151 |                 return false;
152 |             }
153 |             else if (parent is UIElement parentElement && parentElement.IsKeyboardFocusWithin)
154 |             {
155 |                 return true;
156 |             }
157 |             return IsParentFocused(parent);
158 |         }
159 |     }
160 | }


--------------------------------------------------------------------------------
/Controls/out_of_order/CommandControl_UpdateOneTimeBind.cs.txt:
--------------------------------------------------------------------------------
  1 | 
  2 | using Playnite.SDK;
  3 | using Playnite.SDK.Controls;
  4 | using System;
  5 | using System.Collections.Generic;
  6 | using System.ComponentModel;
  7 | using System.Dynamic;
  8 | using System.Linq;
  9 | using System.Reflection;
 10 | using System.Runtime.CompilerServices;
 11 | using System.Text.RegularExpressions;
 12 | using System.Windows;
 13 | using System.Windows.Controls;
 14 | using System.Windows.Data;
 15 | using System.Windows.Media.Animation;
 16 | using Behaviors = Microsoft.Xaml.Behaviors;
 17 | 
 18 | namespace ThemeOptions.Controls
 19 | {
 20 | 
 21 |     public partial class CommandControl
 22 |     {
 23 |         public RelayCommand<object> UpdateOneTimeBind => new RelayCommand<object>((o) => UpdateOneTimeBindCommand(o));
 24 | 
 25 |         public class CustomTarget
 26 |         {
 27 |             static public bool TryParse(string value, out CustomTarget result)
 28 |             {
 29 |                 result = null;
 30 |                 if (string.IsNullOrEmpty(value))
 31 |                 {
 32 |                     return false;
 33 |                 }
 34 | 
 35 |                 var regex = new Regex(@"\[\s*(?<CommandName>\w+)(?:\s+ElementName\s*=\s*(?<ElementName>\w+))?(?:,\s*Property\s*=\s*(?<Property>\w+))?\s*\]");
 36 |                 var match = regex.Match(value);
 37 |                 if (match.Success && match.Groups["CommandName"].Value == "Target")
 38 |                 {
 39 |                     result = new CustomTarget(
 40 |                         match.Groups["ElementName"].Value,
 41 |                         match.Groups["Property"].Value
 42 |                     );
 43 |                     return true;
 44 |                 }
 45 |                 return false;
 46 |             }
 47 |             public string ElementName;
 48 |             public string Property;
 49 | 
 50 |             public CustomTarget(string elementName, string property)
 51 |             {
 52 |                 ElementName = elementName;
 53 |                 Property = property;
 54 |             }
 55 |         }
 56 |         private void UpdateOneTimeBindCommand(object o)
 57 |         {
 58 |             if (CustomTarget.TryParse(o as string, out CustomTarget target))
 59 |             {
 60 |                 if (FindName(target.ElementName) is DependencyObject element)
 61 |                 {
 62 |                     if (element.GetType()
 63 |                         .GetField($"{target.Property}Property", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
 64 |                         ?.GetValue(null) is DependencyProperty property)
 65 |                     {
 66 |                         if (BindingOperations.GetBindingExpression(element, property) is BindingExpression binding)
 67 |                         {
 68 |                             var oldBinding = binding.ParentBinding;
 69 |                             if (oldBinding.Mode != BindingMode.OneTime)
 70 |                             {
 71 |                                 var newBinding = oldBinding.ElementName is null
 72 |                                     ? new Binding
 73 |                                     {
 74 |                                         Path = oldBinding.Path,
 75 |                                         Source = oldBinding.Source,
 76 |                                         Mode = BindingMode.OneTime,
 77 |                                         UpdateSourceTrigger = oldBinding.UpdateSourceTrigger,
 78 |                                         Converter = oldBinding.Converter,
 79 |                                         ConverterParameter = oldBinding.ConverterParameter,
 80 |                                         ConverterCulture = oldBinding.ConverterCulture,
 81 |                                         StringFormat = oldBinding.StringFormat,
 82 |                                         TargetNullValue = oldBinding.TargetNullValue,
 83 |                                         FallbackValue = oldBinding.FallbackValue
 84 |                                     }
 85 |                                     : new Binding
 86 |                                     {
 87 |                                         Path = oldBinding.Path,
 88 |                                         ElementName = oldBinding.ElementName,
 89 |                                         Mode = BindingMode.OneTime,
 90 |                                         UpdateSourceTrigger = oldBinding.UpdateSourceTrigger,
 91 |                                         Converter = oldBinding.Converter,
 92 |                                         ConverterParameter = oldBinding.ConverterParameter,
 93 |                                         ConverterCulture = oldBinding.ConverterCulture,
 94 |                                         StringFormat = oldBinding.StringFormat,
 95 |                                         TargetNullValue = oldBinding.TargetNullValue,
 96 |                                         FallbackValue = oldBinding.FallbackValue
 97 |                                     };
 98 | 
 99 |                                 // Apply the new binding
100 |                                 BindingOperations.SetBinding(element, property, newBinding);
101 |                             }
102 |                             else
103 |                             {
104 |                                 binding.UpdateTarget();
105 |                             }
106 |                         }
107 |                         else
108 |                         {
109 |                             Logger.Error($"No Binging expression for Element '{target.ElementName}' property '{target.Property}'");
110 |                         }
111 |                     }
112 |                     else
113 |                     {
114 |                         Logger.Error($"No Property '{target.Property}' for Element '{target.ElementName}' ");
115 |                     }
116 |                 }
117 |                 else
118 |                 {
119 |                     Logger.Error($"Element '{target.ElementName}' was not found");
120 |                 }
121 |             }
122 |             else
123 |             {
124 |                 Logger.Error($"UpdateOneTimeBind CommandParameter should match format: [Target ElementName=element_x_name, Property=property_name]");
125 |             }
126 |         }
127 | 
128 |     }
129 | }


--------------------------------------------------------------------------------
/Views/FullscreenSettingsView.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Reflection;
  6 | using System.Windows.Controls;
  7 | using System.Windows;
  8 | using System.Windows.Markup;
  9 | using System.Windows.Media;
 10 | using System.ComponentModel;
 11 | 
 12 | using Playnite.SDK;
 13 | 
 14 | using ThemeOptions.Models;
 15 | 
 16 | 
 17 | namespace ThemeOptions.Views
 18 | {
 19 |     static public class Extension
 20 |     {
 21 |         public static IEnumerable<T> FindVisualChildren<T>(this DependencyObject parent, string typeName=null) where T : DependencyObject
 22 |         {
 23 |             if (parent == null)
 24 |                 throw new ArgumentNullException(nameof(parent));
 25 | 
 26 |             var queue = new Queue<DependencyObject>(new[] { parent });
 27 | 
 28 |             while (queue.Any())
 29 |             {
 30 |                 var reference = queue.Dequeue();
 31 |                 var count = VisualTreeHelper.GetChildrenCount(reference);
 32 | 
 33 |                 for (var i = 0; i < count; i++)
 34 |                 {
 35 |                     var child = VisualTreeHelper.GetChild(reference, i);
 36 |                     if (child is T && (typeName == null || child.GetType().FullName == typeName))
 37 |                         yield return child as T;
 38 | 
 39 |                     queue.Enqueue(child);
 40 |                 }
 41 |             }
 42 |         }
 43 |     }
 44 | 
 45 |     public class FullscreenSettingsView
 46 |     {
 47 |         private static readonly ILogger logger = LogManager.GetLogger();
 48 |         private static readonly string PluginFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
 49 | 
 50 |         static private Theme CurrentTheme;
 51 |         public static void Init()
 52 |         {
 53 |             CurrentTheme = Theme.FromId(ThemeOptions.PlayniteAPI.ApplicationSettings.FullscreenTheme);
 54 |             if (CurrentTheme?.Options == null)
 55 |                 return;
 56 | 
 57 |             EventManager.RegisterClassHandler(
 58 |                 typeof(Window),
 59 |                 Window.LoadedEvent,
 60 |                 new RoutedEventHandler((object sender, RoutedEventArgs e)=>
 61 |                     {
 62 |                         if (sender.GetType().Name != "SettingsWindow") return;
 63 |                         try
 64 |                         {
 65 |                             Load(sender as DependencyObject);
 66 |                         }
 67 |                         catch (Exception exception)
 68 |                         {
 69 |                             logger.Error(exception.Message);
 70 |                         };
 71 |                     }
 72 |                 ));
 73 |         }
 74 | 
 75 |         public static void Load(DependencyObject parent)
 76 |         {
 77 |             dynamic ctx = (parent as Window).DataContext;
 78 |             dynamic sectionViews = ctx
 79 |                 .GetType()
 80 |                 .GetField("sectionViews", BindingFlags.NonPublic | BindingFlags.Instance)
 81 |                 .GetValue(ctx);
 82 | 
 83 |             var assembly = Application.Current.GetType().Assembly;
 84 |             Type type = assembly.GetType("Playnite.FullscreenApp.Controls.SettingsSections.SettingsSectionControl");
 85 |             dynamic hostControl = Activator.CreateInstance(type);
 86 | 
 87 |             Uri resourceUri = new Uri("pack://application:,,,/ThemeOptions;component/Views/FullscreenSettingsView.xaml");
 88 | 
 89 |             using (Stream stream = Application.GetResourceStream(resourceUri).Stream)
 90 |             {
 91 |                 UserControl control = (UserControl)XamlReader.Load(stream);
 92 | 
 93 |                 foreach (string style in new string[] {
 94 |                     "ThemeOptionsPreviewImageGridStyle",
 95 |                     "ThemeOptionsPreviewImageStyle",
 96 |                     "SettingsSectionInputBoxStyle",
 97 |                     "SettingsSectionInputBoxTemplate"
 98 |                 })
 99 |                 {
100 |                     if ( Application.Current.TryFindResource(style) != null )
101 |                     {
102 |                         control.Resources.Remove(style);
103 |                     }
104 |                 }
105 | 
106 |                 control.DataContext = ThemeOptions.Settings;
107 |                 hostControl.Content=control;
108 |             }
109 | 
110 |             int nextKey = (sectionViews.Keys as IEnumerable<int>).ToList().Max() + 1;
111 |             sectionViews[nextKey] = hostControl;
112 | 
113 |             StackPanel stack = parent.FindVisualChildren<DependencyObject>("System.Windows.Controls.StackPanel").FirstOrDefault() as StackPanel;
114 | 
115 |             DataTemplate menuTemplate = Application.Current.TryFindResource("SettingsMenuThemeOptionsButtonTemplate") as DataTemplate
116 |                 ?? ( hostControl.Content.Resources.Contains("SettingsMenuThemeOptionsButtonTemplate")
117 |                         ? hostControl.Content.Resources["SettingsMenuThemeOptionsButtonTemplate"] as DataTemplate
118 |                         : null);
119 | 
120 |             Type ButtonExType = assembly.GetType("Playnite.FullscreenApp.Controls.ButtonEx");
121 |             dynamic newBtn = Activator.CreateInstance(ButtonExType);
122 |             {
123 |                 newBtn.Content = (string)Application.Current.TryFindResource("LOCThemeOptionsSettingsMenu") ?? "Theme Options";
124 |                 newBtn.Style = Application.Current.TryFindResource("SettingsMenuButton") as Style;
125 |                 if (menuTemplate != null)  newBtn.ContentTemplate = menuTemplate;
126 |                 newBtn.Command = ctx.OpenSectionCommand;
127 |                 newBtn.CommandParameter = nextKey.ToString();
128 |             }
129 |             ThemeOptions.Settings.BeginFullscreenEdit(CurrentTheme.Id);
130 | 
131 |             (hostControl as UserControl).Loaded += OnLoad;
132 |             (hostControl as UserControl).Unloaded += OnUnload;
133 | 
134 |             stack.Children.Insert(3, newBtn);
135 |         }
136 | 
137 |         public static void OnLoad(object sender, RoutedEventArgs e)
138 |         {
139 |             (sender as DependencyObject)
140 |                 .FindVisualChildren<Control>()
141 |                 .FirstOrDefault(ctrl => ctrl.Focusable && ctrl.IsVisible)
142 |                 ?.Focus();
143 |         }
144 | 
145 |         public static void OnUnload(object sender, RoutedEventArgs e)
146 |         {
147 |             UserControl control = (sender as UserControl).Content as UserControl;
148 |             SettingsViewModel settings = control.DataContext as SettingsViewModel;
149 |             settings.EndEdit();
150 |         }
151 | 
152 |         static private Variable currentInput;
153 |         static private dynamic InputWindow;
154 |         public static void TextInput(Variable input)
155 |         {
156 |             var assembly = Application.Current.GetType().Assembly;
157 |             Type type = assembly.GetType("Playnite.FullscreenApp.Windows.TextInputWindow");
158 |             InputWindow = Activator.CreateInstance(type);
159 |             currentInput = input;
160 |             var oldValue = input.Value;
161 |             (InputWindow as INotifyPropertyChanged).PropertyChanged += InputWindow_PropertyChanged;
162 |             var result = InputWindow.ShowInput(ThemeOptions.PlayniteAPI.Dialogs.GetCurrentAppWindow(), input.Title, "", input.Value);
163 |             (InputWindow as INotifyPropertyChanged).PropertyChanged -= InputWindow_PropertyChanged;
164 |             input.Value = result.Result ? result.SelectedString : oldValue;
165 |             currentInput = null;
166 |             InputWindow = null;
167 |         }
168 | 
169 |         static private void InputWindow_PropertyChanged(object sender, PropertyChangedEventArgs e)
170 |         {
171 |             if (e.PropertyName == "InputText")
172 |             {
173 |                 currentInput.Value = InputWindow.InputText;
174 |             }
175 |         }
176 |     }
177 | }


--------------------------------------------------------------------------------
/Tools/Gamepad.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Reflection;
  5 | using System.Windows;
  6 | using System.Windows.Input;
  7 | using Playnite.SDK.Events;
  8 | 
  9 | namespace ThemeOptions.Tools
 10 | {
 11 |     public class Gamepad
 12 |     {
 13 |         dynamic Model;
 14 | 
 15 |         static Dictionary<ControllerInput, ControllerInputState> ControllerState = new Dictionary<ControllerInput, ControllerInputState>();
 16 |         public static ControllerInputState GetState(ControllerInput button)
 17 |         {
 18 |             return ControllerState.ContainsKey(button) ? ControllerState[button] : ControllerInputState.Released;
 19 |         }
 20 | 
 21 |         public static ControllerInput GetButton(string buttonName)
 22 |         {
 23 |             return Enum.TryParse(buttonName, ignoreCase: true, out ControllerInput button) ? button : ControllerInput.None;
 24 |         }
 25 |         public static ControllerInputState GetState(string buttonName)
 26 |         {
 27 |             ControllerInput button = GetButton(buttonName);
 28 |             return ControllerState.ContainsKey(button)
 29 |                     ? ControllerState[button] : ControllerInputState.Released;
 30 |         }
 31 | 
 32 |         public static void SetState(OnControllerButtonStateChangedArgs args)
 33 |         {
 34 |             ControllerState[args.Button] = args.State;
 35 |             if (args.State == ControllerInputState.Released)
 36 |             {
 37 |                 ButtonUp?.Invoke(null, args.Button);
 38 |                 ButtonChanged?.Invoke(null, args.Button);
 39 |             }
 40 |             else
 41 |             {
 42 |                 ButtonDown?.Invoke(null, args.Button);
 43 |                 ButtonChanged?.Invoke(null, args.Button);
 44 |             }
 45 |         }
 46 | 
 47 |         public Gamepad()
 48 |         {
 49 |             dynamic model = Application.Current.MainWindow?.DataContext;
 50 |             if (model != null && model.GetType().Name == "FullscreenAppViewModel")
 51 |             {
 52 |                 Model = model;
 53 |             }
 54 |         }
 55 | 
 56 |         static public EventHandler<ControllerInput> ButtonUp;
 57 |         static public EventHandler<ControllerInput> ButtonDown;
 58 |         static public EventHandler<ControllerInput> ButtonChanged;
 59 | 
 60 |         int GetControllesStateHash()
 61 |         {
 62 |             int combinedHash = 17;
 63 |             foreach (ControllerInputState v in  ControllerState.Values)
 64 |             {
 65 |                 unchecked // Allow arithmetic overflow, numbers will "wrap around"
 66 |                 {
 67 |                     combinedHash = combinedHash * 23 + v.GetHashCode();
 68 |                 }
 69 |             }
 70 | 
 71 |             return combinedHash;
 72 |         }
 73 |         public void LongPressCommand(ICommand shortCommand, ICommand longCommand, object shortParameter, object longParameter)
 74 |         {
 75 |             var startState = GetControllesStateHash();
 76 |             DateTime startTime = DateTime.Now;
 77 | 
 78 |             bool shortPress = false;
 79 |             bool cancelPress = false;
 80 | 
 81 |             void onButtonUp(object sender, ControllerInput e)
 82 |             {
 83 |                 shortPress = true;
 84 |             }
 85 | 
 86 |             void onButtonDown(object sender, ControllerInput e)
 87 |             {
 88 |                 cancelPress = true;
 89 |             }
 90 | 
 91 |             void removeHandlers()
 92 |             {
 93 |                 ButtonDown -= onButtonDown;
 94 |                 ButtonUp -= onButtonUp;
 95 |             }
 96 | 
 97 |             System.Timers.Timer timer = new System.Timers.Timer(50)
 98 |             {
 99 |                 AutoReset = false,
100 |                 Enabled = true
101 |             };
102 | 
103 |             timer.Elapsed += (sender, e) =>
104 |             {
105 |                 Application.Current.Dispatcher.Invoke(() =>
106 |                 {
107 |                     if (cancelPress)
108 |                     {
109 |                         removeHandlers();
110 |                         return;
111 |                     }
112 |                     else if (shortPress)
113 |                     {
114 |                         removeHandlers();
115 |                         timer.Stop();
116 |                         timer.Dispose();
117 |                         if (shortCommand?.CanExecute(shortParameter) == true)
118 |                         {
119 |                             shortCommand?.Execute(shortParameter);
120 |                         }
121 |                     }
122 |                     else if ((DateTime.Now - startTime).TotalMilliseconds > 500)
123 |                     {
124 |                         removeHandlers();
125 |                         timer.Stop();
126 |                         timer.Dispose();
127 |                         if (longCommand?.CanExecute(longParameter) == true)
128 |                         {
129 |                             longCommand?.Execute(longParameter);
130 |                         }
131 |                     }
132 |                     else
133 |                     {
134 |                         ButtonUp += onButtonUp;
135 |                         ButtonDown += onButtonDown;
136 |                         timer.Start();
137 |                     }
138 |                 });
139 |             };
140 |             timer.Start();
141 | 
142 |         }
143 | 
144 |         public bool IsPressed(string buttonName)
145 |         {
146 |             return EnableGameControllerSupport && GetState(buttonName) == ControllerInputState.Pressed;
147 |         }
148 | 
149 |         private bool altProcessing = false;
150 |         public bool AltProcessing
151 |         {
152 |             get
153 |             {
154 |                 return EnableGameControllerSupport && altProcessing && !Model?.App?.GameController?.StandardProcessingEnabled;
155 |             }
156 |             set
157 |             {
158 |                 if (Model != null)
159 |                 {
160 |                     altProcessing = value;
161 |                     Model.App.GameController.StandardProcessingEnabled = !value && EnableGameControllerSupport;
162 |                 }
163 |             }
164 |         }
165 | 
166 |         public bool EnableGameControllerSupport
167 |         {
168 |             get
169 |             {
170 |                 return Model != null && Model.AppSettings.Fullscreen.EnableGameControllerSupport;
171 |             }
172 |         }
173 |         public void DefaultProcess(string buttonName, bool pressed)
174 |         {
175 |             if (Model == null || InputManager.Current.PrimaryKeyboardDevice?.ActiveSource == null)
176 |             {
177 |                 return;
178 |             }
179 | 
180 |             Assembly assembly = Assembly.LoadFrom(Path.Combine( AppDomain.CurrentDomain.BaseDirectory, "playnite.dll"));;
181 |             Type eventArgs = assembly.GetType("Playnite.Input.GameControllerInputEventArgs");
182 |             ControllerInputState inputState = pressed ? ControllerInputState.Pressed : ControllerInputState.Released;
183 |             ControllerInput controllerInput = GetButton(buttonName);
184 | 
185 |             InputEventArgs args = Activator.CreateInstance( eventArgs, new object[] { Key.None, inputState, controllerInput }) as InputEventArgs;
186 | 
187 |             if (Model.App.GameController.GetType().GetField("inputManager", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(Model.App.GameController) is InputManager manager)
188 |             {
189 |                 MethodInfo MapPadToKeyboard = Model.App.GameController.GetType().GetMethod("MapPadToKeyboard", BindingFlags.Instance | BindingFlags.NonPublic);
190 |                 MethodInfo SimulateKeyInput = Model.App.GameController.GetType().GetMethod("SimulateKeyInput", BindingFlags.Instance | BindingFlags.NonPublic);
191 | 
192 |                 manager.ProcessInput(args);
193 | 
194 |                 var keyboard = MapPadToKeyboard.Invoke(Model.App.GameController, new object[] { controllerInput });
195 | 
196 |                 Model.App.GameController.StandardProcessingEnabled = EnableGameControllerSupport;
197 |                 SimulateKeyInput.Invoke(Model.App.GameController, new object[] { keyboard, true });
198 |                 Model.App.GameController.StandardProcessingEnabled = false;
199 |             }
200 |         }
201 |     }
202 | }


--------------------------------------------------------------------------------
/Tests/Models/VariableValuesSearization.test.cs:
--------------------------------------------------------------------------------
  1 | using ThemeOptions.Models;
  2 | //using NUnit.Framework;
  3 | using Microsoft.VisualStudio.TestTools.UnitTesting;
  4 | using System;
  5 | using System.Windows;
  6 | using System.Collections.Generic;
  7 | using Playnite.SDK.Data;
  8 | 
  9 | namespace Tests.Models
 10 | {
 11 | 
 12 |     public class VariableComparer : IEqualityComparer<Variable>
 13 |     {
 14 |         public bool Equals(Variable x, Variable y)
 15 |         {
 16 |             if (x == null || y == null) return false;
 17 |             return
 18 |                 x.Type == y.Type &&
 19 |                 x.Value == y.Value &&
 20 |                 x.Title == y.Title &&
 21 |                 x.LocKey == y.LocKey &&
 22 |                 x.Default == y.Default &&
 23 |                 x.Description == y.Description &&
 24 |                 x.Preview == y.Preview &&
 25 |                 Equals(x.Slider, y.Slider) &&
 26 |                 x.TitleStyle == y.TitleStyle &&
 27 |                 x.Style == y.Style;
 28 |         }
 29 | 
 30 |         public int GetHashCode(Variable obj)
 31 |         {
 32 |             if (obj == null) return 0;
 33 |             return CombineHashCodes(
 34 |                             obj.Type?.GetHashCode() ?? 0,
 35 |                                     obj.Value?.GetHashCode() ?? 0,
 36 |                                     obj.Title?.GetHashCode() ?? 0,
 37 |                                     obj.LocKey?.GetHashCode() ?? 0,
 38 |                                     obj.Default?.GetHashCode() ?? 0,
 39 |                                     obj.Description?.GetHashCode() ?? 0,
 40 |                                     obj.Preview?.GetHashCode() ?? 0,
 41 |                                     obj.Slider?.GetHashCode() ?? 0,
 42 |                                     obj.TitleStyle?.GetHashCode() ?? 0,
 43 |                                     obj.Style?.GetHashCode() ?? 0);
 44 |         }
 45 | 
 46 |         private static int CombineHashCodes(params int[] hashCodes)
 47 |         {
 48 |             int hash = 17;
 49 |             foreach (var code in hashCodes)
 50 |             {
 51 |                 hash = hash * 31 + code;
 52 |             }
 53 |             return hash;
 54 |         }
 55 |     }
 56 | 
 57 |     public class VariableValueComparer : IEqualityComparer<VariableValue>
 58 |     {
 59 |         public bool Equals(VariableValue x, VariableValue y)
 60 |         {
 61 |             if (x == null || y == null) return false;
 62 |             return
 63 |                 x.Type == y.Type &&
 64 |                 x.Value == y.Value;
 65 |         }
 66 | 
 67 |         public int GetHashCode(VariableValue obj)
 68 |         {
 69 |             if (obj == null) return 0;
 70 |             return CombineHashCodes(
 71 |                             obj.Type?.GetHashCode() ?? 0,
 72 |                                     obj.Value?.GetHashCode() ?? 0);
 73 |         }
 74 | 
 75 |         private static int CombineHashCodes(params int[] hashCodes)
 76 |         {
 77 |             int hash = 17;
 78 |             foreach (var code in hashCodes)
 79 |             {
 80 |                 hash = hash * 31 + code;
 81 |             }
 82 |             return hash;
 83 |         }
 84 |     }
 85 | 
 86 |     [TestClass]
 87 |     public class VariableValuesSerialization
 88 |     {
 89 | 
 90 |         private VariablesValues setupVariablesValues1()
 91 |         => new VariablesValues
 92 |             {
 93 |                 { "stringKey1", new Variable() { Type = "String", Value = "value1" } },
 94 |                 { "booleanKey2",  new Variable() { Type = "Boolean", Value = "True" } },
 95 |                 { "int32Key3", new Variable() { Type = "Int32", Value = "123" } },
 96 |                 { "doubleKey4", new Variable() { Type = "Double", Value = "123.45" } },
 97 |                 { "visibilityKey5", new Variable() { Type = "Visibility", Value = "Visible" } },
 98 |                 { "timespanKey6", new Variable() { Type = "TimeSpan", Value = "00:01:00" } },
 99 |                 { "colorKey7", new Variable() { Type = "Color", Value = "#FF0000" } },
100 |                 { "thicknessKey8", new Variable() { Type = "Thickness", Value = "1,2,3,4" } },
101 |                 { "durationKey9", new Variable() { Type = "Duration", Value = "00:00:10" } },
102 |                 { "cornerRadiusKey10", new Variable() { Type = "CornerRadius", Value = "5,5,5,5" } },
103 |                 { "solidColorBrushKey11", new Variable() { Type = "SolidColorBrush", Value = "#FF0000" } }
104 |             };
105 | 
106 |         private VariablesValues setupVariablesValues2()
107 |         => new VariablesValues(new List<KeyValuePair<string, Variable>>()
108 |             {
109 |                 new KeyValuePair<string, Variable>( "key1", new Variable() { Type = "String", Value = "value1Key1" } ),
110 |                 new KeyValuePair<string, Variable>( "key2", new Variable() { Type = "Boolean", Value = "False" } ),
111 |                 new KeyValuePair<string, Variable>( "key3", new Variable() { Type = "Int32", Value = "999" } ),
112 |                 new KeyValuePair<string, Variable>( "key4", new Variable() { Type = "Double", Value = "123.45" } ),
113 |                 new KeyValuePair<string, Variable>( "key5", new Variable() { Type = "Visibility", Value = "Collapsed" } ),
114 |                 new KeyValuePair<string, Variable>( "key6", new Variable() { Type = "TimeSpan", Value = "00:01:00" } ),
115 |                 new KeyValuePair<string, Variable>( "key7", new Variable() { Type = "Color", Value = "#FF0000" } ),
116 |                 new KeyValuePair<string, Variable>( "key8", new Variable() { Type = "Thickness", Value = "1,2,3,4" } ),
117 |                 new KeyValuePair<string, Variable>( "key9", new Variable() { Type = "Duration", Value = "00:00:10" } ),
118 |                 new KeyValuePair<string, Variable>( "key10", new Variable() { Type = "CornerRadius", Value = "5,5,5,5" } ),
119 |                 new KeyValuePair<string, Variable>( "key11", new Variable() { Type = "SolidColorBrush", Value = "#FF0000" } )
120 |         });
121 | 
122 |         private VariablesValues setupVariablesValuesCommon()
123 |         => new VariablesValues(new List<KeyValuePair<string, Variable>>()
124 |             {
125 |                 new KeyValuePair<string, Variable>(  "stringKey1", new Variable() { Type = "String", Value = "value1Key1" } ),
126 |                 new KeyValuePair<string, Variable>(  "booleanKey2", new Variable() { Type = "Boolean", Value = "False" } ),
127 |                 new KeyValuePair<string, Variable>(  "int32Key3", new Variable() { Type = "Int32", Value = "999" } ),
128 |                 new KeyValuePair<string, Variable>(  "doubleKey4", new Variable() { Type = "Double", Value = "123.45" } ),
129 |                 new KeyValuePair<string, Variable>(  "visibilityKey5", new Variable() { Type = "Visibility", Value = "Collapsed" } ),
130 |                 new KeyValuePair<string, Variable>(  "timeSpanKey6", new Variable() { Type = "TimeSpan", Value = "00:01:00" } ),
131 |                 new KeyValuePair<string, Variable>(  "colorKey7", new Variable() { Type = "Color", Value = "#FF0000" } ),
132 |                 new KeyValuePair<string, Variable>(  "thicknessKey8", new Variable() { Type = "Thickness", Value = "1,2,3,4" } ),
133 |                 new KeyValuePair<string, Variable>(  "durationKey9", new Variable() { Type = "Duration", Value = "00:00:10" } ),
134 |                 new KeyValuePair<string, Variable>(  "cornerRadiusKey10", new Variable() { Type = "CornerRadius", Value = "5,5,5,5" } ),
135 |                 new KeyValuePair<string, Variable>(  "solidColorBrushKey11", new Variable() { Type = "SolidColorBrush", Value = "#FF0000" } )
136 |             });
137 | 
138 |         [TestMethod]
139 |         public void ToDynamicPropertiesTest()
140 |         {
141 |             var dynamicProperties = setupVariablesValues1().ToDynamicProperties();
142 |         }
143 | 
144 |         [TestMethod]
145 |         public void MergeTest()
146 |         {
147 |             var actual = setupVariablesValues1().Merge(setupVariablesValuesCommon());
148 |         }
149 | 
150 |         [TestMethod]
151 |         public void FormatResourceDictionaryTest()
152 |         {
153 |             var values = setupVariablesValues2();
154 |             var resource = values.FormatResourceDictionary();
155 |         }
156 | 
157 |         [TestMethod]
158 |         public void FromDynamicPropertiesTest()
159 |         {
160 |             var start = setupVariablesValues1().Merge(setupVariablesValuesCommon());
161 |             var expected = setupVariablesValues1()
162 |                             .Merge(setupVariablesValuesCommon())
163 |                             .Merge(setupVariablesValues2());
164 |             var dynSource = setupVariablesValuesCommon().Merge(setupVariablesValues2());
165 |             var dyn = dynSource.ToDynamicProperties();
166 |             var actual = start.FromDynamicProperties(dyn);
167 | 
168 |             foreach (var v in actual)
169 |             {
170 |                 Assert.AreEqual(
171 |                     expected[v.Key],
172 |                     actual[v.Key],
173 |                     comparer: new VariableValueComparer(),
174 |                     message: $"{v.Key} are not equal: expected ({expected[v.Key].Type}:{expected[v.Key].Value}),  actual:({actual[v.Key].Type}:{actual[v.Key].Value})" );
175 |             }
176 |         }
177 |     }
178 | }


--------------------------------------------------------------------------------
/ThemeOptions.yaml:
--------------------------------------------------------------------------------
  1 | AddonId: 'ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef'
  2 | Packages:
  3 |   - Version: 0.32
  4 |     RequiredApiVersion: 6.12.0
  5 |     ReleaseDate: 2025-11-05
  6 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.32/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_32.pext
  7 |     Changelog:
  8 |       - Regression fix on slider field
  9 |   - Version: 0.31
 10 |     RequiredApiVersion: 6.12.0
 11 |     ReleaseDate: 2025-11-05
 12 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.31/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_31.pext
 13 |     Changelog:
 14 |       - Fixed Random crash on startup #17
 15 |       - Fixed Scroll behavior issue with headers in ThemeOptions setings #18
 16 |   - Version: 0.30
 17 |     RequiredApiVersion: 6.12.0
 18 |     ReleaseDate: 2025-10-30
 19 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.30/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_30.pext
 20 |     Changelog:
 21 |       - Fixed crash if old preset is in config #15
 22 |   - Version: 0.29
 23 |     RequiredApiVersion: 6.12.0
 24 |     ReleaseDate: 2025-10-21
 25 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.29/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_29.pext
 26 |     Changelog:
 27 |       - Add initial support for extensions.yaml by Jono #14
 28 |   - Version: 0.28
 29 |     RequiredApiVersion: 6.12.0
 30 |     ReleaseDate: 2025-08-20
 31 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.28/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_28.pext
 32 |     Changelog:
 33 |       - Added custom window support by Jono #13
 34 |   - Version: 0.27
 35 |     RequiredApiVersion: 6.12.0
 36 |     ReleaseDate: 2025-08-13
 37 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.27/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_27.pext
 38 |     Changelog:
 39 |       - Added Display Aspect Ratio Detector
 40 |   - Version: 0.26
 41 |     RequiredApiVersion: 6.12.0
 42 |     ReleaseDate: 2025-08-10
 43 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.26/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_26.pext
 44 |     Changelog:
 45 |       - Added proxifing of OpenClientsCommand, OpenToolsCommand, OpenExtensionsCommand
 46 |   - Version: 0.25
 47 |     RequiredApiVersion: 6.12.0
 48 |     ReleaseDate: 2025-06-15
 49 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.25/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_25.pext
 50 |     Changelog:
 51 |       - Support new Playnite API for gamepad controllers
 52 |   - Version: 0.24
 53 |     RequiredApiVersion: 6.11.0
 54 |     ReleaseDate: 2025-02-04
 55 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.24/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_24.pext
 56 |     Changelog:
 57 |       - Fixed Alternative Gamepad double press
 58 |   - Version: 0.23
 59 |     RequiredApiVersion: 6.11.0
 60 |     ReleaseDate: 2025-01-19
 61 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.23/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_23.pext
 62 |     Changelog:
 63 |       - Fixed Alternative Gamepad binds on Playnite reactivation
 64 |   - Version: 0.22
 65 |     RequiredApiVersion: 6.11.0
 66 |     ReleaseDate: 2025-01-15
 67 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.22/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_22.pext
 68 |     Changelog:
 69 |       - Changing layout from modified one back to default does not trigger restart, even if NeedRestart is defined (#10)
 70 |       - Support of Advanced Game controler bindings and Game controller state
 71 |   - Version: 0.21
 72 |     RequiredApiVersion: 6.11.0
 73 |     ReleaseDate: 2025-01-05
 74 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.21/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_21.pext
 75 |     Changelog:
 76 |       - Installation check fix
 77 |       - Fixed couple of crash scenarios on empty plugin settings
 78 |       - Fixed crash in Desktop mode
 79 |   - Version: 0.19
 80 |     RequiredApiVersion: 6.11.0
 81 |     ReleaseDate: 2025-01-04
 82 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.19/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_19.pext
 83 |     Changelog:
 84 |       - Added option to specify 'NeedRestart' variables or presets
 85 |       - MainMenu commands are proxied via 'Content.MainMenu.***Command'
 86 |   - Version: 0.18
 87 |     RequiredApiVersion: 6.11.0
 88 |     ReleaseDate: 2025-01-03
 89 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.18/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_18.pext
 90 |     Changelog:
 91 |       - New features for theme designers are implemented
 92 |       - "Live theme options reload: theme options applied without reboot as soon as Theme options settings are closed"
 93 |       - "Bindable theme variables: now it is possible to bind theme variables as usual DataSource via {PluginSettings}"
 94 |       - "TwoWay binded variables (even not registered as theme Variables) values are saved on Playnite exit - it may used to save triggers current states"
 95 |       - "Extended theme options version verification"
 96 |   - Version: 0.17
 97 |     RequiredApiVersion: 6.11.0
 98 |     ReleaseDate: 2024-12-25
 99 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.17/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_17.pext
100 |     Changelog:
101 |       - Short / Long press gamepad binding support
102 |   - Version: 0.16
103 |     RequiredApiVersion: 6.11.0
104 |     ReleaseDate: 2024-12-04
105 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.16/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_16.pext
106 |     Changelog:
107 |       - Scrollbar for desktop settings
108 |   - Version: 0.15
109 |     RequiredApiVersion: 6.11.0
110 |     ReleaseDate: 2024-11-21
111 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.15/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_15.pext
112 |     Changelog:
113 |       - Scrollbar for desktop settings
114 |   - Version: 0.14
115 |     RequiredApiVersion: 6.11.0
116 |     ReleaseDate: 2024-11-09
117 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.14/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_14.pext
118 |     Changelog:
119 |       - Added commands may be required for themes implementation.
120 |       - Republished
121 |   - Version: 0.13
122 |     RequiredApiVersion: 6.11.0
123 |     ReleaseDate: 2024-10-18
124 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.13/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_13.pext
125 |     Changelog:
126 |       - Added CornerRadius support
127 |   - Version: 0.12
128 |     RequiredApiVersion: 6.11.0
129 |     ReleaseDate: 2024-09-26
130 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.12/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_12.pext
131 |     Changelog:
132 |       - Added SolidColorBrush object definition
133 |   - Version: 0.11
134 |     RequiredApiVersion: 6.11.0
135 |     ReleaseDate: 2024-07-10
136 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.11/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_11.pext
137 |     Changelog:
138 |       - Problem navigating ThemeOptions in full-screen mode (#7)
139 |       - Variable as slider (#5)
140 |   - Version: 0.10
141 |     RequiredApiVersion: 6.11.0
142 |     ReleaseDate: 2024-07-09
143 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.10/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_10.pext
144 |     Changelog:
145 |       - Theme enumerated incorrectly for Installed mode (#6)
146 |   - Version: 0.9
147 |     RequiredApiVersion: 6.11.0
148 |     ReleaseDate: 2024-07-07
149 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.9/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_9.pext
150 |     Changelog:
151 |       - Lookup themes in both User Appdata and installation path (#4)
152 |   - Version: 0.8
153 |     RequiredApiVersion: 6.11.0
154 |     ReleaseDate: 2024-07-07
155 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.8/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_8.pext
156 |     Changelog:
157 |       - Need to check theme folder exists before enumerating (#3)
158 |   - Version: 0.7
159 |     RequiredApiVersion: 6.11.0
160 |     ReleaseDate: 2024-06-27
161 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.7/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_7.pext
162 |     Changelog:
163 |       - Added PluginSettings IsInstalled bool to check installed status (#2)
164 |   - Version: 0.6
165 |     RequiredApiVersion: 6.11.0
166 |     ReleaseDate: 2024-06-26
167 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.6/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_6.pext
168 |     Changelog:
169 |       - Remove focus from ScrollView by default (#1)
170 |   - Version: 0.5
171 |     RequiredApiVersion: 6.11.0
172 |     ReleaseDate: 2024-06-25
173 |     PackageUrl: https://github.com/ashpynov/ThemeOptions/releases/download/v0.5/ThemeOptions_904cbf3b-573f-48f8-9642-0a09d05c64ef_0_5.pext
174 |     Changelog:
175 |       - Initial publication
176 | 


--------------------------------------------------------------------------------
/Models/Variables.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Windows;
  5 | using System.Windows.Media;
  6 | using System.Globalization;
  7 | 
  8 | 
  9 | namespace ThemeOptions.Models
 10 | {
 11 |     public class Variables : DictNoCase<Variable>{}
 12 | 
 13 |     public class VariablesValues : DictNoCase<VariableValue>
 14 |     {
 15 |         public VariablesValues() : base() {}
 16 |         public VariablesValues(IEnumerable<KeyValuePair<string, Variable>> pairs) : base()
 17 |         {
 18 |             if (pairs == null) return;
 19 | 
 20 |             foreach(var p in pairs)
 21 |             {
 22 |                 this[p.Key] = new VariableValue() { Type = p.Value.Type, Value = p.Value.Value };
 23 |             }
 24 |         }
 25 |         public VariablesValues(IEnumerable<KeyValuePair<string, VariableValue>> pairs) : base()
 26 |         {
 27 |             if (pairs == null) return;
 28 | 
 29 |             foreach(var p in pairs)
 30 |             {
 31 |                 this[p.Key] = p.Value;
 32 |             }
 33 |         }
 34 | 
 35 |         public VariablesValues Merge(IEnumerable<KeyValuePair<string, VariableValue>> pairs)
 36 |         {
 37 |             if (pairs == null) return this;
 38 | 
 39 |             foreach(var p in pairs)
 40 |             {
 41 |                 this[p.Key] = p.Value;
 42 |             }
 43 |             return this;
 44 |         }
 45 | 
 46 |         public string FormatResourceDictionary()
 47 |         {
 48 |             List<string> nss = new List<string>()
 49 |             {
 50 |                 "xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"",
 51 |                 "xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\"",
 52 |                 "xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\""
 53 |             };
 54 | 
 55 |             List<string> items = new List<string>();
 56 | 
 57 |             const string ns_sys = "xmlns:sys=\"clr-namespace:System;assembly=mscorlib\"";
 58 | 
 59 |             foreach (var v in this)
 60 |             {
 61 |                 if (
 62 |                     v.Value.Type == "String"
 63 |                  || v.Value.Type == "Boolean"
 64 |                  || v.Value.Type == "Int32"
 65 |                  || v.Value.Type == "Double"
 66 |                  || v.Value.Type == "TimeSpan"
 67 |                 )
 68 |                 {
 69 |                     items.Add($"<sys:{v.Value.Type} x:Key=\"{v.Key}\">{v.Value.Value}</sys:{v.Value.Type}>");
 70 |                     nss.AddMissing(ns_sys);
 71 |                 }
 72 |                 else if (
 73 |                     v.Value.Type == "Color"
 74 |                  || v.Value.Type == "Thickness"
 75 |                  || v.Value.Type == "Duration"
 76 |                  || v.Value.Type == "CornerRadius"
 77 |                  || v.Value.Type == "Visibility"
 78 |                 )
 79 |                 {
 80 |                     items.Add($"<{v.Value.Type} x:Key=\"{v.Key}\">{v.Value.Value}</{v.Value.Type}>");
 81 |                 }
 82 |                 else if (
 83 |                     v.Value.Type == "SolidColorBrush"
 84 |                 )
 85 |                 {
 86 |                     items.Add($"<{v.Value.Type} x:Key=\"{v.Key}\" Color=\"{v.Value.Value}\" />");
 87 |                 }
 88 |             }
 89 | 
 90 |             return "<ResourceDictionary "
 91 |                 + string.Join("\n    ", nss)
 92 |                 + " >\n    "
 93 |                 + string.Join("\n    ", items)
 94 |                 + "\n</ResourceDictionary>\n";
 95 |         }
 96 | 
 97 |         public static Thickness ConvertToThickness(string thicknessString)
 98 |         {
 99 |             // Split the string by commas
100 |             string[] values = thicknessString.Split(',');
101 | 
102 |             // Parse the values to integers
103 |             if (values.Length == 4 &&
104 |                 double.TryParse(values[0], NumberStyles.Any, CultureInfo.InvariantCulture, out double left) &&
105 |                 double.TryParse(values[1], NumberStyles.Any, CultureInfo.InvariantCulture, out double top) &&
106 |                 double.TryParse(values[2], NumberStyles.Any, CultureInfo.InvariantCulture, out double right) &&
107 |                 double.TryParse(values[3], NumberStyles.Any, CultureInfo.InvariantCulture, out double bottom))
108 |             {
109 |                 return new Thickness(left, top, right, bottom);
110 |             }
111 |             else if (values.Length == 1 && double.TryParse(values[0], NumberStyles.Any, CultureInfo.InvariantCulture,out double uniform))
112 |             {
113 |                 return new Thickness(uniform);
114 |             }
115 |             else
116 |             {
117 |                 return new Thickness();
118 |             }
119 |         }
120 | 
121 |         public static CornerRadius ConvertToCornerRadius(string cornerRadiusString)
122 |         {
123 |             // Split the string by commas
124 |             string[] values = cornerRadiusString.Split(',');
125 | 
126 |             if (values.Length == 4 &&
127 |                 double.TryParse(values[0], NumberStyles.Any, CultureInfo.InvariantCulture, out double left) &&
128 |                 double.TryParse(values[1], NumberStyles.Any, CultureInfo.InvariantCulture, out double top) &&
129 |                 double.TryParse(values[2], NumberStyles.Any, CultureInfo.InvariantCulture, out double right) &&
130 |                 double.TryParse(values[3], NumberStyles.Any, CultureInfo.InvariantCulture, out double bottom))
131 |             {
132 |                 return new CornerRadius(left, top, right, bottom);
133 |             }
134 |             else if (values.Length == 1 && double.TryParse(values[0], NumberStyles.Any, CultureInfo.InvariantCulture, out double uniform))
135 |             {
136 |                 return new CornerRadius(uniform);
137 |             }
138 |             else
139 |             {
140 |                 return new CornerRadius();
141 |             }
142 |         }
143 | 
144 |         public static object CastToObject(VariableValue variable)
145 |         {
146 |             object result = null;
147 |             switch (variable.Type.ToLower())
148 |                 {
149 |                     case "string":
150 |                         result = variable.Value;
151 |                         break;
152 |                     case "boolean":
153 |                         result = variable.Value.Equals("True", StringComparison.OrdinalIgnoreCase);
154 |                         break;
155 |                     case "int32":
156 |                         result = int.TryParse(variable.Value, out int _int) ? _int : 0;
157 |                         break;
158 |                     case "double":
159 |                         result = double.TryParse(variable.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out double _double) ? _double : double.NaN;
160 |                         break;
161 |                     case "visibility":
162 |                         result = variable.Value.Equals("Visible", StringComparison.OrdinalIgnoreCase) ? Visibility.Visible : Visibility.Collapsed;
163 |                         break;
164 |                     case "timespan":
165 |                         result = TimeSpan.TryParse(variable.Value, out TimeSpan _timespan) ? _timespan : TimeSpan.Zero;
166 |                         break;
167 |                     case "color":
168 |                         result = ColorConverter.ConvertFromString(variable.Value);
169 |                         break;
170 |                     case "thickness":
171 |                         result = ConvertToThickness(variable.Value);
172 |                         break;
173 |                     case "duration":
174 |                         result = new DurationConverter().ConvertFromString(variable.Value);
175 |                         break;
176 |                     case "cornerradius":
177 |                         result =  ConvertToCornerRadius(variable.Value);
178 |                         break;
179 |                     case "solidcolorbrush":
180 |                         result = new SolidColorBrush((Color)ColorConverter.ConvertFromString(variable.Value));
181 |                         break;
182 |                     default:
183 |                         // Handle unknown types if necessary
184 |                         break;
185 |                 }
186 |             return result;
187 |         }
188 | 
189 |         public DynamicProperties ToDynamicProperties()
190 |         {
191 |             DynamicProperties properties = new DynamicProperties();
192 |             List<string> existed = new List<string>();
193 |             foreach (var v in this)
194 |             {
195 |                 object value = CastToObject(v.Value);
196 |                 if (value != null)
197 |                 {
198 |                     existed.Add(v.Key);
199 |                     if (properties[v.Key] != value)
200 |                     {
201 |                         properties[v.Key] = value;
202 |                     }
203 |                 }
204 |             }
205 |             return properties;
206 |         }
207 | 
208 |         static public string CastToValue(object obj)
209 |         {
210 |             if (obj is double d) return d.ToString(CultureInfo.InvariantCulture);
211 |             if (obj is Color c) return (c.A == 255) ? $"#{c.R:X2}{c.G:X2}{c.B:X2}" : c.ToString();
212 |             if (obj is SolidColorBrush b) return (b.Color.A == 255) ? $"#{b.Color.R:X2}{b.Color.G:X2}{b.Color.B:X2}" : b.Color.ToString();
213 |             return obj.ToString();
214 |         }
215 |         public VariablesValues FromDynamicProperties(DynamicProperties properties)
216 |         {
217 |             foreach (var v in properties)
218 |             {
219 |                 if (ContainsKey(v.Key))
220 |                 {
221 |                     this[v.Key].Value = CastToValue(v.Value);
222 |                 }
223 |                 else
224 |                 {
225 |                     Add(v.Key, new Variable() {
226 |                          Type = v.Value.GetType().Name,
227 |                          Value = CastToValue(v.Value)
228 |                     });
229 |                 }
230 |             }
231 |             return this;
232 |         }
233 |     }
234 | }


--------------------------------------------------------------------------------
/Views/SettingsView.xaml:
--------------------------------------------------------------------------------
  1 | <UserControl x:Class="ThemeOptions.Views.SettingsView"
  2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4 |              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  5 |              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  6 |              xmlns:local="clr-namespace:ThemeOptions"
  7 |              xmlns:views="clr-namespace:ThemeOptions.Views"
  8 |              xmlns:con="clr-namespace:ThemeOptions.Converters"
  9 |              mc:Ignorable="d"
 10 |              d:DesignHeight="400" d:DesignWidth="600">
 11 |     <UserControl.Resources>
 12 |         <views:VariablePanelItemsDataTemplateSelector x:Key="VariableTemplateSelector"/>
 13 |         <con:DurationToDouble x:Key="DurationToDoubleConverter"/>
 14 |         <con:DurationToString x:Key="DurationToStringConverter"/>
 15 |         <con:VisibilityToBooleanConverter x:Key="VisibilityToBooleanConverter" />
 16 |     </UserControl.Resources>
 17 | 
 18 |     <ScrollViewer Focusable="False">
 19 | 
 20 |     <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Margin="20,20,20,20">
 21 |         <Grid.ColumnDefinitions>
 22 |             <ColumnDefinition Width="600"/>
 23 |             <ColumnDefinition Width="*"/>
 24 |         </Grid.ColumnDefinitions>
 25 |         <Grid.RowDefinitions>
 26 |             <RowDefinition Height="Auto"/>              <!-- 0. Combo to select theme -->
 27 |             <RowDefinition Height="Auto"/>              <!-- 1. Presets -->
 28 |             <RowDefinition Height="Auto"/>              <!-- 2. Variables -->
 29 |             <RowDefinition Height="*"/>                 <!-- 3.  -->
 30 |         </Grid.RowDefinitions>
 31 | 
 32 |         <StackPanel HorizontalAlignment="Stretch"
 33 |             Grid.Column="0"  Grid.Row="0"
 34 |         >
 35 |             <DockPanel Margin="0,0,0,10" >
 36 |                 <TextBlock DockPanel.Dock="Left"
 37 |                     Margin="0,0,10,0"
 38 |                     MinWidth="200"
 39 |                     MaxWidth="200"
 40 |                     Text="{DynamicResource LOCThemeOptionsSettingsChooseTheme}"
 41 |                     VerticalAlignment="Center"/>
 42 | 
 43 |                 <ComboBox HorizontalAlignment="Stretch"
 44 |                     x:Name="SelectedTheme"
 45 |                     SelectedItem="{Binding SelectedTheme, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
 46 |                     ItemsSource="{Binding CustomizableThemes}"
 47 |                     >
 48 |                     <ComboBox.ItemTemplate>
 49 |                         <DataTemplate>
 50 |                             <TextBlock Text="{Binding Name}"/>
 51 |                         </DataTemplate>
 52 |                     </ComboBox.ItemTemplate>
 53 |                 </ComboBox>
 54 |             </DockPanel >
 55 | 
 56 |             <Separator Margin="0,0,0,10" />
 57 |         </StackPanel>
 58 |         <StackPanel HorizontalAlignment="Stretch" Margin="20,0,0,0"
 59 |             Grid.Column="0" Grid.Row="1" >
 60 |             <StackPanel x:Name="Presets" HorizontalAlignment="Stretch" Margin="20,0,0,0"
 61 |                 Visibility="{Binding ElementName=SelectedTheme, Path=SelectedItem.PresetList, Converter={StaticResource ICollectionNullOrEmptyToVisibilityConverter}}">
 62 |                 <TextBlock Margin="-20,0,0,10" Text="{DynamicResource LOCThemeOptionsSettingsPresets}" />
 63 |                 <Separator Margin="-20,0,0,10" />
 64 |                 <ItemsControl ItemsSource="{Binding ElementName=SelectedTheme, Path=SelectedItem.PresetList}">
 65 |                     <ItemsControl.ItemTemplate>
 66 |                         <DataTemplate>
 67 |                             <DockPanel>
 68 |                                 <Separator DockPanel.Dock="Bottom" Margin="0,5,0,5" />
 69 |                                 <TextBlock DockPanel.Dock="Left"
 70 |                                     Style="{StaticResource BaseTextBlockStyle}"
 71 |                                     MinWidth="200"
 72 |                                     VerticalAlignment="Center"
 73 |                                     Text="{Binding Name}" />
 74 |                                 <ComboBox HorizontalAlignment="Stretch"
 75 |                                     ItemsSource="{Binding OptionsList}"
 76 |                                     SelectedValue="{Binding Selected}"
 77 |                                     >
 78 |                                     <ComboBox.ItemTemplate>
 79 |                                         <DataTemplate>
 80 |                                             <StackPanel>
 81 |                                                 <TextBlock Text="{Binding Name}"/>
 82 |                                             </StackPanel>
 83 |                                         </DataTemplate>
 84 |                                     </ComboBox.ItemTemplate>
 85 |                                     <ComboBox.ItemContainerStyle>
 86 |                                         <Style TargetType="{x:Type ComboBoxItem}">
 87 |                                             <Setter Property="local:Views.FocusHelper.IsFocused" Value = "{Binding RelativeSource={RelativeSource Self}, Path=IsFocused}" />
 88 |                                         </Style>
 89 |                                     </ComboBox.ItemContainerStyle>
 90 |                                 </ComboBox>
 91 |                             </DockPanel>
 92 |                         </DataTemplate>
 93 |                     </ItemsControl.ItemTemplate>
 94 |                 </ItemsControl>
 95 |             </StackPanel>
 96 | 
 97 |             <StackPanel x:Name="Variables" HorizontalAlignment="Stretch" Margin="20,20,0,0"
 98 |                 Visibility="{Binding ElementName=SelectedTheme, Path=SelectedItem.VariablesList, Converter={StaticResource ICollectionNullOrEmptyToVisibilityConverter}}"
 99 |                 >
100 |                 <TextBlock Margin="-20,0,0,10" Text="{DynamicResource LOCThemeOptionsSettingsVariables}" />
101 |                 <Separator Margin="-20,0,0,10" />
102 |                 <ItemsControl
103 |                     ItemsSource="{Binding ElementName=SelectedTheme, Path=SelectedItem.VariablesList}"
104 |                     ItemTemplateSelector="{StaticResource VariableTemplateSelector}">
105 |                     <ItemsControl.Resources>
106 |                         <DataTemplate x:Key="HEADER_PanelTemplate">
107 |                             <TextBlock Margin="-20,10,0,10" Text="{Binding Title}" Style="{StaticResource BaseTextBlockStyle}" />
108 |                         </DataTemplate>
109 |                         <DataTemplate x:Key="STRING_PanelTemplate">
110 |                             <DockPanel Margin="0,0,0,10" MinHeight="30">
111 |                                 <Button DockPanel.Dock="Right" Margin="10,0,0,0"
112 |                                     Command="{x:Static views:Commands.ResetToDefault}"
113 |                                     CommandParameter="{Binding}"
114 |                                 >
115 |                                     <TextBlock Text="&#xee0b;" Margin="-3" FontFamily="{DynamicResource FontIcoFont}" />
116 |                                 </Button>
117 |                                 <TextBlock
118 |                                     Style="{StaticResource BaseTextBlockStyle}"
119 |                                     DockPanel.Dock="Left" Margin="0,0,10,0" MinWidth="100" Text="{Binding Title}" VerticalAlignment="Center"/>
120 |                                 <TextBox
121 |                                     HorizontalAlignment="Stretch" Text="{Binding Value}"/>
122 |                             </DockPanel>
123 |                         </DataTemplate>
124 |                         <DataTemplate x:Key="BOOLEAN_PanelTemplate">
125 |                             <DockPanel Margin="0,0,0,10" MinHeight="30" >
126 |                                 <Button DockPanel.Dock="Right" Margin="10,0,0,0"
127 |                                     Command="{x:Static views:Commands.ResetToDefault}"
128 |                                     CommandParameter="{Binding}" >
129 |                                     <TextBlock Text="&#xee0b;" Margin="-3" FontFamily="{DynamicResource FontIcoFont}" />
130 |                                 </Button>
131 |                                 <CheckBox VerticalAlignment="Center" IsChecked="{Binding Value}" DockPanel.Dock="Left" Margin="0,0,0,0" >
132 |                                     <TextBlock Margin="10,0,0,0"
133 |                                         Style="{StaticResource BaseTextBlockStyle}"
134 |                                         Text="{Binding Title}" VerticalAlignment="Center"/>
135 |                                 </CheckBox>
136 |                             </DockPanel>
137 |                         </DataTemplate>
138 |                         <DataTemplate x:Key="VISIBILITY_PanelTemplate">
139 |                                 <DockPanel Margin="0,0,0,10" MinHeight="30" >
140 |                                     <CheckBox VerticalAlignment="Center"
141 |                                         IsChecked="{Binding Value, Converter={StaticResource VisibilityToBooleanConverter}}"
142 |                                         DockPanel.Dock="Left" Margin="0,0,0,0" >
143 |                                         <TextBlock Margin="10,0,0,0"
144 |                                             Style="{StaticResource BaseTextBlockStyle}"
145 |                                             Text="{Binding Title}" VerticalAlignment="Center"/>
146 |                                     </CheckBox>
147 |                                 </DockPanel>
148 |                             </DataTemplate>
149 |                         <DataTemplate x:Key="SLIDER_PanelTemplate">
150 |                             <DockPanel LastChildFill="False" Margin="0,0,0,10" MinHeight="30">
151 |                                 <TextBlock Text="{Binding Title}"
152 |                                            VerticalAlignment="Center"
153 |                                            Style="{StaticResource BaseTextBlockStyle}"/>
154 |                                 <Button DockPanel.Dock="Right" Margin="10,0,0,0"
155 |                                     Command="{x:Static views:Commands.ResetToDefault}"
156 |                                     VerticalAlignment="Center"
157 |                                     CommandParameter="{Binding}" >
158 |                                     <TextBlock Text="&#xee0b;" Margin="-3" FontFamily="{DynamicResource FontIcoFont}" />
159 |                                 </Button>
160 |                                 <Slider
161 |                                             DockPanel.Dock="Right"
162 |                                             Width="200"
163 |                                             VerticalAlignment="Center"
164 |                                             Value="{Binding Value, UpdateSourceTrigger=PropertyChanged}"
165 |                                             Minimum="{Binding Slider.Min}"
166 |                                             Maximum="{Binding Slider.Max}"
167 |                                             TickFrequency="{Binding Slider.SmallChange}"
168 |                                             SmallChange="{Binding Slider.SmallChange}"
169 |                                             LargeChange="{Binding Slider.LargeChange}"
170 |                                             IsSnapToTickEnabled="True"
171 |                                 />
172 |                                 <TextBlock
173 |                                             DockPanel.Dock="Right"
174 |                                             VerticalAlignment="Center"
175 |                                             Text="{Binding Value}"
176 |                                             Margin="0,0,10,0"
177 |                                             Style="{StaticResource BaseTextBlockStyle}"/>
178 |                             </DockPanel>
179 |                         </DataTemplate>
180 |                         <DataTemplate x:Key="DURATION_PanelTemplate">
181 |                             <DockPanel LastChildFill="False" Margin="0,0,0,10" MinHeight="30">
182 |                                 <TextBlock Text="{Binding Title}"
183 |                                            VerticalAlignment="Center"
184 |                                            Style="{StaticResource BaseTextBlockStyle}"/>
185 |                                 <Button DockPanel.Dock="Right" Margin="10,0,0,0"
186 |                                     VerticalAlignment="Center"
187 |                                     Command="{x:Static views:Commands.ResetToDefault}"
188 |                                     CommandParameter="{Binding}" >
189 |                                     <TextBlock Text="&#xee0b;" Margin="-3" FontFamily="{DynamicResource FontIcoFont}" />
190 |                                 </Button>
191 |                                 <Slider
192 |                                             DockPanel.Dock="Right"
193 |                                             Width="200"
194 |                                             VerticalAlignment="Center"
195 |                                             Value="{Binding Value, UpdateSourceTrigger=PropertyChanged, Converter={StaticResource DurationToDoubleConverter}}"
196 |                                             Minimum="{Binding Slider.Min}"
197 |                                             Maximum="{Binding Slider.Max}"
198 |                                             TickFrequency="{Binding Slider.SmallChange}"
199 |                                             SmallChange="{Binding Slider.SmallChange}"
200 |                                             LargeChange="{Binding Slider.LargeChange}"
201 |                                             IsSnapToTickEnabled="True"
202 |                                 />
203 |                                 <TextBlock
204 |                                             VerticalAlignment="Center"
205 |                                             DockPanel.Dock="Right"
206 |                                             Text="{Binding Value, Converter={StaticResource DurationToStringConverter}}"
207 |                                             Margin="0,0,10,0"
208 |                                             Style="{StaticResource BaseTextBlockStyle}"/>
209 |                             </DockPanel>
210 |                         </DataTemplate>
211 |                     </ItemsControl.Resources>
212 |                 </ItemsControl>
213 |             </StackPanel>
214 |         </StackPanel>
215 |         <Image
216 |             Grid.Column="1" Grid.Row="1" Grid.RowSpan="3"
217 |             Margin="40,0,0,0"
218 |             VerticalAlignment="Top"
219 |             HorizontalAlignment="Left"
220 |             Stretch="Uniform"
221 |             MaxWidth="{Binding Source.PixelWidth,RelativeSource={RelativeSource Self}}"
222 |             MaxHeight="{Binding Source.PixelHeight,RelativeSource={RelativeSource Self}}"
223 |             Source="{Binding PreviewImage, TargetNullValue={x:Null}}"
224 |         />
225 |     </Grid>
226 |     </ScrollViewer>
227 | 
228 | </UserControl>


--------------------------------------------------------------------------------
/Views/FullscreenSettingsView.xaml:
--------------------------------------------------------------------------------
  1 | <UserControl
  2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4 |              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  5 |              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  6 |              xmlns:pctrls="clr-namespace:Playnite.FullscreenApp.Controls;assembly=Playnite.FullscreenApp"
  7 |              xmlns:pbeh="clr-namespace:Playnite.Behaviors;assembly=Playnite"
  8 |              xmlns:local="clr-namespace:ThemeOptions;assembly=ThemeOptions"
  9 |              xmlns:views="clr-namespace:ThemeOptions.Views;assembly=ThemeOptions"
 10 |              xmlns:con="clr-namespace:ThemeOptions.Converters;assembly=ThemeOptions"
 11 |              mc:Ignorable="d"
 12 |              d:DesignHeight="400" d:DesignWidth="600"
 13 |              >
 14 |     <UserControl.Resources>
 15 |         <views:VariablePanelItemsDataTemplateSelector x:Key="VariableTemplateSelector"/>
 16 |         <con:DurationToDouble x:Key="DurationToDoubleConverter"/>
 17 |         <con:DurationToString x:Key="DurationToStringConverter"/>
 18 |         <con:VisibilityToBooleanConverter x:Key="VisibilityToBooleanConverter" />
 19 | 
 20 |         <Style TargetType="pctrls:CheckBoxEx" BasedOn="{StaticResource SettingsSectionCheckbox}" />
 21 |         <Style TargetType="pctrls:ComboBoxEx" BasedOn="{StaticResource SettingsSectionCombobox}" />
 22 |         <Style TargetType="TextBlock" BasedOn="{StaticResource SettingsSectionText}" />
 23 |         <Style TargetType="Grid" x:Key="ThemeOptionsPreviewImageGridStyle">
 24 |             <Setter Property="Margin" Value="0,420,-440,-600" />
 25 |             <Setter Property="Width" Value="360" />
 26 |             <Setter Property="Height" Value="360" />
 27 |             <Setter Property="VerticalAlignment" Value="Top" />
 28 |             <Setter Property="HorizontalAlignment" Value="Right" />
 29 |         </Style>
 30 |         <Style TargetType="Image" x:Key="ThemeOptionsPreviewImageStyle">
 31 |             <Setter Property="VerticalAlignment" Value="Top" />
 32 |             <Setter Property="HorizontalAlignment" Value="Left" />
 33 |         </Style>
 34 | 
 35 |         <DataTemplate x:Key="SettingsMenuThemeOptionsButtonTemplate">
 36 |             <StackPanel Orientation="Horizontal">
 37 |                 <TextBlock Text="&#xef4b;" FontFamily="{DynamicResource FontIcoFont}" FontSize="24"
 38 |                            VerticalAlignment="Center" HorizontalAlignment="Center" Margin="0,0,10,0"/>
 39 |                 <TextBlock Text="{DynamicResource LOCThemeOptionsSettingsMenu}" VerticalAlignment="Center" />
 40 |             </StackPanel>
 41 |         </DataTemplate>
 42 | 
 43 |         <Style x:Key="SettingsSectionInputBoxStyle" TargetType="{x:Type ButtonEx}" BasedOn="{StaticResource {x:Type ButtonEx}}">
 44 |             <Setter Property="BorderThickness" Value="2" />
 45 |             <Setter Property="MinWidth" Value="300" />
 46 |             <Setter Property="Margin"  Value="10,0,10,10" />
 47 |         </Style>
 48 | 
 49 |         <DataTemplate x:Key="SettingsSectionInputBoxTemplate">
 50 |             <DockPanel MinWidth="{Binding MinWidth, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ButtonEx}}}">
 51 |                 <Viewbox DockPanel.Dock="Right" Height="20" Margin="10,0,0,0">
 52 |                     <TextBlock Text="&#xec55;" FontFamily="{StaticResource FontIcoFont}"
 53 |                                Foreground="{DynamicResource TextBrush}"
 54 |                                FontSize="{DynamicResource FontSize}"
 55 |                                VerticalAlignment="Center"/>
 56 |                 </Viewbox>
 57 |                 <ContentPresenter DockPanel.Dock="Left"
 58 |                                   Content="{Binding}"
 59 |                                   HorizontalAlignment="Left"
 60 |                                   VerticalAlignment="Center"/>
 61 |             </DockPanel>
 62 |         </DataTemplate>
 63 |     </UserControl.Resources>
 64 | 
 65 |     <Grid
 66 |         HorizontalAlignment="Stretch" VerticalAlignment="Top" Margin="20,20,20,20"
 67 | 
 68 |     >
 69 |         <DockPanel HorizontalAlignment="Stretch"  VerticalAlignment="Top">
 70 |             <StackPanel x:Name="ThemeSelector"
 71 |                 HorizontalAlignment="Stretch"
 72 |                 Visibility="Collapsed"
 73 |             >
 74 |                 <DockPanel Margin="0,0,0,10" >
 75 |                     <TextBlock DockPanel.Dock="Left"
 76 |                         Margin="0,0,10,0"
 77 |                         MinWidth="200"
 78 |                         MaxWidth="200"
 79 |                         Text="Choose theme to set options:"
 80 |                         VerticalAlignment="Center"/>
 81 | 
 82 |                     <pctrls:ComboBoxEx HorizontalAlignment="Stretch"
 83 |                         x:Name="SelectedTheme"
 84 |                         Style="{StaticResource SettingsSectionCombobox}"
 85 |                         SelectedItem="{Binding SelectedTheme, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
 86 |                         ItemsSource="{Binding CustomizableThemes}"
 87 |                         MinWidth="200"
 88 |                         >
 89 |                         <pctrls:ComboBoxEx.ItemTemplate>
 90 |                             <DataTemplate>
 91 |                                 <TextBlock Text="{Binding Name}"/>
 92 |                             </DataTemplate>
 93 |                         </pctrls:ComboBoxEx.ItemTemplate>
 94 |                     </pctrls:ComboBoxEx>
 95 |                 </DockPanel >
 96 |             </StackPanel>
 97 |             <ItemsControl
 98 |                 ItemsSource="{Binding ElementName=SelectedTheme, Path=SelectedItem.SettingsList}"
 99 |                 Focusable="False"
100 |                 ItemTemplateSelector="{StaticResource VariableTemplateSelector}">
101 |                 <ItemsControl.Resources>
102 |                     <DataTemplate x:Key="PRESET_PanelTemplate">
103 |                         <DockPanel LastChildFill="False">
104 |                             <TextBlock DockPanel.Dock="Left"
105 |                                 Text="{Binding Name}"
106 |                                 Style="{StaticResource SettingsSectionText}" />
107 |                             <pctrls:ComboBoxEx HorizontalAlignment="Stretch"
108 |                                 ItemsSource="{Binding OptionsList}"
109 |                                 SelectedValue="{Binding Selected}"
110 |                                 DockPanel.Dock="Right"
111 |                                 Style="{StaticResource SettingsSectionCombobox}"
112 |                                 >
113 |                                 <pctrls:ComboBoxEx.ItemTemplate>
114 |                                     <DataTemplate>
115 |                                         <TextBlock Text="{Binding Name}" />
116 |                                     </DataTemplate>
117 |                                 </pctrls:ComboBoxEx.ItemTemplate>
118 |                                 <pctrls:ComboBoxEx.ItemContainerStyle>
119 |                                     <Style TargetType="{x:Type ComboBoxItem}" BasedOn="{StaticResource {x:Type ComboBoxItem}}">
120 |                                         <Setter Property="local:Views.FocusHelper.IsFocused" Value = "{Binding RelativeSource={RelativeSource Self}, Path=IsFocused}" />
121 |                                     </Style>
122 |                                 </pctrls:ComboBoxEx.ItemContainerStyle>
123 |                             </pctrls:ComboBoxEx>
124 |                         </DockPanel>
125 |                     </DataTemplate>
126 |                     <DataTemplate x:Key="HEADER_PanelTemplate">
127 |                         <DockPanel LastChildFill="False" Style="{Binding DockPanelStyle}">
128 |                             <TextBlock Text="{Binding Title}"
129 |                                 Style="{Binding TextBlockStyle, TargetNullValue={StaticResource SettingsSectionText}}" />
130 |                         </DockPanel>
131 |                     </DataTemplate>
132 |                     <DataTemplate x:Key="STRING_PanelTemplate">
133 |                         <DockPanel LastChildFill="False" Style="{Binding DockPanelStyle}">
134 |                             <TextBlock Text="{Binding Title}"
135 |                                 Style="{StaticResource SettingsSectionText}"
136 |                                 DockPanel.Dock="Left" />
137 | 
138 |                             <pctrls:ButtonEx
139 |                                 Style="{StaticResource SettingsSectionInputBoxStyle}"
140 |                                 DockPanel.Dock="Right"
141 |                                 Content="{Binding Value}"
142 |                                 ContentTemplate="{DynamicResource SettingsSectionInputBoxTemplate}"
143 |                                 HorizontalAlignment="Right"
144 |                                 Command="{x:Static views:Commands.TextInputCommand}"
145 |                                 CommandParameter="{Binding}"
146 |                                 >
147 |                             </pctrls:ButtonEx>
148 |                         </DockPanel>
149 |                     </DataTemplate>
150 |                     <DataTemplate x:Key="BOOLEAN_PanelTemplate">
151 |                         <DockPanel LastChildFill="True" Style="{Binding DockPanelStyle}">
152 |                             <pctrls:CheckBoxEx
153 |                                 Style="{StaticResource SettingsSectionCheckbox}"
154 |                                 Content="{Binding Title}"
155 |                                 VerticalAlignment="Center"
156 |                                 IsChecked="{Binding Value}"
157 |                                 DockPanel.Dock="Left" >
158 |                             </pctrls:CheckBoxEx>
159 |                         </DockPanel>
160 |                     </DataTemplate>
161 |                     <DataTemplate x:Key="VISIBILITY_PanelTemplate">
162 |                         <DockPanel LastChildFill="True" Style="{Binding DockPanelStyle}">
163 |                             <pctrls:CheckBoxEx
164 |                                 Style="{StaticResource SettingsSectionCheckbox}"
165 |                                 Content="{Binding Title}"
166 |                                 VerticalAlignment="Center"
167 |                                 IsChecked="{Binding Value, Converter={StaticResource VisibilityToBooleanConverter}}"
168 |                                 DockPanel.Dock="Left" >
169 |                             </pctrls:CheckBoxEx>
170 |                         </DockPanel>
171 |                     </DataTemplate>
172 |                     <DataTemplate x:Key="SLIDER_PanelTemplate">
173 |                         <DockPanel LastChildFill="False" Style="{Binding DockPanelStyle}">
174 |                             <TextBlock Text="{Binding Title}"
175 |                                     Style="{StaticResource SettingsSectionText}"/>
176 | 
177 |                             <pctrls:SliderEx
178 |                                         DockPanel.Dock="Right"
179 |                                         Style="{DynamicResource SettingsSectionSlider}"
180 |                                         Value="{Binding Value, UpdateSourceTrigger=PropertyChanged}"
181 |                                         Minimum="{Binding Slider.Min}"
182 |                                         Maximum="{Binding Slider.Max}"
183 |                                         TickFrequency="{Binding Slider.SmallChange}"
184 |                                         SmallChange="{Binding Slider.SmallChange}"
185 |                                         LargeChange="{Binding Slider.LargeChange}"
186 |                                         IsSnapToTickEnabled="True"
187 |                             />
188 |                             <TextBlock
189 |                                         DockPanel.Dock="Right"
190 |                                         Text="{Binding Value}"
191 |                                         Margin="0,0,10,0"
192 |                                         Style="{StaticResource SettingsSectionText}"/>
193 |                         </DockPanel>
194 |                     </DataTemplate>
195 |                     <DataTemplate x:Key="DURATION_PanelTemplate">
196 |                         <DockPanel LastChildFill="False" Style="{Binding DockPanelStyle}">
197 |                             <TextBlock Text="{Binding Title}"
198 |                                     Style="{StaticResource SettingsSectionText}"/>
199 | 
200 |                             <pctrls:SliderEx
201 |                                         DockPanel.Dock="Right"
202 |                                         Style="{DynamicResource SettingsSectionSlider}"
203 |                                         Value="{Binding Value, UpdateSourceTrigger=PropertyChanged, Converter={StaticResource DurationToDoubleConverter}}"
204 |                                         Minimum="{Binding Slider.Min}"
205 |                                         Maximum="{Binding Slider.Max}"
206 |                                         TickFrequency="{Binding Slider.SmallChange}"
207 |                                         SmallChange="{Binding Slider.SmallChange}"
208 |                                         LargeChange="{Binding Slider.LargeChange}"
209 |                                         IsSnapToTickEnabled="True"
210 |                             />
211 |                             <TextBlock
212 |                                         DockPanel.Dock="Right"
213 |                                         Text="{Binding Value, Converter={StaticResource DurationToStringConverter}}"
214 |                                         Margin="0,0,10,0"
215 |                                         Style="{StaticResource SettingsSectionText}"/>
216 |                         </DockPanel>
217 |                     </DataTemplate>
218 | 
219 |                 </ItemsControl.Resources>
220 |                 <ItemsControl.Template>
221 |                     <ControlTemplate>
222 |                         <ScrollViewer
223 |                             Focusable="False"
224 |                             KeyboardNavigation.DirectionalNavigation="None"
225 |                             HorizontalScrollBarVisibility="Disabled"
226 |                             VerticalScrollBarVisibility="Auto"
227 |                             CanContentScroll="True">
228 |                             <ItemsPresenter />
229 |                         </ScrollViewer>
230 |                     </ControlTemplate>
231 |                 </ItemsControl.Template>
232 |             </ItemsControl>
233 |         </DockPanel>
234 |         <Grid Style="{DynamicResource ThemeOptionsPreviewImageGridStyle}" >
235 |             <Image
236 |                 Style="{DynamicResource ThemeOptionsPreviewImageStyle}"
237 |                 Stretch="Uniform"
238 |                 MaxWidth="{Binding Source.PixelWidth,RelativeSource={RelativeSource Self}}"
239 |                 MaxHeight="{Binding Source.PixelHeight,RelativeSource={RelativeSource Self}}"
240 |                 Source="{Binding PreviewImage, TargetNullValue={x:Null}}"
241 |             />
242 |         </Grid>
243 |     </Grid>
244 | </UserControl>
245 | 


--------------------------------------------------------------------------------
/ThemeOptions.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Collections.Generic;
  4 | using System.Reflection;
  5 | using System.Windows.Controls;
  6 | using System.Windows;
  7 | using System.Windows.Markup;
  8 | 
  9 | using Playnite.SDK;
 10 | using Playnite.SDK.Plugins;
 11 | using Playnite.SDK.Data;
 12 | 
 13 | using ThemeOptions.Models;
 14 | using ThemeOptions.Views;
 15 | using ThemeOptions.Controls;
 16 | using Playnite.SDK.Events;
 17 | using ThemeOptions.Tools;
 18 | 
 19 | 
 20 | namespace ThemeOptions
 21 | {
 22 |     public class ThemeOptions : GenericPlugin
 23 |     {
 24 |         private static readonly ILogger logger = LogManager.GetLogger();
 25 | 
 26 |         public static string PluginVersion;
 27 |         private static readonly string PluginFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
 28 |         public static IPlayniteAPI PlayniteAPI { get; private set; }
 29 | 
 30 |         public static SettingsViewModel Settings { get; set; }
 31 |         public Views.SettingsView SettingsView { get; private set; }
 32 |         public static Window CustomWindow { get; private set; }
 33 | 
 34 |         public string CurrentThemeId;
 35 | 
 36 |         public Extensions MissingExtensions { get; private set; } = new Extensions();
 37 | 
 38 |         public override Guid Id { get; } = Guid.Parse("904cbf3b-573f-48f8-9642-0a09d05c64ef");
 39 |         List<ResourceDictionary> themeResources = new List<ResourceDictionary>();
 40 | 
 41 |         public ResourceDictionary LoadResource(string resourceFile, bool mandatory = true)
 42 |         {
 43 |             if (File.Exists(resourceFile))
 44 |             {
 45 |                 try
 46 |                 {
 47 |                     using (var stream = new StreamReader(resourceFile))
 48 |                     {
 49 |                         ResourceDictionary resource = (ResourceDictionary)XamlReader.Load(stream.BaseStream);
 50 |                         resource.Source = new Uri(resourceFile, UriKind.Absolute);
 51 |                         Application.Current.Resources.MergedDictionaries.Add(resource);
 52 |                         return resource;
 53 |                     }
 54 |                 }
 55 |                 catch (Exception e)
 56 |                 {
 57 |                     logger.Error($"Error: '{e.Message}' during loading resource {resourceFile} ");
 58 |                 }
 59 |             }
 60 |             else if (mandatory)
 61 |             {
 62 |                 logger.Error($"File not found {resourceFile}");
 63 |             }
 64 |             else
 65 |             {
 66 |                 logger.Info($"Optional file not found {resourceFile}");
 67 |             }
 68 |             return null;
 69 |         }
 70 |         public void LoadThemeOption()
 71 |         {
 72 |             foreach (ResourceDictionary resource in themeResources)
 73 |             {
 74 |                 Application.Current.Resources.MergedDictionaries.Remove(resource);
 75 |             }
 76 |             themeResources.Clear();
 77 | 
 78 |             Theme theme = Theme.FromId(CurrentThemeId);
 79 |             if (theme == null) return;
 80 | 
 81 |             if (theme.Options?.Presets?.Count > 0)
 82 |             {
 83 |                 List<string> selectedPresets = Settings.ThemePresets(theme.Id);
 84 |                 if (selectedPresets?.Count > 0)
 85 |                 {
 86 |                     var presets = String.Join(", ", selectedPresets);
 87 |                     logger.Info($"Loading presets {presets}");
 88 |                     foreach (var presetResource in theme.Options.Presets.GetResourceFiles(selectedPresets))
 89 |                     {
 90 |                         logger.Info($"Loading resource {presetResource}");
 91 |                         if (LoadResource(Path.Combine(theme.Path, presetResource)) is ResourceDictionary resource)
 92 |                         {
 93 |                             themeResources.Add(resource);
 94 |                         }
 95 |                     }
 96 |                 }
 97 |             }
 98 | 
 99 | 
100 |             var missingRequired = new List<string>();
101 |             var missingRecommended = new List<string>();
102 | 
103 |             var installedExtensions = PlayniteAPI.Addons.Addons;
104 |             if (theme.Extensions?.Required?.Count > 0)
105 |             {
106 |                 foreach (var ext in theme.Extensions.Required)
107 |                 {
108 |                     if (!installedExtensions.Exists(a => a.Equals(ext, StringComparison.OrdinalIgnoreCase)))
109 |                     {
110 |                         missingRequired.Add(ext);
111 |                     }
112 |                 }
113 |             }
114 | 
115 |             if(theme.Extensions?.Recommended?.Count > 0)
116 |             {
117 |                 foreach (var ext in theme.Extensions.Recommended)
118 |                 {
119 |                     if (!installedExtensions.Exists(a => a.Equals(ext, StringComparison.OrdinalIgnoreCase)))
120 |                     {
121 |                         missingRecommended.Add(ext);
122 |                     }
123 |                 }
124 |             }
125 | 
126 |             MissingExtensions = new Extensions
127 |             {
128 |                 Required = missingRequired,
129 |                 Recommended = missingRecommended
130 |             };
131 | 
132 |             if (PlayniteAPI.ApplicationSettings.Language != "en_US")
133 |             {
134 |                 logger.Info($"Loading theme localization {PlayniteAPI.ApplicationSettings.Language}");
135 |                 Localization.Load(theme.Path, PlayniteAPI.ApplicationSettings.Language);
136 |             }
137 | 
138 |             if (theme.Options != null)
139 |             {
140 |                 var themeSettings = Settings.ThemeSettings(theme.Id);
141 |                 if (themeSettings != null && themeSettings.Count > 0)
142 |                 {
143 |                     try
144 |                     {
145 |                         var settingsText = themeSettings.FormatResourceDictionary();
146 |                         logger.Debug("FormatResourceDictionary:\n" + settingsText);
147 |                         ResourceDictionary resource = (ResourceDictionary)XamlReader.Parse(settingsText);
148 |                         Application.Current.Resources.MergedDictionaries.Add(resource);
149 |                         themeResources.Add(resource);
150 |                     }
151 |                     catch (Exception e)
152 |                     {
153 |                         logger.Error($"Error while parsing settings: {e.Message}");
154 |                     }
155 |                 }
156 |             }
157 |         }
158 | 
159 |         public static void OpenWindow(string styleName)
160 |         {
161 |             var parent = PlayniteAPI.Dialogs.GetCurrentAppWindow();
162 |             CustomWindow = PlayniteAPI.Dialogs.CreateWindow(new WindowCreationOptions
163 |             {
164 |                 ShowMinimizeButton = false
165 |             });
166 | 
167 |             CustomWindow.Height = parent.Height;
168 |             CustomWindow.Width = parent.Width;
169 |             CustomWindow.Title = "MoData";
170 | 
171 |             string xamlString = $@"
172 |             <Viewbox Stretch=""Uniform""
173 |                      xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation""
174 |                      xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml""
175 |                      xmlns:pbeh=""clr-namespace:Playnite.Behaviors;assembly=Playnite"">
176 |                 <Grid Width=""1920"" Height=""1080"">
177 |                     <ContentControl x:Name=""CustomWindow""
178 |                                     Focusable=""False""
179 |                                     Style=""{{DynamicResource {styleName}}}"" />
180 |                 </Grid>
181 |             </Viewbox>";
182 | 
183 |             // Parse the XAML string
184 |             var element = (FrameworkElement)XamlReader.Parse(xamlString);
185 | 
186 | 
187 |             CustomWindow.Content = element;
188 | 
189 |             CustomWindow.DataContext = parent.DataContext;
190 | 
191 |             CustomWindow.Owner = parent;
192 |             CustomWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
193 | 
194 |             CustomWindow.PreviewKeyDown += (s, e) =>
195 |             {
196 |                 if (e.Key == System.Windows.Input.Key.Escape)
197 |                 {
198 |                     CustomWindow.Close();
199 |                     CustomWindow = null;
200 |                     e.Handled = true;
201 |                 }
202 |             };
203 | 
204 |             CustomWindow.ShowDialog();
205 |         }
206 | 
207 |         public ThemeOptions(IPlayniteAPI api) : base(api)
208 |         {
209 |             PlayniteAPI = api;
210 |             CurrentThemeId =
211 |                 PlayniteAPI.ApplicationInfo.Mode == ApplicationMode.Fullscreen
212 |                     ? PlayniteAPI.ApplicationSettings.FullscreenTheme
213 |                     : PlayniteAPI.ApplicationSettings.DesktopTheme;
214 | 
215 |             Settings = new SettingsViewModel(this);
216 |             Properties = new GenericPluginProperties
217 |             {
218 |                 HasSettings = true
219 |             };
220 |             Localization.Load(PluginFolder, PlayniteAPI.ApplicationSettings.Language);
221 |             LoadThemeOption();
222 |             if (PlayniteAPI.ApplicationInfo.Mode == ApplicationMode.Fullscreen)
223 |             {
224 |                 FullscreenSettingsView.Init();
225 |             }
226 | 
227 |             AddSettingsSupport(new AddSettingsSupportArgs
228 |             {
229 |                 SourceName = "ThemeOptions",
230 |                 SettingsRoot = $"{nameof(Settings)}.{nameof(Settings.Settings)}"
231 |             });
232 | 
233 | 
234 |             AddCustomElementSupport(new AddCustomElementSupportArgs
235 |             {
236 |                 SourceName = "ThemeOptions",
237 |                 ElementList = new List<string>
238 |                 {
239 |                     "Command",
240 |                     "GamepadAdd",
241 |                     "GamepadAlt",
242 |                     "GamepadAddGlobal",
243 |                     "GamepadAltGlobal"
244 |                 }
245 |             });
246 |         }
247 | 
248 |         public Options FromFile(string optionsFile)
249 |         {
250 |             if (!File.Exists(optionsFile)) return null;
251 | 
252 |             try
253 |             {
254 |                 return Serialization.FromYamlFile<Options>(optionsFile);
255 |             }
256 |             catch (Exception e)
257 |             {
258 |                 logger.Error($"Error loading theme option file {optionsFile}: \n{e.Message}");
259 |                 return null;
260 |             }
261 |         }
262 | 
263 |         public override ISettings GetSettings(bool firstRunSettings)
264 |         {
265 |             return Settings;
266 |         }
267 | 
268 |         public override UserControl GetSettingsView(bool firstRunSettings)
269 |         {
270 |             if (SettingsView == null)
271 |                 SettingsView = new Views.SettingsView();
272 |             return SettingsView as UserControl;
273 |         }
274 | 
275 |         public override Control GetGameViewControl(GetGameViewControlArgs args)
276 |         {
277 |             var strArgs = args.Name.Split('_');
278 | 
279 |             var controlType = strArgs[0];
280 | 
281 |             switch (controlType)
282 |             {
283 |                 case "Command":
284 |                     return new CommandControl();
285 |                 case "GamepadAdd":
286 |                     return new GamepadAltControl(suppressDefaults: false);
287 |                 case "GamepadAlt":
288 |                     return new GamepadAltControl(suppressDefaults: true);
289 |                 case "GamepadAddGlobal":
290 |                     return new GamepadAltControl(suppressDefaults: false, global: true);
291 |                 case "GamepadAltGlobal":
292 |                     return new GamepadAltControl(suppressDefaults: true, global: true);
293 |                 default:
294 |                     throw new ArgumentException($"Unrecognized controlType '{controlType}' for request '{args.Name}'");
295 |             }
296 |         }
297 | 
298 |         public override void OnApplicationStarted(OnApplicationStartedEventArgs args)
299 |         {
300 |             if (MissingExtensions?.Required?.Count > 0)
301 |             {
302 |                 var result = PlayniteAPI.Dialogs.ShowMessage(
303 |                     $"You are missing {MissingExtensions.Required.Count} required extensions for this theme. Would you like to open their addon pages?",
304 |                     "Missing Extensions",
305 |                     MessageBoxButton.YesNo
306 |                 );
307 |                 if (result == MessageBoxResult.Yes)
308 |                 {
309 |                     foreach (var ext in MissingExtensions.Required)
310 |                     {
311 |                         System.Diagnostics.Process.Start($"https://playnite.link/addons.html#{ext}");
312 |                     }
313 |                 }
314 |             }
315 |             if (MissingExtensions?.Recommended?.Count > 0)
316 |             {
317 |                 PlayniteAPI.Notifications.Add(
318 |                     new NotificationMessage(
319 |                         "ThemeOptions-MissingExtensions",
320 |                         $"You are missing {MissingExtensions.Recommended.Count} recommended extensions for this theme.",
321 |                         NotificationType.Info,
322 |                         () =>
323 |                         {
324 |                             var result = PlayniteAPI.Dialogs.ShowMessage(
325 |                                 $"You are missing {MissingExtensions.Recommended.Count} recommended extensions for this theme. Would you like to open their addon pages?",
326 |                                 "Missing Extensions",
327 |                                 MessageBoxButton.YesNo
328 |                             );
329 |                             if (result == MessageBoxResult.Yes)
330 |                             {
331 |                                 foreach (var ext in MissingExtensions.Recommended)
332 |                                 {
333 |                                     System.Diagnostics.Process.Start($"https://playnite.link/addons.html#{ext}");
334 |                                 }
335 |                             }
336 |                         }
337 |                     )
338 |                 );
339 |             }
340 |         }
341 | 
342 |         public override void OnApplicationStopped(OnApplicationStoppedEventArgs args)
343 |         {
344 |             Settings.Settings.OptionsToTheme(CurrentThemeId);
345 |             SavePluginSettings(Settings.Settings);
346 |         }
347 |         public override void OnControllerButtonStateChanged(OnControllerButtonStateChangedArgs args)
348 |         {
349 | 
350 |             if (CustomWindow != null && CustomWindow.IsVisible && args.Button == ControllerInput.B && args.State == ControllerInputState.Pressed)
351 |             {
352 |                 CustomWindow.Close();
353 |                 CustomWindow = null;
354 |             }
355 |             else
356 |             {
357 |                 Gamepad.SetState(args);
358 |             }
359 |         }
360 |     }
361 | }


--------------------------------------------------------------------------------
/Models/SettingsViewModel.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using System.Linq;
  3 | using System.Windows;
  4 | using System.ComponentModel;
  5 | 
  6 | using Playnite.SDK;
  7 | using Playnite.SDK.Data;
  8 | using ThemeOptions.Tools;
  9 | using System.Windows.Input;
 10 | 
 11 | 
 12 | namespace ThemeOptions.Models
 13 | {
 14 |     using ThemesSelectedPresets = Dictionary<string, List<string>>;
 15 |     using ThemesSettings = Dictionary<string, VariablesValues>;
 16 | 
 17 |     public static class DictionaryExtension
 18 |     {
 19 |         static public TValue Get<TKey,TValue>(this Dictionary<TKey,TValue>dict, TKey key, TValue def = default)
 20 |         {
 21 |             return dict != null && dict.ContainsKey(key) ? dict[key] : def;
 22 |         }
 23 |     }
 24 | 
 25 |     public class OpenWindowHelper
 26 |     {
 27 |         public ICommand this[string key]
 28 |         {
 29 |             get
 30 |             {
 31 |                 return new RelayCommand(() => ThemeOptions.OpenWindow(key));
 32 |             }
 33 |         }
 34 |     }
 35 | 
 36 |     public class Settings : ObservableObject
 37 |     {
 38 | 
 39 |         [DontSerialize]
 40 |         public OpenWindowHelper OpenWindow { get; } = new OpenWindowHelper();
 41 | 
 42 |         private ThemesSelectedPresets selectedPresets = new ThemesSelectedPresets();
 43 | 
 44 |         private ThemesSettings userSettings = new ThemesSettings();
 45 | 
 46 |         public ThemesSelectedPresets SelectedPresets { get => selectedPresets; }
 47 | 
 48 |         public ThemesSettings UserSettings { get => userSettings; }
 49 | 
 50 |         [DontSerialize]
 51 |         public DynamicProperties Options { get; } = new DynamicProperties();
 52 | 
 53 |         [DontSerialize]
 54 |         public GamepadState GamepadState { get; } = new GamepadState();
 55 | 
 56 |         [DontSerialize]
 57 |         public MinimalVersion MinimalVersion { get; } = new MinimalVersion();
 58 | 
 59 |         [DontSerialize]
 60 |         public string Version { get => MinimalVersion.PluginVersion; }
 61 | 
 62 |         [DontSerialize]
 63 |         public bool IsInstalled { get => true; }
 64 | 
 65 |         [DontSerialize]
 66 |         private string aspectRatio = "dsp169";
 67 | 
 68 |         [DontSerialize]
 69 |         public string AspectRatio
 70 |         {
 71 |             get => aspectRatio;
 72 |             set
 73 |             {
 74 |                 if (aspectRatio != value)
 75 |                 {
 76 |                     aspectRatio = value;
 77 |                     OnPropertyChanged();
 78 |                 }
 79 |             }
 80 |         }
 81 | 
 82 |         public void ThemeToOptions(string themeId)
 83 |         {
 84 |             Options themeOptions = Theme.FromId(themeId)?.Options;
 85 | 
 86 |             Variables themeSettings = themeOptions?.Variables;
 87 |             VariablesValues presetSettings = themeOptions?.Presets?.GetConstants(SelectedPresets.Get(themeId));
 88 |             VariablesValues userSettings = UserSettings.Get(themeId);
 89 | 
 90 |             VariablesValues variableValues = new VariablesValues(themeSettings).Merge(presetSettings).Merge(userSettings);
 91 |             Options.Update(variableValues);
 92 |         }
 93 | 
 94 |         public void OptionsToTheme(string themeId)
 95 |         {
 96 |             VariablesValues themeValues = UserSettings.Get(themeId, new VariablesValues());
 97 |             VariablesValues userSettings = themeValues.FromDynamicProperties(Options);
 98 |             if (userSettings?.Count > 0)
 99 |             {
100 |                 UserSettings[themeId] = userSettings;
101 |             }
102 |         }
103 |     }
104 | 
105 |     public class SettingsViewModel : ObservableObject, ISettings, INotifyPropertyChanged
106 |     {
107 |         private readonly ThemeOptions plugin;
108 |         public Theme SelectedTheme { get; set; }
109 | 
110 |         public List<Theme> CustomizableThemes { get; set; }
111 | 
112 |         private string _PreviewImage;
113 |         public string PreviewImage
114 |         {
115 |             get { return _PreviewImage; }
116 |             set
117 |             {
118 |                 _PreviewImage = value;
119 |                 OnPropertyChanged("PreviewImage");
120 |             }
121 |         }
122 |         public void UpdatePreview(string path, bool show)
123 |         {
124 |             if (show)
125 |             {
126 |                 PreviewImage = path ;
127 |             }
128 |             else if (PreviewImage == path)
129 |             {
130 |                 PreviewImage = null;
131 |             }
132 |         }
133 | 
134 |         private Settings settings;
135 |         public Settings Settings
136 |         {
137 |             get => settings;
138 |             set
139 |             {
140 |                 settings = value;
141 |                 OnPropertyChanged();
142 |             }
143 |         }
144 |         public void UpdateAspectRatio()
145 |         {
146 |             if (plugin.PlayniteApi.Dialogs.GetCurrentAppWindow() is Window window
147 |                 && !(window.Width is double.NaN)
148 |                 && !(window.Height is double.NaN)
149 |                 && window.Width != 0
150 |                 && window.Height != 0)
151 |             {
152 |                 Settings.AspectRatio = DisplayAspectRatio.GetAspectRatio(window.Width, window.Height );
153 |             }
154 |         }
155 |         public List<string> ThemePresets(string themeId) => settings.SelectedPresets.Get(themeId, new List<string>());
156 |         public VariablesValues ThemeSettings(string themeId)
157 |         {
158 |             Theme theme = Theme.FromId(themeId);
159 |             if (theme == null) return new VariablesValues();
160 |             Variables themeSettings = Theme.FromId(themeId)?.Options?.Variables ?? new Variables();
161 |             VariablesValues userSettings = settings.UserSettings.Get(themeId, new VariablesValues());
162 |             VariablesValues filtered = new VariablesValues(userSettings.Where(
163 |                 s => s.Value.Value != null
164 |                   && s.Value.Type == themeSettings.Get(s.Key)?.Type
165 |                   && s.Value.Value != themeSettings.Get(s.Key)?.Default)
166 |             );
167 | 
168 |             var result = theme.Options.Presets?.GetConstants(ThemePresets(themeId)) ?? new VariablesValues();
169 |             return result.Merge(filtered);
170 |         }
171 | 
172 |         public SettingsViewModel(ThemeOptions plugin)
173 |         {
174 |             // Injecting your plugin instance is required for Save/Load method because Playnite saves data to a location based on what plugin requested the operation.
175 |             this.plugin = plugin;
176 | 
177 |             // Load saved settings.
178 |             var savedSettings = plugin.LoadPluginSettings<Settings>();
179 | 
180 |             // LoadPluginSettings returns null if no saved data is available.
181 |             if (savedSettings != null)
182 |             {
183 |                 Settings = savedSettings;
184 |             }
185 |             else
186 |             {
187 |                 Settings = new Settings();
188 |             }
189 | 
190 |             Settings.ThemeToOptions(plugin.CurrentThemeId);
191 |             Settings.Options.PropertyChanged += (o, e) =>
192 |             {
193 |                 Settings.OnPropertyChanged("Options");
194 |             };
195 |         }
196 | 
197 | 
198 | 
199 |         public Options SelectedThemeOptions = null;
200 | 
201 |         public Dictionary<string, Options> ThemesOptions = null;
202 | 
203 | 
204 |         private void LoadCustomizableThemes()
205 |         {
206 |             CustomizableThemes = Theme.EnumThemes().ToList();
207 |             SelectedTheme = CustomizableThemes.FirstOrDefault(t => t.Id == ThemeOptions.PlayniteAPI.ApplicationSettings.FullscreenTheme) ??
208 |                             CustomizableThemes.FirstOrDefault(t => t.Id == ThemeOptions.PlayniteAPI.ApplicationSettings.DesktopTheme) ??
209 |                             CustomizableThemes.FirstOrDefault();
210 | 
211 |         }
212 | 
213 |         private void LoadFromSettings(Settings settings, List<Theme> themes )
214 |         {
215 |             foreach (var theme in themes)
216 |             {
217 |                 theme.TranslateOptions();
218 | 
219 |                 foreach (var variable in theme?.Options?.Variables ?? new Variables())
220 |                 {
221 |                     if (variable.Value.NeedRestart)
222 |                     {
223 |                         variable.Value.Title += " *";
224 |                     }
225 |                 }
226 | 
227 |                 if (theme?.Options?.Presets?.Count > 0)
228 |                 {
229 |                     theme.Options.Presets.Enumerate().ForEach(p => {
230 |                         if (p.Value.NeedRestart)
231 |                         {
232 |                             p.Value.Name += " *";
233 |                         }
234 |                     });
235 |                 }
236 | 
237 |                 foreach (var preset in theme.PresetList)
238 |                 {
239 |                     preset.Selected = preset.OptionsList
240 |                         .FirstOrDefault(
241 |                             option => settings.SelectedPresets.Get(theme.Id)?.Contains(option.Id) == true);
242 |                 }
243 | 
244 |                 if (theme.Options.Variables != null)
245 |                 {
246 |                     var themeSettings = settings.UserSettings.Get(theme.Id);
247 | 
248 |                     foreach (var variable in theme.Options.Variables)
249 |                     {
250 |                         variable.Value.Value = (
251 |                             themeSettings != null &&
252 |                             variable.Value.Type != null &&
253 |                             themeSettings.Get(variable.Key)?.Type == variable.Value.Type
254 |                             ? themeSettings[variable.Key].Value : null)
255 |                             ?? variable.Value.Default;
256 |                     }
257 |                 }
258 |             }
259 |         }
260 | 
261 |         private bool SaveToSettings(List<Theme> themes, Settings settings)
262 |         {
263 |             Settings original = Serialization.GetClone(settings);
264 | 
265 |             foreach (var theme in themes)
266 |             {
267 |                 var selectedPresets = theme
268 |                     .PresetList
269 |                     .Where(p => p.Selected != null && !p.Selected.Id.ToLower().EndsWith("default"))
270 |                     .Select(p => p.Selected.Id).ToList();
271 | 
272 |                 if (theme.PresetList?.Count > 0)
273 |                 {
274 |                     settings.SelectedPresets[theme.Id] = selectedPresets;
275 |                 }
276 | 
277 |                 if (theme.Options.Variables != null)
278 |                 {
279 |                     var variables = new VariablesValues(
280 |                         theme.Options.Variables
281 |                         .Where(v => v.Value.Value != v.Value.Default)
282 |                     );
283 | 
284 |                     if (variables?.Count > 0)
285 |                     {
286 |                         settings.UserSettings[theme.Id] = variables;
287 |                     }
288 | 
289 |                     List<string> defaultValues = original.UserSettings.Get(theme.Id, new VariablesValues())
290 |                         .Where(v => !theme.Options.Variables.ContainsKey(v.Key) ||  v.Value.Value == theme.Options.Variables[v.Key]?.Default)
291 |                         .Select(v => v.Key)
292 |                         .ToList();
293 | 
294 |                     foreach( var key in defaultValues)
295 |                     {
296 |                         original.UserSettings[theme.Id].Remove(key);
297 |                     }
298 |                 }
299 |             }
300 | 
301 |             string currentTheme = plugin.CurrentThemeId;
302 | 
303 |             Settings updated = Serialization.GetClone(settings);
304 | 
305 |             List<string> needsRestart = Theme.FromId(currentTheme)?.Options?.Variables
306 |                 ?.Where(v=>v.Value.NeedRestart)
307 |                 ?.Select(v => v.Key)
308 |                 ?.ToList()
309 |                 ?? new List<string>();
310 | 
311 |             List<string> needsPresetsRestart = Theme.FromId(currentTheme)?.Options?.Presets
312 |                 ?.SelectMany(p => p.Value.Presets?.Where(sp => sp.Value.NeedRestart).Select(sp => $"{p.Key}.{sp.Key}"))
313 |                 ?.ToList();
314 | 
315 |             var originalNonDefaultPreset = original.SelectedPresets.Get(plugin.CurrentThemeId, new List<string>());
316 | 
317 |             var originalPreset = Theme.FromId(currentTheme)
318 |                 ?.PresetList
319 |                 ?.Select(
320 |                     p => p.OptionsList.FirstOrDefault(o => originalNonDefaultPreset.Contains(o.Id))?.Id
321 |                     ?? p.OptionsList.FirstOrDefault(o => o.Id.ToLower().EndsWith("default"))?.Id)
322 |                 ?.ToList() ?? new List<string>();
323 | 
324 |             var updatedNonDefaultPreset = updated.SelectedPresets.Get(plugin.CurrentThemeId, new List<string>());
325 |             var updatedPreset = Theme.FromId(currentTheme)
326 |                 ?.PresetList
327 |                 ?.Select(
328 |                     p => p.OptionsList.FirstOrDefault(o => updatedNonDefaultPreset.Contains(o.Id))?.Id
329 |                     ?? p.OptionsList.FirstOrDefault(o => o.Id.ToLower().EndsWith("default"))?.Id)
330 |                 ?.ToList() ?? new List<string>();
331 | 
332 |             var presetsEqual = Serialization.AreObjectsEqual(
333 |                 originalPreset.Where(p => needsPresetsRestart.Contains(p)),
334 |                 updatedPreset.Where(p => needsPresetsRestart.Contains(p))
335 |             );
336 | 
337 | 
338 |             var variablesEqual = Serialization.AreObjectsEqual(
339 |                 original.UserSettings.Get(plugin.CurrentThemeId, new VariablesValues()).Where(v => needsRestart.Contains(v.Key)),
340 |                 updated.UserSettings.Get(plugin.CurrentThemeId, new VariablesValues()).Where(v => needsRestart.Contains(v.Key))
341 |             );
342 | 
343 |             return  !presetsEqual || !variablesEqual;
344 |        }
345 | 
346 |         public void BeginEdit()
347 |         {
348 |             LoadCustomizableThemes();
349 |             Settings.OptionsToTheme(plugin.CurrentThemeId);
350 |             LoadFromSettings(Settings, CustomizableThemes);
351 |         }
352 | 
353 |         public void BeginFullscreenEdit(string themeId)
354 |         {
355 |             SelectedTheme = Theme.FromId(themeId);
356 |             CustomizableThemes = new List<Theme> { SelectedTheme };
357 | 
358 |             Settings.OptionsToTheme(plugin.CurrentThemeId);
359 |             LoadFromSettings(Settings, CustomizableThemes);
360 |         }
361 | 
362 |         public void CancelEdit()
363 |         {
364 |         }
365 | 
366 |         public void EndEdit()
367 |         {
368 |             bool needReload = SaveToSettings(CustomizableThemes, Settings);
369 |             plugin.SavePluginSettings(Settings);
370 |             Settings.ThemeToOptions(plugin.CurrentThemeId);
371 | 
372 |             if (needReload)
373 |             {
374 | 
375 |                 dynamic ctx = Application.Current.MainWindow.DataContext;
376 |                 ctx.AppSettings.Fullscreen.OnPropertyChanged("Theme");
377 |                 ctx.AppSettings.OnPropertyChanged("Theme");
378 |             }
379 |             else
380 |             {
381 |                 plugin.LoadThemeOption();
382 |             }
383 |         }
384 | 
385 |         public bool VerifySettings(out List<string> errors)
386 |         {
387 |             // Code execute when user decides to confirm changes made since BeginEdit was called.
388 |             // Executed before EndEdit is called and EndEdit is not called if false is returned.
389 |             // List of errors is presented to user if verification fails.
390 |             errors = new List<string>();
391 |             return true;
392 |         }
393 |     }
394 | }


--------------------------------------------------------------------------------