refactor: split Background out of MainViewModel — Commit 4/12 (tag refactor-commit-4)
This commit is contained in:
@@ -0,0 +1,568 @@
|
||||
using System.Collections.ObjectModel;
|
||||
using System.IO;
|
||||
using System.Windows;
|
||||
using System.Windows.Input;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using ytLive.Helpers;
|
||||
using ytLive.Models;
|
||||
using ytLive.Services;
|
||||
|
||||
namespace ytLive.ViewModels;
|
||||
|
||||
public partial class MainViewModel
|
||||
{
|
||||
// Screen background: a permanent live capture (desktop/game) that every scene
|
||||
// shows at the bottom layer. One shared capture session per key — the
|
||||
// ScreenCaptureManager refcounts by key, mirroring CameraManager.
|
||||
private readonly IFullScreenDetector _fullScreenDetector;
|
||||
private readonly ScreenCaptureManager _screenCaptureManager;
|
||||
private readonly ScreenCaptureSourceFactory _screenCaptureFactory;
|
||||
|
||||
private ImageSource? _activeBackgroundImage;
|
||||
private ImageSource? _backgroundImage;
|
||||
private bool _backgroundSizeMismatch;
|
||||
private string _backgroundSizeMismatchText = "";
|
||||
private HashSet<string> _liveCaptureKeys = new();
|
||||
|
||||
public ObservableCollection<DisplayInfo> Displays { get; } = new();
|
||||
|
||||
public ImageSource? ActiveBackgroundImage
|
||||
{
|
||||
get => _activeBackgroundImage;
|
||||
private set => SetProperty(ref _activeBackgroundImage, value);
|
||||
}
|
||||
|
||||
/// <summary>The active scene's live-capture background frame (rendered below the
|
||||
/// static background). Set from the shared capture bitmap as it arrives.</summary>
|
||||
public ImageSource? BackgroundImage
|
||||
{
|
||||
get => _backgroundImage;
|
||||
private set
|
||||
{
|
||||
if (SetProperty(ref _backgroundImage, value))
|
||||
{
|
||||
OnPropertyChanged(nameof(ShowPreviewPlaceholder));
|
||||
OnPropertyChanged(nameof(BackgroundVisible));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public bool BackgroundVisible => StagedScene?.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground)?.IsVisible == true;
|
||||
|
||||
public bool BackgroundSizeMismatch
|
||||
{
|
||||
get => _backgroundSizeMismatch;
|
||||
private set => SetProperty(ref _backgroundSizeMismatch, value);
|
||||
}
|
||||
|
||||
public string BackgroundSizeMismatchText
|
||||
{
|
||||
get => _backgroundSizeMismatchText;
|
||||
private set => SetProperty(ref _backgroundSizeMismatchText, value);
|
||||
}
|
||||
|
||||
public ICommand ChangeCaptureCommand { get; }
|
||||
public ICommand RefreshCaptureCommand { get; }
|
||||
public ICommand SetBackgroundDisplayCommand { get; }
|
||||
public ICommand ToggleShowDesktopCommand { get; }
|
||||
public ICommand BrowseBackgroundCommand { get; }
|
||||
|
||||
private void UpdateActiveBackground()
|
||||
{
|
||||
// Static-art rows only. Capture-flavored rows (Live) must NEVER feed
|
||||
// ActiveBackgroundImage — it renders above BackgroundImage, so it would
|
||||
// permanently cover the desktop/game capture. Live's canvas shows
|
||||
// DisplaySource instead (capture, falling back to live-background.jpg).
|
||||
var background = StagedScene?.Elements.OfType<Source>().FirstOrDefault(s => s.Type == SourceType.Background);
|
||||
ActiveBackgroundImage = background != null && !string.IsNullOrWhiteSpace(background.AssetId)
|
||||
? ImageCache.Get(background.AssetId)
|
||||
: null;
|
||||
OnPropertyChanged(nameof(ShowPreviewPlaceholder));
|
||||
}
|
||||
|
||||
private void UpdateBackgroundImage()
|
||||
{
|
||||
var scene = StagedScene;
|
||||
var background = scene?.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
|
||||
BackgroundImage = background?.DisplaySource;
|
||||
|
||||
if (background != null && !background.UseDefaultBackground
|
||||
&& !string.IsNullOrWhiteSpace(background.CustomBackgroundPath)
|
||||
&& System.IO.File.Exists(background.CustomBackgroundPath))
|
||||
{
|
||||
try
|
||||
{
|
||||
var bmi = new System.Windows.Media.Imaging.BitmapImage();
|
||||
bmi.BeginInit();
|
||||
bmi.UriSource = new System.Uri(background.CustomBackgroundPath);
|
||||
bmi.CacheOption = System.Windows.Media.Imaging.BitmapCacheOption.OnLoad;
|
||||
bmi.EndInit();
|
||||
bmi.Freeze();
|
||||
|
||||
double expectedRatio = 1920.0 / 1080.0;
|
||||
double imageRatio = (double)bmi.PixelWidth / bmi.PixelHeight;
|
||||
double ratioDiff = Math.Abs(imageRatio - expectedRatio) / expectedRatio;
|
||||
|
||||
if (ratioDiff > 0.05)
|
||||
{
|
||||
BackgroundSizeMismatch = true;
|
||||
BackgroundSizeMismatchText =
|
||||
$"Image is {bmi.PixelWidth}\u00d7{bmi.PixelHeight} \u2014 stream expects 1920\u00d71080 (16:9)";
|
||||
}
|
||||
else
|
||||
{
|
||||
BackgroundSizeMismatch = false;
|
||||
BackgroundSizeMismatchText = "";
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
BackgroundSizeMismatch = false;
|
||||
BackgroundSizeMismatchText = "";
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
BackgroundSizeMismatch = false;
|
||||
BackgroundSizeMismatchText = "";
|
||||
}
|
||||
}
|
||||
|
||||
private void RefreshSnapshotsAsync()
|
||||
{
|
||||
foreach (var scene in Scenes)
|
||||
{
|
||||
// Minis never render live captures. While the Live screen is staged
|
||||
// (being previewed) its mini shows the green placeholder; unstaged,
|
||||
// it shows the stored default art. Real-time surface = center only.
|
||||
var stagedLive = ReferenceEquals(scene, StagedScene)
|
||||
&& SceneCatalog.Is(scene.Name, SceneCatalog.Live);
|
||||
var img = stagedLive ? null : LoadBackgroundImage(scene);
|
||||
if (img != null)
|
||||
scene.Snapshot = img;
|
||||
else if (scene.Snapshot == null || stagedLive)
|
||||
scene.Snapshot = CreatePlaceholderSnapshot(scene.Name);
|
||||
}
|
||||
}
|
||||
|
||||
internal static System.Windows.Media.Imaging.BitmapSource? LoadBackgroundImage(Scene scene)
|
||||
{
|
||||
var bg = scene.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
|
||||
if (bg != null && !bg.UseDefaultBackground
|
||||
&& !string.IsNullOrWhiteSpace(bg.CustomBackgroundPath)
|
||||
&& System.IO.File.Exists(bg.CustomBackgroundPath))
|
||||
{
|
||||
try
|
||||
{
|
||||
var bitmap = new System.Windows.Media.Imaging.BitmapImage();
|
||||
bitmap.BeginInit();
|
||||
bitmap.UriSource = new Uri(bg.CustomBackgroundPath);
|
||||
bitmap.CacheOption = System.Windows.Media.Imaging.BitmapCacheOption.OnLoad;
|
||||
bitmap.EndInit();
|
||||
bitmap.Freeze();
|
||||
return bitmap;
|
||||
}
|
||||
catch { /* fall through to AssetId */ }
|
||||
}
|
||||
if (bg != null && !string.IsNullOrWhiteSpace(bg.AssetId))
|
||||
return ImageCache.Get(bg.AssetId);
|
||||
return null;
|
||||
}
|
||||
|
||||
private static BitmapSource CreatePlaceholderSnapshot(string sceneName)
|
||||
{
|
||||
var colors = new Dictionary<string, System.Windows.Media.Brush>(StringComparer.OrdinalIgnoreCase)
|
||||
{
|
||||
["Starting"] = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(233, 69, 96)),
|
||||
["Live"] = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(34, 197, 94)),
|
||||
["BRB"] = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(234, 179, 8)),
|
||||
["Chat"] = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(59, 130, 246)),
|
||||
["Ending"] = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(168, 85, 247)),
|
||||
};
|
||||
var brush = colors.TryGetValue(sceneName, out var c) ? c
|
||||
: new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(60, 60, 80));
|
||||
var dv = new System.Windows.Media.DrawingVisual();
|
||||
using (var ctx = dv.RenderOpen())
|
||||
{
|
||||
ctx.DrawRectangle(brush, null, new System.Windows.Rect(0, 0, 320, 180));
|
||||
var ft = new System.Windows.Media.FormattedText(
|
||||
sceneName,
|
||||
System.Globalization.CultureInfo.InvariantCulture,
|
||||
System.Windows.FlowDirection.LeftToRight,
|
||||
new System.Windows.Media.Typeface("Segoe UI"),
|
||||
18,
|
||||
System.Windows.Media.Brushes.White,
|
||||
96);
|
||||
ctx.DrawText(ft, new System.Windows.Point(160 - ft.Width / 2, 90 - ft.Height / 2));
|
||||
}
|
||||
var rtb = new System.Windows.Media.Imaging.RenderTargetBitmap(
|
||||
320, 180, 96, 96, System.Windows.Media.PixelFormats.Pbgra32);
|
||||
rtb.Render(dv);
|
||||
rtb.Freeze();
|
||||
return rtb;
|
||||
}
|
||||
|
||||
// ─── Screen background capture (live desktop/game) ───
|
||||
|
||||
private const string MonitorKeyPrefix = "monitor:";
|
||||
|
||||
/// <summary>Every background-enabled scene has exactly one background, kept at index 0 (bottom layer).
|
||||
/// Returns null for a scene with <see cref="Scene.HasBackground"/> = false.</summary>
|
||||
internal static Source? EnsureBackground(Scene scene)
|
||||
{
|
||||
if (!scene.HasBackground) return null;
|
||||
var background = scene.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
|
||||
if (background != null) return background;
|
||||
|
||||
background = CreateBackground(scene.Name);
|
||||
scene.Elements.Insert(0, background);
|
||||
return background;
|
||||
}
|
||||
|
||||
/// <summary>The one Background row for a scene. Live gets the capture flavor
|
||||
/// (Show Desktop / monitor switch / fullscreen-game detect) falling back to
|
||||
/// live-background.jpg; every other screen is a static default-art layer.
|
||||
/// Both are named "Background" — the user never sees capture jargon here.</summary>
|
||||
internal static Source CreateBackground(string sceneName)
|
||||
{
|
||||
var isLive = SceneCatalog.Is(sceneName, SceneCatalog.Live);
|
||||
return new Source
|
||||
{
|
||||
Name = "Background",
|
||||
Type = isLive ? SourceType.DisplayCapture : SourceType.Background,
|
||||
IsBackground = true,
|
||||
IsEnabled = true,
|
||||
X = 0,
|
||||
Y = 0,
|
||||
Width = MasterFrameWidth,
|
||||
Height = MasterFrameHeight,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Heals any loaded layout to the locked Background model: exactly
|
||||
/// one Background per canonical scene, correct flavor for the scene (static
|
||||
/// art everywhere, DisplayCapture on Live only), at index 0, named
|
||||
/// "Background". Duplicates and stale rows are dropped; missing ones seeded;
|
||||
/// non-canonical scenes get HasBackground=false and lose any backgrounds.</summary>
|
||||
internal static void NormalizeBackgrounds(IEnumerable<Scene> scenes)
|
||||
{
|
||||
foreach (var scene in scenes)
|
||||
{
|
||||
if (!SceneCatalog.HasBackground(scene.Name))
|
||||
{
|
||||
scene.HasBackground = false;
|
||||
foreach (var stale in scene.Elements.OfType<Source>().Where(s => s.IsBackground).ToList())
|
||||
scene.Elements.Remove(stale);
|
||||
continue;
|
||||
}
|
||||
|
||||
scene.HasBackground = true;
|
||||
var isLive = SceneCatalog.Is(scene.Name, SceneCatalog.Live);
|
||||
var wantedType = isLive ? SourceType.DisplayCapture : SourceType.Background;
|
||||
|
||||
var candidates = scene.Elements.OfType<Source>().Where(s => s.IsBackground).ToList();
|
||||
var keep = candidates.FirstOrDefault(b => b.Type == wantedType) ?? candidates.FirstOrDefault();
|
||||
|
||||
foreach (var extra in candidates.Where(b => !ReferenceEquals(b, keep)))
|
||||
scene.Elements.Remove(extra);
|
||||
|
||||
if (keep == null)
|
||||
{
|
||||
keep = CreateBackground(scene.Name);
|
||||
scene.Elements.Insert(0, keep);
|
||||
}
|
||||
|
||||
// Source.Type's setter derives IsBackground from the enum, so a
|
||||
// flavor correction must re-assert the flag afterwards.
|
||||
if (keep.Type != wantedType)
|
||||
{
|
||||
keep.Type = wantedType;
|
||||
keep.IsBackground = true;
|
||||
}
|
||||
|
||||
keep.Name = "Background";
|
||||
keep.IsEnabled = true;
|
||||
|
||||
var index = scene.Elements.IndexOf(keep);
|
||||
if (index > 0)
|
||||
scene.Elements.Move(index, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Only the Live screen's background is a real-time surface. Every other
|
||||
// lookup below (auto-capture, focus hooks, refresh) must ignore the static
|
||||
// default-art rows so they can never start a desktop capture session.
|
||||
private IEnumerable<Source> AllBackgrounds()
|
||||
=> Scenes.Where(s => SceneCatalog.Is(s.Name, SceneCatalog.Live))
|
||||
.SelectMany(s => s.Elements.OfType<Source>().Where(x => x.IsBackground));
|
||||
|
||||
// Full-screen game on its monitor, else null (static bg fallback — no
|
||||
// infinity mirror). Called at launch (from ReacquireScreenCaptures, before
|
||||
// the window steals focus) and on focus regain (RefreshBackgroundAutoCapture).
|
||||
// When a background has ShowDesktop=true, returns the primary monitor instead
|
||||
// of null so the desktop is always visible.
|
||||
private string? ResolveAutoCaptureKey()
|
||||
{
|
||||
var gameMonitor = _fullScreenDetector.GetForegroundFullScreenMonitorIndex();
|
||||
if (gameMonitor != null)
|
||||
return $"{MonitorKeyPrefix}{gameMonitor}";
|
||||
|
||||
if (AllBackgrounds().Any(b => b.ShowDesktop))
|
||||
return $"{MonitorKeyPrefix}{_fullScreenDetector.PrimaryMonitorIndex()}";
|
||||
return null;
|
||||
}
|
||||
|
||||
// After a layout load / file open: make sure every background-enabled scene
|
||||
// has a background, give any background without a persisted key the auto-detected
|
||||
// one, then acquire one capture per unique background key. ScreenCaptureManager
|
||||
// refcounts by key, so every scene pointing at the same monitor shares one
|
||||
// session. Captures no longer referenced by any scene are released.
|
||||
private void ReacquireScreenCaptures()
|
||||
{
|
||||
HealBackgrounds();
|
||||
|
||||
var auto = ResolveAutoCaptureKey();
|
||||
if (auto == null)
|
||||
{
|
||||
foreach (var background in AllBackgrounds())
|
||||
background.CaptureKey = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var background in AllBackgrounds())
|
||||
if (string.IsNullOrWhiteSpace(background.CaptureKey))
|
||||
background.CaptureKey = auto;
|
||||
}
|
||||
|
||||
var keys = AllBackgrounds()
|
||||
.Select(b => b.CaptureKey!)
|
||||
.Where(k => !string.IsNullOrWhiteSpace(k))
|
||||
.ToHashSet();
|
||||
|
||||
// A layout reload replaces the scenes; stop captures that are no longer
|
||||
// referenced (mirrors ReacquireWebcam's device swap).
|
||||
foreach (var stale in _liveCaptureKeys.Except(keys))
|
||||
_ = _screenCaptureManager.ReleaseAllAsync(stale);
|
||||
_liveCaptureKeys = keys;
|
||||
|
||||
foreach (var key in keys)
|
||||
_ = _screenCaptureManager.AcquireAsync(key);
|
||||
|
||||
_fullScreenDetector.StartWatching();
|
||||
}
|
||||
|
||||
// ScreenCaptureManager creates the shared WriteableBitmap on the UI thread;
|
||||
// every background pointing at that key picks it up.
|
||||
private void OnScreenPreviewBitmapChanged(string key, WriteableBitmap bitmap)
|
||||
{
|
||||
var activeBackground = StagedScene?.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
|
||||
if (activeBackground?.CaptureKey == key)
|
||||
BackgroundImage = bitmap;
|
||||
|
||||
foreach (var background in AllBackgrounds().Where(b => b.CaptureKey == key))
|
||||
background.VideoImageSource = bitmap;
|
||||
}
|
||||
|
||||
// EVENT_SYSTEM_FOREGROUND fires whenever the foreground window changes.
|
||||
// When a full-screen game appears on a different monitor than the current
|
||||
// background, auto-redesignate. When ShowDesktop is enabled and no fullscreen
|
||||
// game is detected, fall back to the primary monitor (desktop view).
|
||||
private void OnFullscreenMonitorChanged(int? monitor)
|
||||
{
|
||||
if (monitor != null)
|
||||
{
|
||||
var newKey = $"{MonitorKeyPrefix}{monitor}";
|
||||
var current = AllBackgrounds().FirstOrDefault();
|
||||
if (current?.CaptureKey == newKey) return;
|
||||
_ = RedesignateBackgroundAsync(newKey);
|
||||
}
|
||||
else if (AllBackgrounds().Any(b => b.ShowDesktop))
|
||||
{
|
||||
var desktopKey = $"{MonitorKeyPrefix}{_fullScreenDetector.PrimaryMonitorIndex()}";
|
||||
var current = AllBackgrounds().FirstOrDefault();
|
||||
if (current?.CaptureKey == desktopKey) return;
|
||||
_ = RedesignateBackgroundAsync(desktopKey);
|
||||
}
|
||||
}
|
||||
|
||||
// Manual refresh: the "Refresh Capture" context menu item. Reads the
|
||||
// current foreground directly (no caching needed — the hook handles
|
||||
// automatic detection).
|
||||
public void RefreshBackgroundAutoCapture()
|
||||
{
|
||||
var detected = _fullScreenDetector.GetForegroundFullScreenMonitorIndex();
|
||||
if (detected == null) return;
|
||||
_ = RedesignateBackgroundAsync($"{MonitorKeyPrefix}{detected}");
|
||||
}
|
||||
|
||||
/// <summary>Whether the active background is in Show Desktop mode.
|
||||
/// Bindable IsChecked property for the context menu toggle.</summary>
|
||||
public bool BackgroundShowDesktop
|
||||
{
|
||||
get => StagedScene?.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground)?.ShowDesktop ?? false;
|
||||
set
|
||||
{
|
||||
var background = StagedScene?.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
|
||||
if (background == null || background.ShowDesktop == value) return;
|
||||
background.ShowDesktop = value;
|
||||
OnPropertyChanged(nameof(BackgroundShowDesktop));
|
||||
ScheduleSave();
|
||||
if (value)
|
||||
{
|
||||
_ = RedesignateBackgroundAsync($"{MonitorKeyPrefix}{_fullScreenDetector.PrimaryMonitorIndex()}");
|
||||
}
|
||||
else
|
||||
{
|
||||
var gameMonitor = _fullScreenDetector.GetForegroundFullScreenMonitorIndex();
|
||||
if (gameMonitor != null)
|
||||
_ = RedesignateBackgroundAsync($"{MonitorKeyPrefix}{gameMonitor}");
|
||||
else
|
||||
_ = ClearBackgroundCaptureAsync();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void ToggleBackgroundShowDesktop() => BackgroundShowDesktop = !BackgroundShowDesktop;
|
||||
|
||||
private void BrowseBackground()
|
||||
{
|
||||
var scene = StagedScene;
|
||||
if (scene == null) return;
|
||||
var bg = scene.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
|
||||
if (bg == null) return;
|
||||
|
||||
var dlg = new Microsoft.Win32.OpenFileDialog
|
||||
{
|
||||
Title = "Select background image",
|
||||
Filter = "Image files (*.jpg;*.jpeg;*.png;*.bmp)|*.jpg;*.jpeg;*.png;*.bmp|All files (*.*)|*.*",
|
||||
};
|
||||
if (dlg.ShowDialog() != true) return;
|
||||
|
||||
bg.CustomBackgroundPath = dlg.FileName;
|
||||
bg.UseDefaultBackground = false;
|
||||
try
|
||||
{
|
||||
using var fs = new System.IO.FileStream(dlg.FileName, System.IO.FileMode.Open, System.IO.FileAccess.Read);
|
||||
var bytes = new byte[fs.Length];
|
||||
fs.Read(bytes, 0, bytes.Length);
|
||||
var assetId = AddAsset(bytes);
|
||||
if (assetId != null)
|
||||
bg.AssetId = assetId;
|
||||
}
|
||||
catch { /* non-critical */ }
|
||||
|
||||
UpdateActiveBackground();
|
||||
RefreshSnapshotsAsync();
|
||||
ScheduleSave();
|
||||
}
|
||||
|
||||
/// <summary>Release the background capture so the static placeholder image shows.</summary>
|
||||
private async Task ClearBackgroundCaptureAsync()
|
||||
{
|
||||
var oldKeys = AllBackgrounds()
|
||||
.Select(b => b.CaptureKey!)
|
||||
.Where(k => !string.IsNullOrWhiteSpace(k))
|
||||
.ToHashSet();
|
||||
|
||||
foreach (var background in AllBackgrounds())
|
||||
{
|
||||
background.CaptureKey = null;
|
||||
background.VideoImageSource = null;
|
||||
}
|
||||
|
||||
foreach (var key in oldKeys)
|
||||
await _screenCaptureManager.ReleaseAllAsync(key);
|
||||
|
||||
_liveCaptureKeys.Clear();
|
||||
UpdateBackgroundImage();
|
||||
ScheduleSave();
|
||||
}
|
||||
|
||||
private async Task RedesignateBackgroundAsync(string newKey)
|
||||
{
|
||||
var oldKeys = AllBackgrounds()
|
||||
.Select(b => b.CaptureKey!)
|
||||
.Where(k => !string.IsNullOrWhiteSpace(k))
|
||||
.ToHashSet();
|
||||
|
||||
foreach (var background in AllBackgrounds())
|
||||
background.CaptureKey = newKey;
|
||||
|
||||
foreach (var oldKey in oldKeys.Where(k => k != newKey))
|
||||
await _screenCaptureManager.ReleaseAllAsync(oldKey);
|
||||
if (!oldKeys.Contains(newKey))
|
||||
await _screenCaptureManager.AcquireAsync(newKey);
|
||||
_liveCaptureKeys = new HashSet<string> { newKey };
|
||||
UpdateBackgroundImage();
|
||||
ScheduleSave();
|
||||
}
|
||||
|
||||
// "Change Capture…": the OS GraphicsCapturePicker designates the target.
|
||||
// Picks are transient (see ScreenCaptureSourceFactory) — a reload falls
|
||||
// back to auto-detection.
|
||||
public async Task ChangeBackgroundCaptureAsync()
|
||||
{
|
||||
var key = await _screenCaptureFactory.PickAsync();
|
||||
if (key == null) return;
|
||||
await RedesignateBackgroundAsync(key);
|
||||
}
|
||||
|
||||
// In-app display picker: point every background at a specific monitor.
|
||||
private void SetBackgroundCapture(DisplayInfo? display)
|
||||
{
|
||||
if (display == null) return;
|
||||
_ = RedesignateBackgroundAsync($"{MonitorKeyPrefix}{display.Index}");
|
||||
}
|
||||
|
||||
// ─── Background model (TASK 25): exactly ONE Background per screen, index 0,
|
||||
// never removable or re-addable. Static default art on Starting/BRB/Chat/Ending;
|
||||
// on Live it's the capture-flavored row (Show Desktop / monitor switch /
|
||||
// fullscreen-game detect) falling back to live-background.jpg. ───
|
||||
|
||||
private static string? DefaultBackgroundAsset(string sceneName) => sceneName switch
|
||||
{
|
||||
SceneCatalog.Starting => "starting-background.jpg",
|
||||
SceneCatalog.Brb => "brb-background.jpg",
|
||||
SceneCatalog.Chat => "chat-background.jpg",
|
||||
SceneCatalog.Ending => "ending-background.jpg",
|
||||
SceneCatalog.Live => "live-background.jpg",
|
||||
_ => null,
|
||||
};
|
||||
|
||||
/// <summary>Heals every scene to the locked Background model after a layout
|
||||
/// load: keeps the correct flavor per scene at index 0 named "Background",
|
||||
/// drops duplicates/stale rows, re-seeds missing ones.</summary>
|
||||
private void HealBackgrounds()
|
||||
{
|
||||
NormalizeBackgrounds(Scenes);
|
||||
foreach (var scene in Scenes)
|
||||
{
|
||||
var background = scene.Elements.OfType<Source>().FirstOrDefault(s => s.IsBackground);
|
||||
if (background != null)
|
||||
StampDefaultBackgroundAsset(background, scene.Name);
|
||||
}
|
||||
OnPropertyChanged(nameof(ShowSourcesEmptyHint));
|
||||
}
|
||||
|
||||
/// <summary>Points a background row at its scene's shipped default art when it
|
||||
/// carries none. A custom image (Browse…) always wins and is never overwritten.</summary>
|
||||
private void StampDefaultBackgroundAsset(Source background, string sceneName)
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(background.AssetId)) return;
|
||||
if (!background.UseDefaultBackground && !string.IsNullOrWhiteSpace(background.CustomBackgroundPath)) return;
|
||||
var asset = DefaultBackgroundAsset(sceneName);
|
||||
if (asset == null) return;
|
||||
|
||||
try
|
||||
{
|
||||
var uri = new Uri($"pack://application:,,,/Assets/{asset}", UriKind.Absolute);
|
||||
using var stream = Application.GetResourceStream(uri)?.Stream;
|
||||
if (stream == null) return;
|
||||
using var ms = new MemoryStream();
|
||||
stream.CopyTo(ms);
|
||||
background.AssetId = AddAsset(ms.ToArray());
|
||||
}
|
||||
catch { /* non-critical — the app works without default art */ }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user