diff --git a/CHANGELOG.md b/CHANGELOG.md
index 521dcfb..d2e9631 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,31 @@ All notable changes are documented here. Versions follow the Playnite extension
## [Unreleased]
+## [0.8.1] - 2026-09-16
+
+### Added
+
+- Shortcut icon selection for PBS-managed Desktop and Start menu shortcuts: Playnite Boot Screen, Playnite Fullscreen, or a persistent custom `.ico` file.
+- A guided Quick Setup page that groups launch methods, boot-video selection, and Playnite reveal behavior with a compact readiness indicator.
+
+### Changed
+
+- Settings are organized into Quick Setup, Playback, Streaming, Advanced, and Diagnostics tabs.
+- Fresh installations use the Playnite Boot Screen shortcut icon by default; upgrades from 0.8.0 keep the existing Playnite Fullscreen icon choice.
+- Runtime updated to 1.0.13.
+
+### Fixed
+
+- Desktop-to-Fullscreen readiness now refreshes the active Windows display topology while Playnite is starting, fixing transitions such as Extended desktop to a single TV/display.
+- Fullscreen readiness keeps `MainWindowHandle` as the primary path and falls back to visible top-level windows owned by the exact Playnite Fullscreen PID when the main handle is still transient.
+- Foreground handoff reuses the window handle that actually satisfied readiness detection.
+- A media-device/decoder failure now hides the failed video surface and continues with the Playnite-readiness fallback instead of leaving a frozen frame visible.
+
+### Compatibility
+
+- Existing settings, shortcuts, custom media, and streaming configuration are migrated automatically.
+- Manual PBS monitor selection remains an explicit overlay-placement option; dynamic topology refresh affects Switch readiness only.
+
## [0.8.0] - 2026-09-14
### Added
diff --git a/PlayniteBoot.sln b/PlayniteBoot.sln
index 07c36ff..d2f3f38 100644
--- a/PlayniteBoot.sln
+++ b/PlayniteBoot.sln
@@ -1,21 +1,24 @@
Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.0.31903.59
+# Visual Studio Version 18
+VisualStudioVersion = 18.10.12201.205 stable
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PlayniteBoot", "PlayniteBoot\PlayniteBoot.csproj", "{29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}"
EndProject
Global
- GlobalSection(SolutionConfigurationPlatforms) = preSolution
- Debug|Any CPU = Debug|Any CPU
- Release|Any CPU = Release|Any CPU
- EndGlobalSection
- GlobalSection(ProjectConfigurationPlatforms) = postSolution
- {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
- {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Release|Any CPU.ActiveCfg = Release|Any CPU
- {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Release|Any CPU.Build.0 = Release|Any CPU
- EndGlobalSection
- GlobalSection(SolutionProperties) = preSolution
- HideSolutionNode = FALSE
- EndGlobalSection
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {29F3BCC1-12ED-423E-8C61-D0EB0218EEC3}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {ADC8B5E3-5897-422C-A2B2-3206A7D66225}
+ EndGlobalSection
EndGlobal
diff --git a/PlayniteBoot/Localization/en_US.xaml b/PlayniteBoot/Localization/en_US.xaml
index f154314..e358648 100644
--- a/PlayniteBoot/Localization/en_US.xaml
+++ b/PlayniteBoot/Localization/en_US.xaml
@@ -126,8 +126,8 @@
Runtime is not ready yet. Use Repair runtime if automatic synchronization does not complete.
Valid
Needs repair
- ● Installed
- ○ Not installed
+ Installed
+ Not installed
Status unavailable
Shortcut “{0}” created or updated in {1}.
Shortcut removed from {0}.
@@ -161,6 +161,66 @@
The shortcut installer was not found.
PowerShell could not be started to create the shortcut.
The shortcut operation timed out.
- Launch Playnite Fullscreen with a custom boot video and no console window.
+ Launch Playnite Fullscreen through Playnite Boot Screen with the configured boot video.
Video files
+
+
+ Quick Setup
+ Playback
+ Advanced
+ Diagnostics
+
+ Set up your custom Playnite startup in just a few steps. PBS shows a boot video while Playnite Fullscreen is opening.
+ Adjust where and how the boot video is displayed. These settings apply to every PBS launch method.
+ Advanced readiness and launch settings. The defaults are recommended for most setups.
+ Runtime maintenance, logging and diagnostic information.
+
+ 1. Start Playnite with PBS
+ 2. Choose your boot video
+ 3. Choose when Playnite appears
+ PBS shortcuts
+ Desktop → Fullscreen
+ Display
+ Readiness detection
+ Playnite launch
+ External / manual launch
+ Launch method state
+
+ Create a shortcut that starts PBS before Playnite Fullscreen.
+ Playnite's normal Fullscreen startup remains unchanged and does not show the boot screen.
+ Choose how to start PBS, select your video, and decide when Playnite should appear.
+ Choose when Playnite Boot Screen should be shown.
+ Choose the video shown while Playnite is starting. Accepted formats: {0}.
+ Ready
+ Playnite Boot Screen is ready to use.
+ Setup needed
+ Create a PBS shortcut or enable Desktop → Fullscreen.
+ Desktop PBS shortcut installed
+ Desktop PBS shortcut not installed
+ Start menu PBS shortcut installed
+ Start menu PBS shortcut not installed
+ Desktop to Fullscreen integration enabled
+ Desktop to Fullscreen integration disabled
+ Streaming preload support enabled
+ Streaming preload support disabled
+
+ Shortcut icon
+ Custom .ico
+ Playnite Boot Screen
+ Playnite Fullscreen
+ Custom (.ico)
+ No .ico file selected.
+ Custom icon selected.
+ Icon files (*.ico)|*.ico
+ Choose .ico...
+ Custom shortcut icon copied to the PBS data folder.
+
+ Other launchers can invoke PBS directly with this command. Launchers that start Playnite.FullscreenApp.exe themselves bypass PBS unless they explicitly integrate this command.
+ Shortcut state is detected from PBS-managed shortcuts. External launcher configuration is not inspected.
+
+ The selected shortcut icon mode is not valid.
+ Choose a custom .ico file or select another shortcut icon.
+ Custom shortcut icons must use the .ico format.
+ The shortcut icon file does not exist: {0}
+
diff --git a/PlayniteBoot/Localization/it_IT.xaml b/PlayniteBoot/Localization/it_IT.xaml
index 6f475c2..5f584db 100644
--- a/PlayniteBoot/Localization/it_IT.xaml
+++ b/PlayniteBoot/Localization/it_IT.xaml
@@ -126,8 +126,8 @@
Il runtime non è ancora pronto. Usa Ripara runtime se la sincronizzazione automatica non si completa.
Valida
Da riparare
- ● Installato
- ○ Non installato
+ Installato
+ Non installato
Stato non disponibile
Collegamento “{0}” creato o aggiornato in {1}.
Collegamento rimosso da {0}.
@@ -161,6 +161,66 @@
Installer dei collegamenti non trovato.
Impossibile avviare PowerShell per creare il collegamento.
Timeout durante l'operazione sul collegamento.
- Avvia Playnite Fullscreen con un video personalizzato e senza finestra console.
+ Avvia Playnite Fullscreen tramite Playnite Boot Screen con il video di avvio configurato.
File video
+
+
+ Configurazione rapida
+ Riproduzione
+ Avanzate
+ Diagnostica
+
+ Configura il tuo avvio personalizzato di Playnite in pochi passaggi. PBS mostra un video di boot mentre Playnite Fullscreen si sta aprendo.
+ Regola dove e come viene mostrato il video di avvio. Queste impostazioni si applicano a tutti i metodi di avvio PBS.
+ Impostazioni avanzate per rilevamento e avvio. I valori predefiniti sono consigliati per la maggior parte delle configurazioni.
+ Manutenzione del runtime, log e informazioni diagnostiche.
+
+ 1. Avvia Playnite con PBS
+ 2. Scegli il video di avvio
+ 3. Scegli quando mostrare Playnite
+ Collegamenti PBS
+ Desktop → Fullscreen
+ Schermo
+ Rilevamento disponibilità
+ Avvio Playnite
+ Avvio esterno / manuale
+ Stato metodi di avvio
+
+ Crea un collegamento che avvia PBS prima di Playnite Fullscreen.
+ Il normale avvio di Playnite Fullscreen rimane invariato e non mostra la schermata di boot.
+ Scegli come avviare PBS, seleziona il tuo video e decidi quando mostrare Playnite.
+ Scegli quando deve essere mostrato Playnite Boot Screen.
+ Scegli il video mostrato durante l'avvio di Playnite. Formati accettati: {0}.
+ Pronto
+ Playnite Boot Screen è pronto per l'uso.
+ Configurazione necessaria
+ Crea un collegamento PBS o abilita Desktop → Fullscreen.
+ Collegamento PBS sul Desktop installato
+ Collegamento PBS sul Desktop non installato
+ Collegamento PBS nel menu Start installato
+ Collegamento PBS nel menu Start non installato
+ Integrazione Desktop a Fullscreen abilitata
+ Integrazione Desktop a Fullscreen disabilitata
+ Supporto preload streaming abilitato
+ Supporto preload streaming disabilitato
+
+ Icona collegamento
+ File .ico
+ Playnite Boot Screen
+ Playnite Fullscreen
+ Personalizzata (.ico)
+ Nessun file .ico selezionato.
+ Icona personalizzata selezionata.
+ File icona (*.ico)|*.ico
+ Scegli .ico...
+ Icona personalizzata copiata nella cartella dati di PBS.
+
+ Altri launcher possono richiamare PBS direttamente con questo comando. I launcher che avviano autonomamente Playnite.FullscreenApp.exe bypassano PBS, a meno che non integrino esplicitamente questo comando.
+ Lo stato dei collegamenti viene rilevato dai collegamenti gestiti da PBS. La configurazione dei launcher esterni non viene ispezionata.
+
+ La modalità selezionata per l'icona del collegamento non è valida.
+ Scegli un file .ico personalizzato oppure seleziona un'altra icona per il collegamento.
+ Le icone personalizzate dei collegamenti devono usare il formato .ico.
+ Il file dell'icona del collegamento non esiste: {0}
+
diff --git a/PlayniteBoot/Models/PlayniteBootSettingsData.cs b/PlayniteBoot/Models/PlayniteBootSettingsData.cs
index f485712..e83156f 100644
--- a/PlayniteBoot/Models/PlayniteBootSettingsData.cs
+++ b/PlayniteBoot/Models/PlayniteBootSettingsData.cs
@@ -3,6 +3,35 @@
namespace PlayniteBoot.Models
{
+ public static class ShortcutIconModes
+ {
+ public const string Pbs = "pbs";
+ public const string Playnite = "playnite";
+ public const string Custom = "custom";
+
+ public static bool IsValid(string value)
+ {
+ return string.Equals(value, Pbs, StringComparison.OrdinalIgnoreCase) ||
+ string.Equals(value, Playnite, StringComparison.OrdinalIgnoreCase) ||
+ string.Equals(value, Custom, StringComparison.OrdinalIgnoreCase);
+ }
+
+ public static string Normalize(string value)
+ {
+ if (string.Equals(value, Playnite, StringComparison.OrdinalIgnoreCase))
+ {
+ return Playnite;
+ }
+
+ if (string.Equals(value, Custom, StringComparison.OrdinalIgnoreCase))
+ {
+ return Custom;
+ }
+
+ return Pbs;
+ }
+ }
+
public static class VideoEndBehaviors
{
public const string Ready = "ready";
@@ -34,7 +63,7 @@ public static string Normalize(string value)
public class PlayniteBootSettingsData : ObservableObject
{
- public const int CurrentSettingsVersion = 5;
+ public const int CurrentSettingsVersion = 6;
private int settingsVersion;
private string playniteExecutable = "auto";
@@ -64,6 +93,9 @@ public class PlayniteBootSettingsData : ObservableObject
private bool enableDesktopFullscreenSwitch = true;
private bool logEnabled = true;
private string shortcutName = "Playnite Fullscreen";
+ private string shortcutIconMode = ShortcutIconModes.Pbs;
+ private string customShortcutIconPath = string.Empty;
+ private string customShortcutIconFileName = string.Empty;
private StreamingSettings streaming = new StreamingSettings();
public static PlayniteBootSettingsData CreateDefault()
@@ -117,6 +149,9 @@ public double Volume
public bool EnableDesktopFullscreenSwitch { get => enableDesktopFullscreenSwitch; set => SetValue(ref enableDesktopFullscreenSwitch, value); }
public bool LogEnabled { get => logEnabled; set => SetValue(ref logEnabled, value); }
public string ShortcutName { get => shortcutName; set => SetValue(ref shortcutName, value); }
+ public string ShortcutIconMode { get => shortcutIconMode; set => SetValue(ref shortcutIconMode, value); }
+ public string CustomShortcutIconPath { get => customShortcutIconPath; set => SetValue(ref customShortcutIconPath, value); }
+ public string CustomShortcutIconFileName { get => customShortcutIconFileName; set => SetValue(ref customShortcutIconFileName, value); }
public StreamingSettings Streaming { get => streaming; set => SetValue(ref streaming, value); }
}
}
diff --git a/PlayniteBoot/PlayniteBootPlugin.cs b/PlayniteBoot/PlayniteBootPlugin.cs
index a8f6b37..6da717f 100644
--- a/PlayniteBoot/PlayniteBootPlugin.cs
+++ b/PlayniteBoot/PlayniteBootPlugin.cs
@@ -124,10 +124,12 @@ public string CreateShortcut(PlayniteBootSettingsData settings, ShortcutLocation
var compatibilityResult = configWriter.Write(settings);
LogVideoCompatibility(compatibilityResult);
logger.Info($"{ProductName} runtime ready at {Paths.RuntimeDirectory}. Version {result.Version}.");
+ var iconPath = ResolveShortcutIconPath(settings);
return shortcutService.Create(
location,
settings.ShortcutName,
- "LOCPlayniteBootShortcutDescription".GetLocalized());
+ "LOCPlayniteBootShortcutDescription".GetLocalized(),
+ iconPath);
}
}
@@ -139,6 +141,36 @@ public bool RemoveShortcut(PlayniteBootSettingsData settings, ShortcutLocation l
}
}
+ private string ResolveShortcutIconPath(PlayniteBootSettingsData settings)
+ {
+ var mode = ShortcutIconModes.Normalize(settings?.ShortcutIconMode);
+ if (string.Equals(mode, ShortcutIconModes.Playnite, StringComparison.OrdinalIgnoreCase))
+ {
+ // Null preserves the shortcut installer's historical behavior: it
+ // discovers Playnite.FullscreenApp.exe and uses its icon.
+ return null;
+ }
+
+ var iconPath = string.Equals(mode, ShortcutIconModes.Custom, StringComparison.OrdinalIgnoreCase)
+ ? settings?.CustomShortcutIconPath
+ : Paths.DefaultShortcutIconPath;
+
+ if (string.IsNullOrWhiteSpace(iconPath))
+ {
+ throw new InvalidOperationException("LOCPlayniteBootValidationCustomShortcutIconMissing".GetLocalized());
+ }
+
+ iconPath = Path.GetFullPath(iconPath);
+ if (!File.Exists(iconPath))
+ {
+ throw new FileNotFoundException(
+ string.Format("LOCPlayniteBootValidationShortcutIconFileMissing".GetLocalized(), iconPath),
+ iconPath);
+ }
+
+ return iconPath;
+ }
+
private static void LogVideoCompatibility(VideoCompatibilityResult result)
{
if (result == null)
diff --git a/PlayniteBoot/PlayniteBootSettings.cs b/PlayniteBoot/PlayniteBootSettings.cs
index 80fb6d4..7361c4f 100644
--- a/PlayniteBoot/PlayniteBootSettings.cs
+++ b/PlayniteBoot/PlayniteBootSettings.cs
@@ -10,6 +10,7 @@
using System.IO;
using System.Linq;
using System.Reflection;
+using System.Security.Cryptography;
using System.Text;
using System.Windows;
using System.Web.Script.Serialization;
@@ -33,11 +34,16 @@ public PlayniteBootSettingsData Settings
if (settings != null)
{
settings.PropertyChanged -= SettingsPropertyChanged;
+ if (settings.Streaming != null)
+ {
+ settings.Streaming.PropertyChanged -= StreamingSettingsPropertyChanged;
+ }
}
settings = value;
EnsureDefaultsAndMigrate();
settings.PropertyChanged += SettingsPropertyChanged;
+ settings.Streaming.PropertyChanged += StreamingSettingsPropertyChanged;
OnPropertyChanged();
OnPropertyChanged(nameof(DirectCommand));
@@ -50,6 +56,11 @@ public PlayniteBootSettingsData Settings
OnPropertyChanged(nameof(VolumePercent));
OnPropertyChanged(nameof(SelectedVideoPath));
OnPropertyChanged(nameof(SelectedVideoPathDisplay));
+ OnPropertyChanged(nameof(IsShortcutIconPbs));
+ OnPropertyChanged(nameof(IsShortcutIconPlaynite));
+ OnPropertyChanged(nameof(IsShortcutIconCustom));
+ OnPropertyChanged(nameof(IsCustomShortcutIcon));
+ OnPropertyChanged(nameof(CustomShortcutIconPathDisplay));
NotifyInstallationStatusChanged();
if (videoLibrary != null)
@@ -88,6 +99,24 @@ public string SelectedVideoPath
? string.Empty
: GetConfiguredVideoPath();
+ public string ProductIconPath
+ {
+ get
+ {
+ try
+ {
+ var directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+ var path = Path.Combine(directory ?? string.Empty, "icon.png");
+ return File.Exists(path) ? path : string.Empty;
+ }
+ catch
+ {
+ return string.Empty;
+ }
+ }
+ }
+
+ public string BootVideoDescription => F("LOCPlayniteBootSetupVideoDescription", VideoLibraryService.AcceptedFormatsDisplay);
public string AcceptedVideoFormats => F("LOCPlayniteBootAcceptedFormats", VideoLibraryService.AcceptedFormatsDisplay);
public string AcceptedVideoFormatsToolTip => L("LOCPlayniteBootTipAcceptedFormats");
@@ -155,6 +184,73 @@ public int VolumePercent
: L("LOCPlayniteBootStatusConfigurationNeedsRepair");
public string DesktopShortcutStatus => GetShortcutStatus(ShortcutLocation.Desktop);
public string StartMenuShortcutStatus => GetShortcutStatus(ShortcutLocation.StartMenu);
+ public bool IsDesktopShortcutInstalled => IsShortcutInstalled(ShortcutLocation.Desktop);
+ public bool IsStartMenuShortcutInstalled => IsShortcutInstalled(ShortcutLocation.StartMenu);
+ public bool IsDesktopFullscreenLaunchEnabled => Settings != null && Settings.EnableDesktopFullscreenSwitch;
+ public bool IsStreamingPreloadEnabled => Settings?.Streaming != null && Settings.Streaming.Enabled;
+ public bool IsQuickSetupReady => IsDesktopFullscreenLaunchEnabled ||
+ IsDesktopShortcutInstalled ||
+ IsStartMenuShortcutInstalled;
+ public bool IsShortcutIconPbs
+ {
+ get => Settings == null || string.Equals(Settings.ShortcutIconMode, ShortcutIconModes.Pbs, StringComparison.OrdinalIgnoreCase);
+ set
+ {
+ if (value)
+ {
+ SetShortcutIconMode(ShortcutIconModes.Pbs);
+ }
+ }
+ }
+
+ public bool IsShortcutIconPlaynite
+ {
+ get => Settings != null && string.Equals(Settings.ShortcutIconMode, ShortcutIconModes.Playnite, StringComparison.OrdinalIgnoreCase);
+ set
+ {
+ if (value)
+ {
+ SetShortcutIconMode(ShortcutIconModes.Playnite);
+ }
+ }
+ }
+
+ public bool IsShortcutIconCustom
+ {
+ get => Settings != null && string.Equals(Settings.ShortcutIconMode, ShortcutIconModes.Custom, StringComparison.OrdinalIgnoreCase);
+ set
+ {
+ if (value)
+ {
+ SetShortcutIconMode(ShortcutIconModes.Custom);
+ }
+ }
+ }
+
+ public bool IsCustomShortcutIcon => IsShortcutIconCustom;
+ public string CustomShortcutIconPathDisplay => IsCustomShortcutIcon
+ ? (string.IsNullOrWhiteSpace(Settings.CustomShortcutIconPath)
+ ? L("LOCPlayniteBootShortcutCustomIconNone")
+ : (!string.IsNullOrWhiteSpace(Settings.CustomShortcutIconFileName)
+ ? Settings.CustomShortcutIconFileName
+ : L("LOCPlayniteBootShortcutCustomIconSelected")))
+ : string.Empty;
+ public string DesktopLaunchMethodStatus => GetLaunchMethodStatus(
+ IsDesktopShortcutInstalled,
+ "LOCPlayniteBootSetupDesktopShortcutEnabled",
+ "LOCPlayniteBootSetupDesktopShortcutDisabled");
+ public string StartMenuLaunchMethodStatus => GetLaunchMethodStatus(
+ IsStartMenuShortcutInstalled,
+ "LOCPlayniteBootSetupStartMenuShortcutEnabled",
+ "LOCPlayniteBootSetupStartMenuShortcutDisabled");
+ public string DesktopFullscreenLaunchMethodStatus => GetLaunchMethodStatus(
+ IsDesktopFullscreenLaunchEnabled,
+ "LOCPlayniteBootSetupDesktopFullscreenEnabled",
+ "LOCPlayniteBootSetupDesktopFullscreenDisabled");
+ public string StreamingPreloadStatus => GetLaunchMethodStatus(
+ IsStreamingPreloadEnabled,
+ "LOCPlayniteBootSetupStreamingPreloadEnabled",
+ "LOCPlayniteBootSetupStreamingPreloadDisabled");
public string ExtensionVersionDisplay
{
get
@@ -182,6 +278,7 @@ public string ExtensionVersionDisplay
public RelayCommand CreateStartMenuShortcutCommand { get; }
public RelayCommand RemoveDesktopShortcutCommand { get; }
public RelayCommand RemoveStartMenuShortcutCommand { get; }
+ public RelayCommand BrowseShortcutIconCommand { get; }
public RelayCommand CopyDirectCommand { get; }
public RelayCommand CopyPreloadCommand { get; }
public RelayCommand CopyContinueCommand { get; }
@@ -209,7 +306,6 @@ public PlayniteBootSettingsViewModel(PlayniteBootPlugin plugin)
{
new LocalizedOption("standalone", L("LOCPlayniteBootOptionFallbackStandalone"))
};
-
BrowseVideoCommand = new RelayCommand(BrowseVideo);
RefreshVideoLibraryCommand = new RelayCommand(() => RefreshVideoLibrary(true));
OpenVideoFolderCommand = new RelayCommand(() => ExecuteAction(OpenVideoFolder));
@@ -220,6 +316,7 @@ public PlayniteBootSettingsViewModel(PlayniteBootPlugin plugin)
CreateStartMenuShortcutCommand = new RelayCommand(() => ExecuteAction(() => CreateShortcut(ShortcutLocation.StartMenu)));
RemoveDesktopShortcutCommand = new RelayCommand(() => ExecuteAction(() => RemoveShortcut(ShortcutLocation.Desktop)));
RemoveStartMenuShortcutCommand = new RelayCommand(() => ExecuteAction(() => RemoveShortcut(ShortcutLocation.StartMenu)));
+ BrowseShortcutIconCommand = new RelayCommand(() => ExecuteAction(BrowseShortcutIcon));
CopyDirectCommand = new RelayCommand(() => CopyToClipboard(DirectCommand));
CopyPreloadCommand = new RelayCommand(() => CopyToClipboard(PreloadCommand));
CopyContinueCommand = new RelayCommand(() => CopyToClipboard(ContinueCommand));
@@ -248,6 +345,7 @@ public void EndEdit()
{
Settings.SettingsVersion = PlayniteBootSettingsData.CurrentSettingsVersion;
Settings.ShortcutName = (Settings.ShortcutName ?? string.Empty).Trim();
+ Settings.ShortcutIconMode = ShortcutIconModes.Normalize(Settings.ShortcutIconMode);
if (IsManualMonitorSelection(Settings.Monitor))
{
Settings.MonitorFallback = Settings.Monitor;
@@ -310,6 +408,25 @@ public bool VerifySettings(out List errors)
ValidateMinimum(errors, Settings.Streaming.PreloadAbandonTimeoutMilliseconds, 5000, L("LOCPlayniteBootLabelPreloadAbandonTimeout"));
}
+ if (!ShortcutIconModes.IsValid(Settings.ShortcutIconMode))
+ {
+ errors.Add(L("LOCPlayniteBootValidationShortcutIconMode"));
+ }
+ else if (string.Equals(Settings.ShortcutIconMode, ShortcutIconModes.Custom, StringComparison.OrdinalIgnoreCase))
+ {
+ if (string.IsNullOrWhiteSpace(Settings.CustomShortcutIconPath))
+ {
+ errors.Add(L("LOCPlayniteBootValidationCustomShortcutIconMissing"));
+ }
+ else if (!string.Equals(Path.GetExtension(Settings.CustomShortcutIconPath), ".ico", StringComparison.OrdinalIgnoreCase))
+ {
+ errors.Add(L("LOCPlayniteBootValidationCustomShortcutIconFormat"));
+ }
+ else if (!File.Exists(Settings.CustomShortcutIconPath))
+ {
+ errors.Add(F("LOCPlayniteBootValidationShortcutIconFileMissing", Settings.CustomShortcutIconPath));
+ }
+ }
ValidateShortcutName(errors, Settings.ShortcutName);
return errors.Count == 0;
@@ -356,8 +473,39 @@ private void SettingsPropertyChanged(object sender, PropertyChangedEventArgs eve
if (eventArgs.PropertyName == nameof(PlayniteBootSettingsData.ShortcutName))
{
- OnPropertyChanged(nameof(DesktopShortcutStatus));
- OnPropertyChanged(nameof(StartMenuShortcutStatus));
+ NotifyLaunchMethodStatusChanged();
+ return;
+ }
+
+ if (eventArgs.PropertyName == nameof(PlayniteBootSettingsData.ShortcutIconMode))
+ {
+ OnPropertyChanged(nameof(IsShortcutIconPbs));
+ OnPropertyChanged(nameof(IsShortcutIconPlaynite));
+ OnPropertyChanged(nameof(IsShortcutIconCustom));
+ OnPropertyChanged(nameof(IsCustomShortcutIcon));
+ OnPropertyChanged(nameof(CustomShortcutIconPathDisplay));
+ return;
+ }
+
+ if (eventArgs.PropertyName == nameof(PlayniteBootSettingsData.CustomShortcutIconPath) ||
+ eventArgs.PropertyName == nameof(PlayniteBootSettingsData.CustomShortcutIconFileName))
+ {
+ OnPropertyChanged(nameof(CustomShortcutIconPathDisplay));
+ return;
+ }
+
+ if (eventArgs.PropertyName == nameof(PlayniteBootSettingsData.EnableDesktopFullscreenSwitch))
+ {
+ NotifyLaunchMethodStatusChanged();
+ }
+ }
+
+ private void StreamingSettingsPropertyChanged(object sender, PropertyChangedEventArgs eventArgs)
+ {
+ if (eventArgs.PropertyName == nameof(StreamingSettings.Enabled))
+ {
+ OnPropertyChanged(nameof(IsStreamingPreloadEnabled));
+ OnPropertyChanged(nameof(StreamingPreloadStatus));
}
}
@@ -377,6 +525,22 @@ private void SetVideoEndBehavior(string behavior)
Settings.VideoEndBehavior = normalized;
}
+ private void SetShortcutIconMode(string mode)
+ {
+ if (Settings == null)
+ {
+ return;
+ }
+
+ var normalized = ShortcutIconModes.Normalize(mode);
+ if (string.Equals(Settings.ShortcutIconMode, normalized, StringComparison.OrdinalIgnoreCase))
+ {
+ return;
+ }
+
+ Settings.ShortcutIconMode = normalized;
+ }
+
private void EnsureDefaultsAndMigrate()
{
if (settings == null)
@@ -446,6 +610,18 @@ private void EnsureDefaultsAndMigrate()
settings.Streaming.PreloadAbandonTimeoutMilliseconds = 10000;
}
+ if (settings.SettingsVersion < 6)
+ {
+ // Existing shortcuts historically used Playnite's Fullscreen icon.
+ // Preserve that appearance on upgrade. New installations default
+ // to the dedicated PBS icon.
+ settings.ShortcutIconMode = ShortcutIconModes.Playnite;
+ }
+ else
+ {
+ settings.ShortcutIconMode = ShortcutIconModes.Normalize(settings.ShortcutIconMode);
+ }
+
settings.SettingsVersion = PlayniteBootSettingsData.CurrentSettingsVersion;
if (string.IsNullOrWhiteSpace(settings.VideoPath))
@@ -500,6 +676,11 @@ private void EnsureDefaultsAndMigrate()
settings.ShortcutName = "Playnite Fullscreen";
}
+ if (settings.CustomShortcutIconPath == null)
+ {
+ settings.CustomShortcutIconPath = string.Empty;
+ }
+
if (string.IsNullOrWhiteSpace(settings.Streaming.FallbackMode))
{
settings.Streaming.FallbackMode = "standalone";
@@ -603,6 +784,52 @@ private void OpenVideoFolder()
ShellService.OpenFolder(plugin.Paths.MediaDirectory);
}
+ private void BrowseShortcutIcon()
+ {
+ var selected = plugin.PlayniteApi.Dialogs.SelectFile(L("LOCPlayniteBootShortcutIconFileFilter"));
+ if (string.IsNullOrWhiteSpace(selected))
+ {
+ return;
+ }
+
+ if (!string.Equals(Path.GetExtension(selected), ".ico", StringComparison.OrdinalIgnoreCase))
+ {
+ plugin.PlayniteApi.Dialogs.ShowErrorMessage(
+ L("LOCPlayniteBootValidationCustomShortcutIconFormat"),
+ PlayniteBootPlugin.ProductName);
+ return;
+ }
+
+ var sourcePath = Path.GetFullPath(selected);
+ var targetPath = ImportShortcutIcon(sourcePath);
+
+ Settings.CustomShortcutIconPath = targetPath;
+ Settings.CustomShortcutIconFileName = Path.GetFileName(sourcePath);
+ Settings.ShortcutIconMode = ShortcutIconModes.Custom;
+ RuntimeStatus = L("LOCPlayniteBootStatusCustomShortcutIconSelected");
+ }
+
+ private string ImportShortcutIcon(string sourcePath)
+ {
+ Directory.CreateDirectory(plugin.Paths.ShortcutIconsDirectory);
+
+ byte[] hash;
+ using (var stream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read, FileShare.Read))
+ using (var sha256 = SHA256.Create())
+ {
+ hash = sha256.ComputeHash(stream);
+ }
+
+ var hashName = string.Concat(hash.Take(12).Select(value => value.ToString("x2", CultureInfo.InvariantCulture)));
+ var targetPath = Path.Combine(plugin.Paths.ShortcutIconsDirectory, hashName + ".ico");
+ if (!File.Exists(targetPath))
+ {
+ File.Copy(sourcePath, targetPath, false);
+ }
+
+ return targetPath;
+ }
+
private void RefreshVideoLibrary(bool updateStatus)
{
var selectedPath = GetConfiguredVideoPath();
@@ -858,6 +1085,7 @@ private string BuildDiagnostics()
b.AppendLine("Video end behavior: " + VideoEndBehaviors.Normalize(Settings.VideoEndBehavior));
b.AppendLine("Streaming preload: " + (Settings.Streaming != null && Settings.Streaming.Enabled ? "enabled" : "disabled"));
b.AppendLine("Desktop -> Fullscreen boot: " + (Settings.EnableDesktopFullscreenSwitch ? "enabled" : "disabled"));
+ b.AppendLine("Shortcut icon: " + ShortcutIconModes.Normalize(Settings.ShortcutIconMode));
b.AppendLine("Runtime installed: " + YesNo(File.Exists(plugin.Paths.ScriptPath) && File.Exists(plugin.Paths.ConfigPath)));
b.AppendLine("Video exists: " + YesNo(videoExists));
b.AppendLine("Desktop shortcut: " + YesNo(plugin.ShortcutExists(Settings, ShortcutLocation.Desktop)));
@@ -922,6 +1150,37 @@ private void NotifyInstallationStatusChanged()
OnPropertyChanged(nameof(DesktopShortcutStatus));
OnPropertyChanged(nameof(StartMenuShortcutStatus));
OnPropertyChanged(nameof(ExtensionVersionDisplay));
+ NotifyLaunchMethodStatusChanged();
+ }
+
+ private void NotifyLaunchMethodStatusChanged()
+ {
+ OnPropertyChanged(nameof(IsQuickSetupReady));
+ OnPropertyChanged(nameof(IsDesktopShortcutInstalled));
+ OnPropertyChanged(nameof(IsStartMenuShortcutInstalled));
+ OnPropertyChanged(nameof(IsDesktopFullscreenLaunchEnabled));
+ OnPropertyChanged(nameof(IsStreamingPreloadEnabled));
+ OnPropertyChanged(nameof(DesktopLaunchMethodStatus));
+ OnPropertyChanged(nameof(StartMenuLaunchMethodStatus));
+ OnPropertyChanged(nameof(DesktopFullscreenLaunchMethodStatus));
+ OnPropertyChanged(nameof(StreamingPreloadStatus));
+ }
+
+ private static string GetLaunchMethodStatus(bool enabled, string enabledKey, string disabledKey)
+ {
+ return L(enabled ? enabledKey : disabledKey);
+ }
+
+ private bool IsShortcutInstalled(ShortcutLocation location)
+ {
+ try
+ {
+ return Settings != null && plugin.ShortcutExists(Settings, location);
+ }
+ catch
+ {
+ return false;
+ }
}
private bool IsRuntimeConfigurationValid()
diff --git a/PlayniteBoot/PlayniteBootSettingsView.xaml b/PlayniteBoot/PlayniteBootSettingsView.xaml
index ade39d1..e04ce2a 100644
--- a/PlayniteBoot/PlayniteBootSettingsView.xaml
+++ b/PlayniteBoot/PlayniteBootSettingsView.xaml
@@ -5,116 +5,301 @@
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
d:DesignHeight="760" d:DesignWidth="920">
+
+
+
+
-
+
-
-
-
-
+
+
-
+
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
-
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Margin="0,3,0,6">
+ TextWrapping="Wrap" Opacity="0.72" Margin="0,1,0,0" />
+ Margin="0,3,0,6">
+ TextWrapping="Wrap" Opacity="0.72" Margin="0,1,0,0" />
+ Margin="0,3,0,0">
+ TextWrapping="Wrap" Opacity="0.72" Margin="0,1,0,0" />
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-
+
@@ -123,6 +308,7 @@
+
+
+
@@ -184,80 +374,6 @@
Margin="6,3" />
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -354,9 +470,120 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/PlayniteBoot/Properties/AssemblyInfo.cs b/PlayniteBoot/Properties/AssemblyInfo.cs
index caa2b4e..9b9c89e 100644
--- a/PlayniteBoot/Properties/AssemblyInfo.cs
+++ b/PlayniteBoot/Properties/AssemblyInfo.cs
@@ -8,5 +8,5 @@
[assembly: AssemblyCopyright("Copyright © VirtualGIT20 2026")]
[assembly: ComVisible(false)]
[assembly: Guid("29f3bcc1-12ed-423e-8c61-d0eb0218eec3")]
-[assembly: AssemblyVersion("0.8.0.0")]
-[assembly: AssemblyFileVersion("0.8.0.0")]
+[assembly: AssemblyVersion("0.8.1.0")]
+[assembly: AssemblyFileVersion("0.8.1.0")]
diff --git a/PlayniteBoot/RuntimeTemplate/Install-Shortcut.ps1 b/PlayniteBoot/RuntimeTemplate/Install-Shortcut.ps1
index bf555b4..52a6e09 100644
--- a/PlayniteBoot/RuntimeTemplate/Install-Shortcut.ps1
+++ b/PlayniteBoot/RuntimeTemplate/Install-Shortcut.ps1
@@ -32,6 +32,7 @@ function Get-Utf8Base64EnvironmentValue {
$ShortcutName = Get-Utf8Base64EnvironmentValue -Name 'PLAYNITEBOOT_SHORTCUT_NAME_B64' -Fallback $ShortcutName
$ShortcutDescription = Get-Utf8Base64EnvironmentValue -Name 'PLAYNITEBOOT_SHORTCUT_DESCRIPTION_B64' -Fallback $ShortcutDescription
+$ExplicitIconPathValue = Get-Utf8Base64EnvironmentValue -Name 'PLAYNITEBOOT_SHORTCUT_ICON_B64' -Fallback $null
if ([string]::IsNullOrWhiteSpace($ShortcutName)) {
throw 'ShortcutName cannot be empty.'
@@ -92,29 +93,44 @@ function Resolve-ConfiguredPath([string]$Value) {
return [IO.Path]::GetFullPath((Join-Path $scriptDirectory $expanded))
}
-$iconCandidates = New-Object System.Collections.Generic.List[string]
-
-# First choice: an explicit Playnite path configured in config.json.
-if (Test-Path -LiteralPath $configPath -PathType Leaf) {
- try {
- $config = Get-Content -LiteralPath $configPath -Raw -Encoding UTF8 | ConvertFrom-Json
- if ($config.playniteExecutable -and [string]$config.playniteExecutable -ne 'auto') {
- $configuredPlaynite = Resolve-ConfiguredPath ([string]$config.playniteExecutable)
- if ($configuredPlaynite) { $iconCandidates.Add($configuredPlaynite) }
- }
+$iconPath = $null
+if (-not [string]::IsNullOrWhiteSpace($ExplicitIconPathValue)) {
+ $explicitIconPath = Resolve-ConfiguredPath $ExplicitIconPathValue
+ if ($explicitIconPath -and (Test-Path -LiteralPath $explicitIconPath -PathType Leaf)) {
+ $iconPath = $explicitIconPath
}
- catch {
- Write-Warning "Could not read config.json to determine the icon: $($_.Exception.Message)"
+ else {
+ Write-Warning "Configured shortcut icon was not found: $ExplicitIconPathValue"
}
}
-if ($env:LOCALAPPDATA) { $iconCandidates.Add((Join-Path $env:LOCALAPPDATA 'Playnite\Playnite.FullscreenApp.exe')) }
-if ($env:ProgramFiles) { $iconCandidates.Add((Join-Path $env:ProgramFiles 'Playnite\Playnite.FullscreenApp.exe')) }
-if (${env:ProgramFiles(x86)}) { $iconCandidates.Add((Join-Path ${env:ProgramFiles(x86)} 'Playnite\Playnite.FullscreenApp.exe')) }
+# Without an explicit icon, retain the historical behavior and use Playnite's
+# Fullscreen executable icon.
+if (-not $iconPath) {
+ $iconCandidates = New-Object System.Collections.Generic.List[string]
+
+ # First choice: an explicit Playnite path configured in config.json.
+ if (Test-Path -LiteralPath $configPath -PathType Leaf) {
+ try {
+ $config = Get-Content -LiteralPath $configPath -Raw -Encoding UTF8 | ConvertFrom-Json
+ if ($config.playniteExecutable -and [string]$config.playniteExecutable -ne 'auto') {
+ $configuredPlaynite = Resolve-ConfiguredPath ([string]$config.playniteExecutable)
+ if ($configuredPlaynite) { $iconCandidates.Add($configuredPlaynite) }
+ }
+ }
+ catch {
+ Write-Warning "Could not read config.json to determine the icon: $($_.Exception.Message)"
+ }
+ }
-$iconPath = $iconCandidates |
- Where-Object { $_ -and (Test-Path -LiteralPath $_ -PathType Leaf) } |
- Select-Object -First 1
+ if ($env:LOCALAPPDATA) { $iconCandidates.Add((Join-Path $env:LOCALAPPDATA 'Playnite\Playnite.FullscreenApp.exe')) }
+ if ($env:ProgramFiles) { $iconCandidates.Add((Join-Path $env:ProgramFiles 'Playnite\Playnite.FullscreenApp.exe')) }
+ if (${env:ProgramFiles(x86)}) { $iconCandidates.Add((Join-Path ${env:ProgramFiles(x86)} 'Playnite\Playnite.FullscreenApp.exe')) }
+
+ $iconPath = $iconCandidates |
+ Where-Object { $_ -and (Test-Path -LiteralPath $_ -PathType Leaf) } |
+ Select-Object -First 1
+}
$shell = New-Object -ComObject WScript.Shell
foreach ($shortcutPath in $shortcutPaths) {
diff --git a/PlayniteBoot/RuntimeTemplate/PlayniteBoot.ico b/PlayniteBoot/RuntimeTemplate/PlayniteBoot.ico
new file mode 100644
index 0000000..1b1fd1d
Binary files /dev/null and b/PlayniteBoot/RuntimeTemplate/PlayniteBoot.ico differ
diff --git a/PlayniteBoot/RuntimeTemplate/PlayniteBoot.ps1 b/PlayniteBoot/RuntimeTemplate/PlayniteBoot.ps1
index 1340176..e59f0a3 100644
--- a/PlayniteBoot/RuntimeTemplate/PlayniteBoot.ps1
+++ b/PlayniteBoot/RuntimeTemplate/PlayniteBoot.ps1
@@ -1002,6 +1002,7 @@ try {
Add-Type @"
using System;
+using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
@@ -1216,6 +1217,33 @@ public static class PlayniteBootNative
[DllImport("user32.dll")]
public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+
+ private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+ [DllImport("user32.dll")]
+ private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+
+ [DllImport("user32.dll")]
+ private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+
+ public static IntPtr[] GetTopLevelWindowsForProcess(int processId)
+ {
+ List windows = new List();
+
+ EnumWindows(delegate(IntPtr hWnd, IntPtr lParam)
+ {
+ uint ownerProcessId;
+ GetWindowThreadProcessId(hWnd, out ownerProcessId);
+ if (ownerProcessId == (uint)processId)
+ {
+ windows.Add(hWnd);
+ }
+
+ return true;
+ }, IntPtr.Zero);
+
+ return windows.ToArray();
+ }
}
"@
@@ -1226,6 +1254,7 @@ public static class PlayniteBootNative
# least 85% of the monitor it actually occupies. The monitor is selected by
# the largest intersection area, independently from the boot overlay.
$minimumPlayniteMonitorCoverage = 0.85
+ $switchTopologyRefreshIntervalMilliseconds = 250
function Test-PlayniteWindowReady {
param(
@@ -1245,64 +1274,102 @@ public static class PlayniteBootNative
}
$Process.Refresh()
- $windowHandle = $Process.MainWindowHandle
- if ($windowHandle -eq [IntPtr]::Zero) {
- return $null
- }
+ $processId = [int]$Process.Id
+ $mainWindowHandle = [IntPtr]$Process.MainWindowHandle
- if (-not [PlayniteBootNative]::IsWindowVisible($windowHandle)) {
- return $null
- }
+ $testWindowHandle = {
+ param(
+ [IntPtr]$WindowHandle,
+ [string]$Source
+ )
- $windowRectangle = New-Object PlayniteBootNative+RECT
- if (-not [PlayniteBootNative]::GetWindowRect($windowHandle, [ref]$windowRectangle)) {
- return $null
- }
+ if ($WindowHandle -eq [IntPtr]::Zero -or
+ -not [PlayniteBootNative]::IsWindowVisible($WindowHandle)) {
+ return $null
+ }
- $windowWidth = $windowRectangle.Right - $windowRectangle.Left
- $windowHeight = $windowRectangle.Bottom - $windowRectangle.Top
- if ($windowWidth -lt 200 -or $windowHeight -lt 120) {
- return $null
- }
+ $windowRectangle = New-Object PlayniteBootNative+RECT
+ if (-not [PlayniteBootNative]::GetWindowRect($WindowHandle, [ref]$windowRectangle)) {
+ return $null
+ }
+
+ $windowWidth = $windowRectangle.Right - $windowRectangle.Left
+ $windowHeight = $windowRectangle.Bottom - $windowRectangle.Top
+ if ($windowWidth -lt 200 -or $windowHeight -lt 120) {
+ return $null
+ }
- $bestScreen = $null
- $bestIntersectionArea = 0.0
- foreach ($screen in @($AvailableScreens)) {
- $bounds = $screen.Bounds
- $intersectionLeft = [Math]::Max($windowRectangle.Left, $bounds.Left)
- $intersectionTop = [Math]::Max($windowRectangle.Top, $bounds.Top)
- $intersectionRight = [Math]::Min($windowRectangle.Right, $bounds.Right)
- $intersectionBottom = [Math]::Min($windowRectangle.Bottom, $bounds.Bottom)
+ $bestScreen = $null
+ $bestIntersectionArea = 0.0
+ foreach ($screen in @($AvailableScreens)) {
+ $bounds = $screen.Bounds
+ $intersectionLeft = [Math]::Max($windowRectangle.Left, $bounds.Left)
+ $intersectionTop = [Math]::Max($windowRectangle.Top, $bounds.Top)
+ $intersectionRight = [Math]::Min($windowRectangle.Right, $bounds.Right)
+ $intersectionBottom = [Math]::Min($windowRectangle.Bottom, $bounds.Bottom)
+
+ $intersectionWidth = [Math]::Max(0, $intersectionRight - $intersectionLeft)
+ $intersectionHeight = [Math]::Max(0, $intersectionBottom - $intersectionTop)
+ $intersectionArea = [double]$intersectionWidth * [double]$intersectionHeight
+
+ if ($intersectionArea -gt $bestIntersectionArea) {
+ $bestIntersectionArea = $intersectionArea
+ $bestScreen = $screen
+ }
+ }
+
+ if ($null -eq $bestScreen) {
+ return $null
+ }
- $intersectionWidth = [Math]::Max(0, $intersectionRight - $intersectionLeft)
- $intersectionHeight = [Math]::Max(0, $intersectionBottom - $intersectionTop)
- $intersectionArea = [double]$intersectionWidth * [double]$intersectionHeight
+ $monitorArea = [double]$bestScreen.Bounds.Width * [double]$bestScreen.Bounds.Height
+ if ($monitorArea -le 0) {
+ return $null
+ }
- if ($intersectionArea -gt $bestIntersectionArea) {
- $bestIntersectionArea = $intersectionArea
- $bestScreen = $screen
+ return [PSCustomObject]@{
+ Screen = $bestScreen
+ Coverage = $bestIntersectionArea / $monitorArea
+ WindowHandle = $WindowHandle
+ Source = $Source
}
}
- if ($null -eq $bestScreen) {
- return $null
+ # Preserve the 0.8.0 behavior whenever MainWindowHandle is already a
+ # valid Fullscreen candidate. Enumeration is only a fallback for the
+ # transition cases where MainWindowHandle still points to a splash or
+ # another transient Playnite window.
+ if ($mainWindowHandle -ne [IntPtr]::Zero) {
+ $mainCandidate = & $testWindowHandle -WindowHandle $mainWindowHandle -Source 'main'
+ if ($null -ne $mainCandidate -and $mainCandidate.Coverage -ge $MinimumCoverage) {
+ return $mainCandidate
+ }
}
- $monitorArea = [double]$bestScreen.Bounds.Width * [double]$bestScreen.Bounds.Height
- if ($monitorArea -le 0) {
- return $null
+ $bestCandidate = $null
+ foreach ($windowHandle in @([PlayniteBootNative]::GetTopLevelWindowsForProcess($processId))) {
+ if ($windowHandle -eq [IntPtr]::Zero -or $windowHandle -eq $mainWindowHandle) {
+ continue
+ }
+
+ # GetTopLevelWindowsForProcess filters EnumWindows by the exact
+ # tracked Playnite Fullscreen PID, so unrelated applications can
+ # never become readiness candidates.
+ $candidate = & $testWindowHandle -WindowHandle $windowHandle -Source 'enumerated'
+ if ($null -eq $candidate) {
+ continue
+ }
+
+ if ($null -eq $bestCandidate -or $candidate.Coverage -gt $bestCandidate.Coverage) {
+ $bestCandidate = $candidate
+ }
}
- $coverage = $bestIntersectionArea / $monitorArea
- if ($coverage -lt $MinimumCoverage) {
+ if ($null -eq $bestCandidate -or $bestCandidate.Coverage -lt $MinimumCoverage) {
return $null
}
- return [PSCustomObject]@{
- Screen = $bestScreen
- Coverage = $coverage
- WindowHandle = $windowHandle
- }
+ return $bestCandidate
}
catch {
return $null
@@ -1315,7 +1382,10 @@ public static class PlayniteBootNative
$Process,
[Parameter(Mandatory = $false)]
- [string]$Phase = ''
+ [string]$Phase = '',
+
+ [Parameter(Mandatory = $false)]
+ [IntPtr]$WindowHandle = [IntPtr]::Zero
)
if ($null -eq $Process) {
@@ -1327,13 +1397,20 @@ public static class PlayniteBootNative
return
}
- $Process.Refresh()
- $windowHandle = $Process.MainWindowHandle
- if ($windowHandle -ne [IntPtr]::Zero) {
+ $windowHandleToActivate = $WindowHandle
+ if ($windowHandleToActivate -eq [IntPtr]::Zero -or
+ -not [PlayniteBootNative]::IsWindowVisible($windowHandleToActivate)) {
+ $Process.Refresh()
+ $windowHandleToActivate = [IntPtr]$Process.MainWindowHandle
+ }
+
+ if ($windowHandleToActivate -ne [IntPtr]::Zero) {
# SW_RESTORE = 9. Ripristiniamo la finestra prima di chiedere il
- # foreground, come nella baseline originale.
- $showResult = [PlayniteBootNative]::ShowWindowAsync($windowHandle, 9)
- $foregroundResult = [PlayniteBootNative]::SetForegroundWindow($windowHandle)
+ # foreground, come nella baseline originale. Quando la readiness
+ # ha trovato una top-level window diversa da MainWindowHandle,
+ # riutilizziamo esattamente quella finestra per l'handoff.
+ $showResult = [PlayniteBootNative]::ShowWindowAsync($windowHandleToActivate, 9)
+ $foregroundResult = [PlayniteBootNative]::SetForegroundWindow($windowHandleToActivate)
if (-not [string]::IsNullOrWhiteSpace($Phase)) {
Write-Log "Foreground handoff [$Phase] for Playnite Fullscreen PID $($Process.Id): ShowWindowAsync=$showResult; SetForegroundWindow=$foregroundResult."
@@ -1534,6 +1611,34 @@ public static class PlayniteBootNative
}
}
+ function Get-ScreenTopologySignature {
+ param(
+ [Parameter(Mandatory = $true)]
+ $AvailableScreens
+ )
+
+ $parts = @($AvailableScreens | ForEach-Object {
+ $bounds = $_.Bounds
+ "{0}|{1},{2},{3},{4}|primary={5}" -f $_.DeviceName, $bounds.X, $bounds.Y, $bounds.Width, $bounds.Height, [bool]$_.Primary
+ } | Sort-Object)
+
+ return ($parts -join ';')
+ }
+
+ function Get-ScreenTopologyDescription {
+ param(
+ [Parameter(Mandatory = $true)]
+ $AvailableScreens
+ )
+
+ $parts = @($AvailableScreens | ForEach-Object {
+ $bounds = $_.Bounds
+ "{0} {1}x{2} at {3},{4}{5}" -f $_.DeviceName, $bounds.Width, $bounds.Height, $bounds.X, $bounds.Y, $(if ($_.Primary) { ' primary' } else { '' })
+ } | Sort-Object)
+
+ return ($parts -join '; ')
+ }
+
$screens = @([System.Windows.Forms.Screen]::AllScreens)
if ($screens.Count -eq 0) {
throw 'No monitors were detected.'
@@ -1629,6 +1734,12 @@ public static class PlayniteBootNative
ReadySince = $null
ReadyProcessId = $null
ReadyWindowHandle = [IntPtr]::Zero
+ ScreenTopologySignature = $(if ($Mode -eq 'Switch') { Get-ScreenTopologySignature -AvailableScreens $screens } else { $null })
+ ScreenTopologyCount = $(if ($Mode -eq 'Switch') { $screens.Count } else { 0 })
+ ScreenTopologyRefreshWarningLogged = $false
+ ReadinessScreens = $screens
+ ScreenTopologyRefreshWatch = [Diagnostics.Stopwatch]::StartNew()
+ LastScreenTopologyRefreshMilliseconds = -$switchTopologyRefreshIntervalMilliseconds
StartWatch = [Diagnostics.Stopwatch]::new()
PreloadWatch = [Diagnostics.Stopwatch]::new()
Closing = $false
@@ -1661,6 +1772,10 @@ public static class PlayniteBootNative
StreamingPidRolloverLogged = $false
}
+ if ($Mode -eq 'Switch') {
+ Write-Log "Switch readiness display topology initialized with $($screens.Count) active display(s): $(Get-ScreenTopologyDescription -AvailableScreens $screens)."
+ }
+
$uninstallAltF4Hook = {
if ($state.AltF4HookInstalled) {
try {
@@ -1933,7 +2048,26 @@ public static class PlayniteBootNative
$media.Add_MediaFailed({
param($sender, $eventArgs)
$state.VideoFailed = $true
- Write-Log "Video playback failed: $($eventArgs.ErrorException.Message). Using the Playnite-readiness fallback." 'WARN'
+
+ # A decoder/device failure can leave the last MediaElement surface
+ # frozen on screen, especially while Windows is changing display
+ # topology. Do not retry here: hide the failed surface immediately and
+ # keep the black overlay while readiness continues to track Playnite.
+ try {
+ $media.BeginAnimation([System.Windows.UIElement]::OpacityProperty, $null)
+ $media.Opacity = 0.0
+ $media.Visibility = [System.Windows.Visibility]::Hidden
+ }
+ catch {
+ }
+
+ try {
+ $media.Stop()
+ }
+ catch {
+ }
+
+ Write-Log "Video playback failed: $($eventArgs.ErrorException.Message). The failed video surface was hidden; using the Playnite-readiness fallback." 'WARN'
})
$closeImmediately = {
@@ -2170,7 +2304,7 @@ public static class PlayniteBootNative
}
if (-not $state.UserYieldedForeground) {
- Activate-PlayniteWindow -Process $candidateProcess -Phase 'pre-fade'
+ Activate-PlayniteWindow -Process $candidateProcess -Phase 'pre-fade' -WindowHandle $state.ReadyWindowHandle
}
if ($settings.FadeOutMilliseconds -le 0) {
@@ -2240,6 +2374,7 @@ public static class PlayniteBootNative
# La timeline visibile parte soltanto dopo Continue.
$hostWaitingAfterPreload = $Mode -eq 'Host' -and -not $state.LaunchStarted -and $state.PreloadPrepared
if ($videoExists -and
+ -not $state.VideoFailed -and
-not $state.VideoRevealed -and
-not $state.VideoEnded -and
-not $hostWaitingAfterPreload) {
@@ -2344,9 +2479,54 @@ public static class PlayniteBootNative
}
}
+ $readinessScreens = $screens
+ if ($Mode -eq 'Switch' -and $null -ne $candidateProcess) {
+ $readinessScreens = $state.ReadinessScreens
+ $topologyRefreshElapsedMilliseconds = $state.ScreenTopologyRefreshWatch.ElapsedMilliseconds
+ if (($topologyRefreshElapsedMilliseconds - $state.LastScreenTopologyRefreshMilliseconds) -ge $switchTopologyRefreshIntervalMilliseconds) {
+ $state.LastScreenTopologyRefreshMilliseconds = $topologyRefreshElapsedMilliseconds
+
+ try {
+ $currentScreens = @([System.Windows.Forms.Screen]::AllScreens)
+ if ($currentScreens.Count -gt 0) {
+ $currentTopologySignature = Get-ScreenTopologySignature -AvailableScreens $currentScreens
+ if ($currentTopologySignature -ne $state.ScreenTopologySignature) {
+ $previousTopologyCount = $state.ScreenTopologyCount
+ $state.ScreenTopologySignature = $currentTopologySignature
+ $state.ScreenTopologyCount = $currentScreens.Count
+
+ # A candidate cannot accumulate stability time across two
+ # different Windows display topologies. This matters for
+ # setups that switch from Extend to Second screen only
+ # while Playnite Fullscreen is starting.
+ $state.ReadySince = $null
+ $state.ReadyProcessId = $null
+ $state.ReadyWindowHandle = [IntPtr]::Zero
+
+ Write-Log "Display topology changed during Switch readiness: ${previousTopologyCount} -> $($currentScreens.Count) active display(s). Current topology: $(Get-ScreenTopologyDescription -AvailableScreens $currentScreens)." 'WARN'
+ }
+
+ $state.ReadinessScreens = $currentScreens
+ $readinessScreens = $currentScreens
+ $state.ScreenTopologyRefreshWarningLogged = $false
+ }
+ elseif (-not $state.ScreenTopologyRefreshWarningLogged) {
+ $state.ScreenTopologyRefreshWarningLogged = $true
+ Write-Log 'Windows temporarily reported no active displays during Switch readiness. Keeping the last valid display snapshot.' 'WARN'
+ }
+ }
+ catch {
+ if (-not $state.ScreenTopologyRefreshWarningLogged) {
+ $state.ScreenTopologyRefreshWarningLogged = $true
+ Write-Log "Could not refresh the Windows display topology during Switch readiness: $($_.Exception.Message). Keeping the last valid display snapshot." 'WARN'
+ }
+ }
+ }
+ }
+
$windowReadiness = $null
if ($null -ne $candidateProcess) {
- $windowReadiness = Test-PlayniteWindowReady -Process $candidateProcess -AvailableScreens $screens -MinimumCoverage $minimumPlayniteMonitorCoverage
+ $windowReadiness = Test-PlayniteWindowReady -Process $candidateProcess -AvailableScreens $readinessScreens -MinimumCoverage $minimumPlayniteMonitorCoverage
}
$windowIsReady = $null -ne $windowReadiness
@@ -2355,9 +2535,8 @@ public static class PlayniteBootNative
if ($windowIsReady) {
try {
- $candidateProcess.Refresh()
$candidateProcessId = [int]$candidateProcess.Id
- $candidateWindowHandle = [IntPtr]$candidateProcess.MainWindowHandle
+ $candidateWindowHandle = [IntPtr]$windowReadiness.WindowHandle
if ($candidateWindowHandle -eq [IntPtr]::Zero) {
$windowIsReady = $false
@@ -2382,7 +2561,8 @@ public static class PlayniteBootNative
$state.ReadyWindowHandle = $candidateWindowHandle
$coveragePercent = [Math]::Round($windowReadiness.Coverage * 100.0, 1)
$playniteScreenName = $windowReadiness.Screen.DeviceName
- Write-Log "Fullscreen window detected for PID ${candidateProcessId} on ${playniteScreenName}: monitor coverage is ${coveragePercent}%."
+ $readinessSource = [string]$windowReadiness.Source
+ Write-Log "Fullscreen window detected for PID ${candidateProcessId} on ${playniteScreenName}: monitor coverage is ${coveragePercent}% (window source: ${readinessSource})."
if ($playniteScreenName -ne $selectedScreen.DeviceName) {
Write-Log "Playnite Fullscreen is on ${playniteScreenName} while the boot overlay is on $($selectedScreen.DeviceName). The overlay will close normally." 'WARN'
}
@@ -2508,7 +2688,7 @@ public static class PlayniteBootNative
if ($state.WindowWasReady -and
-not $state.UserYieldedForeground -and
-not $state.BootCancelled) {
- Activate-PlayniteWindow -Process $trackedProcess -Phase 'post-overlay'
+ Activate-PlayniteWindow -Process $trackedProcess -Phase 'post-overlay' -WindowHandle $state.ReadyWindowHandle
}
if ($state.BootCancelled) {
diff --git a/PlayniteBoot/RuntimeTemplate/VERSION.txt b/PlayniteBoot/RuntimeTemplate/VERSION.txt
index 66c4c22..2ac9634 100644
--- a/PlayniteBoot/RuntimeTemplate/VERSION.txt
+++ b/PlayniteBoot/RuntimeTemplate/VERSION.txt
@@ -1 +1 @@
-1.0.9
+1.0.13
diff --git a/PlayniteBoot/Services/RuntimeInstaller.cs b/PlayniteBoot/Services/RuntimeInstaller.cs
index ac63af3..12f71be 100644
--- a/PlayniteBoot/Services/RuntimeInstaller.cs
+++ b/PlayniteBoot/Services/RuntimeInstaller.cs
@@ -20,6 +20,7 @@ public class RuntimeInstaller
"Launch-PlayniteBoot.vbs",
"Install-Shortcut.ps1",
"Test-Configuration.ps1",
+ "PlayniteBoot.ico",
"VERSION.txt"
};
diff --git a/PlayniteBoot/Services/RuntimePaths.cs b/PlayniteBoot/Services/RuntimePaths.cs
index 4afcd91..c84e6ea 100644
--- a/PlayniteBoot/Services/RuntimePaths.cs
+++ b/PlayniteBoot/Services/RuntimePaths.cs
@@ -17,6 +17,8 @@ public RuntimePaths(string pluginDataPath, string extensionInstallPath)
ScriptPath = Path.Combine(RuntimeDirectory, "PlayniteBoot.ps1");
ShortcutInstallerPath = Path.Combine(RuntimeDirectory, "Install-Shortcut.ps1");
ShortcutStatePath = Path.Combine(pluginDataPath, "shortcut-state.json");
+ ShortcutIconsDirectory = Path.Combine(pluginDataPath, "shortcut-icons");
+ DefaultShortcutIconPath = Path.Combine(RuntimeDirectory, "PlayniteBoot.ico");
DefaultTemplateVideoPath = Path.Combine(RuntimeTemplateDirectory, "media", "boot-4k60.mp4");
DefaultVideoPath = Path.Combine(MediaDirectory, "boot-4k60.mp4");
LogPath = Path.Combine(LogsDirectory, "PlayniteBoot.log");
@@ -33,6 +35,8 @@ public RuntimePaths(string pluginDataPath, string extensionInstallPath)
public string ScriptPath { get; }
public string ShortcutInstallerPath { get; }
public string ShortcutStatePath { get; }
+ public string ShortcutIconsDirectory { get; }
+ public string DefaultShortcutIconPath { get; }
public string DefaultTemplateVideoPath { get; }
public string DefaultVideoPath { get; }
public string LogPath { get; }
diff --git a/PlayniteBoot/Services/ShortcutService.cs b/PlayniteBoot/Services/ShortcutService.cs
index 75c890c..2f7f0fb 100644
--- a/PlayniteBoot/Services/ShortcutService.cs
+++ b/PlayniteBoot/Services/ShortcutService.cs
@@ -36,7 +36,7 @@ public ShortcutService(RuntimePaths paths)
this.paths = paths;
}
- public string Create(ShortcutLocation location, string shortcutName, string description)
+ public string Create(ShortcutLocation location, string shortcutName, string description, string iconPath)
{
if (!File.Exists(paths.ShortcutInstallerPath))
{
@@ -79,6 +79,11 @@ public string Create(ShortcutLocation location, string shortcutName, string desc
Convert.ToBase64String(Encoding.UTF8.GetBytes(normalizedName));
startInfo.EnvironmentVariables["PLAYNITEBOOT_SHORTCUT_DESCRIPTION_B64"] =
Convert.ToBase64String(Encoding.UTF8.GetBytes(description ?? string.Empty));
+ if (!string.IsNullOrWhiteSpace(iconPath))
+ {
+ startInfo.EnvironmentVariables["PLAYNITEBOOT_SHORTCUT_ICON_B64"] =
+ Convert.ToBase64String(Encoding.UTF8.GetBytes(iconPath));
+ }
using (var process = Process.Start(startInfo))
{
diff --git a/PlayniteBoot/extension.yaml b/PlayniteBoot/extension.yaml
index 8f601cb..c43db51 100644
--- a/PlayniteBoot/extension.yaml
+++ b/PlayniteBoot/extension.yaml
@@ -1,7 +1,7 @@
Id: PlayniteBoot_71b5c099-3c25-4fe7-b26f-1262c7f0e138
Name: Playnite Boot Screen
Author: VirtualGIT20
-Version: 0.8.0
+Version: 0.8.1
Module: PlayniteBoot.dll
Type: GenericPlugin
Icon: icon.png
diff --git a/README.md b/README.md
index 38535e4..978cb58 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ https://github.com/user-attachments/assets/6d77a081-9165-4f0f-a6bb-785642ced0e7
- Choose whether to reveal Playnite as soon as it is ready, wait for the video to finish, or loop until Playnite is ready.
- Cover Playnite's built-in Desktop-to-Fullscreen transition with the configured boot video; enabled by default and optional in settings.
- Managed runtime stored outside the replaceable extension installation directory.
-- Configurable Desktop and Start menu shortcut name.
+- Configurable Desktop and Start menu shortcut name and icon: Playnite Boot Screen, Playnite Fullscreen, or a custom `.ico`.
- Streaming Preload and Continue commands shown directly in the settings page.
- Public runtime marker for theme/helper plugins that need to suppress duplicate startup intros.
- English and Italian localization.
@@ -52,10 +52,10 @@ Close Playnite, then run:
## Direct launch
-In **Installation and diagnostics**:
+In **Quick Setup**:
-1. choose a shortcut name;
-2. select **Create/update Desktop shortcut** or **Create/update Start shortcut**;
+1. choose a shortcut name and icon;
+2. select **Create/update** for the Desktop or Start menu shortcut;
3. close Playnite completely;
4. launch the new shortcut.
@@ -96,6 +96,7 @@ Persistent files are stored under Playnite's extension data directory:
│ ├── cache\
│ │ └── video-compat\
│ └── logs\
+├── shortcut-icons\
└── shortcut-state.json
```
diff --git a/README_IT.md b/README_IT.md
index 085d267..f8c15a8 100644
--- a/README_IT.md
+++ b/README_IT.md
@@ -18,7 +18,7 @@ https://github.com/user-attachments/assets/fc1d7d9a-7a05-4b44-a43e-959a9b4a4fad
- Possibilità di mostrare Playnite appena pronto, attendere la fine del video oppure ripeterlo in loop finché Playnite non è pronto.
- Copertura della transizione integrata Desktop → Fullscreen con il video configurato, attiva di default e disattivabile dalle impostazioni.
- Runtime gestito fuori dalla directory sostituita durante gli aggiornamenti dell'estensione.
-- Nome personalizzabile per i collegamenti Desktop e menu Start.
+- Nome e icona personalizzabili per i collegamenti Desktop e menu Start: Playnite Boot Screen, Playnite Fullscreen oppure un file `.ico` personalizzato.
- Comandi Preload e Continue nella schermata Streaming.
- Marker runtime pubblico per temi/helper che devono evitare intro di avvio duplicate.
- Interfaccia in inglese e italiano.
@@ -48,10 +48,10 @@ Per una build di sviluppo, chiudi Playnite ed esegui:
## Avvio diretto
-In **Installazione e diagnostica**:
+In **Configurazione rapida**:
-1. scegli il nome del collegamento;
-2. seleziona **Crea/aggiorna collegamento Desktop** oppure **Crea/aggiorna collegamento Start**;
+1. scegli nome e icona del collegamento;
+2. seleziona **Crea/aggiorna** per il collegamento Desktop o menu Start;
3. chiudi completamente Playnite;
4. avvia il nuovo collegamento.
@@ -90,6 +90,7 @@ I file persistenti vengono salvati nella directory dati dell’estensione:
│ ├── cache\
│ │ └── video-compat\
│ └── logs\
+├── shortcut-icons\
└── shortcut-state.json
```
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 3a35604..00f595c 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -1,24 +1,19 @@
-# Playnite Boot Screen 0.8.0
+# Playnite Boot Screen 0.8.1
-Version 0.8.0 focuses on predictable video completion, cleaner streaming startup, WebM compatibility, and better cooperation with Fullscreen themes and helpers.
+Version 0.8.1 focuses on a clearer first-time setup and more reliable Desktop-to-Fullscreen startup on systems that change display topology while Playnite is opening.
## Highlights
-- **New video-end behavior controls** — reveal Playnite as soon as it is ready, wait for the video to finish, or loop until Playnite is ready.
-- **WebM compatibility** — WebM files are exposed to the Windows media pipeline through a local MKV compatibility alias, without transcoding or FFmpeg.
-- **Improved Sunshine / Apollo / VibePollo startup** — Preload primes and rewinds the decoder, then Continue restarts playback from the beginning.
-- **Aniki ReMake / Aniki Helper integration** — compatible helpers can detect when PBS is already handling the startup intro and avoid playing a duplicate intro.
-- **Optional Aniki ReMake intro included** — the extended intro is bundled as a selectable video while custom media remains fully supported.
-- **Safer streaming failure handling** — an abandoned Preload now closes after 10 seconds, and a new Continue-entry log helps diagnose rare Detached launch failures.
-
-## Aniki ReMake integration
-
-Playnite Boot Screen now publishes `Local\PlayniteBootScreen.StartupIntroHandled.v1` while it is actively handling startup. Aniki Helper can use this marker to suppress its own startup intro for that launch, avoiding two intro videos back to back.
-
-The integration is independent from the selected video: the bundled extended Aniki ReMake intro is optional, and PBS continues to work normally with custom videos and other themes.
+- **Guided Quick Setup** — the main settings page now keeps the essential launch, video, and reveal controls together, with a compact Ready / Setup needed status in the header.
+- **Shortcut icon choices** — PBS-managed Desktop and Start menu shortcuts can use the Playnite Boot Screen icon, the Playnite Fullscreen icon, or a custom `.ico` file copied into persistent extension data.
+- **Topology-aware Desktop → Fullscreen readiness** — Switch mode refreshes the active Windows display layout while Playnite starts, so setups that move from Extended mode to a single TV/display no longer keep checking against a stale monitor snapshot.
+- **Safer Fullscreen window detection** — PBS still prefers Playnite's `MainWindowHandle`, but can fall back to another visible top-level window owned by the exact Playnite Fullscreen PID when the main handle is temporarily pointing at a transient window.
+- **Safer video failure fallback** — if Windows media playback fails during a display change, the failed video surface is hidden and PBS continues waiting for Playnite instead of leaving a frozen frame visible.
## Compatibility
-Existing 0.7.x playback settings are migrated automatically. Existing shortcuts, custom media, and streaming configuration remain compatible.
+Existing 0.8.0 settings are migrated automatically. Existing installations keep the historical Playnite Fullscreen shortcut icon choice, while fresh installations default to the Playnite Boot Screen icon. Custom media, shortcut state, and streaming configuration remain compatible.
+
+The dynamic display-topology refresh is limited to Desktop-to-Fullscreen Switch readiness; it does not retarget or move the PBS overlay. Manual monitor selection remains available for explicit overlay placement.
-Runtime updated to 1.0.9.
+Runtime updated to 1.0.13.
diff --git a/distribution/installer.yaml b/distribution/installer.yaml
index eb52497..b580d01 100644
--- a/distribution/installer.yaml
+++ b/distribution/installer.yaml
@@ -1,5 +1,14 @@
AddonId: PlayniteBoot_71b5c099-3c25-4fe7-b26f-1262c7f0e138
Packages:
+ - Version: 0.8.1
+ RequiredApiVersion: 6.16.0
+ ReleaseDate: 2026-09-16
+ PackageUrl: https://github.com/VirtualGIT20/Playnite-Boot-Screen/releases/download/v0.8.1/Playnite-Boot-Screen-v0.8.1.pext
+ Changelog:
+ - Add a guided Quick Setup page and selectable PBS, Playnite Fullscreen, or custom shortcut icons.
+ - Fix Desktop-to-Fullscreen readiness when Windows changes display topology during startup.
+ - Add an exact-PID top-level window fallback while preserving MainWindowHandle as the primary readiness path.
+ - Hide a failed video surface and continue with the safe readiness fallback instead of leaving a frozen frame.
- Version: 0.8.0
RequiredApiVersion: 6.16.0
ReleaseDate: 2026-09-14
diff --git a/docs/RELEASE_CHECKLIST.md b/docs/RELEASE_CHECKLIST.md
index cdc1233..72c8cad 100644
--- a/docs/RELEASE_CHECKLIST.md
+++ b/docs/RELEASE_CHECKLIST.md
@@ -1,4 +1,4 @@
-# Release checklist — 0.8.0
+# Release checklist — 0.8.1
## Code and behavior
@@ -26,12 +26,18 @@
- [ ] Follow Playnite selects Playnite's configured secondary display when primary-display mode is disabled.
- [ ] Missing, invalid, or stale Playnite display settings fall back without stopping the launcher.
- [ ] Playnite readiness is detected when the overlay and Playnite Fullscreen are on different monitors.
+- [ ] During Desktop → Fullscreen, changing Windows from an extended topology to a single active display is detected without the 45-second readiness timeout.
+- [ ] If `MainWindowHandle` is not the valid Fullscreen window, the exact-PID top-level window fallback can complete readiness and foreground handoff.
+- [ ] A `MediaFailed` event hides the failed video surface and falls back to a black overlay while readiness continues.
- [ ] The standard video folder list refreshes, ignores subfolders, and keeps external video paths supported.
- [ ] Standard-folder videos are written to `config.json` as relative `.\media\...` paths.
- [ ] Desktop and Start shortcuts can be created, renamed, and removed.
+- [ ] PBS-managed shortcuts can use the PBS icon, Playnite Fullscreen icon, and a custom `.ico`; custom icons persist from the extension data folder.
+- [ ] Upgrading 0.8.0 preserves the Playnite Fullscreen shortcut icon choice, while a fresh 0.8.1 profile defaults to the PBS icon.
+- [ ] Quick Setup reports Ready when a PBS shortcut exists or Desktop → Fullscreen is enabled, and Setup needed otherwise.
- [ ] Invalid or modified shortcut state cannot escape the Desktop or Start menu directories.
- [ ] Runtime log rotates to `PlayniteBoot.log.1` after 2 MiB.
-- [ ] With `VERSION.txt` unchanged at `1.0.9`, modifying a managed installed runtime file is repaired automatically on the next Playnite start.
+- [ ] With `VERSION.txt` unchanged at `1.0.13`, modifying a managed installed runtime file is repaired automatically on the next Playnite start.
## Display matrix
@@ -44,9 +50,10 @@
## Packaging
-- [ ] `scripts/verify-release.ps1 -Version 0.8.0` succeeds.
+- [ ] `scripts/verify-release.ps1 -Version 0.8.1` succeeds.
- [ ] `scripts/pack.ps1 -Configuration Release` creates exactly one expected `.pext`.
- [ ] Build output and `.pext` both contain `RuntimeTemplate\SwitchBootstrap.ps1`.
+- [ ] Build output and `.pext` both contain `RuntimeTemplate\PlayniteBoot.ico`.
- [ ] Build output and `.pext` both contain `RuntimeTemplate\media\Aniki_Remake_Intro.mp4`.
- [ ] Build and package contain no `.pdb`, source, temporary, or stale files.
- [ ] SHA-256 file matches the package.
@@ -59,12 +66,12 @@
- [ ] Repository description, topics, and license are set.
- [ ] Private vulnerability reporting is enabled.
- [ ] CI workflow succeeds.
-- [ ] Tag `v0.8.0` creates a release with `.pext` and checksum.
-- [ ] Release notes highlight the playback model, WebM compatibility, streaming preload improvements, and Aniki ReMake integration.
+- [ ] Tag `v0.8.1` creates a release with `.pext` and checksum.
+- [ ] Release notes highlight Quick Setup, shortcut icon choices, topology-aware Switch readiness, and the MediaFailed fallback.
## Playnite add-on database
- [ ] GitHub release asset URL is live.
- [ ] `distribution/installer.yaml` verifies with Toolbox.
- [ ] `distribution/addon.yaml` verifies with Toolbox.
-- [ ] Published store entry resolves `distribution/installer.yaml` and exposes version `0.8.0`; no database pull request is needed unless central metadata changes.
+- [ ] Published store entry resolves `distribution/installer.yaml` and exposes version `0.8.1`; no database pull request is needed unless central metadata changes.
diff --git a/docs/TROUBLESHOOTING.md b/docs/TROUBLESHOOTING.md
index 48d8006..4aaa4b7 100644
--- a/docs/TROUBLESHOOTING.md
+++ b/docs/TROUBLESHOOTING.md
@@ -36,7 +36,7 @@ Diagnostic steps:
1. Repeat the launch with Playnite's default Fullscreen theme.
2. Check `%APPDATA%\Playnite\playnite.log` and `%APPDATA%\Playnite\extensions.log`.
-3. Open the Playnite Boot Screen runtime log from **Installation and diagnostics → Open logs**.
+3. Open the Playnite Boot Screen runtime log from **Diagnostics → Open logs**.
4. Check whether the runtime log contains `Launcher exited with code 0`.
When the launcher exits successfully, investigate the active Fullscreen theme, virtual-display configuration, and Playnite rendering logs before treating the boot overlay as the cause.
@@ -50,7 +50,7 @@ Playnite logs:
%APPDATA%\Playnite\extensions.log
```
-Runtime logs are available through **Installation and diagnostics → Open logs**.
+Runtime logs are available through **Diagnostics → Open logs**.
The active runtime log is limited to 2 MiB. When it reaches the limit, it is moved to `PlayniteBoot.log.1`; any older backup is replaced.
diff --git a/scripts/pack.ps1 b/scripts/pack.ps1
index 6f6d20c..cd154bd 100644
--- a/scripts/pack.ps1
+++ b/scripts/pack.ps1
@@ -67,6 +67,7 @@ $requiredFiles = @(
'RuntimeTemplate\Launch-PlayniteBoot.vbs',
'RuntimeTemplate\Install-Shortcut.ps1',
'RuntimeTemplate\Test-Configuration.ps1',
+ 'RuntimeTemplate\PlayniteBoot.ico',
'RuntimeTemplate\VERSION.txt',
'RuntimeTemplate\media\boot-4k60.mp4',
'RuntimeTemplate\media\Aniki_Remake_Intro.mp4'
diff --git a/scripts/verify-source.ps1 b/scripts/verify-source.ps1
index 06b5c44..486c3fe 100644
--- a/scripts/verify-source.ps1
+++ b/scripts/verify-source.ps1
@@ -59,6 +59,39 @@ if ($keyDifferences.Count -gt 0) {
throw "English and Italian localization keys differ:`n$($keyDifferences | Out-String)"
}
+Write-Host 'Checking setup-first shortcut integration...'
+$settingsDataPath = Join-Path $root 'PlayniteBoot\Models\PlayniteBootSettingsData.cs'
+$settingsModelPath = Join-Path $root 'PlayniteBoot\PlayniteBootSettings.cs'
+$shortcutServicePath = Join-Path $root 'PlayniteBoot\Services\ShortcutService.cs'
+$shortcutInstallerPath = Join-Path $root 'PlayniteBoot\RuntimeTemplate\Install-Shortcut.ps1'
+$shortcutIconPath = Join-Path $root 'PlayniteBoot\RuntimeTemplate\PlayniteBoot.ico'
+$settingsViewPath = Join-Path $root 'PlayniteBoot\PlayniteBootSettingsView.xaml'
+foreach ($requiredPath in @($settingsDataPath, $settingsModelPath, $shortcutServicePath, $shortcutInstallerPath, $shortcutIconPath, $settingsViewPath)) {
+ if (-not (Test-Path -LiteralPath $requiredPath -PathType Leaf)) {
+ throw "Required setup/shortcut file not found: $requiredPath"
+ }
+}
+$settingsDataSource = Get-Content -LiteralPath $settingsDataPath -Raw -Encoding UTF8
+$settingsModelSource = Get-Content -LiteralPath $settingsModelPath -Raw -Encoding UTF8
+$shortcutServiceSource = Get-Content -LiteralPath $shortcutServicePath -Raw -Encoding UTF8
+$shortcutInstallerSource = Get-Content -LiteralPath $shortcutInstallerPath -Raw -Encoding UTF8
+$settingsViewSource = Get-Content -LiteralPath $settingsViewPath -Raw -Encoding UTF8
+$shortcutChecks = @(
+ @{ Name = 'setup-first tab'; Pass = $settingsViewSource -match 'LOCPlayniteBootTabSetup' },
+ @{ Name = 'shortcut icon modes'; Pass = $settingsDataSource -match 'ShortcutIconModes' -and $settingsDataSource -match 'CurrentSettingsVersion = 6' },
+ @{ Name = 'custom ICO picker'; Pass = $settingsModelSource -match 'BrowseShortcutIconCommand' -and $settingsModelSource -match 'ShortcutIconsDirectory' -and $settingsModelSource -match 'SHA256.Create' },
+ @{ Name = 'explicit shortcut icon handoff'; Pass = $shortcutServiceSource -match 'PLAYNITEBOOT_SHORTCUT_ICON_B64' -and $shortcutInstallerSource -match 'PLAYNITEBOOT_SHORTCUT_ICON_B64' },
+ @{ Name = 'bundled PBS shortcut icon'; Pass = (Get-Item -LiteralPath $shortcutIconPath).Length -gt 1024 }
+)
+$failedShortcutChecks = @($shortcutChecks | Where-Object { -not $_.Pass })
+foreach ($check in $shortcutChecks) {
+ Write-Host ("Setup/shortcut {0}: {1}" -f $check.Name, $(if ($check.Pass) { 'OK' } else { 'FAILED' }))
+}
+if ($failedShortcutChecks.Count -gt 0) {
+ throw 'Setup-first shortcut integration is incomplete.'
+}
+Write-Host 'Setup-first shortcut integration: OK'
+
Write-Host 'Checking runtime and media files...'
$runtimeVersionPath = Join-Path $root 'PlayniteBoot\RuntimeTemplate\VERSION.txt'
$runtimeVersion = (Get-Content -LiteralPath $runtimeVersionPath -Raw).Trim()
@@ -75,7 +108,10 @@ $runtimeBehaviorChecks = @(
@{ Name = 'foreground polling removed'; Pass = $runtimeScript -notmatch '\$yieldForegroundIfNeeded' },
@{ Name = 'Playnite monitor following'; Pass = $runtimeScript -match 'fullscreenConfig\.json' },
@{ Name = 'monitor fallback'; Pass = $runtimeScript -match 'MonitorFallback' },
- @{ Name = 'cross-monitor readiness'; Pass = $runtimeScript -match 'largest intersection area|bestIntersectionArea' }
+ @{ Name = 'cross-monitor readiness'; Pass = $runtimeScript -match 'largest intersection area|bestIntersectionArea' },
+ @{ Name = 'PID top-level window readiness fallback'; Pass = $runtimeScript -match 'GetTopLevelWindowsForProcess' -and $runtimeScript -match 'GetWindowThreadProcessId' -and $runtimeScript -match 'Preserve the 0\.8\.0 behavior whenever MainWindowHandle' -and $runtimeScript -match '\$windowReadiness\.WindowHandle' },
+ @{ Name = 'Switch topology-aware readiness'; Pass = $runtimeScript -match 'Get-ScreenTopologySignature' -and $runtimeScript -match 'Display topology changed during Switch readiness' -and $runtimeScript -match '\$readinessScreens' },
+ @{ Name = 'MediaFailed black-surface fallback'; Pass = $runtimeScript -match 'The failed video surface was hidden' -and $runtimeScript -match '\$media\.Visibility = \[System\.Windows\.Visibility\]::Hidden' -and $runtimeScript -match '-not \$state\.VideoFailed' }
)
$failedRuntimeBehaviorChecks = @($runtimeBehaviorChecks | Where-Object { -not $_.Pass })
@@ -112,7 +148,6 @@ Write-Host 'Checking managed video library integration...'
$videoLibraryPath = Join-Path $root 'PlayniteBoot\Services\VideoLibraryService.cs'
$videoCompatibilityPath = Join-Path $root 'PlayniteBoot\Services\VideoCompatibilityService.cs'
$configWriterPath = Join-Path $root 'PlayniteBoot\Services\RuntimeConfigWriter.cs'
-$settingsViewPath = Join-Path $root 'PlayniteBoot\PlayniteBootSettingsView.xaml'
foreach ($requiredPath in @($videoLibraryPath, $videoCompatibilityPath, $configWriterPath, $settingsViewPath)) {
if (-not (Test-Path -LiteralPath $requiredPath -PathType Leaf)) {
throw "Required video library file not found: $requiredPath"