Skip to content

Free, open-source Windows optimization tool for performance, privacy, and simplicity.

feat: gate optimizations by system conditions and refresh the bloatware list

fatDuckf1d65b09e055
diff --git a/optimizerDuck.Test/Domain/Conditions/ConditionTests.cs b/optimizerDuck.Test/Domain/Conditions/ConditionTests.cs
new file mode 100644
index 0000000..117c806
--- /dev/null
+++ b/optimizerDuck.Test/Domain/Conditions/ConditionTests.cs
@@ -0,0 +1,482 @@
+using Microsoft.Extensions.Logging.Abstractions;
+using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
+using optimizerDuck.Domain.Optimizations.Models;
+using optimizerDuck.Domain.Optimizations.Models.Services;
+using optimizerDuck.Domain.UI;
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.Conditions;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Test.Domain.Conditions;
+
+public class ConditionTests
+{
+ #region Snapshot builder
+
+ private static SystemSnapshot Snapshot(
+ string build = "22631",
+ GpuVendor gpuVendor = GpuVendor.Unknown,
+ CpuVendor cpuVendor = CpuVendor.Unknown,
+ double ramGb = 0
+ ) => new()
+ {
+ Cpu = new CpuInfo
+ {
+ Name = "Test CPU",
+ Manufacturer = "TestManufacturer",
+ Vendor = cpuVendor,
+ Architecture = "64-bit",
+ Cores = 8,
+ Threads = 16,
+ MaxClockMHz = 4000,
+ CurrentClockMHz = 4000,
+ L2CacheKB = 0,
+ L3CacheKB = 0,
+ },
+ Ram = new RamInfo
+ {
+ TotalGB = ramGb,
+ TotalMB = (long)(ramGb * 1024),
+ TotalKB = (long)(ramGb * 1024 * 1024),
+ AvailableGB = ramGb,
+ UsedPercent = 0,
+ UsedGB = 0,
+ Modules = [],
+ },
+ Os = new OsInfo
+ {
+ Name = "Microsoft Windows 11 Pro",
+ Version = "11",
+ BuildNumber = build,
+ Edition = "Pro",
+ Architecture = "64-bit",
+ DeviceType = "Desktop",
+ InstallDate = "2024-01-01",
+ LastBootUpTime = "2024-01-01 00:00",
+ },
+ Bios = BiosInfo.Unknown,
+ Gpus =
+ gpuVendor == GpuVendor.Unknown
+ ? []
+ :
+ [
+ new GpuInfo
+ {
+ Name = "Test GPU",
+ DriverVersion = "1.0",
+ Vendor = gpuVendor,
+ MemoryMB = 8192,
+ },
+ ],
+ PrimaryGpu = null,
+ Disk = DiskInfo.Unknown,
+ };
+
+ #endregion
+
+ #region ConditionResult
+
+ [Fact]
+ public void ConditionResult_Available_IsNotBlocking()
+ {
+ Assert.False(ConditionResult.Available.IsBlocking);
+ Assert.Equal(ConditionState.Available, ConditionResult.Available.State);
+ }
+
+ [Fact]
+ public void ConditionResult_Unsupported_IsBlocking()
+ {
+ var result = ConditionResult.Unsupported(() => "k.Title", () => "k.Description");
+ Assert.True(result.IsBlocking);
+ }
+
+ [Fact]
+ public void ConditionResult_Error_IsNotBlocking()
+ {
+ var result = ConditionResult.Error();
+ Assert.False(result.IsBlocking);
+ Assert.Equal(ConditionState.Error, result.State);
+ }
+
+ [Fact]
+ public void ConditionResult_ResolvesLocalizedTitleAndDescription()
+ {
+ var result = ConditionResult.Unsupported(
+ () => Translations.Condition_Windows11_Title,
+ () => Translations.Condition_Windows11_Description
+ );
+
+ Assert.False(string.IsNullOrEmpty(result.Title));
+ Assert.False(string.IsNullOrEmpty(result.Description));
+ }
+
+ #endregion
+
+ #region OS conditions
+
+ [Theory]
+ [InlineData("22000")]
+ [InlineData("22631")]
+ [InlineData("26100")]
+ public void Windows11Condition_Win11Builds_Available(string build)
+ {
+ var result = new Windows11Condition().Evaluate(Snapshot(build: build));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void Windows11Condition_DottedBuild_ParsesMajorVersionOnly()
+ {
+ // Real UBR-suffixed builds (e.g. 24H2 with KB5055627 reports 26100.3915)
+ // must be compared by major build number only.
+ var result = new Windows11Condition().Evaluate(Snapshot(build: "26100.3915"));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Theory]
+ [InlineData("10240")]
+ [InlineData("19045")]
+ public void Windows11Condition_Win10Builds_Unsupported(string build)
+ {
+ var result = new Windows11Condition().Evaluate(Snapshot(build: build));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Theory]
+ [InlineData("10240")]
+ [InlineData("19045")]
+ public void Windows10Condition_Win10Builds_Available(string build)
+ {
+ var result = new Windows10Condition().Evaluate(Snapshot(build: build));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Theory]
+ [InlineData("22000")]
+ [InlineData("22631")]
+ public void Windows10Condition_Win11Builds_Unsupported(string build)
+ {
+ var result = new Windows10Condition().Evaluate(Snapshot(build: build));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Theory]
+ [InlineData("26100")]
+ [InlineData("26120")]
+ public void Windows11_24H2OrGreaterCondition_24H2Builds_Available(string build)
+ {
+ var result = new Windows11_24H2OrGreaterCondition().Evaluate(Snapshot(build: build));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Theory]
+ [InlineData("22631")]
+ [InlineData("22000")]
+ [InlineData("19045")]
+ public void Windows11_24H2OrGreaterCondition_OlderBuilds_Unsupported(string build)
+ {
+ var result = new Windows11_24H2OrGreaterCondition().Evaluate(Snapshot(build: build));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ #endregion
+
+ #region Hardware conditions
+
+ [Fact]
+ public void AmdGpuCondition_AmdGpu_Available()
+ {
+ var result = new AmdGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.AMD));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void AmdGpuCondition_NvidiaGpu_Unsupported()
+ {
+ var result = new AmdGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.NVIDIA));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Fact]
+ public void NvidiaGpuCondition_NvidiaGpu_Available()
+ {
+ var result = new NvidiaGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.NVIDIA));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void NvidiaGpuCondition_AmdGpu_Unsupported()
+ {
+ var result = new NvidiaGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.AMD));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Fact]
+ public void IntelGpuCondition_IntelGpu_Available()
+ {
+ var result = new IntelGpuCondition().Evaluate(Snapshot(gpuVendor: GpuVendor.Intel));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void IntelCpuCondition_IntelCpu_Available()
+ {
+ var result = new IntelCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.Intel));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void IntelCpuCondition_AmdCpu_Unsupported()
+ {
+ var result = new IntelCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.AMD));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Fact]
+ public void AmdCpuCondition_AmdCpu_Available()
+ {
+ var result = new AmdCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.AMD));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void IntelCpuCondition_UnknownCpu_FailsOpenToError()
+ {
+ // An undetected CPU vendor means detection failed, which must never hide the
+ // item: the result is non-blocking Error instead of Unsupported.
+ var result = new IntelCpuCondition().Evaluate(Snapshot(cpuVendor: CpuVendor.Unknown));
+ Assert.Equal(ConditionState.Error, result.State);
+ Assert.False(result.IsBlocking);
+ }
+
+ [Fact]
+ public void SixteenGbRamCondition_16Gb_Available()
+ {
+ var result = new SixteenGbRamCondition().Evaluate(Snapshot(ramGb: 16));
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void SixteenGbRamCondition_8Gb_Unsupported()
+ {
+ var result = new SixteenGbRamCondition().Evaluate(Snapshot(ramGb: 8));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Fact]
+ public void NvidiaGpuCondition_NoGpu_FailsOpenToError()
+ {
+ // A missing/undetected GPU list means detection failed, which must never hide
+ // the item: the result is non-blocking Error instead of Unsupported.
+ var result = new NvidiaGpuCondition().Evaluate(Snapshot());
+ Assert.Equal(ConditionState.Error, result.State);
+ Assert.False(result.IsBlocking);
+ }
+
+ #endregion
+
+ #region Registry & Service conditions
+
+ private static readonly Func<string> KTitle = () => "k.Title";
+ private static readonly Func<string> KDescription = () => "k.Description";
+
+ private sealed class ExistingKeyCondition : RegistryKeyExistsCondition
+ {
+ protected override RegistryItem RegistryItem =>
+ new(@"HKCU\Software\Microsoft\Windows\CurrentVersion");
+
+ protected override Func<string> Title => KTitle;
+ protected override Func<string> Description => KDescription;
+ }
+
+ private sealed class MissingKeyCondition : RegistryKeyExistsCondition
+ {
+ protected override RegistryItem RegistryItem =>
+ new(@"HKCU\Software\OptimizerDuck_DefinitelyMissing_Key");
+
+ protected override Func<string> Title => KTitle;
+ protected override Func<string> Description => KDescription;
+ }
+
+ private sealed class ExistingServiceCondition : ServiceExistsCondition
+ {
+ protected override string ServiceName => "RpcSs";
+ protected override Func<string> Title => KTitle;
+ protected override Func<string> Description => KDescription;
+ }
+
+ private sealed class MissingServiceCondition : ServiceExistsCondition
+ {
+ protected override string ServiceName => "OptimizerDuckDefinitelyMissingService";
+ protected override Func<string> Title => KTitle;
+ protected override Func<string> Description => KDescription;
+ }
+
+ [Fact]
+ public void RegistryKeyExistsCondition_ExistingKey_Available()
+ {
+ var result = new ExistingKeyCondition().Evaluate(Snapshot());
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void RegistryKeyExistsCondition_MissingKey_Unsupported()
+ {
+ var result = new MissingKeyCondition().Evaluate(Snapshot());
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Fact]
+ public void ServiceExistsCondition_ExistingService_Available()
+ {
+ var result = new ExistingServiceCondition().Evaluate(Snapshot());
+ Assert.Equal(ConditionState.Available, result.State);
+ }
+
+ [Fact]
+ public void ServiceExistsCondition_MissingService_Unsupported()
+ {
+ var result = new MissingServiceCondition().Evaluate(Snapshot());
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ #endregion
+
+ #region ConditionEvaluator
+
+ private static ConditionResult Evaluate(Type? type, SystemSnapshot snapshot) =>
+ ConditionEvaluator.Evaluate(type, snapshot, NullLogger.Instance);
+
+ [Fact]
+ public void ConditionEvaluator_NullType_ReturnsAvailable()
+ {
+ Assert.Equal(ConditionState.Available, Evaluate(null, Snapshot()).State);
+ }
+
+ [Fact]
+ public void ConditionEvaluator_ValidType_ReturnsEvaluatedResult()
+ {
+ var result = Evaluate(typeof(Windows11Condition), Snapshot(build: "19045"));
+ Assert.Equal(ConditionState.Unsupported, result.State);
+ }
+
+ [Fact]
+ public void ConditionEvaluator_UnknownSnapshot_FailOpenToAvailable()
+ {
+ // An unpopulated snapshot (detection not finished/failed) never hides an item.
+ Assert.Equal(ConditionState.Available, Evaluate(typeof(Windows11Condition), SystemSnapshot.Unknown).State);
+ Assert.Equal(ConditionState.Available, Evaluate(typeof(Windows11_24H2OrGreaterCondition), SystemSnapshot.Unknown).State);
+ Assert.Equal(ConditionState.Available, Evaluate(typeof(NvidiaGpuCondition), SystemSnapshot.Unknown).State);
+ Assert.Equal(ConditionState.Available, Evaluate(typeof(SixteenGbRamCondition), SystemSnapshot.Unknown).State);
+ Assert.Equal(ConditionState.Available, Evaluate(typeof(IntelCpuCondition), SystemSnapshot.Unknown).State);
+ }
+
+ [Fact]
+ public void ConditionEvaluator_InvalidType_ReturnsError()
+ {
+ var result = Evaluate(typeof(string), Snapshot());
+ Assert.Equal(ConditionState.Error, result.State);
+ }
+
+ [Fact]
+ public void ConditionEvaluator_ThrowingCondition_ReturnsError()
+ {
+ var result = Evaluate(typeof(ThrowingCondition), Snapshot());
+ Assert.Equal(ConditionState.Error, result.State);
+ }
+
+ [Fact]
+ public void ConditionEvaluator_EvaluateAll_AppliesEveryResult()
+ {
+ var items = new[] { typeof(Windows11Condition), (Type?)null };
+ var applied = new List<ConditionResult>();
+
+ ConditionEvaluator.EvaluateAll(
+ items,
+ t => t,
+ (t, r) => applied.Add(r),
+ Snapshot(build: "19045"),
+ NullLogger.Instance
+ );
+
+ Assert.Equal(2, applied.Count);
+ Assert.Equal(ConditionState.Unsupported, applied[0].State);
+ Assert.Equal(ConditionState.Available, applied[1].State);
+ }
+
+ private sealed class ThrowingCondition : ConditionBase
+ {
+ public override ConditionResult Evaluate(SystemSnapshot snapshot)
+ {
+ throw new InvalidOperationException("boom");
+ }
+ }
+
+ #endregion
+
+ #region BaseOptimization condition blocking
+
+ [Fact]
+ public void BaseOptimization_UnsupportedAndNotApplied_IsBlocked()
+ {
+ var optimization = new ConditionedOptimization { Condition = ConditionState.Unsupported };
+ Assert.True(optimization.IsConditionBlocked);
+ }
+
+ [Fact]
+ public void BaseOptimization_UnsupportedAndApplied_IsNotBlocked()
+ {
+ var optimization = new ConditionedOptimization { Condition = ConditionState.Unsupported };
+ optimization.State.IsApplied = true;
+ Assert.False(optimization.IsConditionBlocked);
+ }
+
+ [Fact]
+ public void BaseOptimization_UnsupportedAndHidden_IsNotBlocked()
+ {
+ var optimization = new ConditionedOptimization { Condition = ConditionState.Unsupported };
+ optimization.IsConditionHidden = true;
+ Assert.False(optimization.IsConditionBlocked);
+ }
+
+ [Fact]
+ public void BaseOptimization_Available_IsNotBlocked()
+ {
+ var optimization = new ConditionedOptimization { Condition = ConditionState.Available };
+ Assert.False(optimization.IsConditionBlocked);
+ }
+
+ [Fact]
+ public void BaseOptimization_ConditionType_ReadFromAttribute()
+ {
+ var optimization = new ConditionedOptimization();
+ Assert.Equal(typeof(Windows11Condition), optimization.ConditionType);
+ }
+
+ #endregion
+
+ [Optimization(
+ Id = "00000000-0000-0000-0000-000000000001",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.System,
+ Condition = typeof(Windows11Condition)
+ )]
+ private sealed class ConditionedOptimization : BaseOptimization
+ {
+ public ConditionState Condition
+ {
+ get => ConditionResult.State;
+ set =>
+ ConditionResult =
+ value == ConditionState.Available
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(() => "k.Title", () => "k.Description");
+ }
+
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ ) => Task.FromResult(ApplyResult.True());
+ }
+}
diff --git a/optimizerDuck.Test/Domain/Customize/BaseCustomizeSettingTests.cs b/optimizerDuck.Test/Domain/Customize/BaseCustomizeSettingTests.cs
index 8fdf505..62e1fa3 100644
--- a/optimizerDuck.Test/Domain/Customize/BaseCustomizeSettingTests.cs
+++ b/optimizerDuck.Test/Domain/Customize/BaseCustomizeSettingTests.cs
@@ -6,6 +6,7 @@ using Microsoft.Win32;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Customize.Models;
using optimizerDuck.Domain.Optimizations.Models.Services;
+using optimizerDuck.Services.Configuration;
using optimizerDuck.Services.Optimization.Providers;
using Xunit;
@@ -32,7 +33,6 @@ public class BaseCustomizeSettingTests : IDisposable
#region GetStateWithRetryAsync helpers
- /// <summary>Always returns the same stable state.</summary>
private sealed class StableStateSetting : BaseCustomizeSetting
{
public bool State { get; set; }
@@ -40,14 +40,11 @@ public class BaseCustomizeSettingTests : IDisposable
public override Task<bool> GetStateAsync() => Task.Run(() => State);
}
- /// <summary>Uses base GetStateAsync (no toggles → returns false).</summary>
private sealed class EmptyTogglesSetting : BaseCustomizeSetting
{
- // No RegistryToggles override → empty
- // No GetStateAsync override → uses base (empty toggles → false)
+ // No overrides: base GetStateAsync reads empty toggles → returns false
}
- /// <summary>Alternates on every call — never stabilises.</summary>
private sealed class OscillatingStateSetting : BaseCustomizeSetting
{
private int _callCount;
@@ -56,7 +53,6 @@ public class BaseCustomizeSettingTests : IDisposable
Task.Run(() => Interlocked.Increment(ref _callCount) % 2 == 1);
}
- /// <summary>Returns stable after a configurable delay.</summary>
private sealed class DelayedStateSetting : BaseCustomizeSetting
{
public bool State { get; set; } = true;
@@ -72,7 +68,6 @@ public class BaseCustomizeSettingTests : IDisposable
}
}
- /// <summary>Setting with multiple toggles to test path dedup.</summary>
private sealed class MultiToggleSetting : BaseCustomizeSetting
{
protected override IEnumerable<RegistryToggle> RegistryToggles =>
@@ -311,13 +306,11 @@ public class BaseCustomizeSettingTests : IDisposable
private static bool GetNeedsPostAction(BaseCustomizeSetting s) =>
(bool)NeedsPostActionProperty.GetValue(s)!;
- /// <summary>Plain setting with no overrides - must be opt-in for post-action.</summary>
private sealed class DefaultScopeSetting : BaseCustomizeSetting
{
public override Task<bool> GetStateAsync() => Task.FromResult(false);
}
- /// <summary>Setting that opts into the default explorer-level refresh.</summary>
private sealed class DefaultExplorerScopeSetting : BaseCustomizeSetting
{
protected override CustomizeRefreshScope RefreshScope => CustomizeRefreshScope.Default;
@@ -325,7 +318,6 @@ public class BaseCustomizeSettingTests : IDisposable
public override Task<bool> GetStateAsync() => Task.FromResult(false);
}
- /// <summary>Setting that opts into the desktop-icon refresh.</summary>
private sealed class DesktopIconsScopeSetting : BaseCustomizeSetting
{
protected override CustomizeRefreshScope RefreshScope => CustomizeRefreshScope.DesktopIcons;
@@ -333,7 +325,6 @@ public class BaseCustomizeSettingTests : IDisposable
public override Task<bool> GetStateAsync() => Task.FromResult(false);
}
- /// <summary>Setting that opts into the global HideIcons cache refresh.</summary>
private sealed class HideDesktopIconsScopeSetting : BaseCustomizeSetting
{
protected override CustomizeRefreshScope RefreshScope =>
@@ -342,7 +333,6 @@ public class BaseCustomizeSettingTests : IDisposable
public override Task<bool> GetStateAsync() => Task.FromResult(false);
}
- /// <summary>Setting that opts into the taskbar refresh.</summary>
private sealed class TaskbarScopeSetting : BaseCustomizeSetting
{
protected override CustomizeRefreshScope RefreshScope =>
@@ -351,7 +341,6 @@ public class BaseCustomizeSettingTests : IDisposable
public override Task<bool> GetStateAsync() => Task.FromResult(false);
}
- /// <summary>Setting that opts into a multi-flag custom scope.</summary>
private sealed class MultiScopeSetting : BaseCustomizeSetting
{
protected override CustomizeRefreshScope RefreshScope =>
@@ -714,6 +703,279 @@ public class BaseCustomizeSettingTests : IDisposable
CleanupTestKeys();
}
+ #region Options (Custom option) tests
+
+ [Fact]
+ public void Options_ValueInScope_ReturnsDeclaredOptionsOnly()
+ {
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 1));
+
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(2, effective!.Count);
+ Assert.DoesNotContain(effective, o => Equals(o.Value, 99));
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public void Options_ValueOutOfScope_AppendsCustomOptionWithRawValue()
+ {
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 99));
+
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(3, effective!.Count);
+ Assert.Equal(99, effective[2].Value);
+ Assert.Equal(Loc.Instance[BaseCustomizeSetting.CustomOptionTranslationKey], effective[2].DisplayName);
+ Assert.Null(effective[2].Bindings);
+ Assert.Equal(99, setting.CurrentValue);
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public void Options_ValueReturnsInScope_RemovesCustomOption()
+ {
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 99));
+ Assert.Equal(3, setting.Options!.Count);
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 2));
+
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(2, effective!.Count);
+ Assert.DoesNotContain(effective, o => Equals(o.Value, 99));
+ Assert.Equal(2, setting.CurrentValue);
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public void Options_ValueChangesOutOfScope_UpdatesCustomOptionValue()
+ {
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 99));
+ Assert.Equal(99, setting.Options![2].Value);
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 123));
+
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(3, effective!.Count);
+ Assert.Equal(123, effective[2].Value);
+ Assert.Equal(123, setting.CurrentValue);
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public void Options_MissingValue_AddsCustomFallbackWithSentinel()
+ {
+ // Even when the registry value is missing entirely, the ComboBox must never
+ // render empty: a synthetic fallback (with a stable non-null sentinel value so
+ // WPF can select it) is appended, labeled distinctly from "Custom".
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.DeleteValue(new RegistryItem(TestKeyPath, "DropdownTest"));
+
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(3, effective!.Count);
+ Assert.Equal(
+ Loc.Instance[BaseCustomizeSetting.CustomOptionNotSetTranslationKey],
+ effective[2].DisplayName
+ );
+ Assert.Same(BaseCustomizeSetting.MissingValueSentinel, effective[2].Value);
+ Assert.Null(effective[2].Bindings);
+ Assert.Same(BaseCustomizeSetting.MissingValueSentinel, setting.CurrentValue);
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public async Task ApplyAsync_MissingValueSentinel_IsSafeNoOp()
+ {
+ // The sentinel must never leak into the registry: applying it resolves against
+ // declared Options (where it never exists), so nothing is written and it throws.
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 1));
+ await setting.ApplyAsync(BaseCustomizeSetting.MissingValueSentinel);
+
+ var value = RegistryService.Read<int>(new RegistryItem(TestKeyPath, "DropdownTest"));
+ Assert.Equal(1, value);
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public void Options_MissingValueThenDeclaredValue_RemovesCustomFallback()
+ {
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.DeleteValue(new RegistryItem(TestKeyPath, "DropdownTest"));
+ Assert.Equal(3, setting.Options!.Count);
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 2));
+
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(2, effective!.Count);
+ Assert.Equal(2, setting.CurrentValue);
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public void Options_NonDropdownSetting_ReturnsDeclaredOptions()
+ {
+ var setting = new TestCustomizeSetting { OwnerType = typeof(TestCustomizeSetting) };
+
+ Assert.Null(setting.Options);
+ }
+
+ [Fact]
+ public void Options_PartialMultiBindingMatch_DoesNotDuplicateDeclaredValue()
+ {
+ var setting = new TestMultiBindingDropdown { OwnerType = typeof(TestMultiBindingDropdown) };
+
+ // Key A = 1 (matches "On" primary) but Key B = 0 → no full match; the raw primary
+ // value (1) already equals the declared "On" value, so no "Custom" duplicate.
+ RegistryService.Write(new RegistryItem(TestKeyPath, "Key1", 1));
+ RegistryService.Write(new RegistryItem(@"HKCU\Software\TestOptimizerDuckMultiKey", "Key2", 0));
+
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(2, effective!.Count);
+ Assert.DoesNotContain(
+ effective,
+ o => o.DisplayName == Loc.Instance[BaseCustomizeSetting.CustomOptionTranslationKey]
+ );
+ Assert.Equal(1, setting.CurrentValue);
+
+ CleanupTestKeys();
+ try
+ {
+ using var hkcu = Microsoft.Win32.Registry.CurrentUser;
+ hkcu.DeleteSubKeyTree(@"Software\TestOptimizerDuckMultiKey", false);
+ }
+ catch { }
+ }
+
+ [Fact]
+ public void Options_CustomOptionIsMemoryOnly_NeverPersisted()
+ {
+ // The synthetic option is derived from live registry state and is never stored,
+ // so re-reading it must always reflect the current registry value.
+ var setting = new TestDropdownSetting { OwnerType = typeof(TestDropdownSetting) };
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "DropdownTest", 99));
+ var first = setting.Options!;
+ var second = setting.Options!;
+
+ Assert.Equal(99, first[2].Value);
+ Assert.Equal(99, second[2].Value);
+ Assert.NotSame(first, second);
+
+ CleanupTestKeys();
+ }
+
+ #endregion
+
+ private sealed class TestNotSetOptionDropdown : BaseCustomizeSetting
+ {
+ private const string RegPath = @"HKCU\Software\TestOptimizerDuckCustomize";
+ private const string RegName = "NotSetOptionTest";
+
+ public override CustomizeControlType ControlType => CustomizeControlType.Dropdown;
+
+ protected override IReadOnlyList<SettingOption>? GetOptions() =>
+ [
+ new SettingOption("Off", 0, [new RegistryBinding(RegPath, RegName, 0)]),
+ new SettingOption("On", 1, [new RegistryBinding(RegPath, RegName, 1)]),
+ new SettingOption("NotSet", "notset", [new RegistryBinding(RegPath, RegName, null)]),
+ ];
+ }
+
+ [Fact]
+ public void Options_DeclaredNullBindingOption_MissingValue_MatchesDeclaredNotSet()
+ {
+ var setting = new TestNotSetOptionDropdown { OwnerType = typeof(TestNotSetOptionDropdown) };
+
+ RegistryService.DeleteValue(new RegistryItem(TestKeyPath, "NotSetOptionTest"));
+
+ // The declared null-binding option matches the missing state (null == null),
+ // so no synthetic fallback is appended; CurrentValue is the declared value.
+ var effective = setting.Options;
+
+ Assert.NotNull(effective);
+ Assert.Equal(3, effective!.Count);
+ Assert.Equal("notset", setting.CurrentValue);
+ Assert.DoesNotContain(
+ effective,
+ o => ReferenceEquals(o.Value, BaseCustomizeSetting.MissingValueSentinel)
+ );
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public async Task ApplyAsync_DeclaredNullBindingOption_DeletesValueLikeNotSet()
+ {
+ var setting = new TestNotSetOptionDropdown { OwnerType = typeof(TestNotSetOptionDropdown) };
+
+ RegistryService.Write(new RegistryItem(TestKeyPath, "NotSetOptionTest", 1));
+ Assert.Equal(1, setting.CurrentValue);
+
+ // Selecting the declared "NotSet" option deletes the registry value (binding null).
+ await setting.ApplyAsync("notset");
+
+ var value = RegistryService.Read<object>(
+ new RegistryItem(TestKeyPath, "NotSetOptionTest")
+ );
+ Assert.Null(value);
+ Assert.Equal("notset", setting.CurrentValue);
+
+ CleanupTestKeys();
+ }
+
+ [Fact]
+ public async Task ApplyAsync_NullBindingOption_RoundTripsToDeclaredValue()
+ {
+ var setting = new TestNotSetOptionDropdown { OwnerType = typeof(TestNotSetOptionDropdown) };
+
+ // Not set → apply declared "On" → value written → apply "NotSet" → deleted again.
+ RegistryService.DeleteValue(new RegistryItem(TestKeyPath, "NotSetOptionTest"));
+ Assert.Equal("notset", setting.CurrentValue);
+
+ await setting.ApplyAsync(1);
+ Assert.Equal(1, setting.CurrentValue);
+
+ await setting.ApplyAsync("notset");
+ var value = RegistryService.Read<object>(
+ new RegistryItem(TestKeyPath, "NotSetOptionTest")
+ );
+ Assert.Null(value);
+ Assert.Equal("notset", setting.CurrentValue);
+
+ CleanupTestKeys();
+ }
+
private class TestMultiBindingDropdown : BaseCustomizeSetting
{
private const string RegPathA = @"HKCU\Software\TestOptimizerDuckCustomize";
diff --git a/optimizerDuck.Test/Services/ApplyRevertComprehensiveTests.cs b/optimizerDuck.Test/Services/ApplyRevertComprehensiveTests.cs
index 2f7cc80..b339568 100644
--- a/optimizerDuck.Test/Services/ApplyRevertComprehensiveTests.cs
+++ b/optimizerDuck.Test/Services/ApplyRevertComprehensiveTests.cs
@@ -6,6 +6,7 @@ using optimizerDuck.Domain.Execution;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Revert;
using optimizerDuck.Domain.Revert.Steps;
+using optimizerDuck.Test.TestDoubles;
using optimizerDuck.Domain.UI;
using optimizerDuck.Services.Optimization;
using optimizerDuck.Services.Revert;
@@ -1107,21 +1108,17 @@ public class ApplyRevertComprehensiveTests
return tcs.Task;
}
- private sealed class TestOptimization : IOptimization
+ private sealed class TestOptimization : StubOptimization
{
- public Guid Id { get; init; } = Guid.NewGuid();
- public OptimizationRisk Risk => OptimizationRisk.Safe;
- public string OptimizationKey => "TestOptimization";
- public string Name => "Test Optimization";
- public string ShortDescription => "Test optimization for comprehensive testing";
- public OptimizationState State { get; set; } = new();
+ public override string Name => "Test Optimization";
+ public override string ShortDescription => "Test optimization for comprehensive testing";
public Func<
(IProgress<ProcessingProgress> progress, OptimizationContext context),
Task<ApplyResult>
> ApplyImpl { get; init; } = _ => Task.FromResult(ApplyResult.True());
- public Task<ApplyResult> ApplyAsync(
+ public override Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
OptimizationContext context
)
diff --git a/optimizerDuck.Test/Services/Managers/RevertManagerTests.cs b/optimizerDuck.Test/Services/Managers/RevertManagerTests.cs
index b07fba4..25bb1bd 100644
--- a/optimizerDuck.Test/Services/Managers/RevertManagerTests.cs
+++ b/optimizerDuck.Test/Services/Managers/RevertManagerTests.cs
@@ -6,6 +6,7 @@ using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Revert;
using optimizerDuck.Domain.Revert.Steps;
+using optimizerDuck.Test.TestDoubles;
using optimizerDuck.Domain.UI;
using optimizerDuck.Services.Revert;
@@ -287,16 +288,14 @@ public class RevertManagerTests
}
}
-public class MockOptimization(Guid id) : IOptimization
+public class MockOptimization(Guid id) : StubOptimization
{
- public Guid Id { get; } = id;
- public OptimizationRisk Risk => OptimizationRisk.Safe;
- public string OptimizationKey => "TestOptimization";
- public string Name => "TestOptimization";
- public string ShortDescription => "Mock description";
- public OptimizationState State { get; set; } = new();
-
- public Task<ApplyResult> ApplyAsync(
+ public override Guid Id => id;
+ public override string OptimizationKey => "TestOptimization";
+ public override string Name => "TestOptimization";
+ public override string ShortDescription => "Mock description";
+
+ public override Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
OptimizationContext context
)
diff --git a/optimizerDuck.Test/Services/OptimizationExecutionContextTests.cs b/optimizerDuck.Test/Services/OptimizationExecutionContextTests.cs
index 20e4fb1..b9490bb 100644
--- a/optimizerDuck.Test/Services/OptimizationExecutionContextTests.cs
+++ b/optimizerDuck.Test/Services/OptimizationExecutionContextTests.cs
@@ -4,6 +4,7 @@ using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Execution;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.UI;
+using optimizerDuck.Test.TestDoubles;
using OptimizationState = optimizerDuck.Domain.UI.OptimizationState;
namespace optimizerDuck.Test.Services;
@@ -171,16 +172,13 @@ public class ExecutionScopeTests
}
}
-public class MockOptimization : IOptimization
+public class MockOptimization : StubOptimization
{
- public Guid Id { get; } = Guid.NewGuid();
- public OptimizationRisk Risk => OptimizationRisk.Safe;
- public string OptimizationKey => "MockOptimization";
- public string Name => "Mock Optimization";
- public string ShortDescription => "Mock description";
- public OptimizationState State { get; set; } = new();
-
- public Task<ApplyResult> ApplyAsync(
+ public override string OptimizationKey => "MockOptimization";
+ public override string Name => "Mock Optimization";
+ public override string ShortDescription => "Mock description";
+
+ public override Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
OptimizationContext context
)
diff --git a/optimizerDuck.Test/Services/OptimizationServiceIntegrationTests.cs b/optimizerDuck.Test/Services/OptimizationServiceIntegrationTests.cs
index c85b773..d4b4411 100644
--- a/optimizerDuck.Test/Services/OptimizationServiceIntegrationTests.cs
+++ b/optimizerDuck.Test/Services/OptimizationServiceIntegrationTests.cs
@@ -12,6 +12,7 @@ using optimizerDuck.Domain.Execution;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Revert;
using optimizerDuck.Domain.UI;
+using optimizerDuck.Test.TestDoubles;
using optimizerDuck.Services.Optimization;
using optimizerDuck.Services.Revert;
using optimizerDuck.Services.System;
@@ -21,24 +22,21 @@ namespace optimizerDuck.Test.Services;
public class OptimizationServiceIntegrationTests : IDisposable
{
- private class PartialFailureOptimization : IOptimization
+ private class PartialFailureOptimization : StubOptimization
{
private int _stepCount;
private readonly bool _shouldFail;
- public Guid Id { get; } = Guid.NewGuid();
- public OptimizationRisk Risk => OptimizationRisk.Safe;
- public string OptimizationKey => "PartialFailureTest";
- public string Name => "Partial Failure Test";
- public string ShortDescription => "Tests partial failure scenarios";
- public OptimizationState State { get; set; } = new();
+ public override string OptimizationKey => "PartialFailureTest";
+ public override string Name => "Partial Failure Test";
+ public override string ShortDescription => "Tests partial failure scenarios";
public PartialFailureOptimization(bool shouldFail = false)
{
_shouldFail = shouldFail;
}
- public Task<ApplyResult> ApplyAsync(
+ public override Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
OptimizationContext context
)
diff --git a/optimizerDuck.Test/Services/OptimizationServiceTests.cs b/optimizerDuck.Test/Services/OptimizationServiceTests.cs
index b2894f7..f74362e 100644
--- a/optimizerDuck.Test/Services/OptimizationServiceTests.cs
+++ b/optimizerDuck.Test/Services/OptimizationServiceTests.cs
@@ -7,6 +7,7 @@ using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Revert;
using optimizerDuck.Domain.Revert.Steps;
using optimizerDuck.Domain.UI;
+using optimizerDuck.Test.TestDoubles;
using optimizerDuck.Services.Optimization;
using optimizerDuck.Services.Revert;
using optimizerDuck.Services.System;
@@ -585,7 +586,7 @@ public class OptimizationServiceTests
return tcs.Task;
}
- private sealed class FakeOptimization : IOptimization
+ private sealed class FakeOptimization : StubOptimization
{
public Type? OwnerType { get; set; }
public string OwnerKey { get; } = "Test";
@@ -600,15 +601,10 @@ public class OptimizationServiceTests
Task<ApplyResult>
> ApplyImpl { get; init; } = _ => Task.FromResult(ApplyResult.True());
- public Guid Id { get; } = Guid.NewGuid();
- public OptimizationRisk Risk { get; } = OptimizationRisk.Safe;
- public string OptimizationKey { get; } = "TestOptimization";
+ public override string Name => "Test";
+ public override string ShortDescription => "Test";
- public string Name { get; } = "Test";
- public string ShortDescription { get; } = "Test";
- public OptimizationState State { get; set; } = new();
-
- public Task<ApplyResult> ApplyAsync(
+ public override Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
OptimizationContext context
)
diff --git a/optimizerDuck.Test/Services/OptimizationServices/RegistryServiceTests.cs b/optimizerDuck.Test/Services/OptimizationServices/RegistryServiceTests.cs
index bd28595..5140d98 100644
--- a/optimizerDuck.Test/Services/OptimizationServices/RegistryServiceTests.cs
+++ b/optimizerDuck.Test/Services/OptimizationServices/RegistryServiceTests.cs
@@ -8,6 +8,7 @@ using optimizerDuck.Domain.Execution;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Optimizations.Models.Services;
using optimizerDuck.Domain.UI;
+using optimizerDuck.Test.TestDoubles;
using optimizerDuck.Services.Optimization.Providers;
using Xunit;
@@ -18,16 +19,13 @@ public class RegistryServiceTests : IDisposable
private const string BaseTestKey = @"HKCU\Software\TestOptimizerDuck";
private readonly ExecutionScope _scope;
- private class DummyOptimization : IOptimization
+ private class DummyOptimization : StubOptimization
{
- public Guid Id { get; } = Guid.NewGuid();
- public OptimizationRisk Risk => OptimizationRisk.Safe;
- public string OptimizationKey => "TestOpt";
- public string Name => "Test";
- public string ShortDescription => "";
- public OptimizationState State { get; set; } = new();
-
- public Task<ApplyResult> ApplyAsync(
+ public override string OptimizationKey => "TestOpt";
+ public override string Name => "Test";
+ public override string ShortDescription => "";
+
+ public override Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
OptimizationContext context
) => Task.FromResult(ApplyResult.True());
diff --git a/optimizerDuck.Test/Services/RegistryWatcherTests.cs b/optimizerDuck.Test/Services/RegistryWatcherTests.cs
index 1785a15..d448785 100644
--- a/optimizerDuck.Test/Services/RegistryWatcherTests.cs
+++ b/optimizerDuck.Test/Services/RegistryWatcherTests.cs
@@ -120,7 +120,7 @@ public class RegistryWatcherTests : IDisposable
// Give cancellation time to interrupt any in-flight delay/operation
await Task.Delay(500, TestContext.Current.CancellationToken);
- // Create key and write — at this point the watcher should be stopped
+ // Create the key and write; the watcher should be stopped by now
using var key = Registry.CurrentUser.CreateSubKey(TestRootNative);
Assert.NotNull(key);
key.SetValue("TestValue", 99);
diff --git a/optimizerDuck.Test/TestDoubles/StubOptimization.cs b/optimizerDuck.Test/TestDoubles/StubOptimization.cs
new file mode 100644
index 0000000..0635799
--- /dev/null
+++ b/optimizerDuck.Test/TestDoubles/StubOptimization.cs
@@ -0,0 +1,23 @@
+using optimizerDuck.Domain.Abstractions;
+using optimizerDuck.Domain.Conditions;
+using optimizerDuck.Domain.Optimizations.Models;
+using optimizerDuck.Domain.UI;
+
+namespace optimizerDuck.Test.TestDoubles;
+
+public abstract class StubOptimization : IOptimization
+{
+ public virtual Guid Id { get; init; } = Guid.NewGuid();
+ public virtual OptimizationRisk Risk { get; init; } = OptimizationRisk.Safe;
+ public virtual string OptimizationKey { get; init; } = "TestOptimization";
+ public virtual string Name { get; init; } = "Test Optimization";
+ public virtual string ShortDescription { get; init; } = "Test optimization";
+ public virtual OptimizationState State { get; set; } = new();
+ public virtual Type? ConditionType { get; init; }
+ public virtual ConditionResult ConditionResult { get; set; } = ConditionResult.Available;
+
+ public abstract Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ );
+}
diff --git a/optimizerDuck.Test/UI/ViewModels/CustomizeItemViewModelTests.cs b/optimizerDuck.Test/UI/ViewModels/CustomizeItemViewModelTests.cs
new file mode 100644
index 0000000..7ec4cb2
--- /dev/null
+++ b/optimizerDuck.Test/UI/ViewModels/CustomizeItemViewModelTests.cs
@@ -0,0 +1,458 @@
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Win32;
+using optimizerDuck.Domain.Abstractions;
+using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Customize.Models;
+using optimizerDuck.Domain.Optimizations.Models.Services;
+using optimizerDuck.Services.Configuration;
+using optimizerDuck.Services.Optimization.Providers;
+using optimizerDuck.Services.System;
+using optimizerDuck.UI.ViewModels.Customize;
+using Wpf.Ui.Controls;
+
+namespace optimizerDuck.Test.UI.ViewModels;
+
+public class CustomizeItemViewModelTests : IDisposable
+{
+ private const string TestKeyPath = @"HKCU\Software\TestOptimizerDuckCustomizeVm";
+ private const string TestKeyPathNative = @"Software\TestOptimizerDuckCustomizeVm";
+ private const string RegName = "DropdownVmTest";
+
+ public CustomizeItemViewModelTests()
+ {
+ CleanupTestKeys();
+ }
+
+ public void Dispose()
+ {
+ CleanupTestKeys();
+ }
+
+ private static void CleanupTestKeys()
+ {
+ try
+ {
+ using var hkcu = Registry.CurrentUser;
+ hkcu.DeleteSubKeyTree(TestKeyPathNative, false);
+ }
+ catch
+ {
+ // Ignore if it doesn't exist
+ }
+ }
+
+ [CustomizeSetting(Icon = SymbolRegular.Settings24)]
+ private sealed class TestDropdownVmSetting : BaseCustomizeSetting
+ {
+ public int ApplyCount;
+
+ public override CustomizeControlType ControlType => CustomizeControlType.Dropdown;
+
+ protected override IReadOnlyList<SettingOption>? GetOptions() =>
+ [
+ Option("OptionA", TestKeyPath, RegName, 1),
+ Option("OptionB", TestKeyPath, RegName, 2),
+ ];
+
+ public override async Task ApplyAsync(object? value)
+ {
+ ApplyCount++;
+ await base.ApplyAsync(value);
+ }
+ }
+
+ private sealed class FakeRegistryWatcher : IRegistryWatcher
+ {
+ public event EventHandler<string>? RegistryKeyChanged;
+
+ public List<string> WatchedPaths { get; } = [];
+ public List<string> UnwatchedPaths { get; } = [];
+
+ public void Watch(string registryPath) => WatchedPaths.Add(registryPath);
+
+ public void Unwatch(string registryPath) => UnwatchedPaths.Add(registryPath);
+
+ public void Raise(string path) => RegistryKeyChanged?.Invoke(this, path);
+
+ public void Dispose() { }
+ }
+
+ private static (TestDropdownVmSetting setting, FakeRegistryWatcher watcher, CustomizeItemViewModel vm)
+ CreateVm()
+ {
+ var setting = new TestDropdownVmSetting { OwnerType = typeof(TestDropdownVmSetting) };
+ var watcher = new FakeRegistryWatcher();
+ var vm = new CustomizeItemViewModel(setting, NullLoggerFactory.Instance, watcher);
+ return (setting, watcher, vm);
+ }
+
+ private static void WriteValue(int value) =>
+ RegistryService.Write(new RegistryItem(TestKeyPath, RegName, value));
+
+ private static void DeleteValue() =>
+ RegistryService.DeleteValue(new RegistryItem(TestKeyPath, RegName));
+
+ private static object? ReadValue() =>
+ RegistryService.Read<object>(new RegistryItem(TestKeyPath, RegName));
+
+ private static async Task WaitUntilAsync(Func<bool> condition, int timeoutMs = 5000)
+ {
+ var token = TestContext.Current.CancellationToken;
+ var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);
+ while (!condition())
+ {
+ if (DateTime.UtcNow > deadline)
+ throw new TimeoutException("Condition not met within timeout");
+ await Task.Delay(25, token);
+ }
+ }
+
+ #region Load state
+
+ [Fact]
+ public async Task LoadState_OutOfScopeValue_ShowsCustomOptionWithRawValue()
+ {
+ WriteValue(99);
+
+ var (setting, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+
+ Assert.Equal(99, vm.CurrentValue);
+ Assert.NotNull(vm.Options);
+ Assert.Equal(3, vm.Options!.Count);
+ Assert.Equal(99, vm.Options[2].Value);
+ Assert.Equal(
+ Loc.Instance[BaseCustomizeSetting.CustomOptionTranslationKey],
+ vm.Options[2].DisplayName
+ );
+ Assert.Contains(TestKeyPath, watcher.WatchedPaths);
+ }
+
+ [Fact]
+ public async Task LoadState_MissingValue_ShowsNotSetOptionWithSentinel()
+ {
+ DeleteValue();
+
+ var (_, _, vm) = CreateVm();
+ await vm.LoadStateAsync();
+
+ Assert.Same(BaseCustomizeSetting.MissingValueSentinel, vm.CurrentValue);
+ Assert.Equal(3, vm.Options!.Count);
+ Assert.Equal(
+ Loc.Instance[BaseCustomizeSetting.CustomOptionNotSetTranslationKey],
+ vm.Options[2].DisplayName
+ );
+ Assert.Same(BaseCustomizeSetting.MissingValueSentinel, vm.Options[2].Value);
+ }
+
+ [Fact]
+ public async Task LoadState_InScopeValue_NoCustomOption()
+ {
+ WriteValue(2);
+
+ var (_, _, vm) = CreateVm();
+ await vm.LoadStateAsync();
+
+ Assert.Equal(2, vm.CurrentValue);
+ Assert.Equal(2, vm.Options!.Count);
+ Assert.DoesNotContain(vm.Options, o => o.Value is 99);
+ }
+
+ #endregion
+
+ #region User selection flows
+
+ [Fact]
+ public async Task SelectDeclaredOption_FromCustomState_AppliesAndRemovesCustom()
+ {
+ WriteValue(99);
+
+ var (setting, _, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(3, vm.Options!.Count); // Custom shown
+
+ // Simulate the ComboBox selection of a declared option.
+ vm.CurrentValue = 2;
+
+ await WaitUntilAsync(() => Equals(ReadValue(), 2) && !vm.IsLoading);
+
+ Assert.Equal(1, setting.ApplyCount);
+ Assert.Equal(2, vm.CurrentValue);
+ Assert.Equal(2, vm.Options!.Count); // Custom gone
+ Assert.DoesNotContain(vm.Options, o => Equals(o.Value, 99));
+ }
+
+ [Fact]
+ public async Task SelectDeclaredOption_FromNotSetState_AppliesAndRemovesNotSet()
+ {
+ DeleteValue();
+
+ var (setting, _, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(3, vm.Options!.Count); // Not set shown
+
+ vm.CurrentValue = 1;
+
+ await WaitUntilAsync(() => Equals(ReadValue(), 1) && !vm.IsLoading);
+
+ Assert.Equal(1, setting.ApplyCount);
+ Assert.Equal(1, vm.CurrentValue);
+ Assert.Equal(2, vm.Options!.Count); // Not set gone
+ Assert.DoesNotContain(
+ vm.Options,
+ o => ReferenceEquals(o.Value, BaseCustomizeSetting.MissingValueSentinel)
+ );
+ }
+
+ [Fact]
+ public async Task SelectCurrentCustomValue_DoesNotReapply()
+ {
+ WriteValue(99);
+
+ var (setting, _, vm) = CreateVm();
+ await vm.LoadStateAsync();
+
+ // Selecting the already-selected "Custom" option is a synchronous no-op: the
+ // value equals the live state, so no apply is queued (IsLoading stays false)
+ // and nothing is written.
+ vm.CurrentValue = 99;
+
+ Assert.False(vm.IsLoading);
+ Assert.Equal(0, setting.ApplyCount);
+ Assert.Equal(99, ReadValue());
+ }
+
+ [Fact]
+ public async Task SelectNotSetOption_DoesNotReapply()
+ {
+ DeleteValue();
+
+ var (setting, _, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(3, vm.Options!.Count); // Not set shown
+
+ // Selecting the already-selected "Not set" fallback is a synchronous no-op: the
+ // sentinel equals the live state, so no apply is queued (IsLoading stays false)
+ // and nothing is written or deleted.
+ vm.CurrentValue = BaseCustomizeSetting.MissingValueSentinel;
+
+ Assert.False(vm.IsLoading);
+ Assert.Equal(0, setting.ApplyCount);
+ Assert.Null(ReadValue());
+ }
+
+ [Fact]
+ public async Task SelectDeclaredOption_ThenExternalOutOfScopeChange_ShowsCustomAgain()
+ {
+ WriteValue(99);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+
+ // Switch to declared option 1.
+ vm.CurrentValue = 1;
+ await WaitUntilAsync(() => Equals(ReadValue(), 1) && !vm.IsLoading);
+ Assert.Equal(2, vm.Options!.Count);
+
+ // External change pushes the value out of scope again.
+ WriteValue(123);
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(() => Equals(vm.CurrentValue, 123) && vm.Options!.Count == 3);
+
+ Assert.Equal(123, vm.Options[2].Value);
+ Assert.Equal(
+ Loc.Instance[BaseCustomizeSetting.CustomOptionTranslationKey],
+ vm.Options[2].DisplayName
+ );
+ }
+
+ #endregion
+
+ #region Watcher (external edit) flows
+
+ [Fact]
+ public async Task Watcher_ExternalChangeToInScope_RemovesCustomOption()
+ {
+ WriteValue(99);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(3, vm.Options!.Count);
+
+ WriteValue(2);
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(() => Equals(vm.CurrentValue, 2) && vm.Options!.Count == 2);
+
+ Assert.Equal(2, vm.CurrentValue);
+ Assert.DoesNotContain(vm.Options, o => Equals(o.Value, 99));
+ }
+
+ [Fact]
+ public async Task Watcher_ExternalChangeToOutOfScope_AddsCustomWithRawValue()
+ {
+ WriteValue(2);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(2, vm.Options!.Count);
+
+ WriteValue(99);
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(() => Equals(vm.CurrentValue, 99) && vm.Options!.Count == 3);
+
+ Assert.Equal(99, vm.Options[2].Value);
+ Assert.Equal(
+ Loc.Instance[BaseCustomizeSetting.CustomOptionTranslationKey],
+ vm.Options[2].DisplayName
+ );
+ }
+
+ [Fact]
+ public async Task Watcher_ExternalChangeToMissing_ShowsNotSetOption()
+ {
+ WriteValue(2);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(2, vm.Options!.Count);
+
+ DeleteValue();
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(
+ () =>
+ ReferenceEquals(vm.CurrentValue, BaseCustomizeSetting.MissingValueSentinel)
+ && vm.Options!.Count == 3
+ );
+
+ Assert.Equal(
+ Loc.Instance[BaseCustomizeSetting.CustomOptionNotSetTranslationKey],
+ vm.Options[2].DisplayName
+ );
+ Assert.Same(BaseCustomizeSetting.MissingValueSentinel, vm.Options[2].Value);
+ }
+
+ [Fact]
+ public async Task Watcher_ExternalChangeFromMissingToInScope_RemovesNotSet()
+ {
+ DeleteValue();
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(3, vm.Options!.Count);
+
+ WriteValue(1);
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(() => Equals(vm.CurrentValue, 1) && vm.Options!.Count == 2);
+
+ Assert.DoesNotContain(
+ vm.Options,
+ o => ReferenceEquals(o.Value, BaseCustomizeSetting.MissingValueSentinel)
+ );
+ }
+
+ [Fact]
+ public async Task Watcher_ExternalChangeWhileCustom_UpdatesCustomValue()
+ {
+ WriteValue(99);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(99, vm.Options![2].Value);
+
+ WriteValue(123);
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(() => Equals(vm.CurrentValue, 123) && Equals(vm.Options[2].Value, 123));
+
+ Assert.Equal(3, vm.Options.Count);
+ Assert.Equal(
+ Loc.Instance[BaseCustomizeSetting.CustomOptionTranslationKey],
+ vm.Options[2].DisplayName
+ );
+ }
+
+ [Fact]
+ public async Task Watcher_ExternalChangeFromCustomToInScope_RemovesCustom()
+ {
+ WriteValue(99);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.Equal(3, vm.Options!.Count);
+
+ WriteValue(1);
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(() => Equals(vm.CurrentValue, 1) && vm.Options!.Count == 2);
+
+ Assert.DoesNotContain(vm.Options, o => Equals(o.Value, 99));
+ }
+
+ #endregion
+
+ #region Not Set ↔ in-scope transitions (round-trip)
+
+ [Fact]
+ public async Task RoundTrip_MissingToDeclared_AppliesWritesValue()
+ {
+ DeleteValue();
+
+ var (setting, _, vm) = CreateVm();
+ await vm.LoadStateAsync();
+
+ vm.CurrentValue = 2;
+ await WaitUntilAsync(() => Equals(ReadValue(), 2) && !vm.IsLoading);
+
+ Assert.Equal(1, setting.ApplyCount);
+ Assert.Equal(2, ReadValue());
+ Assert.Equal(2, vm.CurrentValue);
+ Assert.Equal(2, vm.Options!.Count);
+ }
+
+ [Fact]
+ public async Task RoundTrip_ExternalDeleteAfterDeclared_ShowsNotSet()
+ {
+ WriteValue(1);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+
+ DeleteValue();
+ watcher.Raise(TestKeyPath);
+
+ await WaitUntilAsync(
+ () =>
+ ReferenceEquals(vm.CurrentValue, BaseCustomizeSetting.MissingValueSentinel)
+ && vm.Options!.Count == 3
+ );
+
+ Assert.Equal(1, vm.Options![0].Value);
+ Assert.Equal(2, vm.Options[1].Value);
+ Assert.Same(BaseCustomizeSetting.MissingValueSentinel, vm.Options[2].Value);
+ }
+
+ #endregion
+
+ #region Watcher subscription lifecycle
+
+ [Fact]
+ public async Task Dispose_UnwatchesAllPaths()
+ {
+ WriteValue(1);
+
+ var (_, watcher, vm) = CreateVm();
+ await vm.LoadStateAsync();
+ Assert.NotEmpty(watcher.WatchedPaths);
+
+ vm.Dispose();
+
+ Assert.Equal(watcher.WatchedPaths.OrderBy(p => p).ToArray(), watcher.UnwatchedPaths.OrderBy(p => p).ToArray());
+ }
+
+ #endregion
+}
diff --git a/optimizerDuck/Common/Converters/BooleanConverter.cs b/optimizerDuck/Common/Converters/BooleanConverter.cs
index 27d8509..00f9bfc 100644
--- a/optimizerDuck/Common/Converters/BooleanConverter.cs
+++ b/optimizerDuck/Common/Converters/BooleanConverter.cs
@@ -7,6 +7,7 @@ namespace optimizerDuck.Common.Converters;
// Posted by Atif Aziz, modified by community. See post 'Timeline' for change history
// Retrieved 2026-01-21, License - CC BY-SA 2.5
+/// <summary>Maps a <see cref="bool"/> to one of two configured values of type <typeparamref name="T"/>.</summary>
public class BooleanConverter<T>(T trueValue, T falseValue) : IValueConverter
{
public T True { get; set; } = trueValue;
diff --git a/optimizerDuck/Common/Converters/BooleanToVisibilityConverter.cs b/optimizerDuck/Common/Converters/BooleanToVisibilityConverter.cs
index 584d7f3..8894202 100644
--- a/optimizerDuck/Common/Converters/BooleanToVisibilityConverter.cs
+++ b/optimizerDuck/Common/Converters/BooleanToVisibilityConverter.cs
@@ -2,5 +2,6 @@
namespace optimizerDuck.Common.Converters;
+/// <summary>Converts <c>true</c> to <see cref="Visibility.Visible"/> and <c>false</c> to <see cref="Visibility.Collapsed"/>.</summary>
public sealed class BooleanToVisibilityConverter()
: BooleanConverter<Visibility>(Visibility.Visible, Visibility.Collapsed);
diff --git a/optimizerDuck/Common/Converters/EmptyWhileNotLoadingConverter.cs b/optimizerDuck/Common/Converters/EmptyWhileNotLoadingConverter.cs
index 6d87cb1..aa80046 100644
--- a/optimizerDuck/Common/Converters/EmptyWhileNotLoadingConverter.cs
+++ b/optimizerDuck/Common/Converters/EmptyWhileNotLoadingConverter.cs
@@ -4,6 +4,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Shows an empty-state message when the item count is zero and nothing is loading.</summary>
public class EmptyWhileNotLoadingConverter : IMultiValueConverter
{
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
diff --git a/optimizerDuck/Common/Converters/EqualityToVisibilityConverter.cs b/optimizerDuck/Common/Converters/EqualityToVisibilityConverter.cs
index f52d5fb..d2d5e79 100644
--- a/optimizerDuck/Common/Converters/EqualityToVisibilityConverter.cs
+++ b/optimizerDuck/Common/Converters/EqualityToVisibilityConverter.cs
@@ -4,6 +4,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Shows or hides a control based on whether the value equals the converter parameter.</summary>
public class EqualityToVisibilityConverter : IValueConverter
{
public Visibility True { get; set; } = Visibility.Visible;
diff --git a/optimizerDuck/Common/Converters/InverseBooleanConverter.cs b/optimizerDuck/Common/Converters/InverseBooleanConverter.cs
index 8dfe0b1..faf5912 100644
--- a/optimizerDuck/Common/Converters/InverseBooleanConverter.cs
+++ b/optimizerDuck/Common/Converters/InverseBooleanConverter.cs
@@ -1,3 +1,4 @@
namespace optimizerDuck.Common.Converters;
+/// <summary>Inverts a <see cref="bool"/>: <c>true</c> becomes <c>false</c> and vice versa.</summary>
public sealed class InverseBooleanConverter() : BooleanConverter<bool>(false, true);
diff --git a/optimizerDuck/Common/Converters/InverseBooleanToVisibilityConverter.cs b/optimizerDuck/Common/Converters/InverseBooleanToVisibilityConverter.cs
index 3a9478a..ece0276 100644
--- a/optimizerDuck/Common/Converters/InverseBooleanToVisibilityConverter.cs
+++ b/optimizerDuck/Common/Converters/InverseBooleanToVisibilityConverter.cs
@@ -2,5 +2,6 @@
namespace optimizerDuck.Common.Converters;
+/// <summary>Converts <c>true</c> to <see cref="Visibility.Collapsed"/> and <c>false</c> to <see cref="Visibility.Visible"/>.</summary>
public sealed class InverseBooleanToVisibilityConverter()
: BooleanConverter<Visibility>(Visibility.Collapsed, Visibility.Visible);
diff --git a/optimizerDuck/Common/Converters/MBToGBConverter.cs b/optimizerDuck/Common/Converters/MBToGBConverter.cs
index ace64bf..fa0e1a2 100644
--- a/optimizerDuck/Common/Converters/MBToGBConverter.cs
+++ b/optimizerDuck/Common/Converters/MBToGBConverter.cs
@@ -3,6 +3,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Converts a megabyte value to a formatted gigabyte string, or "N/A" when invalid.</summary>
public class MBToGBConverter : IValueConverter
{
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
diff --git a/optimizerDuck/Common/Converters/MinusNumberConverter.cs b/optimizerDuck/Common/Converters/MinusNumberConverter.cs
index 6fabb24..9e6e6e2 100644
--- a/optimizerDuck/Common/Converters/MinusNumberConverter.cs
+++ b/optimizerDuck/Common/Converters/MinusNumberConverter.cs
@@ -3,6 +3,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Subtracts a fixed amount (default 1) from an integer value.</summary>
public class MinusNumberConverter : IValueConverter
{
public int NumberToMinus { get; set; } = 1;
diff --git a/optimizerDuck/Common/Converters/NumericComparisonToVisibilityConverter.cs b/optimizerDuck/Common/Converters/NumericComparisonToVisibilityConverter.cs
index 9466f43..d9568a6 100644
--- a/optimizerDuck/Common/Converters/NumericComparisonToVisibilityConverter.cs
+++ b/optimizerDuck/Common/Converters/NumericComparisonToVisibilityConverter.cs
@@ -4,6 +4,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Comparison operators supported by <see cref="NumericComparisonToVisibilityConverter"/>.</summary>
public enum NumericComparisonType
{
GreaterThan,
@@ -14,6 +15,7 @@ public enum NumericComparisonType
NotEqual,
}
+/// <summary>Shows or hides a control based on how an integer compares to a threshold.</summary>
public class NumericComparisonToVisibilityConverter : IValueConverter
{
public NumericComparisonType ComparisonType { get; set; } = NumericComparisonType.GreaterThan;
diff --git a/optimizerDuck/Common/Converters/ProgressBarValueToBrushConverter.cs b/optimizerDuck/Common/Converters/ProgressBarValueToBrushConverter.cs
index 651a792..dbd756f 100644
--- a/optimizerDuck/Common/Converters/ProgressBarValueToBrushConverter.cs
+++ b/optimizerDuck/Common/Converters/ProgressBarValueToBrushConverter.cs
@@ -5,6 +5,7 @@ using optimizerDuck.Common.Helpers;
namespace optimizerDuck.Common.Converters;
+/// <summary>Maps a progress percentage to a theme brush: green under 50%, yellow under 80%, red above.</summary>
public class ProgressBarValueToBrushConverter : IValueConverter
{
private static readonly SolidColorBrush GreenBrush =
diff --git a/optimizerDuck/Common/Converters/ProgressBarVisibilityConverter.cs b/optimizerDuck/Common/Converters/ProgressBarVisibilityConverter.cs
index 1f25340..82aab01 100644
--- a/optimizerDuck/Common/Converters/ProgressBarVisibilityConverter.cs
+++ b/optimizerDuck/Common/Converters/ProgressBarVisibilityConverter.cs
@@ -4,6 +4,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Shows the progress bar when there is work to display or it is indeterminate.</summary>
public class ProgressBarVisibilityConverter : IMultiValueConverter
{
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
diff --git a/optimizerDuck/Common/Converters/RecommendationForegroundConverter.cs b/optimizerDuck/Common/Converters/RecommendationForegroundConverter.cs
index 16da59b..b1606c4 100644
--- a/optimizerDuck/Common/Converters/RecommendationForegroundConverter.cs
+++ b/optimizerDuck/Common/Converters/RecommendationForegroundConverter.cs
@@ -8,6 +8,7 @@ using Wpf.Ui.Appearance;
namespace optimizerDuck.Common.Converters;
+/// <summary>Provides theme-aware text brushes for converter use.</summary>
public static class ThemeBrushes
{
public static Brush Primary => Clone("TextFillColorPrimaryBrush");
@@ -26,6 +27,7 @@ public static class ThemeBrushes
}
}
+/// <summary>Picks a foreground brush for a recommendation state based on the current app theme.</summary>
public class RecommendationForegroundConverter : IMultiValueConverter
{
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
diff --git a/optimizerDuck/Common/Converters/ThemeConverterBase.cs b/optimizerDuck/Common/Converters/ThemeConverterBase.cs
index cf46556..0039e72 100644
--- a/optimizerDuck/Common/Converters/ThemeConverterBase.cs
+++ b/optimizerDuck/Common/Converters/ThemeConverterBase.cs
@@ -4,6 +4,7 @@ using Wpf.Ui.Appearance;
namespace optimizerDuck.Common.Converters;
+/// <summary>Base class for converters that map an <see cref="ApplicationTheme"/> to a value.</summary>
public abstract class ThemeConverterBase<T> : IValueConverter
{
public object? Convert(object value, Type targetType, object parameter, CultureInfo culture)
diff --git a/optimizerDuck/Common/Converters/ThemeToGitHubIconConverter.cs b/optimizerDuck/Common/Converters/ThemeToGitHubIconConverter.cs
index 26f9637..5743b58 100644
--- a/optimizerDuck/Common/Converters/ThemeToGitHubIconConverter.cs
+++ b/optimizerDuck/Common/Converters/ThemeToGitHubIconConverter.cs
@@ -3,6 +3,7 @@ using Wpf.Ui.Appearance;
namespace optimizerDuck.Common.Converters;
+/// <summary>Returns the GitHub logo image that matches the current theme.</summary>
public sealed class ThemeToGitHubIconConverter : ThemeConverterBase<BitmapImage>
{
protected override BitmapImage ConvertTheme(ApplicationTheme theme, object parameter)
diff --git a/optimizerDuck/Common/Converters/ThemeToIndexConverter.cs b/optimizerDuck/Common/Converters/ThemeToIndexConverter.cs
index 4a944a4..dee40b1 100644
--- a/optimizerDuck/Common/Converters/ThemeToIndexConverter.cs
+++ b/optimizerDuck/Common/Converters/ThemeToIndexConverter.cs
@@ -4,6 +4,7 @@ using Wpf.Ui.Appearance;
namespace optimizerDuck.Common.Converters;
+/// <summary>Maps an <see cref="ApplicationTheme"/> to a 0-2 index (for tab selection) and back.</summary>
public sealed class ThemeToIndexConverter : IValueConverter
{
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
diff --git a/optimizerDuck/Common/Converters/ValueConditionToVisibilityConverter.cs b/optimizerDuck/Common/Converters/ValueConditionToVisibilityConverter.cs
index 7edeeee..de68611 100644
--- a/optimizerDuck/Common/Converters/ValueConditionToVisibilityConverter.cs
+++ b/optimizerDuck/Common/Converters/ValueConditionToVisibilityConverter.cs
@@ -4,6 +4,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Value checks supported by <see cref="ValueConditionToVisibilityConverter"/>.</summary>
public enum ValueConditionType
{
IsNull,
@@ -14,6 +15,7 @@ public enum ValueConditionType
IsLessThanZero,
}
+/// <summary>Shows or hides a control based on a value condition (null, zero, or sign).</summary>
public class ValueConditionToVisibilityConverter : IValueConverter
{
public ValueConditionType ConditionType { get; set; } = ValueConditionType.IsNull;
diff --git a/optimizerDuck/Common/Converters/WidthToColumnConverter.cs b/optimizerDuck/Common/Converters/WidthToColumnConverter.cs
index da20205..12add4b 100644
--- a/optimizerDuck/Common/Converters/WidthToColumnConverter.cs
+++ b/optimizerDuck/Common/Converters/WidthToColumnConverter.cs
@@ -3,6 +3,7 @@ using System.Windows.Data;
namespace optimizerDuck.Common.Converters;
+/// <summary>Maps a container width to a responsive column count (1 to 4).</summary>
public class WidthToColumnConverter : IValueConverter
{
public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
diff --git a/optimizerDuck/Common/Extensions/CustomizePageRegistryExtensions.cs b/optimizerDuck/Common/Extensions/CustomizePageRegistryExtensions.cs
index abc4bdc..fdf5f35 100644
--- a/optimizerDuck/Common/Extensions/CustomizePageRegistryExtensions.cs
+++ b/optimizerDuck/Common/Extensions/CustomizePageRegistryExtensions.cs
@@ -37,6 +37,7 @@ public static class CustomizePageRegistryExtensions
var registry = serviceProvider.GetRequiredService<CustomizeRegistry>();
var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
var registryWatcher = serviceProvider.GetRequiredService<IRegistryWatcher>();
+ var systemInfoService = serviceProvider.GetRequiredService<SystemInfoService>();
// Fall back to synchronous registration if preloading hasn't completed yet.
// RegisterCategories is a no-op if already preloaded.
@@ -44,7 +45,12 @@ public static class CustomizePageRegistryExtensions
var category = registry.Categories.First(c => c.GetType() == categoryType);
- var viewModel = new CustomizeCategoryViewModel(category, loggerFactory, registryWatcher);
+ var viewModel = new CustomizeCategoryViewModel(
+ category,
+ loggerFactory,
+ registryWatcher,
+ systemInfoService
+ );
return Activator.CreateInstance(pageType, viewModel)!;
}
diff --git a/optimizerDuck/Common/Extensions/OptimizationPageRegistryExtensions.cs b/optimizerDuck/Common/Extensions/OptimizationPageRegistryExtensions.cs
index 238a644..1865f64 100644
--- a/optimizerDuck/Common/Extensions/OptimizationPageRegistryExtensions.cs
+++ b/optimizerDuck/Common/Extensions/OptimizationPageRegistryExtensions.cs
@@ -8,6 +8,7 @@ using optimizerDuck.Domain.Attributes;
using optimizerDuck.Domain.Configuration;
using optimizerDuck.Services.Optimization;
using optimizerDuck.Services.Revert;
+using optimizerDuck.Services.System;
using Wpf.Ui;
using OptimizationCategoryViewModel = optimizerDuck.UI.ViewModels.Optimizer.OptimizationCategoryViewModel;
@@ -43,6 +44,7 @@ public static class OptimizationPageRegistryExtensions
var revertManager = serviceProvider.GetRequiredService<RevertManager>();
var snackbarService = serviceProvider.GetRequiredService<ISnackbarService>();
var contentDialogService = serviceProvider.GetRequiredService<IContentDialogService>();
+ var systemInfoService = serviceProvider.GetRequiredService<SystemInfoService>();
var logger = serviceProvider.GetRequiredService<ILogger<OptimizationCategoryViewModel>>();
var appOptionsMonitor = serviceProvider.GetRequiredService<IOptionsMonitor<AppSettings>>();
@@ -54,6 +56,7 @@ public static class OptimizationPageRegistryExtensions
revertManager,
snackbarService,
contentDialogService,
+ systemInfoService,
logger,
appOptionsMonitor
);
diff --git a/optimizerDuck/Common/Helpers/Shared.cs b/optimizerDuck/Common/Helpers/Shared.cs
index fc83611..2311680 100644
--- a/optimizerDuck/Common/Helpers/Shared.cs
+++ b/optimizerDuck/Common/Helpers/Shared.cs
@@ -44,24 +44,20 @@ public static class Shared
// Bing / MSN / News
"Microsoft.BingWeather",
"Microsoft.BingNews",
- "Microsoft.BingSearch",
+ "Microsoft.MicrosoftNews",
"Microsoft.BingFinance",
"Microsoft.BingSports",
"Microsoft.BingFoodAndDrink",
"Microsoft.BingHealthAndFitness",
"Microsoft.BingTravel",
- "Microsoft.MicrosoftNews",
// Help, Tips & Feedback
- "Microsoft.GetHelp",
"Microsoft.GetStarted",
- "Microsoft.WindowsFeedbackHub",
"Microsoft.WindowsTips",
- "MicrosoftCorporationII.QuickAssist",
- // Communications (Legacy/Web Wrappers)
+ "Microsoft.WindowsFeedbackHub",
+ // Communications (Legacy/Discontinued)
"Microsoft.Messaging",
"Microsoft.OneConnect",
"Microsoft.People",
- "Microsoft.YourPhone",
"Microsoft.SkypeApp",
"MicrosoftTeams",
// Office (Web Wrappers & Legacy)
@@ -70,68 +66,108 @@ public static class Shared
"Microsoft.MicrosoftOfficeHub",
"Microsoft.Office.OneNote",
"Microsoft.Office.Sway",
- "Microsoft.OutlookForWindows",
"Microsoft.MicrosoftJournal",
- // Social & Wallet
+ // Social & Wallet (Legacy)
"Microsoft.Wallet",
"Microsoft.MSWallet",
- "Microsoft.LinkedInForWindows",
- // Mixed Reality & 3D
+ // Mixed Reality & 3D (Legacy, not in Win11 images)
"Microsoft.Microsoft3DViewer",
"Microsoft.MixedReality.Portal",
"Microsoft.Print3D",
"Microsoft.3DBuilder",
- "Microsoft.Paint3D",
- // Multimedia (Legacy/Redundant)
- "Microsoft.ZuneMusic",
+ // Multimedia & Entertainment
"Microsoft.ZuneVideo",
- "Microsoft.Sway",
"Microsoft.WindowsSoundRecorder",
"Microsoft.StickyNotes",
"Microsoft.MicrosoftStickyNotes",
- // Entertainment, Games & Widgets
"Microsoft.MicrosoftSolitaireCollection",
"Microsoft.WindowsAlarms",
"Microsoft.549981C3F5F10", // Cortana
+ // Legacy & Redundant Utilities
"Microsoft.Windows.DevHome",
- "Microsoft.StartExperiencesApp",
- // Third-party (often pre-installed by MS)
+ "Microsoft.WindowsMaps",
+ "Microsoft.XboxApp", // Old Xbox Console Companion (Discontinued)
+ "Microsoft.Windows.AIHub", // Copilot+ AI Hub (Copilot+ PCs)
+ "Drawboard.DrawboardPDF",
+ // Third-party (commonly pre-installed on OEM machines)
"SpotifyAB.SpotifyMusic",
- "Disney.DisneyPlus",
- "Amazon.Amazon",
"Clipchamp.Clipchamp",
- // Legacy / Others
- "WindowsPhone",
- "CommsPhone",
- "Microsoft.DrawboardPDF",
- // Windows 11 Widgets
- "MicrosoftWindows.Client.WebExperience",
+ "Disney.37853FC22B2CE",
+ "Amazon.com.Amazon",
+ "4DF9E0F8.Netflix",
+ "BytedancePte.Ltd.TikTok",
+ "king.com.CandyCrushSaga",
+ "king.com.CandyCrushSodaSaga",
+ "king.com.BubbleWitch3Saga",
+ "AmazonVideo.PrimeVideo",
+ "Facebook.Instagram",
+ "FACEBOOK.FACEBOOK",
+ "7EE7776C.LinkedInforWindows",
+ "Flipboard",
+ "iHeartRadio",
+ "PandoraMediaInc",
+ "TuneInRadio",
+ "Duolingo-LearnLanguagesforFree",
+ "PicsArt-PhotoStudio",
+ "WinZipUniversal",
+ "AdobeSystemsIncorporated.AdobePhotoshopExpress",
+ "OneCalendar",
+ "NYTCrossword",
+ "MarchofEmpires",
+ "flaregamesGmbH.RoyalRevolt",
+ "Asphalt8Airborne",
+ "FarmVille2CountryEscape",
+ "HiddenCity",
+ "CaesarsSlotsFreeCasino",
+ "COOKINGFEVER",
+ "DisneyMagicKingdoms",
+ "PhototasticCollage",
+ "AutodeskSketchBook",
+ "PolarrPhotoEditorAcademicEdition",
+ "Sidia.LiveWallpaper",
+ "HULULLC.HULUPLUS",
+ "SlingTV",
};
public static readonly HashSet<string> CautionApps = new()
{
- // Core Utilities
+ // Core Utilities (default handlers for common file types)
"Microsoft.WindowsCalculator",
"Microsoft.WindowsPhotos",
- "Microsoft.MSPaint",
+ "Microsoft.MSPaint", // Paint 3D
"Microsoft.Paint",
"Microsoft.WindowsNotepad",
"Microsoft.WindowsCamera",
- "Microsoft.ScreenSketch",
- "Microsoft.WindowsMaps",
+ "Microsoft.ScreenSketch", // Snipping Tool
// System Tools
"Microsoft.WindowsStore",
"Microsoft.StorePurchaseApp",
- "Microsoft.DesktopAppInstaller",
+ "Microsoft.DesktopAppInstaller", // winget
"Microsoft.WindowsTerminal",
"Microsoft.WindowsTerminalPreview",
"Microsoft.RemoteDesktop",
"Microsoft.PowerAutomateDesktop",
// Communication & Collaboration
- "Microsoft.WindowsCommunicationsApps",
- // Security & Family
- "MicrosoftCorporationII.MicrosoftFamily",
+ "Microsoft.WindowsCommunicationsApps", // Mail & Calendar
+ "Microsoft.OutlookForWindows", // New Outlook
+ "Microsoft.YourPhone", // Phone Link
+ "MicrosoftWindows.CrossDevice", // Phone Link features in Explorer
+ // Widgets & Search integration
+ "Microsoft.StartExperiencesApp",
+ "MicrosoftWindows.Client.WebExperience",
+ "Microsoft.WidgetsPlatformRuntime",
+ "Microsoft.BingSearch",
+ // Default media handler
+ "Microsoft.ZuneMusic", // Media Player
+ // Security, Family & Support
+ "MicrosoftCorporationII.MicrosoftFamily", // parental controls
"MicrosoftCorporationII.MicrosoftSupportDiagnosticTool",
+ "MicrosoftCorporationII.QuickAssist",
+ "Microsoft.GetHelp", // Required by some Windows 11 Troubleshooters
+ // Cloud & Productivity
+ "Microsoft.OneDrive",
+ "Microsoft.Whiteboard",
+ "Microsoft.M365Companions",
// Media Extensions (Essential for file format support)
"Microsoft.HEIFImageExtension",
"Microsoft.WebMediaExtensions",
@@ -146,9 +182,39 @@ public static class Shared
"Microsoft.XboxSpeechToTextOverlay",
"Microsoft.XboxGameOverlay",
"Microsoft.XboxGamingOverlay",
- "Microsoft.XboxApp",
"Microsoft.Xbox.TCUI",
"Microsoft.GamingApp",
+ // OEM Software (drivers, updates & support from the hardware vendor)
+ "AD2F1837.HPAIExperienceCenter",
+ "AD2F1837.HPConnectedMusic",
+ "AD2F1837.HPConnectedPhotopoweredbySnapfish",
+ "AD2F1837.HPDesktopSupportUtilities",
+ "AD2F1837.HPEasyClean",
+ "AD2F1837.HPFileViewer",
+ "AD2F1837.HPJumpStarts",
+ "AD2F1837.HPPCHardwareDiagnosticsWindows",
+ "AD2F1837.HPPowerManager",
+ "AD2F1837.HPPrinterControl",
+ "AD2F1837.HPPrivacySettings",
+ "AD2F1837.HPQuickDrop",
+ "AD2F1837.HPQuickTouch",
+ "AD2F1837.HPRegistration",
+ "AD2F1837.HPSupportAssistant",
+ "AD2F1837.HPSureShieldAI",
+ "AD2F1837.HPSystemInformation",
+ "AD2F1837.HPWelcome",
+ "AD2F1837.HPWorkWell",
+ "AD2F1837.myHP",
+ "DellInc.DellSupportAssistforPCs",
+ "DellInc.DellDigitalDelivery",
+ "DellInc.DellMobileConnect",
+ "E046963F.LenovoCompanion",
+ "LenovoCompanyLimited.LenovoVantageService",
+ "LGElectronics.LGMonitorApp",
+ "EclipseManager", // Dell OEM
+ "ACGMediaPlayer", // OEM media player
+ "ActiproSoftwareLLC", // OEM-bundled UI components
+ "CyberLinkMediaSuiteEssentials", // OEM media suite
};
public static string RootDirectory =>
diff --git a/optimizerDuck/Common/Helpers/UiThread.cs b/optimizerDuck/Common/Helpers/UiThread.cs
new file mode 100644
index 0000000..54f5c66
--- /dev/null
+++ b/optimizerDuck/Common/Helpers/UiThread.cs
@@ -0,0 +1,47 @@
+using System.Windows;
+using System.Windows.Threading;
+
+namespace optimizerDuck.Common.Helpers;
+
+/// <summary>
+/// Marshals work to the WPF UI thread, degrading gracefully to inline execution when
+/// no <see cref="Application"/> exists (e.g. unit tests or headless hosts). Use this
+/// instead of touching <c>Application.Current.Dispatcher</c> directly so background
+/// threads never need to null-check the application instance.
+/// </summary>
+public static class UiThread
+{
+ /// <summary>
+ /// Runs <paramref name="action"/> on the UI thread. When already on the UI thread,
+ /// or when no <see cref="Application"/> exists, the action runs inline.
+ /// </summary>
+ public static Task InvokeAsync(
+ Action action,
+ DispatcherPriority priority = DispatcherPriority.Normal
+ )
+ {
+ if (Application.Current?.Dispatcher is not { } dispatcher || dispatcher.CheckAccess())
+ {
+ action();
+ return Task.CompletedTask;
+ }
+
+ return dispatcher.InvokeAsync(action, priority).Task;
+ }
+
+ /// <summary>
+ /// Runs <paramref name="action"/> on the UI thread and awaits its completion. When
+ /// already on the UI thread, or when no <see cref="Application"/> exists, the
+ /// action runs inline.
+ /// </summary>
+ public static Task InvokeAsync(
+ Func<Task> action,
+ DispatcherPriority priority = DispatcherPriority.Normal
+ )
+ {
+ if (Application.Current?.Dispatcher is not { } dispatcher || dispatcher.CheckAccess())
+ return action();
+
+ return dispatcher.InvokeAsync(action, priority).Task.Unwrap();
+ }
+}
diff --git a/optimizerDuck/Domain/Abstractions/ICustomizeSetting.cs b/optimizerDuck/Domain/Abstractions/ICustomizeSetting.cs
index 6ddd4ed..f612863 100644
--- a/optimizerDuck/Domain/Abstractions/ICustomizeSetting.cs
+++ b/optimizerDuck/Domain/Abstractions/ICustomizeSetting.cs
@@ -23,29 +23,44 @@ public interface ICustomizeSetting
/// <summary>Gets the unique key used for localization lookup.</summary>
string FeatureKey { get; }
+ /// <summary>
+ /// Gets the compatibility condition type (implementing <see cref="ICondition"/>)
+ /// that determines whether this setting is supported on the current system.
+ /// </summary>
+ Type? ConditionType { get; }
+
/// <summary>Gets the type of UI control to render for this setting.</summary>
CustomizeControlType ControlType { get; }
+ /// <summary>Gets the matched option value, else the raw registry value.</summary>
object? CurrentValue { get; }
+ /// <summary>
+ /// Gets the options displayed for this setting: the declared options plus, when the
+ /// current registry value falls outside them, a memory-only "Custom" option that
+ /// reflects the actual value. It is derived from the live registry state and never
+ /// persisted.
+ /// </summary>
IReadOnlyList<SettingOption>? Options { get; }
/// <summary>Read the current system state. For toggles: true = on, false = off.</summary>
Task<bool> GetStateAsync();
/// <summary>
- /// Reads state with a cooldown and convergence check. Use after
- /// <see cref="ApplyAsync"/> to let the registry settle.
+ /// Reads state until two consecutive reads agree or retries run out. Use after
+ /// <see cref="ApplyAsync"/> to let the registry settle.
/// </summary>
Task<bool> GetStateWithRetryAsync(int maxRetries = 3, int delayMs = 80);
+ /// <summary>Applies a bool (toggles) or a declared dropdown option value.</summary>
Task ApplyAsync(object? value);
/// <summary>
- /// Registry key paths that should be watched for external changes,
- /// so the UI can auto-refresh when someone else modifies a setting.
+ /// Registry key paths that should be watched for external changes,
+ /// so the UI can auto-refresh when someone else modifies a setting.
/// </summary>
IReadOnlyList<string> WatchedRegistryPaths { get; }
+ /// <summary>Returns the setting's recommendation, or <c>null</c> when none exists.</summary>
CustomizeRecommendationResult? GetRecommendation();
}
diff --git a/optimizerDuck/Domain/Abstractions/IOptimization.cs b/optimizerDuck/Domain/Abstractions/IOptimization.cs
index b2f9797..66a7fcb 100644
--- a/optimizerDuck/Domain/Abstractions/IOptimization.cs
+++ b/optimizerDuck/Domain/Abstractions/IOptimization.cs
@@ -1,4 +1,5 @@
-using optimizerDuck.Domain.Optimizations.Models;
+using optimizerDuck.Domain.Conditions;
+using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.UI;
using OptimizationState = optimizerDuck.Domain.UI.OptimizationState;
@@ -39,6 +40,16 @@ public interface IOptimization
/// </summary>
OptimizationState State { get; set; }
+ /// <summary>
+ /// The compatibility condition type (implementing <see cref="ICondition"/>)
+ /// that determines whether this optimization is supported on the current system,
+ /// or <c>null</c> when it is always available.
+ /// </summary>
+ Type? ConditionType { get; }
+
+ /// <summary>Gets or sets the evaluated compatibility result.</summary>
+ ConditionResult ConditionResult { get; set; }
+
/// <summary>
/// Applies this optimization to the system.
/// </summary>
diff --git a/optimizerDuck/Domain/Attributes/CustomizeSettingAttribute.cs b/optimizerDuck/Domain/Attributes/CustomizeSettingAttribute.cs
index 495559c..4c3884c 100644
--- a/optimizerDuck/Domain/Attributes/CustomizeSettingAttribute.cs
+++ b/optimizerDuck/Domain/Attributes/CustomizeSettingAttribute.cs
@@ -10,6 +10,13 @@ public sealed class CustomizeSettingAttribute : Attribute
public required SymbolRegular Icon { get; init; }
public RecommendationState Recommendation { get; init; } = RecommendationState.None;
+ /// <summary>
+ /// The compatibility condition type (implementing <see cref="ICondition"/>)
+ /// that determines whether this setting is supported on the current system.
+ /// When <c>null</c>, the setting is always available.
+ /// </summary>
+ public Type? Condition { get; init; }
+
public string GetSectionName()
{
if (Section == null)
diff --git a/optimizerDuck/Domain/Attributes/OptimizationAttribute.cs b/optimizerDuck/Domain/Attributes/OptimizationAttribute.cs
index 39ddd3d..eff992c 100644
--- a/optimizerDuck/Domain/Attributes/OptimizationAttribute.cs
+++ b/optimizerDuck/Domain/Attributes/OptimizationAttribute.cs
@@ -22,4 +22,11 @@ public sealed class OptimizationAttribute : Attribute
/// The tags that categorize the system areas this optimization affects.
/// </summary>
public required OptimizationTags Tags { get; init; }
+
+ /// <summary>
+ /// The compatibility condition type (implementing <see cref="ICondition"/>)
+ /// that determines whether this optimization is supported on the current system.
+ /// When <c>null</c>, the optimization is always available.
+ /// </summary>
+ public Type? Condition { get; init; }
}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/CpuBrandCondition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/CpuBrandCondition.cs
new file mode 100644
index 0000000..3148a03
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/CpuBrandCondition.cs
@@ -0,0 +1,46 @@
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>Base condition that requires the CPU to belong to a specific brand.</summary>
+public abstract class CpuBrandCondition : ConditionBase
+{
+ /// <summary>The required CPU vendor.</summary>
+ protected abstract CpuVendor RequiredVendor { get; }
+
+ /// <summary>Strongly-typed localized failure title.</summary>
+ protected abstract Func<string> Title { get; }
+
+ /// <summary>Strongly-typed localized failure description.</summary>
+ protected abstract Func<string> Description { get; }
+
+ public override ConditionResult Evaluate(SystemSnapshot snapshot)
+ {
+ // An unknown CPU vendor means hardware detection produced no usable answer
+ // (e.g. WMI/registry failed), fail open so a detection failure never hides
+ // every vendor-specific tweak.
+ if (snapshot.Cpu.Vendor == CpuVendor.Unknown)
+ return ConditionResult.Error();
+
+ return snapshot.Cpu.Vendor == RequiredVendor
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(Title, Description);
+ }
+}
+
+/// <summary>Requires an Intel CPU.</summary>
+public sealed class IntelCpuCondition : CpuBrandCondition
+{
+ protected override CpuVendor RequiredVendor => CpuVendor.Intel;
+ protected override Func<string> Title => () => Translations.Condition_Cpu_Intel_Title;
+ protected override Func<string> Description => () => Translations.Condition_Cpu_Intel_Description;
+}
+
+/// <summary>Requires an AMD CPU.</summary>
+public sealed class AmdCpuCondition : CpuBrandCondition
+{
+ protected override CpuVendor RequiredVendor => CpuVendor.AMD;
+ protected override Func<string> Title => () => Translations.Condition_Cpu_Amd_Title;
+ protected override Func<string> Description => () => Translations.Condition_Cpu_Amd_Description;
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/GpuBrandCondition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/GpuBrandCondition.cs
new file mode 100644
index 0000000..5acedc4
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/GpuBrandCondition.cs
@@ -0,0 +1,58 @@
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>Base condition that requires at least one GPU from a specific vendor.</summary>
+public abstract class GpuBrandCondition : ConditionBase
+{
+ /// <summary>The required GPU vendor.</summary>
+ protected abstract GpuVendor RequiredVendor { get; }
+
+ /// <summary>Strongly-typed localized failure title.</summary>
+ protected abstract Func<string> Title { get; }
+
+ /// <summary>Strongly-typed localized failure description.</summary>
+ protected abstract Func<string> Description { get; }
+
+ public override ConditionResult Evaluate(SystemSnapshot snapshot)
+ {
+ // An empty or all-unknown GPU list means hardware detection produced no usable
+ // answer (e.g. DXGI/WMI failed), fail open so a detection failure never hides
+ // every vendor-specific tweak. "Genuinely no GPU" is indistinguishable from a
+ // detection failure here, so treat both as "could not verify".
+ if (
+ snapshot.Gpus.Count == 0
+ || snapshot.Gpus.All(static g => g.Vendor == GpuVendor.Unknown)
+ )
+ return ConditionResult.Error();
+
+ return snapshot.Gpus.Any(g => g.Vendor == RequiredVendor)
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(Title, Description);
+ }
+}
+
+/// <summary>Requires an NVIDIA GPU.</summary>
+public sealed class NvidiaGpuCondition : GpuBrandCondition
+{
+ protected override GpuVendor RequiredVendor => GpuVendor.NVIDIA;
+ protected override Func<string> Title => () => Translations.Condition_Gpu_Nvidia_Title;
+ protected override Func<string> Description => () => Translations.Condition_Gpu_Nvidia_Description;
+}
+
+/// <summary>Requires an AMD GPU.</summary>
+public sealed class AmdGpuCondition : GpuBrandCondition
+{
+ protected override GpuVendor RequiredVendor => GpuVendor.AMD;
+ protected override Func<string> Title => () => Translations.Condition_Gpu_Amd_Title;
+ protected override Func<string> Description => () => Translations.Condition_Gpu_Amd_Description;
+}
+
+/// <summary>Requires an Intel GPU.</summary>
+public sealed class IntelGpuCondition : GpuBrandCondition
+{
+ protected override GpuVendor RequiredVendor => GpuVendor.Intel;
+ protected override Func<string> Title => () => Translations.Condition_Gpu_Intel_Title;
+ protected override Func<string> Description => () => Translations.Condition_Gpu_Intel_Description;
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/MinimumRamCondition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/MinimumRamCondition.cs
new file mode 100644
index 0000000..acb0ea4
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/MinimumRamCondition.cs
@@ -0,0 +1,30 @@
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>Base condition that requires a minimum amount of installed RAM.</summary>
+public abstract class MinimumRamCondition : ConditionBase
+{
+ /// <summary>The minimum required RAM in gigabytes.</summary>
+ protected abstract double MinimumGb { get; }
+
+ /// <summary>Strongly-typed localized failure title.</summary>
+ protected abstract Func<string> Title { get; }
+
+ /// <summary>Strongly-typed localized failure description.</summary>
+ protected abstract Func<string> Description { get; }
+
+ public override ConditionResult Evaluate(SystemSnapshot snapshot) =>
+ snapshot.Ram.TotalGB >= MinimumGb
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(Title, Description);
+}
+
+/// <summary>Requires at least 16 GB of installed RAM.</summary>
+public sealed class SixteenGbRamCondition : MinimumRamCondition
+{
+ protected override double MinimumGb => 16;
+ protected override Func<string> Title => () => Translations.Condition_Ram_16_Title;
+ protected override Func<string> Description => () => Translations.Condition_Ram_16_Description;
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/RecallInstalledCondition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/RecallInstalledCondition.cs
new file mode 100644
index 0000000..e498087
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/RecallInstalledCondition.cs
@@ -0,0 +1,33 @@
+using System.IO;
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Requires Windows Recall (AI Explorer) to actually be present on the machine.
+/// Recall ships with the Windows AI shell components, which are only installed on
+/// Windows 11 24H2+ systems that have the feature: a build check alone would mark
+/// a plain 24H2 machine as supported even though Recall does not exist there.
+/// </summary>
+public sealed class RecallInstalledCondition : ConditionBase
+{
+ // Recall's AI shell components (speech/AI runtime) live here on machines where the
+ // feature is installed; the directory is absent on systems without it.
+ private const string AiShellDirectory = @"C:\Windows\System32\CoreAISpeech";
+
+ public override ConditionResult Evaluate(SystemSnapshot snapshot)
+ {
+ var isSupported =
+ TryGetOsBuild(snapshot, out var build)
+ && build >= WindowsBuilds.Windows11_24H2
+ && Directory.Exists(AiShellDirectory);
+
+ return isSupported
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(
+ () => Translations.Condition_Recall_Title,
+ () => Translations.Condition_Recall_Description
+ );
+ }
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/RegistryKeyExistsCondition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/RegistryKeyExistsCondition.cs
new file mode 100644
index 0000000..1c5ed8d
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/RegistryKeyExistsCondition.cs
@@ -0,0 +1,28 @@
+using optimizerDuck.Domain.Optimizations.Models.Services;
+using optimizerDuck.Services.Optimization.Providers;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Base condition that requires a specific registry key to exist on the machine.
+/// Subclasses supply the registry item to look up. Failures (e.g. inaccessible hives)
+/// propagate to <see cref="ConditionEvaluator"/>, which converts them to an
+/// <see cref="ConditionState.Error"/> result.
+/// </summary>
+public abstract class RegistryKeyExistsCondition : ConditionBase
+{
+ /// <summary>The registry key that must exist.</summary>
+ protected abstract RegistryItem RegistryItem { get; }
+
+ /// <summary>Strongly-typed localized failure title.</summary>
+ protected abstract Func<string> Title { get; }
+
+ /// <summary>Strongly-typed localized failure description.</summary>
+ protected abstract Func<string> Description { get; }
+
+ public override ConditionResult Evaluate(SystemSnapshot snapshot) =>
+ RegistryService.KeyExists(RegistryItem)
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(Title, Description);
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/ServiceExistsCondition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/ServiceExistsCondition.cs
new file mode 100644
index 0000000..de872f7
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/ServiceExistsCondition.cs
@@ -0,0 +1,30 @@
+using optimizerDuck.Domain.Optimizations.Models.Services;
+using optimizerDuck.Services.Optimization.Providers;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Base condition that requires a Windows service to exist on the machine.
+/// Subclasses supply the service name (the registry subkey under
+/// <c>HKLM\SYSTEM\CurrentControlSet\Services</c>).
+/// </summary>
+public abstract class ServiceExistsCondition : ConditionBase
+{
+ /// <summary>The name of the required service.</summary>
+ protected abstract string ServiceName { get; }
+
+ /// <summary>Strongly-typed localized failure title.</summary>
+ protected abstract Func<string> Title { get; }
+
+ /// <summary>Strongly-typed localized failure description.</summary>
+ protected abstract Func<string> Description { get; }
+
+ public override ConditionResult Evaluate(SystemSnapshot snapshot)
+ {
+ var serviceKey = new RegistryItem($@"HKLM\SYSTEM\CurrentControlSet\Services\{ServiceName}");
+ return RegistryService.KeyExists(serviceKey)
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(Title, Description);
+ }
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/Windows10Condition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/Windows10Condition.cs
new file mode 100644
index 0000000..bb87050
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/Windows10Condition.cs
@@ -0,0 +1,16 @@
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>Requires Windows 10 (build 10240 to 21999).</summary>
+public sealed class Windows10Condition : ConditionBase
+{
+ public override ConditionResult Evaluate(SystemSnapshot snapshot) =>
+ TryGetOsBuild(snapshot, out var build) && build is >= WindowsBuilds.Windows10 and < WindowsBuilds.Windows11
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(
+ () => Translations.Condition_Windows10_Title,
+ () => Translations.Condition_Windows10_Description
+ );
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/Windows11Condition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/Windows11Condition.cs
new file mode 100644
index 0000000..bbc098c
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/Windows11Condition.cs
@@ -0,0 +1,16 @@
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>Requires Windows 11 (build 22000 or later).</summary>
+public sealed class Windows11Condition : ConditionBase
+{
+ public override ConditionResult Evaluate(SystemSnapshot snapshot) =>
+ TryGetOsBuild(snapshot, out var build) && build >= WindowsBuilds.Windows11
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(
+ () => Translations.Condition_Windows11_Title,
+ () => Translations.Condition_Windows11_Description
+ );
+}
diff --git a/optimizerDuck/Domain/Conditions/BuiltIn/Windows11_24H2OrGreaterCondition.cs b/optimizerDuck/Domain/Conditions/BuiltIn/Windows11_24H2OrGreaterCondition.cs
new file mode 100644
index 0000000..0a4d22e
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/BuiltIn/Windows11_24H2OrGreaterCondition.cs
@@ -0,0 +1,19 @@
+using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Requires Windows 11 24H2 (build 26100) or later. Used to gate AI features
+/// that only exist on 24H2 and newer builds.
+/// </summary>
+public sealed class Windows11_24H2OrGreaterCondition : ConditionBase
+{
+ public override ConditionResult Evaluate(SystemSnapshot snapshot) =>
+ TryGetOsBuild(snapshot, out var build) && build >= WindowsBuilds.Windows11_24H2
+ ? ConditionResult.Available
+ : ConditionResult.Unsupported(
+ () => Translations.Condition_Windows11_24H2_Title,
+ () => Translations.Condition_Windows11_24H2_Description
+ );
+}
diff --git a/optimizerDuck/Domain/Conditions/ConditionBase.cs b/optimizerDuck/Domain/Conditions/ConditionBase.cs
new file mode 100644
index 0000000..b540864
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/ConditionBase.cs
@@ -0,0 +1,26 @@
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Base class for conditions. Provides helpers shared by condition implementations.
+/// </summary>
+public abstract class ConditionBase : ICondition
+{
+ /// <inheritdoc />
+ public abstract ConditionResult Evaluate(SystemSnapshot snapshot);
+
+ /// <summary>Attempts to parse the OS build number (e.g. "22631") from the snapshot.</summary>
+ protected static bool TryGetOsBuild(SystemSnapshot snapshot, out int build)
+ {
+ build = 0;
+ if (snapshot.Os.BuildNumber is not { } text)
+ return false;
+
+ var span = text.AsSpan();
+ var dot = span.IndexOf('.');
+ if (dot >= 0)
+ span = span[..dot];
+ return int.TryParse(span, out build);
+ }
+}
diff --git a/optimizerDuck/Domain/Conditions/ConditionResult.cs b/optimizerDuck/Domain/Conditions/ConditionResult.cs
new file mode 100644
index 0000000..91f6d2f
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/ConditionResult.cs
@@ -0,0 +1,71 @@
+using optimizerDuck.Resources.Languages;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// The outcome of evaluating a condition against the current system. Localized
+/// title/description are resolved lazily at read time, so the current culture wins.
+/// </summary>
+/// <remarks>
+/// A plain class (reference equality), not a record: a fresh instance per evaluation
+/// lets view models observe change notifications even when the state is unchanged.
+/// </remarks>
+public sealed class ConditionResult
+{
+ /// <summary>
+ /// Creates a condition result with the given state and optional localized
+ /// title/description providers.
+ /// </summary>
+ /// <param name="state">The outcome state of the check.</param>
+ /// <param name="titleProvider">Provider for the condition title, or <c>null</c>.</param>
+ /// <param name="descriptionProvider">Provider for the condition explanation, or <c>null</c>.</param>
+ public ConditionResult(
+ ConditionState state,
+ Func<string>? titleProvider = null,
+ Func<string>? descriptionProvider = null
+ )
+ {
+ State = state;
+ TitleProvider = titleProvider;
+ DescriptionProvider = descriptionProvider;
+ }
+
+ /// <summary>A convenience result representing a fully supported item.</summary>
+ public static readonly ConditionResult Available = new(ConditionState.Available);
+
+ /// <summary>Creates an "unsupported" result with the given localized title/description.</summary>
+ public static ConditionResult Unsupported(Func<string> title, Func<string> description) =>
+ new(ConditionState.Unsupported, title, description);
+
+ /// <summary>
+ /// Creates an "error" result. Evaluation errors do not block the item: a failure
+ /// never hides an item the user could still use.
+ /// </summary>
+ public static ConditionResult Error() =>
+ new(
+ ConditionState.Error,
+ () => Translations.Condition_Error_Title,
+ () => Translations.Condition_Error_Description
+ );
+
+ /// <summary>Gets the outcome state of the check.</summary>
+ public ConditionState State { get; }
+
+ /// <summary>Gets the provider for the condition title, or <c>null</c>.</summary>
+ public Func<string>? TitleProvider { get; }
+
+ /// <summary>Gets the provider for the condition explanation, or <c>null</c>.</summary>
+ public Func<string>? DescriptionProvider { get; }
+
+ /// <summary>
+ /// Gets whether this result should block the item by default. Only
+ /// <see cref="ConditionState.Unsupported"/> blocks.
+ /// </summary>
+ public bool IsBlocking => State is ConditionState.Unsupported;
+
+ /// <summary>Gets the localized title for this result, or <c>null</c>.</summary>
+ public string? Title => TitleProvider?.Invoke();
+
+ /// <summary>Gets the localized description for this result, or <c>null</c>.</summary>
+ public string? Description => DescriptionProvider?.Invoke();
+}
diff --git a/optimizerDuck/Domain/Conditions/ConditionState.cs b/optimizerDuck/Domain/Conditions/ConditionState.cs
new file mode 100644
index 0000000..aa1a2c0
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/ConditionState.cs
@@ -0,0 +1,16 @@
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Represents the outcome of a compatibility condition check.
+/// </summary>
+public enum ConditionState
+{
+ /// <summary>The item is supported and safe to use on the current system.</summary>
+ Available,
+
+ /// <summary>The item is not supported on the current system.</summary>
+ Unsupported,
+
+ /// <summary>The condition could not be evaluated.</summary>
+ Error,
+}
diff --git a/optimizerDuck/Domain/Conditions/ConditionValidation.cs b/optimizerDuck/Domain/Conditions/ConditionValidation.cs
new file mode 100644
index 0000000..ffba9fe
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/ConditionValidation.cs
@@ -0,0 +1,39 @@
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Validates condition metadata at discovery time so misconfigured attributes
+/// fail fast at startup instead of surfacing as runtime errors later.
+/// </summary>
+public static class ConditionValidation
+{
+ /// <summary>
+ /// Ensures <paramref name="conditionType"/> either is <c>null</c> or is a concrete
+ /// <see cref="ICondition"/> with a public parameterless constructor.
+ /// </summary>
+ /// <param name="conditionType">The condition type declared in an attribute, or <c>null</c>.</param>
+ /// <param name="ownerName">The owning item's display name, used in the error message.</param>
+ /// <exception cref="InvalidOperationException">
+ /// Thrown when the type does not implement <see cref="ICondition"/> or has no
+ /// parameterless constructor.
+ /// </exception>
+ public static void Validate(Type? conditionType, string ownerName)
+ {
+ if (conditionType is null)
+ return;
+
+ if (!typeof(ICondition).IsAssignableFrom(conditionType))
+ throw new InvalidOperationException(
+ $"{ownerName}: condition type {conditionType.FullName} does not implement ICondition."
+ );
+
+ if (conditionType.IsAbstract)
+ throw new InvalidOperationException(
+ $"{ownerName}: condition type {conditionType.FullName} must be a concrete type."
+ );
+
+ if (conditionType.GetConstructor(Type.EmptyTypes) is null)
+ throw new InvalidOperationException(
+ $"{ownerName}: condition type {conditionType.FullName} must have a public parameterless constructor."
+ );
+ }
+}
diff --git a/optimizerDuck/Domain/Conditions/ICondition.cs b/optimizerDuck/Domain/Conditions/ICondition.cs
new file mode 100644
index 0000000..fa59678
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/ICondition.cs
@@ -0,0 +1,14 @@
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Domain.Conditions;
+
+/// <summary>
+/// Evaluates whether a single compatibility requirement is met on the current system.
+/// Implementations must have a parameterless constructor so they can be instantiated
+/// from the <c>Condition = typeof(...)</c> attribute metadata via reflection.
+/// </summary>
+public interface ICondition
+{
+ /// <summary>Evaluates the condition against the system snapshot.</summary>
+ ConditionResult Evaluate(SystemSnapshot snapshot);
+}
diff --git a/optimizerDuck/Domain/Conditions/WindowsBuilds.cs b/optimizerDuck/Domain/Conditions/WindowsBuilds.cs
new file mode 100644
index 0000000..59fd1e5
--- /dev/null
+++ b/optimizerDuck/Domain/Conditions/WindowsBuilds.cs
@@ -0,0 +1,8 @@
+namespace optimizerDuck.Domain.Conditions;
+
+internal static class WindowsBuilds
+{
+ public const int Windows10 = 10240;
+ public const int Windows11 = 22000;
+ public const int Windows11_24H2 = 26100;
+}
diff --git a/optimizerDuck/Domain/Customize/Categories/Preferences.cs b/optimizerDuck/Domain/Customize/Categories/Preferences.cs
index 7a6db62..a56504b 100644
--- a/optimizerDuck/Domain/Customize/Categories/Preferences.cs
+++ b/optimizerDuck/Domain/Customize/Categories/Preferences.cs
@@ -2,6 +2,7 @@ using System.Collections.ObjectModel;
using optimizerDuck.Common.Helpers;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Customize.Models;
using optimizerDuck.Domain.Optimizations.Models.Services;
using optimizerDuck.Domain.UI;
@@ -30,7 +31,8 @@ public class Preferences : ICustomizeCategory
[CustomizeSetting(
Section = nameof(Sections.Taskbar),
- Icon = SymbolRegular.TextAlignDistributedEvenly24
+ Icon = SymbolRegular.TextAlignDistributedEvenly24,
+ Condition = typeof(Windows11Condition)
)]
public class TaskbarAlignment : BaseCustomizeSetting
{
@@ -51,7 +53,8 @@ public class Preferences : ICustomizeCategory
[CustomizeSetting(
Section = nameof(Sections.Taskbar),
Icon = SymbolRegular.Grid24,
- Recommendation = RecommendationState.Off
+ Recommendation = RecommendationState.Off,
+ Condition = typeof(Windows11Condition)
)]
public class TaskbarWidgets : BaseCustomizeSetting
{
@@ -111,7 +114,8 @@ public class Preferences : ICustomizeCategory
[CustomizeSetting(
Section = nameof(Sections.Taskbar),
Icon = SymbolRegular.WindowConsole20,
- Recommendation = RecommendationState.On
+ Recommendation = RecommendationState.On,
+ Condition = typeof(Windows11Condition)
)]
public class TaskbarEndTask : BaseCustomizeSetting
{
@@ -230,7 +234,11 @@ public class Preferences : ICustomizeCategory
];
}
- [CustomizeSetting(Section = nameof(Sections.Explorer), Icon = SymbolRegular.Table24)]
+ [CustomizeSetting(
+ Section = nameof(Sections.Explorer),
+ Icon = SymbolRegular.Table24,
+ Condition = typeof(Windows11Condition)
+ )]
public class ExplorerCompactMode : BaseCustomizeSetting
{
protected override CustomizeRefreshScope RefreshScope => CustomizeRefreshScope.Default;
@@ -248,7 +256,11 @@ public class Preferences : ICustomizeCategory
];
}
- [CustomizeSetting(Section = nameof(Sections.Explorer), Icon = SymbolRegular.Grid24)]
+ [CustomizeSetting(
+ Section = nameof(Sections.Explorer),
+ Icon = SymbolRegular.Grid24,
+ Condition = typeof(Windows11Condition)
+ )]
public class SnapAssistFlyout : BaseCustomizeSetting
{
protected override CustomizeRefreshScope RefreshScope => CustomizeRefreshScope.Default;
@@ -390,19 +402,17 @@ public class Preferences : ICustomizeCategory
[CustomizeSetting(Section = nameof(Sections.Explorer), Icon = SymbolRegular.Folder24)]
public class LaunchToThisPc : BaseCustomizeSetting
{
- protected override CustomizeRefreshScope RefreshScope => CustomizeRefreshScope.Default;
+ private const string RegPath =
+ @"HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced";
- protected override IEnumerable<RegistryToggle> RegistryToggles =>
- [
- new()
- {
- Path = @"HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced",
- Name = "LaunchTo",
- OnValues = [1],
- OffValues = [2],
- DefaultValue = 2,
- },
- ];
+ private const string RegName = "LaunchTo";
+
+ public override CustomizeControlType ControlType => CustomizeControlType.Dropdown;
+
+ protected override IReadOnlyList<SettingOption>? GetOptions() =>
+ [Option("ThisPc", RegPath, RegName, 1), Option("QuickAccess", RegPath, RegName, 2)];
+
+ protected override CustomizeRefreshScope RefreshScope => CustomizeRefreshScope.Default;
}
[CustomizeSetting(
@@ -431,7 +441,8 @@ public class Preferences : ICustomizeCategory
[CustomizeSetting(
Section = nameof(Sections.Explorer),
Icon = SymbolRegular.CursorClick24,
- Recommendation = RecommendationState.On
+ Recommendation = RecommendationState.On,
+ Condition = typeof(Windows11Condition)
)]
public class ClassicContextMenu : BaseCustomizeSetting
{
@@ -495,7 +506,10 @@ public class Preferences : ICustomizeCategory
CustomizeRefreshScope.TaskbarSettings;
}
- [CustomizeSetting(Section = nameof(Sections.Taskbar), Icon = SymbolRegular.CursorClick24)]
+ [CustomizeSetting(
+ Section = nameof(Sections.Taskbar),
+ Icon = SymbolRegular.CursorClick24
+ )]
public class TaskbarLastActiveClick : BaseCustomizeSetting
{
private const string RegPath =
diff --git a/optimizerDuck/Domain/Customize/Categories/SystemFeatures.cs b/optimizerDuck/Domain/Customize/Categories/SystemFeatures.cs
index 49db23a..9c70f1b 100644
--- a/optimizerDuck/Domain/Customize/Categories/SystemFeatures.cs
+++ b/optimizerDuck/Domain/Customize/Categories/SystemFeatures.cs
@@ -1,6 +1,7 @@
using System.Collections.ObjectModel;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Customize.Models;
using optimizerDuck.Domain.UI;
using optimizerDuck.Services.Configuration;
@@ -125,7 +126,11 @@ public class SystemFeatures : ICustomizeCategory
#endregion
- [CustomizeSetting(Section = nameof(Sections.Power), Icon = SymbolRegular.BatteryCharge24)]
+ [CustomizeSetting(
+ Section = nameof(Sections.Power),
+ Icon = SymbolRegular.BatteryCharge24,
+ Condition = typeof(Windows11Condition)
+ )]
public class ShowBatteryPercentage : BaseCustomizeSetting
{
private const string RegPath =
diff --git a/optimizerDuck/Domain/Customize/Models/BaseCustomizeSetting.cs b/optimizerDuck/Domain/Customize/Models/BaseCustomizeSetting.cs
index 68b238c..80bbb86 100644
--- a/optimizerDuck/Domain/Customize/Models/BaseCustomizeSetting.cs
+++ b/optimizerDuck/Domain/Customize/Models/BaseCustomizeSetting.cs
@@ -1,4 +1,5 @@
using System.Reflection;
+using CommunityToolkit.Mvvm.ComponentModel;
using optimizerDuck.Common.Helpers;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Attributes;
@@ -16,7 +17,7 @@ namespace optimizerDuck.Domain.Customize.Models;
/// Windows surfaces should be refreshed after applying.
/// For Dropdown settings, options can carry <see cref="RegistryBinding"/> to auto-read/write.
/// </summary>
-public abstract class BaseCustomizeSetting : ICustomizeSetting
+public abstract partial class BaseCustomizeSetting : ObservableObject, ICustomizeSetting
{
private CustomizeSettingAttribute? _meta;
@@ -39,6 +40,13 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
public string Name => Loc.Instance[$"Customize.{OwnerKey}.{FeatureKey}.Name"];
public string Description => Loc.Instance[$"Customize.{OwnerKey}.{FeatureKey}.Description"];
+ /// <summary>
+ /// Gets the compatibility condition type declared in the
+ /// <see cref="CustomizeSettingAttribute"/> (implementing <see cref="ICondition"/>),
+ /// or <c>null</c> when the setting is always available.
+ /// </summary>
+ public Type? ConditionType => Meta.Condition;
+
public string Section
{
get
@@ -52,6 +60,12 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
public virtual CustomizeControlType ControlType => CustomizeControlType.Toggle;
+ /// <summary>
+ /// For Dropdown settings: the matched option's value, the raw registry value when
+ /// out of scope, or <see cref="MissingValueSentinel"/> when the value is missing.
+ /// Never interpret <c>null</c> as "unset" for Dropdown settings; use
+ /// <see cref="MissingValueSentinel"/> instead.
+ /// </summary>
public virtual object? CurrentValue
{
get
@@ -60,29 +74,78 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
if (ControlType != CustomizeControlType.Dropdown || options == null)
return null;
- foreach (var option in options)
- {
- if (option.Bindings is not { Count: > 0 })
- continue;
+ var resolution = ResolveDropdownValue(options);
+ return resolution.Matched ? resolution.Value : resolution.Value ?? MissingValueSentinel;
+ }
+ }
- var allMatch = option.Bindings.All(b =>
- {
- var actual = RegistryService.Read<object>(new RegistryItem(b.Path, b.Name));
- return ValuesEqual(actual, b.Value);
- });
+ /// <summary>
+ /// Gets the options displayed for a Dropdown setting: the declared options plus,
+ /// when the current registry value falls outside them, a memory-only "Custom"/"Not
+ /// set" option reflecting the actual value. It is derived from the live registry
+ /// state and never persisted; it disappears once the value returns to a declared
+ /// option.
+ /// </summary>
+ public virtual IReadOnlyList<SettingOption>? Options
+ {
+ get
+ {
+ var options = GetOptions();
+ if (ControlType != CustomizeControlType.Dropdown || options == null)
+ return options;
- if (allMatch)
- return option.Value;
- }
+ var resolution = ResolveDropdownValue(options);
+ if (resolution.Matched)
+ return options;
- return ReadPrimaryRawValue(options);
+ // A partial multi-binding match can surface a raw value that already equals a
+ // declared option's Value. Appending "Custom" then would duplicate that Value,
+ // which makes SelectedValuePath="Value" selection ambiguous, so skip it.
+ var displayValue = resolution.Value ?? MissingValueSentinel;
+ if (options.Any(o => ValuesEqual(o.Value, displayValue)))
+ return options;
+
+ return [.. options, CreateCustomOption(displayValue)];
}
}
- public virtual IReadOnlyList<SettingOption>? Options => GetOptions();
+ /// <summary>
+ /// Stable, non-null sentinel used as the fallback option's value when the registry
+ /// value is missing entirely, so WPF can render a selection (null values cannot be
+ /// matched by <c>SelectedValuePath</c>).
+ /// </summary>
+ internal static readonly object MissingValueSentinel = new();
+
+ /// <summary>
+ /// Creates the fallback option shown when the current registry value is outside
+ /// the declared options. When the value is missing entirely
+ /// (<paramref name="rawValue"/> is <see cref="MissingValueSentinel"/>), a distinct
+ /// "Not set" label is used; otherwise the generic "Custom" label shows the actual
+ /// out-of-scope value.
+ /// </summary>
+ private static SettingOption CreateCustomOption(object rawValue) =>
+ new(
+ ReferenceEquals(rawValue, MissingValueSentinel)
+ ? Loc.Instance[CustomOptionNotSetTranslationKey]
+ : Loc.Instance[CustomOptionTranslationKey],
+ rawValue
+ );
+
+ /// <summary>The translation key used for the synthetic "Custom" option label.</summary>
+ public const string CustomOptionTranslationKey = "Customize.CustomOption";
+
+ /// <summary>
+ /// The translation key used for the synthetic fallback label when the registry
+ /// value is missing entirely (see <see cref="MissingValueSentinel"/>).
+ /// </summary>
+ public const string CustomOptionNotSetTranslationKey = "Customize.CustomOption.NotSet";
protected virtual IReadOnlyList<SettingOption>? GetOptions() => null;
+ /// <summary>
+ /// Reads the current registry state. For toggles: <c>true</c> when all required
+ /// toggles are on, <c>false</c> otherwise.
+ /// </summary>
public virtual Task<bool> GetStateAsync()
{
return Task.Run(() =>
@@ -99,6 +162,12 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
});
}
+ /// <summary>
+ /// Reads state until two consecutive reads agree or retries run out. Use after
+ /// <see cref="ApplyAsync"/> to let the registry settle.
+ /// </summary>
+ /// <param name="maxRetries">The number of read attempts.</param>
+ /// <param name="delayMs">The delay between attempts.</param>
public async Task<bool> GetStateWithRetryAsync(int maxRetries = 3, int delayMs = 80)
{
bool? previous = null;
@@ -119,6 +188,13 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
return previous ?? await GetStateAsync();
}
+ /// <summary>
+ /// Applies the value to the registry: for toggles a <see cref="bool"/>, for
+ /// dropdowns the matching declared option's bindings. Then runs any post-apply
+ /// Windows refresh declared by <see cref="RefreshScope"/>.
+ /// </summary>
+ /// <param name="value">The value to apply. The synthetic "Custom"/"Not set" fallback
+ /// value is a safe no-op.</param>
public virtual async Task ApplyAsync(object? value)
{
if (value is bool isOn)
@@ -129,10 +205,12 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
toggle.SetState(isOn);
});
}
- else if (ControlType == CustomizeControlType.Dropdown && Options != null)
+ else if (ControlType == CustomizeControlType.Dropdown && GetOptions() is { } options)
{
- // Find matching option and apply all its bindings
- var option = Options.FirstOrDefault(o => Equals(o.Value, value));
+ // Find the matching declared option and apply all its bindings. The
+ // "Custom"/"Not set" fallback is never a declared option, so applying it
+ // is a safe no-op.
+ var option = options.FirstOrDefault(o => Equals(o.Value, value));
if (option?.Bindings is { Count: > 0 })
{
foreach (var binding in option.Bindings)
@@ -244,6 +322,10 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
protected string RecommendationPrefix => $"Customize.{OwnerKey}.{FeatureKey}.Recommendation";
+ /// <summary>
+ /// Returns the recommendation declared in the <see cref="CustomizeSettingAttribute"/>,
+ /// or <c>null</c> when the setting has none.
+ /// </summary>
public virtual CustomizeRecommendationResult? GetRecommendation()
{
var state = Meta.Recommendation;
@@ -316,6 +398,33 @@ public abstract class BaseCustomizeSetting : ICustomizeSetting
return strA != null && strB != null && strA.Equals(strB, StringComparison.Ordinal);
}
+ /// <summary>
+ /// Matches the live registry values against the declared options. When every
+ /// binding of an option matches, the option is returned; otherwise the raw value
+ /// of the primary binding is returned so out-of-scope values stay visible.
+ /// </summary>
+ private static (bool Matched, object? Value) ResolveDropdownValue(
+ IReadOnlyList<SettingOption> options
+ )
+ {
+ foreach (var option in options)
+ {
+ if (option.Bindings is not { Count: > 0 })
+ continue;
+
+ var allMatch = option.Bindings.All(b =>
+ {
+ var actual = RegistryService.Read<object>(new RegistryItem(b.Path, b.Name));
+ return ValuesEqual(actual, b.Value);
+ });
+
+ if (allMatch)
+ return (true, option.Value);
+ }
+
+ return (false, ReadPrimaryRawValue(options));
+ }
+
private static object? ReadPrimaryRawValue(IReadOnlyList<SettingOption> options)
{
// Read from the primary binding of the first option that has bindings
diff --git a/optimizerDuck/Domain/Customize/Models/SettingOption.cs b/optimizerDuck/Domain/Customize/Models/SettingOption.cs
index 9202da9..2a40528 100644
--- a/optimizerDuck/Domain/Customize/Models/SettingOption.cs
+++ b/optimizerDuck/Domain/Customize/Models/SettingOption.cs
@@ -7,8 +7,8 @@ public sealed record SettingOption(
)
{
/// <summary>
- /// Primary binding — the first binding in the list, or null.
- /// Used by base class for single-key auto-read/write.
+ /// The first binding in the list, or <c>null</c>. Used by the base class for
+ /// single-key auto-read/write.
/// </summary>
public RegistryBinding? PrimaryBinding => Bindings is { Count: > 0 } ? Bindings[0] : null;
}
diff --git a/optimizerDuck/Domain/Optimizations/Categories/AI.cs b/optimizerDuck/Domain/Optimizations/Categories/AI.cs
new file mode 100644
index 0000000..2e534ca
--- /dev/null
+++ b/optimizerDuck/Domain/Optimizations/Categories/AI.cs
@@ -0,0 +1,100 @@
+using System.Collections.ObjectModel;
+using Microsoft.Extensions.Logging;
+using optimizerDuck.Domain.Abstractions;
+using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
+using optimizerDuck.Domain.Optimizations.Models;
+using optimizerDuck.Domain.Optimizations.Models.Services;
+using optimizerDuck.Domain.UI;
+using optimizerDuck.Services.Configuration;
+using optimizerDuck.Services.Optimization.Providers;
+using optimizerDuck.UI.Pages.Optimize.Categories;
+
+namespace optimizerDuck.Domain.Optimizations.Categories;
+
+[OptimizationCategory(typeof(AIOptimizerPage))]
+public class AI : IOptimizationCategory
+{
+ public string Name => Loc.Instance[$"Optimizer.{nameof(AI)}"];
+ public OptimizationCategoryOrder Order { get; init; } = OptimizationCategoryOrder.AI;
+ public ObservableCollection<IOptimization> Optimizations { get; init; } = [];
+
+ [Optimization(
+ Id = "8462E718-42CA-4BE6-940C-3620BF52A533",
+ Risk = OptimizationRisk.Moderate,
+ Tags = OptimizationTags.Privacy | OptimizationTags.System | OptimizationTags.Windows11Only,
+ Condition = typeof(RecallInstalledCondition)
+ )]
+ public class DisableRecall : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ // DisableAIDataAnalysis stops new snapshots (and deletes existing ones);
+ // TurnOffSavingSnapshots mirrors the documented "Turn off saving snapshots"
+ // policy for broad build coverage; AllowRecallEnablement is device-scope only
+ // and removes the Recall bits on Windows 11 24H2+ (Build 26100.3915+).
+ RegistryService.Write(
+ new RegistryItem(
+ @"HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsAI",
+ "DisableAIDataAnalysis",
+ 1
+ ),
+ new RegistryItem(
+ @"HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsAI",
+ "AllowRecallEnablement",
+ 0
+ ),
+ new RegistryItem(
+ @"HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsAI",
+ "TurnOffSavingSnapshots",
+ 1
+ ),
+ new RegistryItem(
+ @"HKCU\Software\Policies\Microsoft\Windows\WindowsAI",
+ "DisableAIDataAnalysis",
+ 1
+ ),
+ new RegistryItem(
+ @"HKCU\Software\Policies\Microsoft\Windows\WindowsAI",
+ "TurnOffSavingSnapshots",
+ 1
+ )
+ );
+ context.Logger.LogInformation("Disabled Windows Recall AI snapshots");
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
+
+ [Optimization(
+ Id = "962C9960-6BFA-4FC5-97D9-BFE772426E39",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.Privacy | OptimizationTags.System | OptimizationTags.Windows11Only,
+ Condition = typeof(Windows11_24H2OrGreaterCondition)
+ )]
+ public class DisableClickToDo : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ RegistryService.Write(
+ new RegistryItem(
+ @"HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsAI",
+ "DisableClickToDo",
+ 1
+ ),
+ new RegistryItem(
+ @"HKCU\Software\Policies\Microsoft\Windows\WindowsAI",
+ "DisableClickToDo",
+ 1
+ )
+ );
+ context.Logger.LogInformation("Disabled Click To Do AI overlay");
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
+}
diff --git a/optimizerDuck/Domain/Optimizations/Categories/Gpu.cs b/optimizerDuck/Domain/Optimizations/Categories/Gpu.cs
deleted file mode 100644
index 82cd383..0000000
--- a/optimizerDuck/Domain/Optimizations/Categories/Gpu.cs
+++ /dev/null
@@ -1,273 +0,0 @@
-using System.Collections.ObjectModel;
-using Microsoft.Extensions.Logging;
-using optimizerDuck.Domain.Abstractions;
-using optimizerDuck.Domain.Attributes;
-using optimizerDuck.Domain.Optimizations.Models;
-using optimizerDuck.Domain.Optimizations.Models.Services;
-using optimizerDuck.Domain.UI;
-using optimizerDuck.Services.Configuration;
-using optimizerDuck.Services.Optimization.Providers;
-using optimizerDuck.Services.System;
-using optimizerDuck.UI.Pages.Optimize.Categories;
-
-namespace optimizerDuck.Domain.Optimizations.Categories;
-
-public abstract class GpuRegistryOptimization : BaseOptimization
-{
- protected abstract GpuVendor Vendor { get; }
-
- protected abstract IReadOnlyList<RegistryItem> CreateItems(string registryPath);
-
- public override Task<ApplyResult> ApplyAsync(
- IProgress<ProcessingProgress> progress,
- OptimizationContext context
- )
- {
- foreach (
- var gpu in context.Snapshot.Gpus.Where(g =>
- g.Vendor == Vendor && !string.IsNullOrEmpty(g.DeviceId)
- )
- )
- {
- if (!Gpu.TryParseDeviceIdToIndex(gpu.DeviceId, out var index))
- {
- context.Logger.LogWarning(
- "Invalid DeviceId for GPU {GpuName} ({DeviceId})",
- gpu.Name,
- gpu.DeviceId
- );
- continue;
- }
-
- var path =
- $@"HKLM\SYSTEM\CurrentControlSet\Control\Class\{{4d36e968-e325-11ce-bfc1-08002be10318}}\{index:D4}";
-
- RegistryService.Write(CreateItems(path).ToArray());
- context.Logger.LogInformation(
- "Applied {Optimization} for GPU {DeviceId}",
- GetType().Name,
- gpu.DeviceId
- );
- }
-
- return Task.FromResult(CompleteFromScope());
- }
-}
-
-[OptimizationCategory(typeof(GpuOptimizerPage))]
-public class Gpu : IOptimizationCategory
-{
- public string Name => Loc.Instance[$"Optimizer.{nameof(Gpu)}"];
- public OptimizationCategoryOrder Order { get; init; } = OptimizationCategoryOrder.Gpu;
- public ObservableCollection<IOptimization> Optimizations { get; init; } = [];
-
- /// <summary>
- /// Attempts to parse a WMI <c>DeviceID</c> (e.g., "VideoController1") into a zero-based registry index
- /// used in the Display Class registry path (e.g., "0000", "0001").
- /// </summary>
- /// <remarks>
- /// <para>
- /// Windows stores display adapter settings under:
- /// <c>HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\{4d36e968-e325-11ce-bfc1-08002be10318}\XXXX</c>
- /// where <c>XXXX</c> is a 4-digit zero-padded index (e.g., <c>0000</c>).
- /// </para>
- /// <para>
- /// The <see cref="Win32_VideoController" /> WMI class provides a <c>DeviceID</c> property in the format:
- /// <c>"VideoController1"</c>, <c>"VideoController2"</c>, etc. This method converts:
- /// <list type="bullet">
- /// <item>
- /// <description><c>"VideoController1"</c> → index <c>0</c> → registry subkey <c>"0000"</c></description>
- /// </item>
- /// <item>
- /// <description><c>"VideoController2"</c> → index <c>1</c> → registry subkey <c>"0001"</c></description>
- /// </item>
- /// </list>
- /// </para>
- /// <para>
- /// This mapping is <strong>required</strong> because the order of GPUs in <see cref="SystemSnapshot.Gpus" />
- /// does <strong>not</strong> guarantee alignment with registry index order. Using array index (0, 1, 2...)
- /// leads to applying tweaks to the wrong GPU (e.g., iGPU instead of dGPU).
- /// </para>
- /// </remarks>
- /// <param name="deviceId">
- /// The <c>DeviceID</c> string from <c>Win32_VideoController</c>, typically in the form
- /// <c>"VideoControllerN"</c> where <c>N</c> is a positive integer starting from 1.
- /// </param>
- /// <param name="index">
- /// When the method returns <c>true</c>, contains the zero-based index suitable for formatting with
- /// <c>:D4</c> (e.g., <c>0</c> → <c>"0000"</c>). When <c>false</c>, the value is <c>-1</c>.
- /// </param>
- /// <returns>
- /// <c>true</c> if <paramref name="deviceId" /> is valid and successfully parsed; otherwise, <c>false</c>.
- /// </returns>
- /// <example>
- /// <code>
- /// string deviceId = "VideoController1";
- /// if (TryParseDeviceIdToIndex(deviceId, out int index))
- /// {
- /// string regPath = $@"HKLM\...\{{4d36e968-...\}}\{index:D4}"; // → "0000"
- /// Console.WriteLine($"Apply tweak to GPU at registry index: {index:D4}");
- /// }
- /// </code>
- /// </example>
- /// <exception cref="ArgumentNullException">
- /// Thrown if <paramref name="deviceId" /> is <c>null</c> — but this method uses <c>string.IsNullOrWhiteSpace</c>
- /// and returns <c>false</c> instead for consistency with TryParse pattern.
- /// </exception>
- /// <seealso cref="GpuInfo.DeviceId" />
- /// <seealso href="https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/win32-videocontroller">
- /// Win32_VideoController WMI class
- /// </seealso>
- public static bool TryParseDeviceIdToIndex(string? deviceId, out int index)
- {
- index = -1;
- if (string.IsNullOrWhiteSpace(deviceId))
- return false;
-
- const string prefix = "VideoController";
- if (!deviceId.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
- return false;
-
- var numberPart = deviceId[prefix.Length..];
- if (!int.TryParse(numberPart, out var deviceNumber) || deviceNumber <= 0)
- return false;
-
- index = deviceNumber - 1; // convert to zero-based index
- return true;
- }
-
- [Optimization(
- Id = "4433CE93-B632-4D67-AE71-0241C31099C0",
- Risk = OptimizationRisk.Safe,
- Tags = OptimizationTags.Amd | OptimizationTags.Power
- )]
- public class AmdDisableUlps : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.AMD;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return [new RegistryItem(path, "EnableULPS", 0)];
- }
- }
-
- [Optimization(
- Id = "A3836587-C461-4BEB-9C4C-88493B36C138",
- Risk = OptimizationRisk.Moderate,
- Tags = OptimizationTags.Amd | OptimizationTags.Performance
- )]
- public class AmdDisablePowerGating : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.AMD;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return
- [
- new RegistryItem(path, "DisablePowerGating", 1),
- new RegistryItem(path, "PP_GPUPowerDownEnabled", 0),
- new RegistryItem(path, "DisableDynamicPstate", 1),
- ];
- }
- }
-
- [Optimization(
- Id = "DB379BB5-FC8C-4AD3-BE32-11BE09E76FBA",
- Risk = OptimizationRisk.Moderate,
- Tags = OptimizationTags.Amd | OptimizationTags.Performance
- )]
- public class AmdDisableVideoClockGating : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.AMD;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return
- [
- new RegistryItem(path, "DisableVCEPowerGating", 1),
- new RegistryItem(path, "DisableVceClockGating", 1),
- new RegistryItem(path, "EnableUvdClockGating", 0),
- new RegistryItem(path, "EnableVceSwClockGating", 0),
- ];
- }
- }
-
- [Optimization(
- Id = "8A4B4C4D-000E-42DB-8BD7-293067F8FAE7",
- Risk = OptimizationRisk.Safe,
- Tags = OptimizationTags.Amd | OptimizationTags.Latency
- )]
- public class AmdDisableAspm : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.AMD;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return
- [
- new RegistryItem(path, "EnableAspmL0s", 0),
- new RegistryItem(path, "EnableAspmL1", 0),
- ];
- }
- }
-
- [Optimization(
- Id = "FA58802F-B98C-4E98-AA67-067C5A394296",
- Risk = OptimizationRisk.Safe,
- Tags = OptimizationTags.Nvidia | OptimizationTags.Power
- )]
- public class NvidiaDisableDynamicPstate : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.NVIDIA;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return [new RegistryItem(path, "DisableDynamicPstate", 1)];
- }
- }
-
- [Optimization(
- Id = "9E7702BE-9E03-4C96-A316-C4E435CB993E",
- Risk = OptimizationRisk.Moderate,
- Tags = OptimizationTags.Nvidia | OptimizationTags.Performance
- )]
- public class NvidiaDisableAsyncPstates : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.NVIDIA;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return [new RegistryItem(path, "DisableASyncPstates", 1)];
- }
- }
-
- [Optimization(
- Id = "DF8739FF-E322-4958-B369-DF584BB9B0C1",
- Risk = OptimizationRisk.Safe,
- Tags = OptimizationTags.Intel | OptimizationTags.Latency
- )]
- public class IntelDisableAsyncFlips : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.Intel;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return [new RegistryItem(path, "Display1_DisableAsyncFlips", 1)];
- }
- }
-
- [Optimization(
- Id = "EBFB0DED-5D1A-4CD1-B5C0-4F7018DD6054",
- Risk = OptimizationRisk.Safe,
- Tags = OptimizationTags.Intel | OptimizationTags.Display
- )]
- public class IntelDisableAdaptiveVsync : GpuRegistryOptimization
- {
- protected override GpuVendor Vendor => GpuVendor.Intel;
-
- protected override IReadOnlyList<RegistryItem> CreateItems(string path)
- {
- return [new RegistryItem(path, "AdaptiveVsyncEnable", 0)];
- }
- }
-}
diff --git a/optimizerDuck/Domain/Optimizations/Categories/Performance.cs b/optimizerDuck/Domain/Optimizations/Categories/Performance.cs
index 0583ce8..7781cbe 100644
--- a/optimizerDuck/Domain/Optimizations/Categories/Performance.cs
+++ b/optimizerDuck/Domain/Optimizations/Categories/Performance.cs
@@ -53,7 +53,7 @@ public class Performance : IOptimizationCategory
Risk = OptimizationRisk.Moderate,
Tags = OptimizationTags.System | OptimizationTags.Performance | OptimizationTags.Ram
)]
- public class SvcHostSplit : BaseOptimization
+ public class ConsolidateServiceHosts : BaseOptimization
{
public override Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
@@ -85,7 +85,7 @@ public class Performance : IOptimizationCategory
)
);
context.Logger.LogInformation(
- "Enabled service host splitting with threshold: {ThresholdKB} KB",
+ "Consolidated service hosts with threshold: {ThresholdKB} KB",
context.Snapshot.Ram.TotalKB
);
return Task.FromResult(CompleteFromScope());
diff --git a/optimizerDuck/Domain/Optimizations/Categories/SecurityAndPrivacy.cs b/optimizerDuck/Domain/Optimizations/Categories/SecurityAndPrivacy.cs
index 00f8c56..7ca2d97 100644
--- a/optimizerDuck/Domain/Optimizations/Categories/SecurityAndPrivacy.cs
+++ b/optimizerDuck/Domain/Optimizations/Categories/SecurityAndPrivacy.cs
@@ -2,6 +2,7 @@ using System.Collections.ObjectModel;
using Microsoft.Extensions.Logging;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Optimizations.Models.Services;
using optimizerDuck.Domain.UI;
@@ -97,6 +98,16 @@ public class SecurityAndPrivacy : IOptimizationCategory
@"HKLM\SOFTWARE\Policies\Microsoft\Assistance\Client\1.0",
"NoActiveHelp",
1
+ ),
+ new RegistryItem(
+ @"HKCU\SOFTWARE\Microsoft\Speech_OneCore\Settings\OnlineSpeechPrivacy",
+ "HasAccepted",
+ 0
+ ),
+ new RegistryItem(
+ @"HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced",
+ "Start_TrackProgs",
+ 0
)
);
RegistryService.DeleteValue([
@@ -119,8 +130,7 @@ public class SecurityAndPrivacy : IOptimizationCategory
new ServiceItem(
"diagnosticshub.standardcollector.service",
ServiceStartupType.Disabled
- ),
- new ServiceItem("DusmSvc", ServiceStartupType.Disabled)
+ )
);
progress?.Report(
@@ -212,7 +222,7 @@ public class SecurityAndPrivacy : IOptimizationCategory
[Optimization(
Id = "B1C2D3E4-F5A6-4B7C-8D9E-0F1A2B3C4D5E",
Risk = OptimizationRisk.Safe,
- Tags = OptimizationTags.Privacy | OptimizationTags.Windows10Only | OptimizationTags.System
+ Tags = OptimizationTags.Privacy | OptimizationTags.System
)]
public class DisableAdvertisingAndSuggestions : BaseOptimization
{
@@ -258,16 +268,6 @@ public class SecurityAndPrivacy : IOptimizationCategory
"DisableThirdPartySuggestions",
1
),
- new RegistryItem(
- @"HKLM\SOFTWARE\Policies\Microsoft\Dsh",
- "AllowNewsAndInterests",
- 0
- ),
- new RegistryItem(
- @"HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer",
- "HideSCAMeetNow",
- 1
- ),
new RegistryItem(
@"HKCU\Software\Microsoft\Windows\CurrentVersion\UserProfileEngagement",
"ScoobeSystemSettingEnabled",
@@ -292,28 +292,69 @@ public class SecurityAndPrivacy : IOptimizationCategory
@"HKCU\Control Panel\International\User Profile",
"HttpAcceptLanguageOptOut",
1
- ),
+ )
+ );
+ // @formatter:on
+ context.Logger.LogInformation(
+ "Disabled advertising ID, consumer features and system suggestions"
+ );
+
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
+
+ [Optimization(
+ Id = "26F3AE39-4EAA-45D4-9375-B244159D5EB3",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.Privacy | OptimizationTags.System
+ )]
+ public class DisableNewsAndInterests : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ RegistryService.Write(
new RegistryItem(
- @"HKCU\Software\Microsoft\Windows\CurrentVersion\StorageSense\Parameters\StoragePolicy",
- "01",
+ @"HKLM\SOFTWARE\Policies\Microsoft\Dsh",
+ "AllowNewsAndInterests",
0
),
- /*new RegistryItem(
+ new RegistryItem(
@"HKCU\Software\Microsoft\Windows\CurrentVersion\Feeds",
"ShellFeedsTaskbarViewMode",
- 2
- ),*/
- new RegistryItem(
- @"HKCU\Software\Microsoft\Windows\CurrentVersion\StorageSense\Parameters\StoragePolicy",
- "02",
0
)
);
- // @formatter:on
- context.Logger.LogInformation(
- "Disabled advertising ID, consumer features and system suggestions"
+
+ context.Logger.LogInformation("Disabled News and Interests feed");
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
+
+ [Optimization(
+ Id = "6D217B90-0957-4861-B3F5-58ECF3E236EE",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.Privacy | OptimizationTags.Windows10Only | OptimizationTags.System,
+ Condition = typeof(Windows10Condition)
+ )]
+ public class HideMeetNowButton : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ RegistryService.Write(
+ new RegistryItem(
+ @"HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer",
+ "HideSCAMeetNow",
+ 1
+ )
);
+ context.Logger.LogInformation("Hidden Meet Now button from the taskbar");
return Task.FromResult(CompleteFromScope());
}
}
@@ -501,7 +542,10 @@ public class SecurityAndPrivacy : IOptimizationCategory
[Optimization(
Id = "6856782A-B530-4623-BD89-942D73FB82FD",
Risk = OptimizationRisk.Moderate,
- Tags = OptimizationTags.Privacy | OptimizationTags.System
+ Tags = OptimizationTags.Privacy
+ | OptimizationTags.System
+ | OptimizationTags.Windows10Only,
+ Condition = typeof(Windows10Condition)
)]
public class DisableCortana : BaseOptimization
{
@@ -536,11 +580,6 @@ public class SecurityAndPrivacy : IOptimizationCategory
"ConnectedSearchUseWeb",
0
),
- new RegistryItem(
- @"HKLM\SOFTWARE\Policies\Microsoft\Windows\Windows Search",
- "DisableWebSearch",
- 1
- ),
new RegistryItem(
@"HKCU\Software\Microsoft\Windows\CurrentVersion\Search",
"CortanaConsent",
@@ -563,7 +602,8 @@ public class SecurityAndPrivacy : IOptimizationCategory
Tags = OptimizationTags.Privacy
| OptimizationTags.System
| OptimizationTags.Windows11Only
- | OptimizationTags.Visual
+ | OptimizationTags.Visual,
+ Condition = typeof(Windows11Condition)
)]
public class DisableCopilot : BaseOptimization
{
@@ -588,30 +628,10 @@ public class SecurityAndPrivacy : IOptimizationCategory
"ShowCopilotButton",
0
),
- new RegistryItem(
- @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Shell\Copilot",
- "IsCopilotAvailable",
- 0
- ),
- new RegistryItem(
- @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Shell\Copilot",
- "CopilotDisabledReason",
- "IsEnabledForGeographicRegionFailed"
- ),
- new RegistryItem(
- @"HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsCopilot",
- "AllowCopilotRuntime",
- 0
- ),
new RegistryItem(
@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Shell Extensions\Blocked",
"{CB3B0003-8088-4EDE-8769-8B354AB2FF8C}",
""
- ),
- new RegistryItem(
- @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Shell\Copilot\BingChat",
- "IsUserEligible",
- 0
)
);
@@ -668,4 +688,55 @@ public class SecurityAndPrivacy : IOptimizationCategory
return Task.FromResult(CompleteFromScope());
}
}
+
+ [Optimization(
+ Id = "A4823C34-0BDD-4418-83A0-4968102D1771",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.Privacy | OptimizationTags.System
+ )]
+ public class DisableFindMyDevice : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ RegistryService.Write(
+ new RegistryItem(
+ @"HKLM\SOFTWARE\Policies\Microsoft\FindMyDevice",
+ "AllowFindMyDevice",
+ 0
+ )
+ );
+ context.Logger.LogInformation("Disabled Find My Device location tracking");
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
+
+ [Optimization(
+ Id = "6F242AD6-4717-4161-A7BF-A2AF5F0C9BDD",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.Network | OptimizationTags.Privacy
+ )]
+ public class DisableDeliveryOptimization : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ RegistryService.Write(
+ new RegistryItem(
+ @"HKLM\SOFTWARE\Policies\Microsoft\Windows\DeliveryOptimization",
+ "DODownloadMode",
+ 0
+ )
+ );
+ context.Logger.LogInformation(
+ "Disabled peer-to-peer Delivery Optimization sharing"
+ );
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
+
}
diff --git a/optimizerDuck/Domain/Optimizations/Categories/UserExperience.cs b/optimizerDuck/Domain/Optimizations/Categories/UserExperience.cs
index 20afdda..1a40a5d 100644
--- a/optimizerDuck/Domain/Optimizations/Categories/UserExperience.cs
+++ b/optimizerDuck/Domain/Optimizations/Categories/UserExperience.cs
@@ -2,6 +2,7 @@ using System.Collections.ObjectModel;
using Microsoft.Extensions.Logging;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Optimizations.Models.Services;
using optimizerDuck.Domain.UI;
@@ -102,4 +103,53 @@ public class UserExperience : IOptimizationCategory
return Task.FromResult(CompleteFromScope());
}
}
+
+ [Optimization(
+ Id = "31A6274C-AD37-4FFA-A32E-727FB71AD085",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.Privacy | OptimizationTags.Visual | OptimizationTags.Windows11Only,
+ Condition = typeof(Windows11Condition)
+ )]
+ public sealed class DisableStartRecommended : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ RegistryService.Write(
+ new RegistryItem(
+ @"HKEY_CURRENT_USER\SOFTWARE\Policies\Microsoft\Windows\Explorer",
+ "HideRecommendedSection",
+ 1
+ )
+ );
+ context.Logger.LogInformation("Disabled Recommended section in Start Menu");
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
+
+ [Optimization(
+ Id = "B36652B1-D094-4D39-BEB8-7961E6094A2E",
+ Risk = OptimizationRisk.Safe,
+ Tags = OptimizationTags.Visual | OptimizationTags.Privacy
+ )]
+ public sealed class DisableSettings365Ads : BaseOptimization
+ {
+ public override Task<ApplyResult> ApplyAsync(
+ IProgress<ProcessingProgress> progress,
+ OptimizationContext context
+ )
+ {
+ RegistryService.Write(
+ new RegistryItem(
+ @"HKLM\SOFTWARE\Policies\Microsoft\Windows\CloudContent",
+ "DisableConsumerAccountStateContent",
+ 1
+ )
+ );
+ context.Logger.LogInformation("Disabled Microsoft 365 ads in Settings");
+ return Task.FromResult(CompleteFromScope());
+ }
+ }
}
diff --git a/optimizerDuck/Domain/Optimizations/Models/BaseOptimization.cs b/optimizerDuck/Domain/Optimizations/Models/BaseOptimization.cs
index 00dd31c..76d25ff 100644
--- a/optimizerDuck/Domain/Optimizations/Models/BaseOptimization.cs
+++ b/optimizerDuck/Domain/Optimizations/Models/BaseOptimization.cs
@@ -1,6 +1,9 @@
+using System.ComponentModel;
using System.Reflection;
+using CommunityToolkit.Mvvm.ComponentModel;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Execution;
using optimizerDuck.Domain.UI;
using optimizerDuck.Resources.Languages;
@@ -15,8 +18,13 @@ namespace optimizerDuck.Domain.Optimizations.Models;
/// decorated with <see cref="OptimizationAttribute"/> to provide metadata. The category
/// (<see cref="OwnerType"/>) is assigned automatically during reflection-based discovery.
/// </summary>
-public abstract class BaseOptimization : IOptimization
+public abstract partial class BaseOptimization : ObservableObject, IOptimization
{
+ protected BaseOptimization()
+ {
+ _state.PropertyChanged += OnStateChanged;
+ }
+
#region Metadata
private OptimizationAttribute? _meta;
@@ -86,8 +94,37 @@ public abstract class BaseOptimization : IOptimization
/// <summary>Gets the collection of tag displays for the UI, derived from <see cref="OptimizationTags"/>.</summary>
public IEnumerable<OptimizationTagDisplay> TagDisplays => Meta.Tags.ToDisplays();
+ private OptimizationState _state = new();
+
/// <summary>Gets or sets the current applied state and timing information for this optimization.</summary>
- public OptimizationState State { get; set; } = new();
+ public OptimizationState State
+ {
+ get => _state;
+ set
+ {
+ if (ReferenceEquals(_state, value))
+ return;
+
+ // Re-subscribe so IsConditionBlocked stays in sync even when State is replaced.
+ _state.PropertyChanged -= OnStateChanged;
+ _state = value;
+ _state.PropertyChanged += OnStateChanged;
+ OnPropertyChanged(nameof(State));
+ OnPropertyChanged(nameof(IsConditionBlocked));
+ }
+ }
+
+ private void OnStateChanged(object? sender, PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName != nameof(OptimizationState.IsApplied))
+ return;
+
+ // Forward IsApplied mutations as a State change so external subscribers that
+ // listen to the optimization (not the nested State) stay in sync even when the
+ // State instance is swapped out later.
+ OnPropertyChanged(nameof(State));
+ OnPropertyChanged(nameof(IsConditionBlocked));
+ }
#endregion
@@ -110,6 +147,38 @@ public abstract class BaseOptimization : IOptimization
#endregion
+ #region Condition
+
+ /// <summary>
+ /// Gets the compatibility condition type declared in the <see cref="OptimizationAttribute"/>
+ /// (implementing <see cref="ICondition"/>), or <c>null</c> when always available.
+ /// </summary>
+ public Type? ConditionType => Meta.Condition;
+
+ /// <summary>Gets or sets the evaluated compatibility result.</summary>
+ [ObservableProperty]
+ [NotifyPropertyChangedFor(nameof(IsConditionBlocked))]
+ private ConditionResult _conditionResult = ConditionResult.Available;
+
+ /// <summary>
+ /// Gets or sets a value indicating that the user chose to hide the unsupported
+ /// state for this session and show the normal card instead. Not persisted.
+ /// </summary>
+ [ObservableProperty]
+ [NotifyPropertyChangedFor(nameof(IsConditionBlocked))]
+ private bool _isConditionHidden;
+
+ /// <summary>
+ /// Gets whether this optimization should be presented in the unsupported state.
+ /// The block only applies on first open when the item is <em>not</em> applied;
+ /// once applied (or hidden by the user) the normal card is shown.
+ /// </summary>
+ public bool IsConditionBlocked =>
+ ConditionResult.IsBlocking && !State.IsApplied && !IsConditionHidden;
+
+ #endregion
+
+ /// <inheritdoc />
public abstract Task<ApplyResult> ApplyAsync(
IProgress<ProcessingProgress> progress,
OptimizationContext context
@@ -125,34 +194,3 @@ public abstract class BaseOptimization : IOptimization
}
}
-/*
-using Microsoft.Extensions.Logging;
-using System.Collections.ObjectModel;
-using optimizerDuck.Domain.Abstractions;
-using optimizerDuck.Domain.Attributes;
-using optimizerDuck.Domain.Optimizations.Models;
-using optimizerDuck.Domain.UI;
-using optimizerDuck.Services.Managers;
-using optimizerDuck.UI.Pages.Optimizations;
-
-namespace optimizerDuck.Domain.Optimizations.Categories;
-
-[OptimizationCategory(typeof(PAGE))]
-public class OPTIMIZER : IOptimizationCategory
-{
- public string Name { get; init; } = Loc.Instance[$"Optimizer.{nameof(OPTIMIZER)}"];
- public OptimizationCategoryOrder Order { get; init; } = OptimizationCategoryOrder.OPTIMIZER_ORDER;
- public ObservableCollection<IOptimization> Optimizations { get; init; } = [];
-
- [Optimization(Id = "OPTIMIZATION_ID", Risk = OptimizationRisk.RISK,
- Tags = OptimizationTags.TAG)]
- public class OPTIMIZATION_NAME : BaseOptimization
- {
- public override Task<ApplyResult> ApplyAsync(IProgress<ProcessingProgress> progress, OptimizationContext context)
- {
- // ... Optimization logic here ...
- return Task.FromResult(ApplyResult.True());
- }
- }
-}
- */
diff --git a/optimizerDuck/Domain/UI/OptimizationCategoryOrder.cs b/optimizerDuck/Domain/UI/OptimizationCategoryOrder.cs
index 98282b7..55a1712 100644
--- a/optimizerDuck/Domain/UI/OptimizationCategoryOrder.cs
+++ b/optimizerDuck/Domain/UI/OptimizationCategoryOrder.cs
@@ -11,9 +11,6 @@ public enum OptimizationCategoryOrder
/// <summary>Security and privacy optimizations.</summary>
SecurityAndPrivacy,
- /// <summary>GPU-specific optimizations.</summary>
- Gpu,
-
/// <summary>Power management optimizations.</summary>
Power,
@@ -22,4 +19,7 @@ public enum OptimizationCategoryOrder
/// <summary>User experience and visual optimizations.</summary>
UserExperience,
+
+ /// <summary>AI-related optimizations.</summary>
+ AI,
}
diff --git a/optimizerDuck/Domain/UI/OptimizationTags.cs b/optimizerDuck/Domain/UI/OptimizationTags.cs
index cfba43d..ef4a58d 100644
--- a/optimizerDuck/Domain/UI/OptimizationTags.cs
+++ b/optimizerDuck/Domain/UI/OptimizationTags.cs
@@ -32,11 +32,6 @@ public enum OptimizationTags
Network = 1 << 3,
NetworkRequired = 1 << 4,
- // GPU Vendors
- Nvidia = 1 << 10,
- Amd = 1 << 11,
- Intel = 1 << 12,
-
// User Experience
Audio = 1 << 8,
Visual = 1 << 9,
@@ -142,24 +137,6 @@ public static class OptimizationTagsToDisplay
Display = Translations.Optimizer_UI_Tags_NetworkRequired,
},
- OptimizationTags.Nvidia => new OptimizationTagDisplay
- {
- Icon = SymbolRegular.VideoClip24,
- Display = Translations.Optimizer_UI_Tags_Nvidia,
- },
-
- OptimizationTags.Amd => new OptimizationTagDisplay
- {
- Icon = SymbolRegular.VideoClip24,
- Display = Translations.Optimizer_UI_Tags_Amd,
- },
-
- OptimizationTags.Intel => new OptimizationTagDisplay
- {
- Icon = SymbolRegular.VideoClip24,
- Display = Translations.Optimizer_UI_Tags_Intel,
- },
-
OptimizationTags.Audio => new OptimizationTagDisplay
{
Icon = SymbolRegular.Headphones24,
diff --git a/optimizerDuck/Resources/Languages/Translations.Designer.cs b/optimizerDuck/Resources/Languages/Translations.Designer.cs
index d55ac90..1c9797c 100644
--- a/optimizerDuck/Resources/Languages/Translations.Designer.cs
+++ b/optimizerDuck/Resources/Languages/Translations.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
@@ -582,6 +582,222 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to This item only works on systems with an AMD processor..
+ /// </summary>
+ internal static string Condition_Cpu_Amd_Description {
+ get {
+ return ResourceManager.GetString("Condition.Cpu.Amd.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to AMD CPU required.
+ /// </summary>
+ internal static string Condition_Cpu_Amd_Title {
+ get {
+ return ResourceManager.GetString("Condition.Cpu.Amd.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item only works on systems with an Intel processor..
+ /// </summary>
+ internal static string Condition_Cpu_Intel_Description {
+ get {
+ return ResourceManager.GetString("Condition.Cpu.Intel.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Intel CPU required.
+ /// </summary>
+ internal static string Condition_Cpu_Intel_Title {
+ get {
+ return ResourceManager.GetString("Condition.Cpu.Intel.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to optimizerDuck could not determine whether this item is supported on your system..
+ /// </summary>
+ internal static string Condition_Error_Description {
+ get {
+ return ResourceManager.GetString("Condition.Error.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Compatibility check failed.
+ /// </summary>
+ internal static string Condition_Error_Title {
+ get {
+ return ResourceManager.GetString("Condition.Error.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item only works on systems with an AMD graphics card..
+ /// </summary>
+ internal static string Condition_Gpu_Amd_Description {
+ get {
+ return ResourceManager.GetString("Condition.Gpu.Amd.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to AMD GPU required.
+ /// </summary>
+ internal static string Condition_Gpu_Amd_Title {
+ get {
+ return ResourceManager.GetString("Condition.Gpu.Amd.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item only works on systems with an Intel graphics card..
+ /// </summary>
+ internal static string Condition_Gpu_Intel_Description {
+ get {
+ return ResourceManager.GetString("Condition.Gpu.Intel.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Intel GPU required.
+ /// </summary>
+ internal static string Condition_Gpu_Intel_Title {
+ get {
+ return ResourceManager.GetString("Condition.Gpu.Intel.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item only works on systems with an NVIDIA graphics card..
+ /// </summary>
+ internal static string Condition_Gpu_Nvidia_Description {
+ get {
+ return ResourceManager.GetString("Condition.Gpu.Nvidia.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to NVIDIA GPU required.
+ /// </summary>
+ internal static string Condition_Gpu_Nvidia_Title {
+ get {
+ return ResourceManager.GetString("Condition.Gpu.Nvidia.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item requires at least 16 GB of installed RAM..
+ /// </summary>
+ internal static string Condition_Ram_16_Description {
+ get {
+ return ResourceManager.GetString("Condition.Ram.16.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to 16 GB RAM required.
+ /// </summary>
+ internal static string Condition_Ram_16_Title {
+ get {
+ return ResourceManager.GetString("Condition.Ram.16.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Windows Recall requires Windows 11 24H2 or later with the Windows AI components installed..
+ /// </summary>
+ internal static string Condition_Recall_Description {
+ get {
+ return ResourceManager.GetString("Condition.Recall.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Windows Recall not available.
+ /// </summary>
+ internal static string Condition_Recall_Title {
+ get {
+ return ResourceManager.GetString("Condition.Recall.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item requires Windows 10..
+ /// </summary>
+ internal static string Condition_Windows10_Description {
+ get {
+ return ResourceManager.GetString("Condition.Windows10.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Windows 10 required.
+ /// </summary>
+ internal static string Condition_Windows10_Title {
+ get {
+ return ResourceManager.GetString("Condition.Windows10.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item requires Windows 11 24H2 (build 26100) or later..
+ /// </summary>
+ internal static string Condition_Windows11_24H2_Description {
+ get {
+ return ResourceManager.GetString("Condition.Windows11_24H2.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Windows 11 24H2 or newer required.
+ /// </summary>
+ internal static string Condition_Windows11_24H2_Title {
+ get {
+ return ResourceManager.GetString("Condition.Windows11_24H2.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This item requires Windows 11..
+ /// </summary>
+ internal static string Condition_Windows11_Description {
+ get {
+ return ResourceManager.GetString("Condition.Windows11.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Windows 11 required.
+ /// </summary>
+ internal static string Condition_Windows11_Title {
+ get {
+ return ResourceManager.GetString("Condition.Windows11.Title", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Custom.
+ /// </summary>
+ internal static string Customize_CustomOption {
+ get {
+ return ResourceManager.GetString("Customize.CustomOption", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Not set.
+ /// </summary>
+ internal static string Customize_CustomOption_NotSet {
+ get {
+ return ResourceManager.GetString("Customize.CustomOption.NotSet", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Personalize Windows settings and everyday behavior..
/// </summary>
@@ -772,7 +988,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Disabling background recording stops DVR from silently capturing gameplay, saving CPU and disk write cycles..
+ /// Looks up a localized string similar to The Background Recording feature captures gameplay in the background, which can use CPU resources and create disk writes..
/// </summary>
internal static string Customize_Gaming_BackgroundRecording_Recommendation_Reason {
get {
@@ -790,7 +1006,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Applies Windows' fullscreen optimizations, which can improve compatibility for some games..
+ /// Looks up a localized string similar to Applies Windows&apos; fullscreen optimizations, which can improve compatibility for some games..
/// </summary>
internal static string Customize_Gaming_FullscreenOptimizations_Description {
get {
@@ -835,7 +1051,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Disabling Game Bar frees up system resources and prevents background overlays from interfering with your games..
+ /// Looks up a localized string similar to The Xbox Game Bar feature provides overlays and background gaming tools that may use system resources..
/// </summary>
internal static string Customize_Gaming_GameBar_Recommendation_Reason {
get {
@@ -916,7 +1132,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Disabling acceleration gives you raw, linear mouse input for better aim precision and muscle memory consistency..
+ /// Looks up a localized string similar to The Mouse Acceleration feature changes cursor movement based on speed; raw linear input can improve aim consistency..
/// </summary>
internal static string Customize_Gaming_MouseAcceleration_Recommendation_Reason {
get {
@@ -1123,7 +1339,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Disabling sync notifications stops OneDrive pop-ups from interrupting file browsing in Explorer..
+ /// Looks up a localized string similar to The Explorer Sync Notifications feature controls OneDrive and cloud-sync pop-ups while browsing files..
/// </summary>
internal static string Customize_Preferences_ExplorerSyncNotifications_Recommendation_Reason {
get {
@@ -1141,7 +1357,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Launch to &quot;This PC&quot;.
+ /// Looks up a localized string similar to File Explorer Startup Location.
/// </summary>
internal static string Customize_Preferences_LaunchToThisPc_Name {
get {
@@ -1149,6 +1365,24 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Quick Access.
+ /// </summary>
+ internal static string Customize_Preferences_LaunchToThisPc_Options_QuickAccess {
+ get {
+ return ResourceManager.GetString("Customize.Preferences.LaunchToThisPc.Options.QuickAccess", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to This PC.
+ /// </summary>
+ internal static string Customize_Preferences_LaunchToThisPc_Options_ThisPc {
+ get {
+ return ResourceManager.GetString("Customize.Preferences.LaunchToThisPc.Options.ThisPc", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Preferences.
/// </summary>
@@ -1249,7 +1483,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Show File Extensions.
+ /// Looks up a localized string similar to File Extensions.
/// </summary>
internal static string Customize_Preferences_ShowFileExtensions_Name {
get {
@@ -1258,7 +1492,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Showing file extensions makes it easy to spot suspicious file types and prevents malware from hiding behind fake icons..
+ /// Looks up a localized string similar to File extensions make suspicious file types easier to spot and prevent malware from hiding behind misleading icons..
/// </summary>
internal static string Customize_Preferences_ShowFileExtensions_Recommendation_Reason {
get {
@@ -1276,7 +1510,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Show Hidden Files.
+ /// Looks up a localized string similar to Hidden Files.
/// </summary>
internal static string Customize_Preferences_ShowHiddenFiles_Name {
get {
@@ -1285,7 +1519,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Hidden files contain system and config data you may need to manage; showing them gives you full visibility of your system..
+ /// Looks up a localized string similar to Hidden files contain system and configuration data that may be needed for administration and troubleshooting..
/// </summary>
internal static string Customize_Preferences_ShowHiddenFiles_Recommendation_Reason {
get {
@@ -1312,7 +1546,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Shows or hides the Snap Layouts menu when you hover over a window's maximize button..
+ /// Looks up a localized string similar to Shows or hides the Snap Layouts menu when you hover over a window&apos;s maximize button..
/// </summary>
internal static string Customize_Preferences_SnapAssistFlyout_Description {
get {
@@ -1348,7 +1582,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Turning off system suggestions stops Windows from recommending apps and settings you did not ask for..
+ /// Looks up a localized string similar to The System Suggestions feature controls Windows recommendations for apps and settings..
/// </summary>
internal static string Customize_Preferences_SystemSuggestions_Recommendation_Reason {
get {
@@ -1474,7 +1708,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Turning off widgets removes the background web service that fetches news and weather, reducing idle network and memory usage..
+ /// Looks up a localized string similar to The Widgets feature can fetch news and weather in the background, which may increase idle network and memory usage..
/// </summary>
internal static string Customize_Preferences_TaskbarWidgets_Recommendation_Reason {
get {
@@ -1528,7 +1762,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Allow All Trusted Apps.
+ /// Looks up a localized string similar to Trusted Apps.
/// </summary>
internal static string Customize_SystemFeatures_AllowAllTrustedApps_Name {
get {
@@ -1681,7 +1915,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Show Battery Percentage.
+ /// Looks up a localized string similar to Battery Percentage.
/// </summary>
internal static string Customize_SystemFeatures_ShowBatteryPercentage_Name {
get {
@@ -1698,6 +1932,33 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Not supported.
+ /// </summary>
+ internal static string Customize_UI_UnsupportedSettings_Badge {
+ get {
+ return ResourceManager.GetString("Customize.UI.UnsupportedSettings.Badge", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Some settings are unavailable on your current system..
+ /// </summary>
+ internal static string Customize_UI_UnsupportedSettings_Description {
+ get {
+ return ResourceManager.GetString("Customize.UI.UnsupportedSettings.Description", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Unsupported Settings ({0}).
+ /// </summary>
+ internal static string Customize_UI_UnsupportedSettings_Header {
+ get {
+ return ResourceManager.GetString("Customize.UI.UnsupportedSettings.Header", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Join my Discord community to... get support or play games with me.
/// </summary>
@@ -2726,210 +2987,156 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Bloatware &amp; Services.
- /// </summary>
- internal static string Optimizer_BloatwareAndServices {
- get {
- return ResourceManager.GetString("Optimizer.BloatwareAndServices", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to Optimize System Services.
- /// </summary>
- internal static string Optimizer_BloatwareAndServices_ConfigureServices_Name {
- get {
- return ResourceManager.GetString("Optimizer.BloatwareAndServices.ConfigureServices.Name", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to Setting startup type for {0} to {1}....
- /// </summary>
- internal static string Optimizer_BloatwareAndServices_ConfigureServices_Progress_ChangeServiceStartupType {
- get {
- return ResourceManager.GetString("Optimizer.BloatwareAndServices.ConfigureServices.Progress.ChangeServiceStartupTyp" +
- "e", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to Adjusts non-essential background services to free up resources while maintaining all necessary Windows functionality..
- /// </summary>
- internal static string Optimizer_BloatwareAndServices_ConfigureServices_ShortDescription {
- get {
- return ResourceManager.GetString("Optimizer.BloatwareAndServices.ConfigureServices.ShortDescription", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to Block Preinstalled Bloatware.
- /// </summary>
- internal static string Optimizer_BloatwareAndServices_DisablePreinstalledApps_Name {
- get {
- return ResourceManager.GetString("Optimizer.BloatwareAndServices.DisablePreinstalledApps.Name", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to Prevents Windows from automatically re-installing unwanted third-party apps and promoted software..
- /// </summary>
- internal static string Optimizer_BloatwareAndServices_DisablePreinstalledApps_ShortDescription {
- get {
- return ResourceManager.GetString("Optimizer.BloatwareAndServices.DisablePreinstalledApps.ShortDescription", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to GPU.
+ /// Looks up a localized string similar to AI.
/// </summary>
- internal static string Optimizer_Gpu {
+ internal static string Optimizer_AI {
get {
- return ResourceManager.GetString("Optimizer.Gpu", resourceCulture);
+ return ResourceManager.GetString("Optimizer.AI", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable AMD ASPM.
+ /// Looks up a localized string similar to Disable Click To Do.
/// </summary>
- internal static string Optimizer_Gpu_AmdDisableAspm_Name {
+ internal static string Optimizer_AI_DisableClickToDo_Name {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisableAspm.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.AI.DisableClickToDo.Name", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets EnableAspmL0s=0, EnableAspmL1=0 to disable Active State Power Management on AMD GPUs, reducing PCIe bus latency. Increases slot power consumption..
+ /// Looks up a localized string similar to Turns off the AI-powered Click To Do overlay that analyzes text and images on your screen..
/// </summary>
- internal static string Optimizer_Gpu_AmdDisableAspm_ShortDescription {
+ internal static string Optimizer_AI_DisableClickToDo_ShortDescription {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisableAspm.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.AI.DisableClickToDo.ShortDescription", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable AMD Power Gating.
+ /// Looks up a localized string similar to Disable Windows Recall.
/// </summary>
- internal static string Optimizer_Gpu_AmdDisablePowerGating_Name {
+ internal static string Optimizer_AI_DisableRecall_Name {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisablePowerGating.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.AI.DisableRecall.Name", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1 to prevent AMD GPU power state transitions. Maintains consistent clocks at cost of higher idle power..
+ /// Looks up a localized string similar to Disables the Windows Recall AI feature that captures and indexes snapshots of your screen. Also removes the Recall component and deletes previously saved snapshots on Windows 11 24H2+ (Build 26100.3915+); a restart is required to take effect..
/// </summary>
- internal static string Optimizer_Gpu_AmdDisablePowerGating_ShortDescription {
+ internal static string Optimizer_AI_DisableRecall_ShortDescription {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisablePowerGating.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.AI.DisableRecall.ShortDescription", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable AMD ULPS.
+ /// Looks up a localized string similar to Bloatware &amp; Services.
/// </summary>
- internal static string Optimizer_Gpu_AmdDisableUlps_Name {
+ internal static string Optimizer_BloatwareAndServices {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisableUlps.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.BloatwareAndServices", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets EnableULPS=0 in AMD GPU registry to prevent Ultra Low Power State wake-up delays and multi-monitor issues. Reduces power saving on idle..
+ /// Looks up a localized string similar to Optimize System Services.
/// </summary>
- internal static string Optimizer_Gpu_AmdDisableUlps_ShortDescription {
+ internal static string Optimizer_BloatwareAndServices_ConfigureServices_Name {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisableUlps.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.BloatwareAndServices.ConfigureServices.Name", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable AMD Video Clock Gating.
+ /// Looks up a localized string similar to Setting startup type for {0} to {1}....
/// </summary>
- internal static string Optimizer_Gpu_AmdDisableVideoClockGating_Name {
+ internal static string Optimizer_BloatwareAndServices_ConfigureServices_Progress_ChangeServiceStartupType {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisableVideoClockGating.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.BloatwareAndServices.ConfigureServices.Progress.ChangeServiceStartupTyp" +
+ "e", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0 for AMD video engines (VCE/UVD) to improve encode/decode stability. Increases video playback power..
+ /// Looks up a localized string similar to Adjusts non-essential background services to free up resources while maintaining all necessary Windows functionality..
/// </summary>
- internal static string Optimizer_Gpu_AmdDisableVideoClockGating_ShortDescription {
+ internal static string Optimizer_BloatwareAndServices_ConfigureServices_ShortDescription {
get {
- return ResourceManager.GetString("Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.BloatwareAndServices.ConfigureServices.ShortDescription", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable Intel Adaptive V-Sync.
+ /// Looks up a localized string similar to Block Preinstalled Bloatware.
/// </summary>
- internal static string Optimizer_Gpu_IntelDisableAdaptiveVsync_Name {
+ internal static string Optimizer_BloatwareAndServices_DisablePreinstalledApps_Name {
get {
- return ResourceManager.GetString("Optimizer.Gpu.IntelDisableAdaptiveVsync.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.BloatwareAndServices.DisablePreinstalledApps.Name", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets AdaptiveVsyncEnable=0 to disable Intel&apos;s adaptive V-Sync that dynamically adjusts to frame rate, using fixed V-Sync instead for stable timing..
+ /// Looks up a localized string similar to Prevents Windows from automatically re-installing unwanted third-party apps and promoted software..
/// </summary>
- internal static string Optimizer_Gpu_IntelDisableAdaptiveVsync_ShortDescription {
+ internal static string Optimizer_BloatwareAndServices_DisablePreinstalledApps_ShortDescription {
get {
- return ResourceManager.GetString("Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.BloatwareAndServices.DisablePreinstalledApps.ShortDescription", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable Intel Async Flips.
+ /// Looks up a localized string similar to Not supported on this system.
/// </summary>
- internal static string Optimizer_Gpu_IntelDisableAsyncFlips_Name {
+ internal static string Optimizer_Condition_BlockedTitle {
get {
- return ResourceManager.GetString("Optimizer.Gpu.IntelDisableAsyncFlips.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.Condition.BlockedTitle", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets Display1_DisableAsyncFlips=1 to force synchronous buffer flips on Intel iGPU, reducing input-to-display latency and screen tearing..
+ /// Looks up a localized string similar to Condition failed.
/// </summary>
- internal static string Optimizer_Gpu_IntelDisableAsyncFlips_ShortDescription {
+ internal static string Optimizer_Condition_FailedTitle {
get {
- return ResourceManager.GetString("Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.Condition.FailedTitle", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable NVIDIA Async P-States.
+ /// Looks up a localized string similar to Hide.
/// </summary>
- internal static string Optimizer_Gpu_NvidiaDisableAsyncPstates_Name {
+ internal static string Optimizer_Condition_Hide {
get {
- return ResourceManager.GetString("Optimizer.Gpu.NvidiaDisableAsyncPstates.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.Condition.Hide", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets DisableASyncPstates=1 to prevent NVIDIA asynchronous power state switching, providing deterministic performance for VR/real-time apps..
+ /// Looks up a localized string similar to Show this optimization again and allow applying it anyway..
/// </summary>
- internal static string Optimizer_Gpu_NvidiaDisableAsyncPstates_ShortDescription {
+ internal static string Optimizer_Condition_Hide_Tooltip {
get {
- return ResourceManager.GetString("Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.Condition.Hide.Tooltip", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Disable NVIDIA Dynamic P-State.
+ /// Looks up a localized string similar to What is this?.
/// </summary>
- internal static string Optimizer_Gpu_NvidiaDisableDynamicPstate_Name {
+ internal static string Optimizer_Condition_WhatIsThis {
get {
- return ResourceManager.GetString("Optimizer.Gpu.NvidiaDisableDynamicPstate.Name", resourceCulture);
+ return ResourceManager.GetString("Optimizer.Condition.WhatIsThis", resourceCulture);
}
}
/// <summary>
- /// Looks up a localized string similar to Sets DisableDynamicPstate=1 to lock NVIDIA GPU into fixed performance state, preventing clock speed fluctuations. Increases idle power draw..
+ /// Looks up a localized string similar to Compatibility conditions check whether an item is supported on your system, e.g. which Windows version or which GPU is installed. When a condition fails, the item is hidden by default because it may not work. If you know what you are doing, you can hide this warning and apply the item anyway..
/// </summary>
- internal static string Optimizer_Gpu_NvidiaDisableDynamicPstate_ShortDescription {
+ internal static string Optimizer_Condition_WhatIsThis_Tooltip {
get {
- return ResourceManager.GetString("Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription", resourceCulture);
+ return ResourceManager.GetString("Optimizer.Condition.WhatIsThis.Tooltip", resourceCulture);
}
}
@@ -2996,6 +3203,33 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Invalid RAM: {0}.
+ /// </summary>
+ internal static string Optimizer_Performance_ConsolidateServiceHosts_Error_InvalidRAM {
+ get {
+ return ResourceManager.GetString("Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Consolidate Service Hosts.
+ /// </summary>
+ internal static string Optimizer_Performance_ConsolidateServiceHosts_Name {
+ get {
+ return ResourceManager.GetString("Optimizer.Performance.ConsolidateServiceHosts.Name", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Raises the Service Host split threshold to total system RAM, keeping services consolidated in fewer processes to reduce memory overhead and process count..
+ /// </summary>
+ internal static string Optimizer_Performance_ConsolidateServiceHosts_ShortDescription {
+ get {
+ return ResourceManager.GetString("Optimizer.Performance.ConsolidateServiceHosts.ShortDescription", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Disable Accessibility Keyboard Hotkeys.
/// </summary>
@@ -3086,33 +3320,6 @@ namespace optimizerDuck.Resources.Languages {
}
}
- /// <summary>
- /// Looks up a localized string similar to Invalid RAM: {0}.
- /// </summary>
- internal static string Optimizer_Performance_SvcHostSplit_Error_InvalidRAM {
- get {
- return ResourceManager.GetString("Optimizer.Performance.SvcHostSplit.Error.InvalidRAM", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to Optimize Service Isolation.
- /// </summary>
- internal static string Optimizer_Performance_SvcHostSplit_Name {
- get {
- return ResourceManager.GetString("Optimizer.Performance.SvcHostSplit.Name", resourceCulture);
- }
- }
-
- /// <summary>
- /// Looks up a localized string similar to Sets the Service Host split threshold to match total system RAM, forcing Windows to isolate services into separate processes for improved stability..
- /// </summary>
- internal static string Optimizer_Performance_SvcHostSplit_ShortDescription {
- get {
- return ResourceManager.GetString("Optimizer.Performance.SvcHostSplit.ShortDescription", resourceCulture);
- }
- }
-
/// <summary>
/// Looks up a localized string similar to Power Management.
/// </summary>
@@ -3295,7 +3502,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Stops non-essential system event logging to reduce continuous disk activity and save CPU cycles..
+ /// Looks up a localized string similar to Stops non-essential WMI/ETW AutoLogger sessions (Diagtrack-Listener, SQMLogger, etc.) from starting at boot to reduce background disk and CPU activity. Note: security software may flag AutoLogger changes as they alter diagnostic tracing..
/// </summary>
internal static string Optimizer_SecurityAndPrivacy_DisableAutoLogger_ShortDescription {
get {
@@ -3349,7 +3556,7 @@ namespace optimizerDuck.Resources.Languages {
}
/// <summary>
- /// Looks up a localized string similar to Turns off the Cortana voice assistant and removes Bing web results from the Windows Search bar..
+ /// Looks up a localized string similar to Turns off the Cortana voice assistant and disables cloud search and web results in Windows Search (Windows 10 only)..
/// </summary>
internal static string Optimizer_SecurityAndPrivacy_DisableCortana_ShortDescription {
get {
@@ -3357,6 +3564,24 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Disable Delivery Optimization (P2P).
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_DisableDeliveryOptimization_Name {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.DisableDeliveryOptimization.Name", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Stops Windows from sharing or downloading update files from other PCs over peer-to-peer, so updates only come from Microsoft servers..
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_DisableDeliveryOptimization_ShortDescription {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.DisableDeliveryOptimization.ShortDescription", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Disable Error Reporting.
/// </summary>
@@ -3375,6 +3600,24 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Disable Find My Device.
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_DisableFindMyDevice_Name {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.DisableFindMyDevice.Name", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Disables the Find My Device feature that periodically reports your device&apos;s location to Microsoft..
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_DisableFindMyDevice_ShortDescription {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.DisableFindMyDevice.ShortDescription", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Disable Location and Sensors.
/// </summary>
@@ -3393,6 +3636,24 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Disable News &amp; Interests.
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_DisableNewsAndInterests_Name {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.Name", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Turns off the News and Interests feed and hides its taskbar button (Windows 10), and disables the Widgets board (Windows 11)..
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_DisableNewsAndInterests_ShortDescription {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Disable Data Collection (Telemetry).
/// </summary>
@@ -3438,6 +3699,24 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Hide Meet Now Button.
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_HideMeetNowButton_Name {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.HideMeetNowButton.Name", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Hides the Meet Now (Skype) button from the taskbar notification area. Windows 10 only..
+ /// </summary>
+ internal static string Optimizer_SecurityAndPrivacy_HideMeetNowButton_ShortDescription {
+ get {
+ return ResourceManager.GetString("Optimizer.SecurityAndPrivacy.HideMeetNowButton.ShortDescription", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to This value reflects the level of intervention and the safety of the optimization process. Please exercise caution and consider carefully before applying any optimization..
/// </summary>
@@ -3474,15 +3753,6 @@ namespace optimizerDuck.Resources.Languages {
}
}
- /// <summary>
- /// Looks up a localized string similar to AMD.
- /// </summary>
- internal static string Optimizer_UI_Tags_Amd {
- get {
- return ResourceManager.GetString("Optimizer.UI.Tags.Amd", resourceCulture);
- }
- }
-
/// <summary>
/// Looks up a localized string similar to Audio.
/// </summary>
@@ -3519,15 +3789,6 @@ namespace optimizerDuck.Resources.Languages {
}
}
- /// <summary>
- /// Looks up a localized string similar to Intel.
- /// </summary>
- internal static string Optimizer_UI_Tags_Intel {
- get {
- return ResourceManager.GetString("Optimizer.UI.Tags.Intel", resourceCulture);
- }
- }
-
/// <summary>
/// Looks up a localized string similar to Latency.
/// </summary>
@@ -3555,15 +3816,6 @@ namespace optimizerDuck.Resources.Languages {
}
}
- /// <summary>
- /// Looks up a localized string similar to NVIDIA.
- /// </summary>
- internal static string Optimizer_UI_Tags_Nvidia {
- get {
- return ResourceManager.GetString("Optimizer.UI.Tags.Nvidia", resourceCulture);
- }
- }
-
/// <summary>
/// Looks up a localized string similar to Performance.
/// </summary>
@@ -3654,6 +3906,24 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Disable Microsoft 365 Ads in Settings.
+ /// </summary>
+ internal static string Optimizer_UserExperience_DisableSettings365Ads_Name {
+ get {
+ return ResourceManager.GetString("Optimizer.UserExperience.DisableSettings365Ads.Name", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Removes the Microsoft 365 and Copilot promotional content from the Settings Home page..
+ /// </summary>
+ internal static string Optimizer_UserExperience_DisableSettings365Ads_ShortDescription {
+ get {
+ return ResourceManager.GetString("Optimizer.UserExperience.DisableSettings365Ads.ShortDescription", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Disable Start Menu Web Search.
/// </summary>
@@ -3672,6 +3942,24 @@ namespace optimizerDuck.Resources.Languages {
}
}
+ /// <summary>
+ /// Looks up a localized string similar to Hide Recommended Section in Start.
+ /// </summary>
+ internal static string Optimizer_UserExperience_DisableStartRecommended_Name {
+ get {
+ return ResourceManager.GetString("Optimizer.UserExperience.DisableStartRecommended.Name", resourceCulture);
+ }
+ }
+
+ /// <summary>
+ /// Looks up a localized string similar to Hides the Recommended section from the Start menu to reduce clutter and stop recent files and apps from being shown..
+ /// </summary>
+ internal static string Optimizer_UserExperience_DisableStartRecommended_ShortDescription {
+ get {
+ return ResourceManager.GetString("Optimizer.UserExperience.DisableStartRecommended.ShortDescription", resourceCulture);
+ }
+ }
+
/// <summary>
/// Looks up a localized string similar to Disable Visual Effects.
/// </summary>
diff --git a/optimizerDuck/Resources/Languages/Translations.ar-SA.resx b/optimizerDuck/Resources/Languages/Translations.ar-SA.resx
index d8bed6a..41e913f 100644
--- a/optimizerDuck/Resources/Languages/Translations.ar-SA.resx
+++ b/optimizerDuck/Resources/Languages/Translations.ar-SA.resx
@@ -1010,6 +1010,9 @@
<data name="Optimizations.Loading.Hint" xml:space="preserve">
<value>يُرجى الانتظار...</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>يعطل ميزة الذكاء الاصطناعي Windows Recall التي تلتقط لقطات شاشة وتفهرسها. كما يزيل مكوّن Recall ويحذف اللقطات المحفوظة مسبقًا؛ يلزم إعادة تشغيل الجهاز حتى يسري التغيير.</value>
+ </data>
<data name="Optimizer.BloatwareAndServices" xml:space="preserve">
<value>التطبيقات والخدمات</value>
</data>
@@ -1028,57 +1031,6 @@
<data name="Optimizer.BloatwareAndServices.DisablePreinstalledApps.ShortDescription" xml:space="preserve">
<value>يمنع ويندوز من إعادة تثبيت تطبيقات الطرف الثالث غير المرغوبة والبرامج المروَّجة تلقائيًا.</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>معالج الرسومات</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>تعطيل ‎ASPM‎ لكروت ‎AMD‎</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>يضبط ‎EnableAspmL0s=0, EnableAspmL1=0‎ لتعطيل إدارة طاقة الحالة النشطة (ASPM) على كروت ‎AMD‎، ما يقلل زمن استجابة ناقل ‎PCIe‎. يزيد استهلاك الطاقة في المنفذ.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>تعطيل ‎Power Gating‎ لكروت ‎AMD‎</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>يضبط ‎DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1‎ لمنع انتقالات حالة الطاقة في كروت ‎AMD‎. يحافظ على ترددات ثابتة مقابل استهلاك أعلى في الخمول.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>تعطيل ‎ULPS‎ لكروت ‎AMD‎</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>يضبط ‎EnableULPS=0‎ في ريجستري كرت ‎AMD‎ لمنع تأخير الاستيقاظ من حالة الطاقة فائقة الانخفاض (ULPS) ومشاكل الشاشات المتعددة. يقلل توفير الطاقة أثناء الخمول.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>تعطيل ‎Video Clock Gating‎ لكروت ‎AMD‎</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>يضبط ‎DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0‎ لمحركات الفيديو في ‎AMD‎ (‎VCE/UVD‎) لتحسين استقرار الترميز وفك الترميز. يزيد استهلاك الطاقة أثناء تشغيل الفيديو.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>تعطيل ‎Adaptive V-Sync‎ لكروت ‎Intel‎</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>يضبط ‎AdaptiveVsyncEnable=0‎ لتعطيل التزامن الرأسي التكيّفي في ‎Intel‎ الذي يتغيّر حسب معدل الإطارات، ويستخدم تزامنًا ثابتًا بدلًا منه لتوقيت مستقر.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>تعطيل ‎Async Flips‎ لكروت ‎Intel‎</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>يضبط ‎Display1_DisableAsyncFlips=1‎ لفرض تبديل المخازن المتزامن على كرت ‎Intel‎ المدمج، ما يقلل زمن الاستجابة وتمزّق الصورة.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>تعطيل ‎Async P-States‎ لكروت ‎NVIDIA‎</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>يضبط ‎DisableASyncPstates=1‎ لمنع التبديل غير المتزامن لحالات الطاقة في ‎NVIDIA‎، ما يوفر أداءً ثابتًا لتطبيقات الواقع الافتراضي والزمن الحقيقي.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>تعطيل ‎Dynamic P-State‎ لكروت ‎NVIDIA‎</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>يضبط ‎DisableDynamicPstate=1‎ لتثبيت كرت ‎NVIDIA‎ على حالة أداء ثابتة ومنع تذبذب الترددات. يزيد استهلاك الطاقة في الخمول.</value>
- </data>
<data name="Optimizer.Menu.ApplyAll" xml:space="preserve">
<value>تطبيق الكل</value>
</data>
@@ -1130,14 +1082,14 @@
<data name="Optimizer.Performance.ProcessPriority.ShortDescription" xml:space="preserve">
<value>يخصص موارد معالج أكثر للتطبيق الذي تستخدمه حاليًا لتجربة أسرع وأكثر استجابة.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>قيمة ذاكرة غير صالحة: {0}</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>تحسين عزل الخدمات</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>دمج مضيفات الخدمات</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>يضبط عتبة تقسيم ‎Service Host‎ لتطابق إجمالي ذاكرة النظام، ما يجبر ويندوز على عزل الخدمات في عمليات منفصلة لتحسين الاستقرار.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>يرفع حد تقسيم مضيف الخدمة إلى إجمالي ذاكرة النظام، مما يبقي الخدمات مجمعة في عدد أقل من العمليات لتقليل استهلاك الذاكرة وعدد العمليات.</value>
</data>
<data name="Optimizer.PowerManagement" xml:space="preserve">
<value>إدارة الطاقة</value>
@@ -1200,7 +1152,7 @@
<value>تعطيل التسجيل في الخلفية</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>يوقف تسجيل أحداث النظام غير الضرورية لتقليل نشاط القرص المستمر وتوفير دورات المعالج.</value>
+ <value>يمنع جلسات WMI/ETW AutoLogger غير الأساسية (Diagtrack-Listener وSQMLogger وغيرها) من البدء عند الإقلاع لتقليل نشاط القرص ووحدة المعالجة المركزية في الخلفية. ملاحظة: قد تشير برامج الأمان إلى تغييرات AutoLogger لأنها تعدّل تتبع التشخيص.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableContentDeliveryManager.Name" xml:space="preserve">
<value>تعطيل المحتوى السحابي</value>
@@ -1218,7 +1170,7 @@
<value>تعطيل ‎Cortana‎ والبحث على الويب</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>يوقف المساعد الصوتي ‎Cortana‎ ويزيل نتائج ‎Bing‎ من شريط بحث ويندوز.</value>
+ <value>يوقف المساعد الصوتي Cortana ويعطل البحث السحابي ونتائج الويب في بحث Windows (لنظام Windows 10 فقط).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableErrorReporting.Name" xml:space="preserve">
<value>تعطيل تقارير الأخطاء</value>
@@ -1231,6 +1183,9 @@
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableLocationAndSensors.ShortDescription" xml:space="preserve">
<value>يعطّل تتبّع الموقع ومستشعرات النظام وتحديثات الخرائط دون اتصال.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>يوقف موجز الأخبار والاهتمامات ويخفي زرّه في شريط المهام (Windows 10)، ويعطل لوحة الأدوات (Windows 11).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableTelemetry.Name" xml:space="preserve">
<value>تعطيل جمع البيانات (Telemetry)</value>
@@ -1259,9 +1214,6 @@
<data name="Optimizer.UI.Risk.Safe" xml:space="preserve">
<value>آمن</value>
</data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
<data name="Optimizer.UI.Tags.Audio" xml:space="preserve">
<value>الصوت</value>
</data>
@@ -1274,9 +1226,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>تشير هذه الوسوم إلى أجزاء النظام التي سيؤثر عليها التحسين.</value>
</data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Latency" xml:space="preserve">
<value>زمن الاستجابة</value>
</data>
@@ -1286,9 +1235,6 @@
<data name="Optimizer.UI.Tags.NetworkRequired" xml:space="preserve">
<value>يتطلب اتصالًا بالإنترنت</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
<data name="Optimizer.UI.Tags.Performance" xml:space="preserve">
<value>الأداء</value>
</data>
@@ -1853,3 +1799,4 @@
<value>ادعم المشروع</value>
</data>
</root>
+
diff --git a/optimizerDuck/Resources/Languages/Translations.de-DE.resx b/optimizerDuck/Resources/Languages/Translations.de-DE.resx
index 32de2f2..e2f1d77 100644
--- a/optimizerDuck/Resources/Languages/Translations.de-DE.resx
+++ b/optimizerDuck/Resources/Languages/Translations.de-DE.resx
@@ -124,6 +124,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Dashboard</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Deaktiviert die Windows-Recall-KI-Funktion, die Bildschirm-Schnappschüsse erfasst und indiziert. Entfernt außerdem die Recall-Komponente und löscht zuvor gespeicherte Schnappschüsse; ein Neustart ist erforderlich, damit die Änderung wirksam wird.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Deaktiviert den Feed „Nachrichten und Interessen“ und blendet dessen Taskleistenschaltfläche aus (Windows 10) und deaktiviert die Widgets-Leiste (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Dashboard</value>
</data>
@@ -274,8 +280,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Tags</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Setzt den Service-Host-Aufteilungsschwellenwert passend zum gesamten Arbeitsspeicher, sodass Windows Dienste zur besseren Stabilität in separate Prozesse isoliert.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Erhöht die Aufteilungsschwelle des Service Host auf den gesamten Systemspeicher, sodass Dienste in weniger Prozessen gebündelt bleiben, was Speicherverbrauch und Prozessanzahl reduziert.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Der aktuell aktive Energiesparplan konnte nicht erkannt werden.</value>
@@ -313,15 +319,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Diese Tags zeigen an, welche Teile des Systems von der Optimierung betroffen sind.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Energie</value>
</data>
@@ -613,10 +610,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Verhindert, dass inaktive Anwendungen im Hintergrund laufen, um RAM freizugeben und CPU-Overhead zu reduzieren.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Dienstisolation optimieren</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Service-Hosts konsolidieren</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>Ungültiger RAM: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -713,13 +710,13 @@
<value>Hintergrundprotokollierung deaktivieren</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Stoppt nicht essenzielle Systemereignisprotokollierung, um fortlaufende Datenträgeraktivität und CPU-Zyklen zu reduzieren.</value>
+ <value>Verhindert, dass nicht unbedingt erforderliche WMI/ETW-AutoLogger-Sitzungen (Diagtrack-Listener, SQMLogger usw.) beim Start ausgeführt werden, um Hintergrundaktivitäten auf Datenträger und CPU zu reduzieren. Hinweis: Sicherheitssoftware kann AutoLogger-Änderungen melden, da diese die Diagnoseablaufverfolgung verändern.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Cortana &amp; Websuche deaktivieren</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Deaktiviert den Cortana-Sprachassistenten und entfernt Bing-Webresultate aus der Windows-Suchleiste.</value>
+ <value>Schaltet den Cortana-Sprachassistenten aus und deaktiviert die Cloud-Suche und Webergebnisse in der Windows-Suche (nur Windows 10).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Windows Copilot deaktivieren</value>
@@ -760,9 +757,6 @@
<data name="Optimizer.UI.Tags.Windows11Only" xml:space="preserve">
<value>Nur Windows 11</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Benutzererfahrung</value>
</data>
@@ -784,54 +778,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Deaktiviert Taskleistenanimationen, ListView-Schatten, Fenstertransparenz und Aero Peek, um GPU/CPU-Ressourcen für bessere Leistung freizugeben.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>AMD ULPS deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Setzt EnableULPS=0 in der AMD-GPU-Registry, um Aufwachverzögerungen durch den Ultra Low Power State und Multi-Monitor-Probleme zu verhindern. Reduziert das Energiesparen im Leerlauf.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>AMD Power Gating deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Setzt DisablePowerGating=1, PP_GPUPowerDownEnabled=0 und DisableDynamicPstate=1, um Wechsel der AMD-GPU-Energiezustände zu verhindern. Hält konstante Taktraten auf Kosten höherer Leerlaufleistung.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>AMD Video Clock Gating deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Setzt DisableVCEPowerGating=1, DisableVceClockGating=1 und EnableUvdClockGating=0 für AMD-Videoengines (VCE/UVD), um die Encode/Decode-Stabilität zu verbessern. Erhöht den Stromverbrauch bei Videowiedergabe.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>AMD ASPM deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Setzt EnableAspmL0s=0 und EnableAspmL1=0, um Active State Power Management bei AMD-GPUs zu deaktivieren und PCIe-Buslatenz zu reduzieren. Erhöht die Leistungsaufnahme des Slots.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>NVIDIA Dynamic P-State deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Setzt DisableDynamicPstate=1, um die NVIDIA-GPU in einem festen Leistungszustand zu halten und Taktschwankungen zu verhindern. Erhöht den Stromverbrauch im Leerlauf.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>NVIDIA Async P-States deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Setzt DisableASyncPstates=1, um asynchrone NVIDIA-Energiezustandswechsel zu verhindern und deterministische Leistung für VR-/Echtzeit-Apps zu bieten.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Intel Async Flips deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Setzt Display1_DisableAsyncFlips=1, um synchrone Buffer-Flips auf Intel-iGPUs zu erzwingen und Eingabe-bis-Anzeige-Latenz sowie Screen Tearing zu reduzieren.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Intel Adaptive V-Sync deaktivieren</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Setzt AdaptiveVsyncEnable=0, um Intels adaptives V-Sync zu deaktivieren, das sich dynamisch an die Bildrate anpasst, und stattdessen festes V-Sync für stabiles Timing zu verwenden.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Taskleiste</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.es-ES.resx b/optimizerDuck/Resources/Languages/Translations.es-ES.resx
index e1c8c74..acca353 100644
--- a/optimizerDuck/Resources/Languages/Translations.es-ES.resx
+++ b/optimizerDuck/Resources/Languages/Translations.es-ES.resx
@@ -66,6 +66,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Panel</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Desactiva la función de IA Windows Recall, que captura e indexa instantáneas de la pantalla. También elimina el componente Recall y borra las instantáneas guardadas anteriormente; es necesario reiniciar para que surta efecto.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Desactiva el feed de Noticias e intereses y oculta su botón de la barra de tareas (Windows 10) y deshabilita el panel de Widgets (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Panel</value>
</data>
@@ -216,8 +222,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Etiquetas</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Establece el umbral de división del Host de servicio para que coincida con la RAM total del sistema, obligando a Windows a aislar los servicios en procesos separados para mejorar la estabilidad.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Eleva el umbral de división del host de servicios al total de RAM del sistema, manteniendo los servicios consolidados en menos procesos para reducir el uso de memoria y el número de procesos.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>No se pudo detectar el plan de energia activo.</value>
@@ -255,15 +261,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Estas etiquetas indican qué partes del sistema afectará la optimización.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Energia</value>
</data>
@@ -555,10 +552,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Evita que las aplicaciones inactivas se ejecuten en segundo plano para liberar RAM y reducir el consumo de CPU.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Optimizar aislamiento de servicios</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Consolidar hosts de servicios</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>RAM no válida: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -655,13 +652,13 @@
<value>Desactivar Registros en Segundo Plano</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Detiene el registro de eventos del sistema no esenciales para reducir la actividad continua en el disco y ahorrar ciclos de CPU.</value>
+ <value>Impide que las sesiones WMI/ETW AutoLogger no esenciales (Diagtrack-Listener, SQMLogger, etc.) se inicien al arrancar para reducir la actividad de disco y CPU en segundo plano. Nota: el software de seguridad puede marcar los cambios de AutoLogger, ya que alteran el seguimiento de diagnóstico.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Desactivar Cortana y Búsqueda Web</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Desactiva el asistente de voz Cortana y elimina los resultados web de Bing en la barra de búsqueda de Windows.</value>
+ <value>Desactiva el asistente de voz Cortana y deshabilita la búsqueda en la nube y los resultados web en la búsqueda de Windows (solo Windows 10).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Desactivar Windows Copilot</value>
@@ -696,9 +693,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Visual</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Experiencia de Usuario</value>
</data>
@@ -714,54 +708,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Desactiva las animaciones de la barra de tareas, sombras de listas y transparencia para liberar recursos de CPU/GPU.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>Desactivar AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Evita los retrasos al despertar del Estado de Ultra Bajo Consumo (ULPS) y problemas con múltiples monitores. Reduce el ahorro de energía en inactividad.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>Desactivar Control de Energía AMD</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Evita las transiciones de estado de energía en la GPU AMD, manteniendo frecuencias consistentes a costa de un mayor consumo.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>Desactivar Control de Reloj de Video AMD</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Desactiva el control de energía de los motores de video AMD (VCE/UVD) para mejorar la estabilidad de codificación/decodificación.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>Desactivar ASPM AMD</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Desactiva el Active State Power Management (ASPM) en GPUs AMD, reduciendo la latencia del bus PCIe.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>Desactivar P-State Dinámico NVIDIA</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Bloquea la GPU NVIDIA en un estado de rendimiento fijo, evitando fluctuaciones de frecuencia. Aumenta el consumo inactivo.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>Desactivar P-States Asíncronos NVIDIA</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Previene el cambio asíncrono de estado de energía, proporcionando un rendimiento determinista en aplicaciones en tiempo real y RV.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Desactivar Volteos Asíncronos Intel</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Fuerza volteos de búfer síncronos en la iGPU de Intel, reduciendo el desgarro de pantalla (tearing) y la latencia.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Desactivar V-Sync Adaptativo Intel</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Desactiva el V-Sync adaptativo de Intel para usar V-Sync fijo, asegurando una tasa de fotogramas estable.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Barra de Tareas</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.fr-FR.resx b/optimizerDuck/Resources/Languages/Translations.fr-FR.resx
index 8955d8e..7adb7d1 100644
--- a/optimizerDuck/Resources/Languages/Translations.fr-FR.resx
+++ b/optimizerDuck/Resources/Languages/Translations.fr-FR.resx
@@ -67,6 +67,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Tableau de bord</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Désactive la fonctionnalité IA Windows Recall, qui capture et indexe des instantanés de votre écran. Supprime également le composant Recall et les instantanés précédemment enregistrés ; un redémarrage est nécessaire pour que la modification prenne effet.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Désactive le flux Actualités et centres d'intérêt et masque son bouton dans la barre des tâches (Windows 10) et désactive le panneau de widgets (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Tableau de bord</value>
</data>
@@ -217,8 +223,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Étiquettes</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Définit le seuil de séparation du Service Host en fonction de la RAM totale du système, forçant Windows à isoler les services dans des processus séparés pour une meilleure stabilité.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Élève le seuil de fractionnement de l'hôte de services à la RAM totale du système, ce qui maintient les services regroupés dans moins de processus pour réduire l'utilisation de la mémoire et le nombre de processus.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Impossible de détecter le plan d'alimentation actif.</value>
@@ -256,15 +262,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Ces étiquettes indiquent les parties du système qui seront affectées par l'optimisation.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Alimentation</value>
</data>
@@ -556,10 +553,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Empêche les applications inactives de s'exécuter en arrière-plan afin de libérer de la RAM et réduire la charge processeur.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Optimiser l'isolation des services</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Consolider les hôtes de services</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>RAM invalide : {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -656,13 +653,13 @@
<value>Désactiver la journalisation en arrière-plan</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Arrête la journalisation non essentielle des événements système pour réduire l'activité disque continue et économiser des cycles processeur.</value>
+ <value>Empêche les sessions WMI/ETW AutoLogger non essentielles (Diagtrack-Listener, SQMLogger, etc.) de démarrer au démarrage afin de réduire l'activité disque et processeur en arrière-plan. Remarque : les logiciels de sécurité peuvent signaler les modifications d'AutoLogger, car elles modifient le suivi de diagnostic.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Désactiver Cortana &amp; la recherche web</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Désactive l'assistant vocal Cortana et supprime les résultats web Bing de la barre de recherche Windows.</value>
+ <value>Désactive l'assistant vocal Cortana et désactive la recherche cloud et les résultats web dans la recherche Windows (Windows 10 uniquement).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Désactiver Windows Copilot</value>
@@ -697,9 +694,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Visuel</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Expérience utilisateur</value>
</data>
@@ -715,54 +709,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Désactive les animations de la barre des tâches, les ombres, la transparence des fenêtres et l'aperçu Aero pour libérer des ressources GPU/CPU et améliorer les performances.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>Désactiver AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Définit EnableULPS=0 dans le registre du GPU AMD pour éviter les délais de réveil en Ultra Low Power State et les problèmes multi-écrans. Réduit les économies d'énergie au repos.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>Désactiver AMD Power Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Définit DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1 pour éviter les transitions d'état d'alimentation du GPU AMD. Maintient des fréquences stables au détriment d'une consommation plus élevée au repos.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>Désactiver AMD Video Clock Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Définit DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0 pour les moteurs vidéo AMD (VCE/UVD) afin d'améliorer la stabilité de l'encodage/décodage. Augmente la consommation lors de la lecture vidéo.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>Désactiver AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Définit EnableAspmL0s=0, EnableAspmL1=0 pour désactiver la gestion ASPM sur les GPU AMD, réduisant la latence du bus PCIe. Augmente la consommation du slot.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>Désactiver NVIDIA Dynamic P-State</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Définit DisableDynamicPstate=1 pour verrouiller le GPU NVIDIA dans un état de performance fixe, évitant les fluctuations de fréquence. Augmente la consommation au repos.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>Désactiver NVIDIA Async P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Définit DisableASyncPstates=1 pour empêcher les changements d'état d'alimentation asynchrones du GPU NVIDIA, offrant des performances déterministes pour la VR et les applications temps réel.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Désactiver Intel Async Flips</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Définit Display1_DisableAsyncFlips=1 pour forcer des basculements de tampon synchrones sur l'iGPU Intel, réduisant la latence d'entrée-affichage et les déchirures d'écran.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Désactiver Intel Adaptive V-Sync</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Définit AdaptiveVsyncEnable=0 pour désactiver la synchronisation verticale adaptative d'Intel qui s'ajuste dynamiquement à la fréquence d'images, utilisant une V-Sync fixe à la place pour un timing stable.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Barre des tâches</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.he-IL.resx b/optimizerDuck/Resources/Languages/Translations.he-IL.resx
index 8c11560..7e957d3 100644
--- a/optimizerDuck/Resources/Languages/Translations.he-IL.resx
+++ b/optimizerDuck/Resources/Languages/Translations.he-IL.resx
@@ -124,6 +124,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>לוח בקרה</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>משבית את תכונת הבינה המלאכותית Windows Recall, הלוכדת ומבנה אינדקס של צילומי מסך. כמו כן מסיר את רכיב Recall ומוחק צילומים שנשמרו בעבר; נדרשת הפעלה מחדש כדי שהשינוי ייכנס לתוקף.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>מכבה את עדכון החדשות והעניינים ומסתיר את הכפתור שלו בשורת המשימות (Windows 10), ומשבית את לוח הווידג'טים (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>לוח בקרה</value>
</data>
@@ -274,8 +280,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>תגיות</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>מגדיר את סף הפיצול של Service Host כך שיתאים לכלל זיכרון ה-RAM במערכת, ומאלץ את Windows לבודד שירותים לתהליכים נפרדים לשיפור היציבות.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>מעלה את סף פיצול מארח השירותים לסך הזיכרון של המערכת, ושומר על שירותים מאוחדים בפחות תהליכים כדי להפחית את צריכת הזיכרון ואת מספר התהליכים.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>זיהוי תוכנית צריכת החשמל הפעילה הנוכחית נכשל.</value>
@@ -313,15 +319,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>תגיות אלה מציינות אילו חלקים במערכת יושפעו מהמיטוב.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>צריכת חשמל</value>
</data>
@@ -613,10 +610,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>מונע מאפליקציות לא פעילות לרוץ ברקע כדי לפנות זיכרון RAM ולהפחית עומס על המעבד.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>מיטוב בידוד שירותים</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>איחוד מארחי שירותים</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>זיכרון RAM לא תקין: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -713,13 +710,13 @@
<value>השבתת רישום פעילות ברקע</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>עוצר רישום אירועי מערכת לא חיוני כדי להפחית פעילות דיסק מתמשכת ולחסוך במחזורי מעבד.</value>
+ <value>מונע הפעלת מושבי WMI/ETW AutoLogger שאינם חיוניים (Diagtrack-Listener, SQMLogger וכו') בעת האתחול כדי להפחית פעילות דיסק ומעבד ברקע. הערה: תוכנת אבטחה עשויה לסמן שינויים ב-AutoLogger מכיוון שהם משנים את מעקב האבחון.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>השבתת Cortana וחיפוש באינטרנט</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>מכבה את עוזרת הקול Cortana ומסיר את תוצאות האינטרנט של Bing משורת החיפוש של Windows.</value>
+ <value>מכבה את העוזרת הקולית Cortana ומשבית חיפוש ענן ותוצאות אינטרנט בחיפוש Windows (Windows 10 בלבד).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>השבתת Windows Copilot</value>
@@ -760,9 +757,6 @@
<data name="Optimizer.UI.Tags.Windows11Only" xml:space="preserve">
<value>Windows 11 בלבד</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>מעבד גרפי (GPU)</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>חוויית משתמש</value>
</data>
@@ -784,54 +778,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>משבית אנימציות של שורת המשימות, צללים ברשימות, שקיפות חלונות ו-Aero Peek כדי לפנות משאבי מעבד גרפי/מעבד לשיפור הביצועים.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>השבתת AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>מגדיר EnableULPS=0 ברישום של מעבד גרפי AMD כדי למנוע השהיות התעוררות ממצב Ultra Low Power ובעיות ריבוי מסכים. מפחית חיסכון בחשמל במצב סרק.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>השבתת AMD Power Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>מגדיר DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1 כדי למנוע מעברי מצב חשמל של מעבד גרפי AMD. שומר על תדרים עקביים במחיר צריכת חשמל גבוהה יותר בסרק.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>השבתת AMD Video Clock Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>מגדיר DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0 עבור מנועי הווידאו של AMD‏ (VCE/UVD) לשיפור יציבות הקידוד/פענוח. מגדיל את צריכת החשמל בהפעלת וידאו.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>השבתת AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>מגדיר EnableAspmL0s=0, EnableAspmL1=0 כדי להשבית ניהול צריכת חשמל לפי מצב פעיל (ASPM) במעבדים גרפיים של AMD, ומפחית את השהיית אפיק ה-PCIe. מגדיל את צריכת החשמל של החריץ.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>השבתת NVIDIA Dynamic P-State</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>מגדיר DisableDynamicPstate=1 כדי לנעול את המעבד הגרפי של NVIDIA למצב ביצועים קבוע ולמנוע תנודות במהירות השעון. מגדיל את צריכת החשמל בסרק.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>השבתת NVIDIA Async P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>מגדיר DisableASyncPstates=1 כדי למנוע החלפת מצבי חשמל אסינכרונית של NVIDIA, ומספק ביצועים דטרמיניסטיים לאפליקציות VR/זמן-אמת.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>השבתת Intel Async Flips</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>מגדיר Display1_DisableAsyncFlips=1 כדי לאלץ החלפות מאגר סינכרוניות במעבד הגרפי המשולב של Intel, ומפחית את ההשהיה מקלט לתצוגה וקרעי מסך.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>השבתת Intel Adaptive V-Sync</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>מגדיר AdaptiveVsyncEnable=0 כדי להשבית את ה-V-Sync המסתגל של Intel שמתאים את עצמו דינמית לקצב הפריימים, ומשתמש ב-V-Sync קבוע במקום לתזמון יציב.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>שורת המשימות</value>
</data>
@@ -1841,7 +1787,7 @@
<data name="Customize.Preferences.TaskbarLastActiveClick.Description" xml:space="preserve">
<value>פותח את החלון האחרון שהיה בשימוש באפליקציה בעת לחיצה על הסמל שלה בשורת המשימות.</value>
</data>
-<data name="Customize.SystemFeatures.ShowBatteryPercentage.Name" xml:space="preserve">
+ <data name="Customize.SystemFeatures.ShowBatteryPercentage.Name" xml:space="preserve">
<value>אחוז הסוללה</value>
</data>
<data name="Customize.SystemFeatures.ShowBatteryPercentage.Description" xml:space="preserve">
diff --git a/optimizerDuck/Resources/Languages/Translations.ja-JP.resx b/optimizerDuck/Resources/Languages/Translations.ja-JP.resx
index c43674c..7adee6c 100644
--- a/optimizerDuck/Resources/Languages/Translations.ja-JP.resx
+++ b/optimizerDuck/Resources/Languages/Translations.ja-JP.resx
@@ -65,6 +65,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>ダッシュボード</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>画面のスナップショットをキャプチャしてインデックス化する Windows Recall AI 機能を無効にします。また、Recall コンポーネントを削除し、以前に保存されたスナップショットを削除します。有効にするには再起動が必要です。</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>ニュースと関心事項フィードをオフにしてタスクバー ボタンを非表示にし (Windows 10)、ウィジェット ボードを無効にします (Windows 11)。</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>ダッシュボード</value>
</data>
@@ -215,8 +221,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>タグ</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Service Host の分割しきい値をシステム RAM の合計に合わせ、Windows がサービスを個別プロセスに分離して安定性を向上させます</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>サービス ホストの分割しきい値をシステムの合計 RAM に引き上げ、サービスをより少ないプロセスに統合したままにすることで、メモリ使用量とプロセス数を削減します。</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>現在のアクティブな電源プランを検出できませんでした</value>
@@ -254,15 +260,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>これらのタグは、最適化がシステムのどの部分に影響するかを示します</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA 向け</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD 向け</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel 向け</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>電源</value>
</data>
@@ -554,10 +551,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>非アクティブなアプリケーションがバックグラウンドで実行されないようにして RAM を解放し、CPU オーバーヘッドを削減します</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>サービス分離を最適化</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>サービス ホストの統合</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>無効な RAM: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -654,13 +651,13 @@
<value>バックグラウンド ロギングを無効化</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>非必須のシステム イベント ロギングを停止して、継続的なディスク アクティビティを削減し CPU サイクルを節約します</value>
+ <value>必須ではない WMI/ETW AutoLogger セッション (Diagtrack-Listener、SQMLogger など) が起動時に開始されないようにして、バックグラウンドのディスクと CPU のアクティビティを削減します。注: AutoLogger の変更は診断トレースを変更するため、セキュリティ ソフトウェアが警告する可能性があります。</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Cortana と Web 検索を無効化</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Cortana 音声アシスタントをオフにし、Windows 検索バーから Bing Web 結果を削除します</value>
+ <value>Cortana 音声アシスタントをオフにし、Windows 検索のクラウド検索と Web 結果を無効にします (Windows 10 のみ)。</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Windows Copilot を無効化</value>
@@ -695,9 +692,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>ビジュアル</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>グラフィックス</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>ユーザー エクスペリエンス</value>
</data>
@@ -713,54 +707,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>タスクバー アニメーション、リスト ビューの影、ウィンドウの透明度、Aero Peek を無効化して GPU/CPU リソースを解放し、パフォーマンスを向上させます</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>AMD ULPS を無効化</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>AMD GPU レジストリで EnableULPS=0 を設定し、Ultra Low Power State のウェイクアップ遅延とマルチモニター問題を防ぎます。アイドル時の省電力は減少します</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>AMD パワー ゲーティングを無効化</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>DisablePowerGating=1、PP_GPUPowerDownEnabled=0、DisableDynamicPstate=1 を設定して AMD GPU の電源状態遷移を防ぎます。アイドル電力は増加しますが、クロックは安定します</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>AMD ビデオ クロック ゲーティングを無効化</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>AMD ビデオ エンジン (VCE/UVD) に DisableVCEPowerGating=1、DisableVceClockGating=1、EnableUvdClockGating=0 を設定してエンコード/デコードの安定性を向上します。ビデオ再生時の電力消費が増加します</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>AMD ASPM を無効化</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>EnableAspmL0s=0、EnableAspmL1=0 を設定して AMD GPU の Active State Power Management を無効化し、PCIe バスの遅延を削減します。スロットの電力消費が増加します</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>NVIDIA Dynamic P-State を無効化</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>DisableDynamicPstate=1 を設定して NVIDIA GPU を固定パフォーマンス状態にロックし、クロック速度の変動を防ぎます。アイドル時の電力消費が増加します</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>NVIDIA Async P-State を無効化</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>DisableASyncPstates=1 を設定して NVIDIA の非同期電源状態切り替えを防ぎ、VR/リアルタイム アプリに決定論的なパフォーマンスを提供します</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Intel Async Flip を無効化</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Display1_DisableAsyncFlips=1 を設定して Intel iGPU で同期バッファ フリップを強制し、入力から表示までの遅延と画面のちらつきを削減します</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Intel Adaptive V-Sync を無効化</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>AdaptiveVsyncEnable=0 を設定して、フレーム レートに動的に調整される Intel の Adaptive V-Sync を無効化し、安定したタイミングのため固定 V-Sync を使用します</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>タスクバー</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.ko-KR.resx b/optimizerDuck/Resources/Languages/Translations.ko-KR.resx
index 1a19d25..0874e57 100644
--- a/optimizerDuck/Resources/Languages/Translations.ko-KR.resx
+++ b/optimizerDuck/Resources/Languages/Translations.ko-KR.resx
@@ -65,6 +65,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>대시보드</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>화면 스냅샷을 캡처하고 인덱싱하는 Windows Recall AI 기능을 사용하지 않도록 설정합니다. 또한 Recall 구성 요소를 제거하고 이전에 저장된 스냅샷을 삭제합니다. 적용하려면 다시 시작해야 합니다.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>뉴스 및 관심사 피드를 끄고 작업 표시줄 버튼을 숨기며(Windows 10), 위젯 보드를 사용하지 않도록 설정합니다(Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>대시보드</value>
</data>
@@ -215,8 +221,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>태그</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Service Host 분리 기준을 시스템 총 RAM에 맞춰 설정하여, Windows가 서비스를 별도 프로세스로 분리하도록 해 안정성을 높입니다</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>서비스 호스트 분할 임계값을 시스템 총 RAM으로 높여 서비스를 더 적은 프로세스에 통합된 상태로 유지하여 메모리 사용량과 프로세스 수를 줄입니다.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>현재 활성 전원 계획을 감지하지 못했습니다</value>
@@ -253,15 +259,6 @@
</data>
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>이 태그는 최적화가 시스템의 어느 부분에 영향을 주는지 보여줍니다</value>
-</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
-</data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
-</data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
</data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>전원</value>
@@ -554,10 +551,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>비활성 상태의 앱이 백그라운드에서 실행되지 않도록 하여 RAM을 확보하고 CPU 부담을 줄입니다</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>서비스 격리 최적화</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>서비스 호스트 통합</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>잘못된 RAM 값: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -654,13 +651,13 @@
<value>백그라운드 로깅 비활성화</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>지속적인 디스크 활동을 줄이고 CPU 주기를 절약하기 위해 필수적이지 않은 시스템 이벤트 로깅을 중지합니다</value>
+ <value>필수적이지 않은 WMI/ETW AutoLogger 세션(Diagtrack-Listener, SQMLogger 등)이 부팅 시 시작되지 않도록 하여 백그라운드 디스크 및 CPU 활동을 줄입니다. 참고: 보안 소프트웨어는 진단 추적을 변경하므로 AutoLogger 변경 사항을 플래그로 표시할 수 있습니다.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Cortana 및 웹 검색 비활성화</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Cortana 음성 도우미를 끄고 Windows 검색 표시줄에서 Bing 웹 결과를 제거합니다</value>
+ <value>Cortana 음성 도우미를 끄고 Windows 검색에서 클라우드 검색 및 웹 결과를 사용하지 않도록 설정합니다(Windows 10 전용).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Windows Copilot 비활성화</value>
@@ -695,9 +692,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Visual</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>사용자 경험</value>
</data>
@@ -713,54 +707,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>더 나은 성능을 위해 GPU/CPU 리소스를 확보하기 위해 작업 표시줄 애니메이션, 목록 보기 그림자, 창 투명도 및 Aero Peek를 비활성화합니다</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>AMD ULPS 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>초저전력 상태 깨우기 지연 및 다중 모니터 문제를 방지하려면 AMD GPU 레지스트리에서 EnableULPS=0을 설정합니다 유휴 상태에서 절전 효과가 줄어듭니다</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>AMD 파워 게이팅 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>AMD GPU 전원 상태 전환을 방지하려면 비활성화PowerGating=1, PP_GPUPowerDownEnabled=0, 비활성화DynamicPstate=1을 설정합니다 더 높은 유휴 전력을 사용하여 일관된 클록을 유지합니다</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>AMD 비디오 클럭 게이팅 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>인코딩/디코딩 안정성을 향상시키기 위해 AMD 비디오 엔진(VCE/UVD)에 대해DisableVCEPowerGating=1,DisableVceClockGating=1,EnableUvdClockGating=0을 설정합니다 비디오 재생 성능을 높입니다</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>AMD ASPM 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>AMD GPU에서 활성 상태 전원 관리를 비활성화하려면 EnableAspmL0s=0, EnableAspmL1=0을 설정하여 PCIe 버스 대기 시간을 줄입니다 슬롯 전력 소비가 증가합니다</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>NVIDIA 동적 P-State 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>NVIDIA GPU를 고정된 성능 상태로 잠그도록 비활성화DynamicPstate=1로 설정하여 클럭 속도 변동을 방지합니다 유휴 전력 소모량이 증가합니다</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>NVIDIA Async P-State 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>NVIDIA 비동기 전원 상태 전환을 방지하고 VR/실시간 앱에 결정적인 성능을 제공하려면 비활성화ASyncPstates=1로 설정합니다</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Intel Async Flip 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Intel iGPU에서 동기식 버퍼 반전을 강제하도록 Display1_DisableAsyncFlips=1을 설정하여 입력-디스플레이 지연 시간과 화면 찢김을 줄입니다</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Intel Adaptive V-Sync 비활성화</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>안정적인 타이밍 대신 고정 V-Sync를 사용하여 프레임 속도에 동적으로 조정되는 Intel의 적응형 V-Sync를 비활성화하려면 AdaptiveVsyncEnable=0을 설정합니다</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>작업 표시줄</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.pl-PL.resx b/optimizerDuck/Resources/Languages/Translations.pl-PL.resx
index 2920d2b..070f516 100644
--- a/optimizerDuck/Resources/Languages/Translations.pl-PL.resx
+++ b/optimizerDuck/Resources/Languages/Translations.pl-PL.resx
@@ -66,6 +66,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Panel główny</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Wyłącza funkcję AI Windows Recall, która przechwytuje i indeksuje zrzuty ekranu. Usuwa również składnik Recall i usuwa wcześniej zapisane zrzuty; aby zmiana zaczęła obowiązywać, wymagany jest restart.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Wyłącza kanał Wiadomości i zainteresowania i ukrywa jego przycisk na pasku zadań (Windows 10) oraz wyłącza panel widżetów (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Panel główny</value>
</data>
@@ -216,8 +222,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Tagi</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Ustawia próg podziału Service Host odpowiednio do całkowitej ilości pamięci RAM, zmuszając system Windows do izolowania usług w osobnych procesach w celu poprawy stabilności.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Podnosi próg dzielenia hosta usług do całkowitej pamięci RAM systemu, utrzymując usługi skonsolidowane w mniejszej liczbie procesów, co zmniejsza zużycie pamięci i liczbę procesów.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Nie udało się wykryć aktualnie aktywnego planu zasilania.</value>
@@ -255,15 +261,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Te tagi wskazują, na które elementy systemu wpłynie optymalizacja.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Zasilanie</value>
</data>
@@ -555,10 +552,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Zapobiega działaniu nieaktywnych aplikacji w tle, aby zwolnić pamięć RAM i zmniejszyć obciążenie procesora.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Optymalizuj izolację usług</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Konsolidacja hostów usług</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>Nieprawidłowa pamięć RAM: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -655,13 +652,13 @@
<value>Wyłącz rejestrowanie w tle</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Zatrzymuje nieistotne rejestrowanie zdarzeń systemowych, aby ograniczyć ciągłą aktywność dysku i oszczędzać cykle procesora.</value>
+ <value>Zapobiega uruchamianiu się nieistotnych sesji WMI/ETW AutoLogger (Diagtrack-Listener, SQMLogger itp.) podczas uruchamiania systemu, aby zmniejszyć aktywność dysku i procesora w tle. Uwaga: oprogramowanie zabezpieczające może oznaczać zmiany AutoLogger, ponieważ zmieniają one śledzenie diagnostyczne.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Wyłącz Cortanę i wyszukiwanie w sieci</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Wyłącza asystenta głosowego Cortana i usuwa wyniki sieciowe Bing z paska wyszukiwania systemu Windows.</value>
+ <value>Wyłącza asystenta głosowego Cortana i wyłącza wyszukiwanie w chmurze oraz wyniki internetowe w wyszukiwarce Windows (tylko Windows 10).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Wyłącz Windows Copilot</value>
@@ -696,9 +693,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Wygląd</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Komfort użytkowania</value>
</data>
@@ -714,54 +708,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Wyłącza animacje paska zadań, cienie list, przezroczystość okien oraz Aero Peek, aby zwolnić zasoby GPU/CPU dla lepszej wydajności.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>Wyłącz AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Ustawia EnableULPS=0 w rejestrze GPU AMD, aby zapobiec opóźnieniom wybudzania ze stanu Ultra Low Power State i problemom z wieloma monitorami. Zmniejsza oszczędzanie energii w bezczynności.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>Wyłącz AMD Power Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Ustawia DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1, aby zapobiec przejściom stanów zasilania GPU AMD. Utrzymuje stałe taktowanie kosztem wyższego poboru mocy w bezczynności.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>Wyłącz AMD Video Clock Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Ustawia DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0 dla silników wideo AMD (VCE/UVD), aby poprawić stabilność kodowania/dekodowania. Zwiększa pobór mocy podczas odtwarzania wideo.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>Wyłącz AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Ustawia EnableAspmL0s=0, EnableAspmL1=0, aby wyłączyć Active State Power Management na GPU AMD, redukując opóźnienia magistrali PCIe. Zwiększa pobór mocy gniazda.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>Wyłącz NVIDIA Dynamic P-State</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Ustawia DisableDynamicPstate=1, aby zablokować GPU NVIDIA w stałym stanie wydajności, zapobiegając wahaniom taktowania. Zwiększa pobór mocy w bezczynności.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>Wyłącz NVIDIA Async P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Ustawia DisableASyncPstates=1, aby zapobiec asynchronicznemu przełączaniu stanów zasilania NVIDIA, zapewniając deterministyczną wydajność w aplikacjach VR/czasu rzeczywistego.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Wyłącz Intel Async Flips</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Ustawia Display1_DisableAsyncFlips=1, aby wymusić synchroniczne przełączanie buforów na iGPU Intel, redukując opóźnienie wejścia-obrazu i rozrywanie obrazu.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Wyłącz Intel Adaptive V-Sync</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Ustawia AdaptiveVsyncEnable=0, aby wyłączyć adaptacyjną synchronizację pionową Intel dynamicznie dostosowującą się do liczby klatek, używając zamiast tego stałej synchronizacji V-Sync dla stabilnego taktowania.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Pasek zadań</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.pt-BR.resx b/optimizerDuck/Resources/Languages/Translations.pt-BR.resx
index 3f2321e..6ce6113 100644
--- a/optimizerDuck/Resources/Languages/Translations.pt-BR.resx
+++ b/optimizerDuck/Resources/Languages/Translations.pt-BR.resx
@@ -66,6 +66,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Dashboard</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Desativa o recurso de IA Windows Recall, que captura e indexa instantâneos da tela. Também remove o componente Recall e exclui os instantâneos salvos anteriormente; é necessário reiniciar para que a alteração tenha efeito.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Desativa o feed de Notícias e interesses e oculta o botão na barra de tarefas (Windows 10) e desativa o painel de Widgets (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Dashboard</value>
</data>
@@ -216,8 +222,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Tags</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Define o limite de divisão do Service Host para corresponder ao total de RAM do sistema, forçando o Windows a isolar serviços em processos separados para melhor estabilidade.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Eleva o limite de divisão do host de serviços para o total de RAM do sistema, mantendo os serviços consolidados em menos processos para reduzir o uso de memória e o número de processos.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Falha ao detectar o plano de energia ativo atual.</value>
@@ -255,15 +261,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Essas tags indicam quais partes do sistema serão afetadas pela otimização.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Energia</value>
</data>
@@ -555,10 +552,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Previne que aplicativos inativos sejam executados em segundo plano para liberar RAM e reduzir a sobrecarga do CPU.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Otimizar Isolamento de Serviços</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Consolidar hosts de serviços</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>RAM inválida: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -655,13 +652,13 @@
<value>Desativar Log de Segundo Plano</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Para o registro de eventos do sistema não essenciais para reduzir a atividade contínua do disco e salvar ciclos de CPU.</value>
+ <value>Impede que sessões WMI/ETW AutoLogger não essenciais (Diagtrack-Listener, SQMLogger etc.) sejam iniciadas na inicialização para reduzir a atividade de disco e CPU em segundo plano. Observação: o software de segurança pode sinalizar alterações no AutoLogger, pois elas alteram o rastreamento de diagnóstico.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Desativar Cortana &amp; Busca na Web</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Desativa o assistente de voz Cortana e remove os resultados da Web do Bing da barra de busca do Windows.</value>
+ <value>Desativa o assistente de voz Cortana e desativa a pesquisa na nuvem e os resultados da web na pesquisa do Windows (somente Windows 10).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Desativar Windows Copilot</value>
@@ -696,9 +693,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Visualização</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Experiência do Usuário</value>
</data>
@@ -714,54 +708,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Desativa as animações da barra de tarefas, sombras da lista de exibição, transparência da janela e Aero Peek para liberar recursos de GPU/CPU para melhor performance.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>Desativar AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Define EnableULPS=0 no registro da GPU AMD para evitar atrasos de wake-up do Estado de Baixa Potência Ultra e problemas de múltiplos monitores. Reduz a economia de energia no estado inativo.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>Desativar Controle de Energia AMD</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Define DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1 para prevenir transições de estado de energia da GPU AMD. Mantém clocks consistentes ao custo de maior consumo de energia no estado inativo.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>Desativar Controle de Clock de Vídeo AMD</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Sets DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0 for AMD video engines (VCE/UVD) to improve encode/decode stability. Increases video playback power.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>Desativar AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Define EnableAspmL0s=0, EnableAspmL1=0 para desativar o Gerenciamento de Estado Ativo na GPU AMD, reduzindo a latência da barramento PCIe. Aumenta o consumo de energia da slot.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>Desativar P-State Dinâmico NVIDIA</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Define DisableDynamicPstate=1 para bloquear a GPU NVIDIA em um estado de performance fixo, evitando flutuações de frequência. Aumenta o consumo de energia no estado inativo.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>Desativar NVIDIA Async P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Define DisableASyncPstates=1 para prevenir a troca de estado de energia assíncrona da NVIDIA, fornecendo performance determinística para aplicativos VR/tempo real.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Desativar Intel Async Flips</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Define Display1_DisableAsyncFlips=1 para forçar reversões de buffer sincronizadas na iGPU Intel, reduzindo a latência de entrada-exibição e rachaduras de tela.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Desativar Intel Adaptive V-Sync</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Define AdaptiveVsyncEnable=0 para desativar o V-Sync adaptativo da Intel que ajusta dinamicamente à taxa de quadros, usando V-Sync fixo em vez disso para timing estável.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Barra de Tarefas</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.resx b/optimizerDuck/Resources/Languages/Translations.resx
index 17473db..57fb3b9 100644
--- a/optimizerDuck/Resources/Languages/Translations.resx
+++ b/optimizerDuck/Resources/Languages/Translations.resx
@@ -166,6 +166,12 @@
<data name="Customize.Description" xml:space="preserve">
<value>Personalize Windows settings and everyday behavior.</value>
</data>
+ <data name="Customize.CustomOption" xml:space="preserve">
+ <value>Custom</value>
+ </data>
+ <data name="Customize.CustomOption.NotSet" xml:space="preserve">
+ <value>Not set</value>
+ </data>
<data name="Customize.Preferences.Name" xml:space="preserve">
<value>Preferences</value>
</data>
@@ -274,8 +280,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Tags</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Sets the Service Host split threshold to match total system RAM, forcing Windows to isolate services into separate processes for improved stability.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Raises the Service Host split threshold to total system RAM, keeping services consolidated in fewer processes to reduce memory overhead and process count.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Failed to detect the current active power plan.</value>
@@ -313,15 +319,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>These tags indicate which parts of the system the optimization will affect.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Power</value>
</data>
@@ -613,10 +610,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Prevents inactive applications from running in the background to free up RAM and reduce CPU overhead.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Optimize Service Isolation</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Consolidate Service Hosts</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>Invalid RAM: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -697,6 +694,18 @@
<data name="Optimizer.SecurityAndPrivacy.DisableAdvertisingAndSuggestions.ShortDescription" xml:space="preserve">
<value>Disables personalized ads, Windows consumer features, and system suggestions.</value>
</data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.Name" xml:space="preserve">
+ <value>Disable News &amp; Interests</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Turns off the News and Interests feed and hides its taskbar button (Windows 10), and disables the Widgets board (Windows 11).</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.HideMeetNowButton.Name" xml:space="preserve">
+ <value>Hide Meet Now Button</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.HideMeetNowButton.ShortDescription" xml:space="preserve">
+ <value>Hides the Meet Now (Skype) button from the taskbar notification area. Windows 10 only.</value>
+ </data>
<data name="Optimizer.SecurityAndPrivacy.DisableActivityHistory.Name" xml:space="preserve">
<value>Disable Activity History</value>
</data>
@@ -713,13 +722,13 @@
<value>Disable Background Logging</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Stops non-essential system event logging to reduce continuous disk activity and save CPU cycles.</value>
+ <value>Stops non-essential WMI/ETW AutoLogger sessions (Diagtrack-Listener, SQMLogger, etc.) from starting at boot to reduce background disk and CPU activity. Note: security software may flag AutoLogger changes as they alter diagnostic tracing.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Disable Cortana &amp; Web Search</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Turns off the Cortana voice assistant and removes Bing web results from the Windows Search bar.</value>
+ <value>Turns off the Cortana voice assistant and disables cloud search and web results in Windows Search (Windows 10 only).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Disable Windows Copilot</value>
@@ -760,9 +769,6 @@
<data name="Optimizer.UI.Tags.Windows11Only" xml:space="preserve">
<value>Windows 11 only</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>User Experience</value>
</data>
@@ -784,54 +790,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Disables taskbar animations, listview shadows, window transparency, and Aero Peek to free up GPU/CPU resources for better performance.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>Disable AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Sets EnableULPS=0 in AMD GPU registry to prevent Ultra Low Power State wake-up delays and multi-monitor issues. Reduces power saving on idle.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>Disable AMD Power Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Sets DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1 to prevent AMD GPU power state transitions. Maintains consistent clocks at cost of higher idle power.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>Disable AMD Video Clock Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Sets DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0 for AMD video engines (VCE/UVD) to improve encode/decode stability. Increases video playback power.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>Disable AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Sets EnableAspmL0s=0, EnableAspmL1=0 to disable Active State Power Management on AMD GPUs, reducing PCIe bus latency. Increases slot power consumption.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>Disable NVIDIA Dynamic P-State</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Sets DisableDynamicPstate=1 to lock NVIDIA GPU into fixed performance state, preventing clock speed fluctuations. Increases idle power draw.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>Disable NVIDIA Async P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Sets DisableASyncPstates=1 to prevent NVIDIA asynchronous power state switching, providing deterministic performance for VR/real-time apps.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Disable Intel Async Flips</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Sets Display1_DisableAsyncFlips=1 to force synchronous buffer flips on Intel iGPU, reducing input-to-display latency and screen tearing.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Disable Intel Adaptive V-Sync</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Sets AdaptiveVsyncEnable=0 to disable Intel's adaptive V-Sync that dynamically adjusts to frame rate, using fixed V-Sync instead for stable timing.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Taskbar</value>
</data>
@@ -1734,6 +1692,12 @@ Update now to enjoy the latest features, improvements, and bug fixes.</value>
<data name="Customize.Preferences.LaunchToThisPc.Description" xml:space="preserve">
<value>Choose whether File Explorer opens to This PC or Quick access.</value>
</data>
+ <data name="Customize.Preferences.LaunchToThisPc.Options.QuickAccess" xml:space="preserve">
+ <value>Quick Access</value>
+ </data>
+ <data name="Customize.Preferences.LaunchToThisPc.Options.ThisPc" xml:space="preserve">
+ <value>This PC</value>
+ </data>
<data name="Customize.Preferences.BingSearch.Name" xml:space="preserve">
<value>Bing Search</value>
</data>
@@ -1862,10 +1826,142 @@ Update now to enjoy the latest features, improvements, and bug fixes.</value>
<data name="Customize.Preferences.TaskbarLastActiveClick.Description" xml:space="preserve">
<value>Makes a taskbar click open the most recently used window for that app.</value>
</data>
-<data name="Customize.SystemFeatures.ShowBatteryPercentage.Name" xml:space="preserve">
+ <data name="Customize.SystemFeatures.ShowBatteryPercentage.Name" xml:space="preserve">
<value>Battery Percentage</value>
</data>
<data name="Customize.SystemFeatures.ShowBatteryPercentage.Description" xml:space="preserve">
<value>Shows the current battery percentage next to the battery icon in the system tray.</value>
</data>
+ <data name="Optimizer.AI" xml:space="preserve">
+ <value>AI</value>
+ </data>
+ <data name="Optimizer.AI.DisableClickToDo.Name" xml:space="preserve">
+ <value>Disable Click To Do</value>
+ </data>
+ <data name="Optimizer.AI.DisableClickToDo.ShortDescription" xml:space="preserve">
+ <value>Turns off the AI-powered Click To Do overlay that analyzes text and images on your screen.</value>
+ </data>
+ <data name="Optimizer.AI.DisableRecall.Name" xml:space="preserve">
+ <value>Disable Windows Recall</value>
+ </data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Disables the Windows Recall AI feature that captures and indexes snapshots of your screen. Also removes the Recall component and deletes previously saved snapshots on Windows 11 24H2+ (Build 26100.3915+); a restart is required to take effect.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableDeliveryOptimization.Name" xml:space="preserve">
+ <value>Disable Delivery Optimization (P2P)</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableDeliveryOptimization.ShortDescription" xml:space="preserve">
+ <value>Stops Windows from sharing or downloading update files from other PCs over peer-to-peer, so updates only come from Microsoft servers.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableFindMyDevice.Name" xml:space="preserve">
+ <value>Disable Find My Device</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableFindMyDevice.ShortDescription" xml:space="preserve">
+ <value>Disables the Find My Device feature that periodically reports your device's location to Microsoft.</value>
+ </data>
+ <data name="Optimizer.UserExperience.DisableSettings365Ads.Name" xml:space="preserve">
+ <value>Disable Microsoft 365 Ads in Settings</value>
+ </data>
+ <data name="Optimizer.UserExperience.DisableSettings365Ads.ShortDescription" xml:space="preserve">
+ <value>Removes the Microsoft 365 and Copilot promotional content from the Settings Home page.</value>
+ </data>
+ <data name="Optimizer.UserExperience.DisableStartRecommended.Name" xml:space="preserve">
+ <value>Hide Recommended Section in Start</value>
+ </data>
+ <data name="Optimizer.UserExperience.DisableStartRecommended.ShortDescription" xml:space="preserve">
+ <value>Hides the Recommended section from the Start menu to reduce clutter and stop recent files and apps from being shown.</value>
+ </data>
+ <data name="Condition.Error.Title" xml:space="preserve">
+ <value>Compatibility check failed</value>
+ </data>
+ <data name="Condition.Error.Description" xml:space="preserve">
+ <value>optimizerDuck could not determine whether this item is supported on your system.</value>
+ </data>
+ <data name="Condition.Windows11.Title" xml:space="preserve">
+ <value>Windows 11 required</value>
+ </data>
+ <data name="Condition.Windows11.Description" xml:space="preserve">
+ <value>This item requires Windows 11.</value>
+ </data>
+ <data name="Condition.Windows10.Title" xml:space="preserve">
+ <value>Windows 10 required</value>
+ </data>
+ <data name="Condition.Windows10.Description" xml:space="preserve">
+ <value>This item requires Windows 10.</value>
+ </data>
+ <data name="Condition.Windows11_24H2.Title" xml:space="preserve">
+ <value>Windows 11 24H2 or newer required</value>
+ </data>
+ <data name="Condition.Windows11_24H2.Description" xml:space="preserve">
+ <value>This item requires Windows 11 24H2 (build 26100) or later.</value>
+ </data>
+ <data name="Condition.Cpu.Intel.Title" xml:space="preserve">
+ <value>Intel CPU required</value>
+ </data>
+ <data name="Condition.Cpu.Intel.Description" xml:space="preserve">
+ <value>This item only works on systems with an Intel processor.</value>
+ </data>
+ <data name="Condition.Cpu.Amd.Title" xml:space="preserve">
+ <value>AMD CPU required</value>
+ </data>
+ <data name="Condition.Cpu.Amd.Description" xml:space="preserve">
+ <value>This item only works on systems with an AMD processor.</value>
+ </data>
+ <data name="Condition.Gpu.Nvidia.Title" xml:space="preserve">
+ <value>NVIDIA GPU required</value>
+ </data>
+ <data name="Condition.Gpu.Nvidia.Description" xml:space="preserve">
+ <value>This item only works on systems with an NVIDIA graphics card.</value>
+ </data>
+ <data name="Condition.Gpu.Amd.Title" xml:space="preserve">
+ <value>AMD GPU required</value>
+ </data>
+ <data name="Condition.Gpu.Amd.Description" xml:space="preserve">
+ <value>This item only works on systems with an AMD graphics card.</value>
+ </data>
+ <data name="Condition.Gpu.Intel.Title" xml:space="preserve">
+ <value>Intel GPU required</value>
+ </data>
+ <data name="Condition.Gpu.Intel.Description" xml:space="preserve">
+ <value>This item only works on systems with an Intel graphics card.</value>
+ </data>
+ <data name="Condition.Ram.16.Title" xml:space="preserve">
+ <value>16 GB RAM required</value>
+ </data>
+ <data name="Condition.Ram.16.Description" xml:space="preserve">
+ <value>This item requires at least 16 GB of installed RAM.</value>
+ </data>
+ <data name="Condition.Recall.Title" xml:space="preserve">
+ <value>Windows Recall not available</value>
+ </data>
+ <data name="Condition.Recall.Description" xml:space="preserve">
+ <value>Windows Recall requires Windows 11 24H2 or later with the Windows AI components installed.</value>
+ </data>
+ <data name="Optimizer.Condition.BlockedTitle" xml:space="preserve">
+ <value>Not supported on this system</value>
+ </data>
+ <data name="Optimizer.Condition.FailedTitle" xml:space="preserve">
+ <value>Condition failed</value>
+ </data>
+ <data name="Optimizer.Condition.Hide" xml:space="preserve">
+ <value>Hide</value>
+ </data>
+ <data name="Optimizer.Condition.Hide.Tooltip" xml:space="preserve">
+ <value>Show this optimization again and allow applying it anyway.</value>
+ </data>
+ <data name="Optimizer.Condition.WhatIsThis" xml:space="preserve">
+ <value>What is this?</value>
+ </data>
+ <data name="Optimizer.Condition.WhatIsThis.Tooltip" xml:space="preserve">
+ <value>Compatibility conditions check whether an item is supported on your system, e.g. which Windows version or which GPU is installed. When a condition fails, the item is hidden by default because it may not work. If you know what you are doing, you can hide this warning and apply the item anyway.</value>
+ </data>
+ <data name="Customize.UI.UnsupportedSettings.Header" xml:space="preserve">
+ <value>Unsupported Settings ({0})</value>
+ </data>
+ <data name="Customize.UI.UnsupportedSettings.Badge" xml:space="preserve">
+ <value>Not supported</value>
+ </data>
+ <data name="Customize.UI.UnsupportedSettings.Description" xml:space="preserve">
+ <value>Some settings are unavailable on your current system.</value>
+ </data>
</root>
\ No newline at end of file
diff --git a/optimizerDuck/Resources/Languages/Translations.ru-RU.resx b/optimizerDuck/Resources/Languages/Translations.ru-RU.resx
index 3d3fec6..e8db9d5 100644
--- a/optimizerDuck/Resources/Languages/Translations.ru-RU.resx
+++ b/optimizerDuck/Resources/Languages/Translations.ru-RU.resx
@@ -66,6 +66,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Главная</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Отключает функцию ИИ Windows Recall, которая захватывает и индексирует снимки экрана. Также удаляет компонент Recall и удаляет ранее сохранённые снимки; для вступления в силу требуется перезагрузка.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Отключает ленту новостей и интересов и скрывает её кнопку на панели задач (Windows 10), а также отключает панель виджетов (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Главная</value>
</data>
@@ -216,8 +222,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Теги</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Устанавливает порог разделения Service Host в соответствии с общим объемом ОЗУ, заставляя Windows изолировать службы в отдельные процессы для повышения стабильности.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Повышает порог разделения узла служб до общего объёма ОЗУ системы, сохраняя службы объединёнными в меньшем числе процессов для снижения потребления памяти и количества процессов.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Не удалось определить текущую активную схему электропитания.</value>
@@ -255,15 +261,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Эти теги показывают, на какие части системы повлияет оптимизация.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Питание</value>
</data>
@@ -555,10 +552,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Запрещает неактивным приложениям работать в фоне, освобождая ОЗУ и снижая нагрузку на ЦП.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Оптимизировать изоляцию служб</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Консолидация узлов служб</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>Некорректное значение ОЗУ: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -655,13 +652,13 @@
<value>Отключить фоновое логирование</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Останавливает ненужное журналирование системных событий для снижения нагрузки на диск и ЦП.</value>
+ <value>Предотвращает запуск необязательных сеансов WMI/ETW AutoLogger (Diagtrack-Listener, SQMLogger и др.) при загрузке системы, снижая фоновую нагрузку на диск и ЦП. Примечание: антивирусные программы могут помечать изменения AutoLogger, поскольку они изменяют диагностическую трассировку.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Отключить Cortana и веб-поиск</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Отключает голосового помощника Cortana и убирает результаты из Bing из панели поиска Windows.</value>
+ <value>Отключает голосового помощника Cortana и отключает облачный поиск и веб-результаты в поиске Windows (только Windows 10).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Отключить Windows Copilot</value>
@@ -696,9 +693,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Визуальные</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Пользовательский опыт</value>
</data>
@@ -714,54 +708,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Отключает анимации панели задач, тени, прозрачность и Aero Peek для освобождения ресурсов GPU/CPU.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>Отключить AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Устанавливает EnableULPS=0 в реестре AMD, предотвращая задержки пробуждения и проблемы с мульти-монитором.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>Отключить AMD Power Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Предотвращает переключение состояний питания AMD GPU. Поддерживает стабильные частоты ценой большего энергопотребления в простое.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>Отключить AMD Video Clock Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Настраивает видео-движки AMD (VCE/UVD) для улучшения стабильности кодирования/декодирования. Увеличивает энергопотребление при видео.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>Отключить AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Отключает Active State Power Management на AMD GPU, снижая задержку шины PCIe. Увеличивает потребление слота.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>Отключить NVIDIA Dynamic P-State</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Фиксирует NVIDIA GPU в состоянии производительности, предотвращая скачки частот. Увеличивает потребление в простое.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>Отключить NVIDIA Async P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Предотвращает асинхронное переключение состояний питания NVIDIA, обеспечивая детерминированную производительность для VR.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Отключить Intel Async Flips</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Принудительно использует синхронное переключение буферов на Intel iGPU, снижая задержку ввода и разрывы кадра.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Отключить Intel Adaptive V-Sync</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Отключает адаптивную V-Sync от Intel, используя фиксированную V-Sync для стабильного тайминга.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Панель задач</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.tr-TR.resx b/optimizerDuck/Resources/Languages/Translations.tr-TR.resx
index 471b476..a63613a 100644
--- a/optimizerDuck/Resources/Languages/Translations.tr-TR.resx
+++ b/optimizerDuck/Resources/Languages/Translations.tr-TR.resx
@@ -65,6 +65,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Gösterge Paneli</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Ekranınızın anlık görüntülerini yakalayıp dizine ekleyen Windows Recall AI özelliğini devre dışı bırakır. Ayrıca Recall bileşenini kaldırır ve daha önce kaydedilmiş anlık görüntüleri siler; değişikliğin etkili olması için yeniden başlatma gerekir.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Haberler ve ilgi alanları akışını kapatır ve görev çubuğu düğmesini gizler (Windows 10) ve Widget'lar panosunu devre dışı bırakır (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Gösterge Paneli</value>
</data>
@@ -215,8 +221,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>Etiketler</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Hizmet Ana Bilgisayarı bölme eşiğini toplam sistem RAM'iyle eşleştirerek Windows'un servisleri ayrı işlemlere izole etmesini sağlar, böylece kararlılık artar.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Hizmet ana bilgisayarı bölme eşiğini toplam sistem RAM'ine yükseltir, hizmetleri daha az işlemde birleşik tutarak bellek kullanımını ve işlem sayısını azaltır.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Mevcut aktif güç planı algılanamadı.</value>
@@ -254,15 +260,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Bu etiketler, optimizasyonun sistemin hangi bölümlerini etkileyeceğini gösterir.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Güç</value>
</data>
@@ -554,10 +551,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Etkin olmayan uygulamaların arka planda çalışmasını önler, böylece RAM serbest kalır ve CPU yükü azalır.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Servis İzolasyonunu Optimize Et</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Hizmet ana bilgisayarlarını birleştirme</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>Geçersiz RAM: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -654,13 +651,13 @@
<value>Arka Plan Günlüğünü Devre Dışı Bırak</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Sürekli disk etkinliğini azaltmak ve CPU döngülerinden tasarruf etmek için temel olmayan sistem olay günlüğünü durdurur.</value>
+ <value>Temel olmayan WMI/ETW AutoLogger oturumlarının (Diagtrack-Listener, SQMLogger vb.) açılışta başlamasını engelleyerek arka plandaki disk ve CPU etkinliğini azaltır. Not: Güvenlik yazılımları, tanılama izlemeyi değiştirdikleri için AutoLogger değişikliklerini işaretleyebilir.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Cortana ve Web Aramayı Devre Dışı Bırak</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Cortana sesli asistanını kapatır ve Windows Arama çubuğundan Bing web sonuçlarını kaldırır.</value>
+ <value>Cortana sesli asistanını kapatır ve Windows Arama'da bulut aramasını ve web sonuçlarını devre dışı bırakır (yalnızca Windows 10).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Windows Copilot'ı Devre Dışı Bırak</value>
@@ -695,9 +692,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Görsel</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Kullanıcı Deneyimi</value>
</data>
@@ -713,54 +707,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Daha iyi performans için GPU/CPU kaynaklarını serbest bırakmak amacıyla görev çubuğu animasyonlarını, liste görünümü gölgelerini, pencere şeffaflığını ve Aero Peek'i devre dışı bırakır.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>AMD ULPS'yi Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Ultra Düşük Güç Durumu uyanma gecikmelerini ve çoklu monitör sorunlarını önlemek için AMD GPU kayıt defterinde EnableULPS=0 değerini ayarlar. Boştayken güç tasarrufunu azaltır.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>AMD Güç Kapılamasını Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>AMD GPU güç durumu geçişlerini önlemek için DisablePowerGating=1, PP_GPUPowerDownEnabled=0, DisableDynamicPstate=1 değerlerini ayarlar. Daha yüksek boşta güç tüketimi karşılığında tutarlı saat hızları sağlar.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>AMD Video Saat Kapılamasını Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Kodlama/kod çözme kararlılığını artırmak için AMD video motorları (VCE/UVD) için DisableVCEPowerGating=1, DisableVceClockGating=1, EnableUvdClockGating=0 değerlerini ayarlar. Video oynatma güç tüketimini artırır.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>AMD ASPM'yi Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>AMD GPU'larda PCIe veri yolu gecikmesini azaltmak için Aktif Durum Güç Yönetimi'ni devre dışı bırakmak amacıyla EnableAspmL0s=0, EnableAspmL1=0 değerlerini ayarlar. Yuva güç tüketimini artırır.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>NVIDIA Dinamik P-State'i Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Saat hızı dalgalanmalarını önlemek için NVIDIA GPU'yu sabit performans durumunda kilitlemek amacıyla DisableDynamicPstate=1 değerini ayarlar. Boştaki güç tüketimini artırır.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>NVIDIA Asenkron P-State'leri Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>VR/gerçek zamanlı uygulamalar için belirleyici performans sağlamak amacıyla NVIDIA asenkron güç durumu geçişini önlemek için DisableASyncPstates=1 değerini ayarlar.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Intel Asenkron Çevirmelerini Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Intel iGPU'da girişten ekrana gecikmeyi ve ekran yırtılmasını azaltmak için senkron tampon geçişlerini zorlamak amacıyla Display1_DisableAsyncFlips=1 değerini ayarlar.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Intel Uyarlamalı V-Sync'i Devre Dışı Bırak</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Kararlı zamanlama için sabit V-Sync kullanmak amacıyla kare hızına göre dinamik olarak ayarlanan Intel uyarlamalı V-Sync'i devre dışı bırakmak için AdaptiveVsyncEnable=0 değerini ayarlar.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Görev Çubuğu</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.vi-VN.resx b/optimizerDuck/Resources/Languages/Translations.vi-VN.resx
index 8414a21..2c1cf62 100644
--- a/optimizerDuck/Resources/Languages/Translations.vi-VN.resx
+++ b/optimizerDuck/Resources/Languages/Translations.vi-VN.resx
@@ -66,6 +66,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>Dashboard</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>Tắt tính năng AI Windows Recall — tính năng chụp và lập chỉ mục ảnh chụp màn hình. Đồng thời gỡ bỏ thành phần Recall và xóa các ảnh chụp đã lưu trữ trước đó; cần khởi động lại máy để có hiệu lực.</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>Tắt nguồn cấp tin tức và sở thích (News and Interests) và ẩn nút của nó trên thanh tác vụ (Windows 10), đồng thời vô hiệu hóa bảng Widgets (Windows 11).</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>Dashboard</value>
</data>
@@ -213,8 +219,8 @@
<data name="OptimizationDetailsDialog.Other" xml:space="preserve">
<value>Khác</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>Chia nhỏ các dịch vụ hệ thống thành các tiến trình riêng biệt để tăng đáng kể độ ổn định.</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>Nâng ngưỡng phân tách Service Host lên bằng tổng RAM hệ thống, giữ các dịch vụ gộp trong ít tiến trình hơn để giảm mức sử dụng bộ nhớ và số tiến trình.</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>Không thể phát hiện power plan đang hoạt động hiện tại.</value>
@@ -252,15 +258,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>Các thẻ này cho biết tối ưu sẽ ảnh hưởng đến phần nào trong hệ thống.</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>Công suất/Điện năng</value>
</data>
@@ -537,10 +534,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>Ngăn các ứng dụng chạy ngầm khi không sử dụng để giải phóng RAM và giảm tải cho CPU.</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>Tối ưu hóa cô lập dịch vụ</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>Hợp nhất các tiến trình dịch vụ</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>RAM không hợp lệ: {0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -637,13 +634,13 @@
<value>Vô hiệu hóa nhật ký hệ thống</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>Ngăn việc ghi lại các nhật ký chẩn đoán chạy ngầm không cần thiết để tiết kiệm tài nguyên CPU/Ổ cứng.</value>
+ <value>Ngăn các phiên WMI/ETW AutoLogger không thiết yếu (Diagtrack-Listener, SQMLogger, v.v.) khởi động cùng hệ thống để giảm hoạt động đĩa và CPU nền. Lưu ý: phần mềm bảo mật có thể cảnh báo các thay đổi AutoLogger vì chúng làm thay đổi quá trình theo dõi chẩn đoán.</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>Vô hiệu hóa Cortana &amp; Tìm kiếm</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>Tắt trợ lý ảo Cortana và ngăn Windows Search tìm kiếm trực tuyến để có kết quả nhanh hơn.</value>
+ <value>Tắt trợ lý giọng nói Cortana và vô hiệu hóa tìm kiếm đám mây cũng như kết quả web trong Windows Search (chỉ dành cho Windows 10).</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>Vô hiệu hóa Windows Copilot</value>
@@ -678,9 +675,6 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>Giao diện</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>Trải nghiệm người dùng</value>
</data>
@@ -696,54 +690,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>Tắt hiệu ứng chuyển động, bóng đổ, độ trong suốt và Aero Peek để giải phóng tài nguyên GPU/CPU cho hiệu suất tốt hơn.</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>Vô hiệu hóa AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>Tắt chế độ siêu tiết kiệm điện của AMD để tránh hiện tượng GPU bị khựng hoặc trễ khi thức dậy.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>Tắt AMD Power Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>Duy trì hiệu năng GPU ổn định bằng cách ngăn việc tự động ngắt nguồn các thành phần bên trong.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>Tắt AMD Video Clock Gating</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>Tăng cường độ ổn định cho quá trình xử lý video bằng cách giữ xung nhịp engine video luôn sẵn sàng.</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>Vô hiệu hóa AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>Giảm độ trễ giao tiếp PCIe cho card đồ họa AMD, giúp tăng tốc độ phản hồi.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>Khóa trạng thái năng lượng NVIDIA</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>Ngăn NVIDIA GPU tự động thay đổi mức năng lượng để duy trì mức hiệu năng nhất quán nhất.</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>Vô hiệu hóa Async P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>Tắt việc chuyển đổi trạng thái hiệu năng không đồng bộ để đạt được sự ổn định cao nhất.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>Bật đồng bộ hình ảnh Intel</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>Sử dụng cơ chế làm mới khung hình đồng bộ để giảm độ trễ hiển thị và hạn chế xé hình.</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>Vô hiệu hóa Adaptive V-Sync</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>Duy trì thời gian xuất khung hình ổn định bằng cách tắt tính năng V-Sync thích ứng của Intel.</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>Thanh tác vụ</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.zh-CN.resx b/optimizerDuck/Resources/Languages/Translations.zh-CN.resx
index f5895ec..659015a 100644
--- a/optimizerDuck/Resources/Languages/Translations.zh-CN.resx
+++ b/optimizerDuck/Resources/Languages/Translations.zh-CN.resx
@@ -66,6 +66,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>控制台</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>禁用捕获并索引屏幕快照的 Windows Recall AI 功能。同时移除 Recall 组件并删除之前保存的快照;需要重启才能生效。</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>关闭新闻和兴趣信息流并隐藏其任务栏按钮(Windows 10),同时禁用小组件面板(Windows 11)。</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>控制台</value>
</data>
@@ -216,8 +222,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>标签</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>设置服务主机拆分阈值以匹配系统总内存,强制 Windows 将服务隔离为独立进程,提升系统稳定性。</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>将服务主机拆分阈值提高到系统总内存,使服务整合在更少的进程中,从而减少内存占用和进程数量。</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>检测当前活动电源计划失败。</value>
@@ -255,15 +261,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>这些标签标识优化操作将影响系统的哪些部分。</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>英伟达</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>电源</value>
</data>
@@ -555,10 +552,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>阻止未激活的应用在后台运行,释放内存并降低 CPU 占用。</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>优化服务隔离</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>整合服务主机</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>内存参数无效:{0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -655,13 +652,13 @@
<value>禁用后台日志记录</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>停止非必要的系统事件日志记录,减少持续磁盘读写,节省 CPU 资源。</value>
+ <value>阻止非必要的 WMI/ETW AutoLogger 会话(Diagtrack-Listener、SQMLogger 等)在启动时运行,以减少后台磁盘和 CPU 活动。注意:安全软件可能会标记 AutoLogger 更改,因为它们会改变诊断跟踪。</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>禁用小娜与网页搜索</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>关闭 Cortana 语音助手,移除 Windows 搜索栏中的必应网页结果。</value>
+ <value>关闭 Cortana 语音助手,并禁用 Windows 搜索中的云搜索和网页结果(仅适用于 Windows 10)。</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>禁用 Windows 智能助手</value>
@@ -702,9 +699,6 @@
<data name="Optimizer.UI.Tags.Windows11Only" xml:space="preserve">
<value>仅 Windows 11</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>显卡优化</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>用户体验</value>
</data>
@@ -726,54 +720,6 @@
<data name="Optimizer.UserExperience.DisableVisualEffects.ShortDescription" xml:space="preserve">
<value>关闭任务栏动画、列表阴影、窗口透明和 Aero 预览,释放显卡与 CPU 资源提升性能。</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>禁用 AMD 超低功耗状态</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>修改 AMD 显卡注册表关闭超低功耗模式,避免唤醒延迟与多显示器问题,降低闲置节能效果。</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>禁用 AMD 电源门控</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>关闭 AMD 显卡功耗切换功能,保持频率稳定,代价是闲置功耗会升高。</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>禁用 AMD 视频时钟门控</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>优化 AMD 显卡视频引擎功耗设置,提升编码解码稳定性,代价是视频播放功耗增加。</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>禁用 AMD 主动电源管理</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>设置关闭 AMD 显卡 PCIe 总线主动电源管理,降低延迟,代价是插槽功耗增加。</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>禁用 NVIDIA 动态性能状态</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>锁定 NVIDIA 显卡为固定性能状态,防止频率波动,代价是闲置功耗增加。</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>禁用 NVIDIA 异步性能状态切换</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>关闭 NVIDIA 异步功耗切换,为 VR/实时应用提供稳定性能。</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>禁用英特尔异步画面翻转</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>强制英特尔核显同步缓冲翻转,降低输入延迟与画面撕裂。</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>禁用英特尔自适应垂直同步</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>关闭自适应垂直同步,改用固定垂直同步,保证时序稳定。</value>
- </data>
<data name="Customize.Preferences.Section.Taskbar" xml:space="preserve">
<value>任务栏</value>
</data>
diff --git a/optimizerDuck/Resources/Languages/Translations.zh-TW.resx b/optimizerDuck/Resources/Languages/Translations.zh-TW.resx
index 706be7e..494e151 100644
--- a/optimizerDuck/Resources/Languages/Translations.zh-TW.resx
+++ b/optimizerDuck/Resources/Languages/Translations.zh-TW.resx
@@ -62,6 +62,12 @@
<data name="Dashboard.Header.Title" xml:space="preserve">
<value>儀表板</value>
</data>
+ <data name="Optimizer.AI.DisableRecall.ShortDescription" xml:space="preserve">
+ <value>停用會擷取並建立螢幕快照索引的 Windows Recall AI 功能。同時移除 Recall 元件並刪除先前儲存的快照;需要重新啟動才能生效。</value>
+ </data>
+ <data name="Optimizer.SecurityAndPrivacy.DisableNewsAndInterests.ShortDescription" xml:space="preserve">
+ <value>關閉新聞與興趣摘要並隱藏其工作列按鈕(Windows 10),同時停用小工具面板(Windows 11)。</value>
+ </data>
<data name="Sidebar.Dashboard" xml:space="preserve">
<value>儀表板</value>
</data>
@@ -197,8 +203,8 @@
<data name="OptimizationDetailsDialog.Tags" xml:space="preserve">
<value>標籤</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.ShortDescription" xml:space="preserve">
- <value>將服務主機分割閾值設定為符合系統總 RAM,強制 Windows 將服務隔離到獨立處理程序中以提升穩定性。</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.ShortDescription" xml:space="preserve">
+ <value>將服務主機分割閾值提高到系統總記憶體,讓服務整合在較少的處理程序中,以減少記憶體佔用與處理程序數量。</value>
</data>
<data name="Optimizer.PowerManagement.InstallOptimizerDuckPowerPlan.Error.DetectActivePlanFailed" xml:space="preserve">
<value>無法偵測目前啟用的電源計畫。</value>
@@ -236,15 +242,6 @@
<data name="Optimizer.UI.Tags.Help" xml:space="preserve">
<value>這些標籤指示最佳化將影響系統的哪些部分。</value>
</data>
- <data name="Optimizer.UI.Tags.Nvidia" xml:space="preserve">
- <value>NVIDIA</value>
- </data>
- <data name="Optimizer.UI.Tags.Amd" xml:space="preserve">
- <value>AMD</value>
- </data>
- <data name="Optimizer.UI.Tags.Intel" xml:space="preserve">
- <value>Intel</value>
- </data>
<data name="Optimizer.UI.Tags.Power" xml:space="preserve">
<value>電源</value>
</data>
@@ -509,10 +506,10 @@
<data name="Optimizer.Performance.DisableBackgroundApps.ShortDescription" xml:space="preserve">
<value>防止閒置的應用程式在背景執行,以釋放 RAM 並減少 CPU 負擔。</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Name" xml:space="preserve">
- <value>最佳化服務隔離</value>
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Name" xml:space="preserve">
+ <value>整合服務主機</value>
</data>
- <data name="Optimizer.Performance.SvcHostSplit.Error.InvalidRAM" xml:space="preserve">
+ <data name="Optimizer.Performance.ConsolidateServiceHosts.Error.InvalidRAM" xml:space="preserve">
<value>無效的 RAM:{0}</value>
</data>
<data name="Optimizer.Performance.ProcessPriority.Name" xml:space="preserve">
@@ -579,13 +576,13 @@
<value>停用背景記錄</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableAutoLogger.ShortDescription" xml:space="preserve">
- <value>停止非必要的系統事件記錄,以減少持續的磁碟活動並節省 CPU 週期。</value>
+ <value>阻止非必要的 WMI/ETW AutoLogger 工作階段(Diagtrack-Listener、SQMLogger 等)在開機時啟動,以減少背景磁碟與 CPU 活動。注意:安全性軟體可能會標記 AutoLogger 變更,因為這些變更會改變診斷追蹤。</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.Name" xml:space="preserve">
<value>停用 Cortana 與網頁搜尋</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCortana.ShortDescription" xml:space="preserve">
- <value>關閉 Cortana 語音助理,並從 Windows 搜尋列中移除 Bing 網頁搜尋結果。</value>
+ <value>關閉 Cortana 語音助理,並停用 Windows 搜尋中的雲端搜尋與網頁結果(僅適用於 Windows 10)。</value>
</data>
<data name="Optimizer.SecurityAndPrivacy.DisableCopilot.Name" xml:space="preserve">
<value>停用 Windows Copilot</value>
@@ -620,60 +617,9 @@
<data name="Optimizer.UI.Tags.Visual" xml:space="preserve">
<value>視覺效果</value>
</data>
- <data name="Optimizer.Gpu" xml:space="preserve">
- <value>GPU</value>
- </data>
<data name="Optimizer.UserExperience" xml:space="preserve">
<value>使用者體驗</value>
</data>
- <data name="Optimizer.Gpu.AmdDisableUlps.Name" xml:space="preserve">
- <value>停用 AMD ULPS</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableUlps.ShortDescription" xml:space="preserve">
- <value>將 AMD GPU 登錄檔中的 EnableULPS 設為 0,以防止超低功耗狀態的喚醒延遲和多顯示器問題。會降低閒置時的省電效果。</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.Name" xml:space="preserve">
- <value>停用 AMD 電源閘控</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisablePowerGating.ShortDescription" xml:space="preserve">
- <value>將 DisablePowerGating=1、PP_GPUPowerDownEnabled=0、DisableDynamicPstate=1 設定以防止 AMD GPU 的電源狀態轉換。維持一致的時脈,代價是較高的閒置功耗。</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.Name" xml:space="preserve">
- <value>停用 AMD 視訊時脈閘控</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableVideoClockGating.ShortDescription" xml:space="preserve">
- <value>針對 AMD 視訊引擎 (VCE/UVD) 設定 DisableVCEPowerGating=1、DisableVceClockGating=1、EnableUvdClockGating=0,以改善編碼/解碼穩定性。會增加視訊播放時的功耗。</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.Name" xml:space="preserve">
- <value>停用 AMD ASPM</value>
- </data>
- <data name="Optimizer.Gpu.AmdDisableAspm.ShortDescription" xml:space="preserve">
- <value>設定 EnableAspmL0s=0、EnableAspmL1=0 以停用 AMD GPU 上的活動狀態電源管理 (ASPM),從而降低 PCIe 匯流排延遲。會增加插槽功耗。</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.Name" xml:space="preserve">
- <value>停用 NVIDIA 動態 P-State</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableDynamicPstate.ShortDescription" xml:space="preserve">
- <value>設定 DisableDynamicPstate=1 以將 NVIDIA GPU 鎖定在固定的效能狀態,防止時脈波動。會增加閒置時的耗電量。</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.Name" xml:space="preserve">
- <value>停用 NVIDIA 非同步 P-States</value>
- </data>
- <data name="Optimizer.Gpu.NvidiaDisableAsyncPstates.ShortDescription" xml:space="preserve">
- <value>設定 DisableASyncPstates=1 以防止 NVIDIA 非同步電源狀態切換,為 VR / 即時應用程式提供確定的效能。</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.Name" xml:space="preserve">
- <value>停用 Intel 非同步翻轉</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAsyncFlips.ShortDescription" xml:space="preserve">
- <value>設定 Display1_DisableAsyncFlips=1 以在 Intel iGPU 上強制同步緩衝區翻轉,減少輸入到顯示的延遲和畫面撕裂。</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.Name" xml:space="preserve">
- <value>停用 Intel 自適應垂直同步</value>
- </data>
- <data name="Optimizer.Gpu.IntelDisableAdaptiveVsync.ShortDescription" xml:space="preserve">
- <value>設定 AdaptiveVsyncEnable=0 以停用會根據影格率動態調整的 Intel 自適應垂直同步,改用固定的垂直同步以獲得穩定的時序。</value>
- </data>
<data name="Settings.Optimize.ShellTimeout.Warning" xml:space="preserve">
<value>除非您非常清楚自己在做什麼,否則請勿變更</value>
</data>
diff --git a/optimizerDuck/Services/Conditions/ConditionEvaluator.cs b/optimizerDuck/Services/Conditions/ConditionEvaluator.cs
new file mode 100644
index 0000000..c051218
--- /dev/null
+++ b/optimizerDuck/Services/Conditions/ConditionEvaluator.cs
@@ -0,0 +1,76 @@
+using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
+using optimizerDuck.Domain.Conditions;
+using optimizerDuck.Services.System;
+
+namespace optimizerDuck.Services.Conditions;
+
+/// <summary>
+/// Evaluates the compatibility conditions declared on optimizations and customize
+/// settings against a system snapshot. Fails open when the snapshot is unpopulated,
+/// so incomplete hardware detection never hides an item.
+/// </summary>
+public static class ConditionEvaluator
+{
+ private static readonly ConcurrentDictionary<Type, ICondition> ConditionCache = new();
+
+ private static ICondition GetOrCreateCondition(Type conditionType) =>
+ ConditionCache.GetOrAdd(
+ conditionType,
+ static t => (ICondition)Activator.CreateInstance(t)!
+ );
+
+ /// <summary>
+ /// Evaluates the condition declared by <paramref name="conditionType"/>, or returns
+ /// <see cref="ConditionResult.Available"/> when there is no condition. Never throws.
+ /// </summary>
+ /// <param name="conditionType">The condition type declared in an attribute, or <c>null</c>.</param>
+ /// <param name="snapshot">The current system snapshot to evaluate against.</param>
+ /// <param name="logger">Logger for evaluation diagnostics.</param>
+ public static ConditionResult Evaluate(
+ Type? conditionType,
+ SystemSnapshot snapshot,
+ ILogger logger
+ )
+ {
+ if (conditionType is null)
+ return ConditionResult.Available;
+
+ // Fail open: an unpopulated snapshot means hardware detection has not finished (or
+ // failed), so never hide an item based on incomplete data. Callers re-evaluate once
+ // a real snapshot is available.
+ if (ReferenceEquals(snapshot, SystemSnapshot.Unknown))
+ return ConditionResult.Available;
+
+ try
+ {
+ return GetOrCreateCondition(conditionType).Evaluate(snapshot);
+ }
+ catch (Exception ex)
+ {
+ logger.LogError(ex, "Condition {ConditionType} failed to evaluate", conditionType);
+ return ConditionResult.Error();
+ }
+ }
+
+ /// <summary>
+ /// Evaluates the condition of every item in <paramref name="items"/> and pushes the
+ /// result through <paramref name="apply"/>.
+ /// </summary>
+ /// <param name="items">The items whose conditions are evaluated.</param>
+ /// <param name="conditionTypeOf">Returns the declared condition type for an item.</param>
+ /// <param name="apply">Receives each item with its evaluated result.</param>
+ /// <param name="snapshot">The system snapshot to evaluate against.</param>
+ /// <param name="logger">Logger for evaluation diagnostics.</param>
+ public static void EvaluateAll<T>(
+ IEnumerable<T> items,
+ Func<T, Type?> conditionTypeOf,
+ Action<T, ConditionResult> apply,
+ SystemSnapshot snapshot,
+ ILogger logger
+ )
+ {
+ foreach (var item in items)
+ apply(item, Evaluate(conditionTypeOf(item), snapshot, logger));
+ }
+}
diff --git a/optimizerDuck/Services/Customize/CustomizeRegistry.cs b/optimizerDuck/Services/Customize/CustomizeRegistry.cs
index d87a3f9..6d6672e 100644
--- a/optimizerDuck/Services/Customize/CustomizeRegistry.cs
+++ b/optimizerDuck/Services/Customize/CustomizeRegistry.cs
@@ -4,6 +4,7 @@ using Microsoft.Extensions.Logging;
using optimizerDuck.Common.Helpers;
using optimizerDuck.Domain.Abstractions;
using optimizerDuck.Domain.Attributes;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Customize.Models;
using Wpf.Ui.Controls;
@@ -56,7 +57,10 @@ public class CustomizeRegistry
var opt = (ICustomizeSetting)Activator.CreateInstance(nt)!;
if (opt is BaseCustomizeSetting bo)
+ {
bo.OwnerType = t;
+ ConditionValidation.Validate(bo.ConditionType, bo.FeatureKey);
+ }
return opt;
})
diff --git a/optimizerDuck/Services/Optimization/OptimizationRegistry.cs b/optimizerDuck/Services/Optimization/OptimizationRegistry.cs
index f4c4627..d3b6580 100644
--- a/optimizerDuck/Services/Optimization/OptimizationRegistry.cs
+++ b/optimizerDuck/Services/Optimization/OptimizationRegistry.cs
@@ -3,6 +3,7 @@ using System.Reflection;
using Microsoft.Extensions.Logging;
using optimizerDuck.Common.Helpers;
using optimizerDuck.Domain.Abstractions;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Optimizations.Models;
namespace optimizerDuck.Services.Optimization;
@@ -45,7 +46,10 @@ public class OptimizationRegistry(ILoggerFactory loggerFactory)
var opt = (IOptimization)Activator.CreateInstance(nt)!;
if (opt is BaseOptimization bo)
+ {
bo.OwnerType = t;
+ ConditionValidation.Validate(bo.ConditionType, bo.OptimizationKey);
+ }
return opt;
})
diff --git a/optimizerDuck/Services/Optimization/Providers/RegistryService.cs b/optimizerDuck/Services/Optimization/Providers/RegistryService.cs
index dfe5f93..5d76aa7 100644
--- a/optimizerDuck/Services/Optimization/Providers/RegistryService.cs
+++ b/optimizerDuck/Services/Optimization/Providers/RegistryService.cs
@@ -902,7 +902,11 @@ public static class RegistryService
}
/// <summary>Removes empty registry keys that were created during an apply operation.</summary>
- /// <remarks>Only deletes keys that were created during apply (tracked in <paramref name="createdSubKeys"/>) and are now completely empty — no values and no subkeys. Sorts by path depth descending so child keys are deleted before parents.</remarks>
+ /// <remarks>
+ /// Only deletes keys that were created during apply (tracked in
+ /// <paramref name="createdSubKeys" />) and are now completely empty (no values, no
+ /// subkeys). Sorts by path depth descending so child keys are deleted before parents.
+ /// </remarks>
/// <param name="createdSubKeys">The list of registry key paths that were created.</param>
public static void CleanupEmptyKeys(IEnumerable<string> createdSubKeys)
{
diff --git a/optimizerDuck/Services/Optimization/Providers/ScheduledTaskService.cs b/optimizerDuck/Services/Optimization/Providers/ScheduledTaskService.cs
index 6356684..73cd62a 100644
--- a/optimizerDuck/Services/Optimization/Providers/ScheduledTaskService.cs
+++ b/optimizerDuck/Services/Optimization/Providers/ScheduledTaskService.cs
@@ -228,7 +228,7 @@ public static class ScheduledTaskService
return results;
}
- /// <summary>Returns startup-related tasks — those with a LogonTrigger or BootTrigger.</summary>
+ /// <summary>Returns startup-related tasks: those with a LogonTrigger or BootTrigger.</summary>
/// <returns>A list of startup-related tasks ordered by name.</returns>
public static List<ScheduledTaskModel> GetStartupTasks()
{
diff --git a/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs b/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs
index 551868c..c292910 100644
--- a/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs
+++ b/optimizerDuck/Services/Optimization/Providers/ServiceProcessService.cs
@@ -18,13 +18,12 @@ public static class ServiceProcessService
/// <summary>
/// Matches the START_TYPE line in <c>sc qc</c> output.
/// Format: <c>FIELD_NAME : &lt;0-4&gt; DESCRIPTION</c>
- /// Uses <c>[0-4]</c> to match all possible START_TYPE values
+ /// Uses <c>[0-4]</c> to cover every START_TYPE value
/// (0=Boot, 1=System, 2=Auto, 3=Demand, 4=Disabled).
- /// The first matching line is always START_TYPE because it appears
- /// before ERROR_CONTROL and TAG in the fixed output order.
- /// The field name is locale-dependent, so structural matching only.
- /// Group 1 = numeric start value (0-4), Group 2 = description text
- /// (used for delayed-auto detection on value 2).
+ /// START_TYPE is the first matching line: it appears before ERROR_CONTROL and
+ /// TAG in the fixed output order. The field name is locale-dependent, so we
+ /// match structurally only. Group 1 = numeric start value (0-4); Group 2 =
+ /// description text (used for delayed-auto detection on value 2).
/// </summary>
private static readonly Regex _startTypeLineRegex = new(
@"^\s*\S+\s*:\s*([0-4])\s(.+)$",
diff --git a/optimizerDuck/Services/Optimization/Providers/ShellService.cs b/optimizerDuck/Services/Optimization/Providers/ShellService.cs
index e339751..20d0587 100644
--- a/optimizerDuck/Services/Optimization/Providers/ShellService.cs
+++ b/optimizerDuck/Services/Optimization/Providers/ShellService.cs
@@ -13,7 +13,7 @@ namespace optimizerDuck.Services.Optimization.Providers;
/// <summary>Defines success criteria and error reporting for shell command execution.</summary>
public sealed class ShellPolicy
{
- /// <summary>The default policy — exit code 0 means success, error is derived from stderr or exit code.</summary>
+ /// <summary>Default policy: exit code 0 means success; error text is taken from stderr or the exit code.</summary>
public static readonly ShellPolicy Default = new();
/// <summary>Gets or sets a function that determines whether a shell result indicates success.</summary>
diff --git a/optimizerDuck/Services/System/CrossPageEventBus.cs b/optimizerDuck/Services/System/CrossPageEventBus.cs
index cd46071..9768501 100644
--- a/optimizerDuck/Services/System/CrossPageEventBus.cs
+++ b/optimizerDuck/Services/System/CrossPageEventBus.cs
@@ -22,7 +22,7 @@ public static class CrossPageEventBus
/// <typeparam name="T">An event type that implements <see cref="ICrossPageEvent"/>.</typeparam>
/// <remarks>
/// The target page picks up this notification the next time it navigates to.
- /// Multiple notifications for the same type are coalesced into one.
+ /// Multiple notifications for the same type are merged into one.
/// </remarks>
public static void NotifyDataChanged<T>()
where T : ICrossPageEvent
diff --git a/optimizerDuck/Services/System/SystemInfoService.cs b/optimizerDuck/Services/System/SystemInfoService.cs
index 45f1e78..61ac385 100644
--- a/optimizerDuck/Services/System/SystemInfoService.cs
+++ b/optimizerDuck/Services/System/SystemInfoService.cs
@@ -33,14 +33,27 @@ public enum GpuVendor
Intel,
}
+/// <summary>
+/// Specifies the CPU vendor manufacturer.
+/// </summary>
+public enum CpuVendor
+{
+ /// <summary>Unknown or unrecognized CPU vendor.</summary>
+ Unknown,
+
+ /// <summary>Intel Corporation.</summary>
+ Intel,
+
+ /// <summary>Advanced Micro Devices (AMD).</summary>
+ AMD,
+}
+
/// <summary>
/// Represents information about a GPU.
/// </summary>
public sealed record GpuInfo
{
- /// <summary>
- /// A sentinel value representing an unknown GPU.
- /// </summary>
+ /// <summary>A sentinel value representing an unknown GPU.</summary>
public static readonly GpuInfo Unknown = new()
{
Name = Translations.Common_Unknown,
@@ -90,14 +103,12 @@ public sealed record GpuInfo
/// </summary>
public sealed record CpuInfo
{
- /// <summary>
- /// A sentinel value representing an unknown CPU.
- /// </summary>
+ /// <summary>A sentinel value representing an unknown CPU.</summary>
public static readonly CpuInfo Unknown = new()
{
Name = Translations.Common_Unknown,
Manufacturer = Translations.Common_Unknown,
- Vendor = Translations.Common_Unknown,
+ Vendor = CpuVendor.Unknown,
Architecture = Translations.Common_Unknown,
Cores = 0,
Threads = 0,
@@ -118,9 +129,9 @@ public sealed record CpuInfo
public required string Manufacturer { get; init; }
/// <summary>
- /// The detected vendor string (e.g., "Intel", "AMD").
+ /// The detected CPU vendor (e.g., <see cref="CpuVendor.Intel"/>).
/// </summary>
- public required string Vendor { get; init; }
+ public required CpuVendor Vendor { get; init; }
/// <summary>
/// The processor architecture (e.g., "64-bit").
@@ -234,9 +245,7 @@ public sealed record DiskVolume
/// </summary>
public sealed record DiskInfo
{
- /// <summary>
- /// A sentinel value representing unknown disk information.
- /// </summary>
+ /// <summary>A sentinel value representing unknown disk information.</summary>
public static readonly DiskInfo Unknown = new() { Volumes = [] };
/// <summary>
@@ -281,9 +290,7 @@ public sealed record RamModule
/// </summary>
public sealed record RamInfo
{
- /// <summary>
- /// A sentinel value representing unknown RAM information.
- /// </summary>
+ /// <summary>A sentinel value representing unknown RAM information.</summary>
public static readonly RamInfo Unknown = new()
{
TotalGB = 0,
@@ -336,9 +343,7 @@ public sealed record RamInfo
/// </summary>
public sealed record OsInfo
{
- /// <summary>
- /// A sentinel value representing unknown OS information.
- /// </summary>
+ /// <summary>A sentinel value representing unknown OS information.</summary>
public static readonly OsInfo Unknown = new()
{
Name = Translations.Common_Unknown,
@@ -397,9 +402,7 @@ public sealed record OsInfo
/// </summary>
public sealed record BiosInfo
{
- /// <summary>
- /// A sentinel value representing unknown BIOS information.
- /// </summary>
+ /// <summary>A sentinel value representing unknown BIOS information.</summary>
public static readonly BiosInfo Unknown = new()
{
Manufacturer = Translations.Common_Unknown,
@@ -440,9 +443,7 @@ public sealed record BiosInfo
/// </summary>
public sealed record SystemSnapshot
{
- /// <summary>
- /// A sentinel value representing a completely unknown system.
- /// </summary>
+ /// <summary>A sentinel value representing a completely unknown system.</summary>
public static readonly SystemSnapshot Unknown = new()
{
Cpu = CpuInfo.Unknown,
@@ -566,7 +567,8 @@ internal static class WmiHelper
/// <summary>
/// Executes a WMI query and passes results to a selector.
/// All ManagementObject items are disposed after the selector completes.
- /// Returns <c>default(T)</c> if the query fails or throws — callers must null-check for reference types.
+ /// Returns <c>default(T)</c> if the query fails or throws; callers must null-check
+ /// the result for reference types.
/// </summary>
public static T? Query<T>(
string query,
@@ -799,14 +801,14 @@ internal static class CpuProvider
}
}
- private static string DetectCpuVendor(string manufacturer)
+ private static CpuVendor DetectCpuVendor(string manufacturer)
{
var lower = manufacturer.ToLowerInvariant();
if (lower.Contains("intel") || lower.Contains("genuineintel"))
- return "Intel";
+ return CpuVendor.Intel;
if (lower.Contains("amd") || lower.Contains("authenticamd"))
- return "AMD";
- return "Unknown";
+ return CpuVendor.AMD;
+ return CpuVendor.Unknown;
}
}
@@ -1622,7 +1624,7 @@ internal static class GpuProvider
}
catch
{
- // DXGI unavailable (e.g., ancient OS or headless server) — fall back to WMI
+ // DXGI unavailable (e.g., old OS or headless server), so fall back to WMI
return GetAllViaWmi();
}
}
@@ -2179,6 +2181,26 @@ public sealed class SystemInfoService : IDisposable
public SystemSnapshot Snapshot { get; private set; } = SystemSnapshot.Unknown;
+ /// <summary>
+ /// Raised whenever a refresh completes with a new snapshot. Fires on the thread
+ /// that finished the refresh (usually a thread-pool thread), so subscribers must
+ /// marshal back to the UI thread before touching the UI.
+ /// </summary>
+ public event EventHandler<SystemSnapshot>? SnapshotRefreshed;
+
+ /// <summary>
+ /// Returns the current snapshot, refreshing it first when it has not been loaded yet.
+ /// Callers that need hardware/OS facts (e.g. compatibility conditions) use this to
+ /// guarantee a populated snapshot before reading it.
+ /// </summary>
+ public async Task<SystemSnapshot> EnsureSnapshotAsync(CancellationToken ct = default)
+ {
+ if (!ReferenceEquals(Snapshot, SystemSnapshot.Unknown))
+ return Snapshot;
+
+ return await RefreshAsync(ct).ConfigureAwait(false);
+ }
+
public async Task<SystemSnapshot> RefreshAsync(CancellationToken ct = default)
{
await _semaphore.WaitAsync(ct).ConfigureAwait(false);
@@ -2239,8 +2261,6 @@ public sealed class SystemInfoService : IDisposable
Disk = await diskTask,
};
}
-
- return Snapshot;
}
catch (OperationCanceledException)
{
@@ -2255,6 +2275,20 @@ public sealed class SystemInfoService : IDisposable
{
_semaphore.Release();
}
+
+ // Raised after the semaphore is released so subscribers can safely call back
+ // into RefreshAsync; handler exceptions are isolated and logged so a failing
+ // subscriber never corrupts the refresh result.
+ try
+ {
+ SnapshotRefreshed?.Invoke(this, Snapshot);
+ }
+ catch (Exception ex)
+ {
+ _logger.LogError(ex, "Snapshot refresh notification handler failed");
+ }
+
+ return Snapshot;
}
public void LogSummary()
diff --git a/optimizerDuck/UI/Pages/Customize/Categories/CustomizeCategoryPage.xaml b/optimizerDuck/UI/Pages/Customize/Categories/CustomizeCategoryPage.xaml
index 8224925..f0b0601 100644
--- a/optimizerDuck/UI/Pages/Customize/Categories/CustomizeCategoryPage.xaml
+++ b/optimizerDuck/UI/Pages/Customize/Categories/CustomizeCategoryPage.xaml
@@ -43,6 +43,175 @@
</Setter.Value>
</Setter>
</Style>
+
+ <!-- Shared setting card used by both the main category content and the Unsupported Settings expander -->
+ <DataTemplate x:Key="SettingCardTemplate">
+ <ui:CardControl Margin="0,0,0,4">
+ <ui:CardControl.Icon>
+ <ui:SymbolIcon Symbol="{Binding Icon}" />
+ </ui:CardControl.Icon>
+ <ui:CardControl.Header>
+ <StackPanel VerticalAlignment="Center">
+ <StackPanel Orientation="Horizontal">
+ <ui:TextBlock
+ Margin="0,0,10,0"
+ FontTypography="Body"
+ Text="{Binding Name}"
+ TextWrapping="Wrap" />
+ <Border
+ Padding="6,2"
+ HorizontalAlignment="Left"
+ CornerRadius="{StaticResource CornerRadiusSmall}"
+ Cursor="Help"
+ ToolTip="{Binding RecommendationReason}"
+ ToolTipService.HasDropShadow="True"
+ ToolTipService.InitialShowDelay="50"
+ ToolTipService.Placement="Top"
+ Visibility="{Binding HasRecommendation, Converter={StaticResource BoolToVisibilityConverter}}">
+ <Border.Style>
+ <Style TargetType="Border">
+ <Setter Property="Background" Value="{DynamicResource SystemFillColorSuccessBrush}" />
+ <Style.Triggers>
+ <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.On}">
+ <Setter Property="Background" Value="{DynamicResource SystemFillColorSuccessBrush}" />
+ </DataTrigger>
+ <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.Off}">
+ <Setter Property="Background" Value="{DynamicResource ControlFillColorSecondaryBrush}" />
+ </DataTrigger>
+ <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.Experimental}">
+ <Setter Property="Background" Value="{DynamicResource SystemFillColorCautionBrush}" />
+ </DataTrigger>
+ <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.Depends}">
+ <Setter Property="Background" Value="{DynamicResource SystemFillColorAttentionBrush}" />
+ </DataTrigger>
+ </Style.Triggers>
+ </Style>
+ </Border.Style>
+ <StackPanel Orientation="Horizontal">
+ <ui:TextBlock
+ Margin="0,0,5,0"
+ HorizontalAlignment="Center"
+ VerticalAlignment="Center"
+ FontTypography="Caption"
+ Style="{StaticResource RecommendationForegroundTextBlockStyle}"
+ Text="{Binding RecommendationStateDisplay}"
+ TextWrapping="Wrap" />
+ <ui:SymbolIcon
+ Margin="0,0,4,0"
+ HorizontalAlignment="Center"
+ VerticalAlignment="Center"
+ Style="{StaticResource RecommendationForegroundSymbolStyle}"
+ Symbol="{Binding RecommendationIcon}" />
+ <ui:SymbolIcon
+ HorizontalAlignment="Center"
+ VerticalAlignment="Center"
+ Style="{StaticResource RecommendationForegroundSymbolStyle}"
+ Symbol="QuestionCircle24" />
+ </StackPanel>
+ </Border>
+
+ </StackPanel>
+ <ui:TextBlock
+ Margin="0,4,0,0"
+ FontTypography="Caption"
+ Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+ Text="{Binding Description}"
+ TextTrimming="WordEllipsis"
+ TextWrapping="Wrap" />
+ <!-- Unsupported explanation -->
+ <StackPanel
+ Margin="0,4,0,0"
+ Orientation="Horizontal"
+ Visibility="{Binding IsUnsupported, Converter={StaticResource BoolToVisibilityConverter}}">
+ <ui:SymbolIcon
+ Margin="0,0,6,0"
+ VerticalAlignment="Center"
+ Foreground="{DynamicResource SystemFillColorCautionBrush}"
+ Symbol="Warning24" />
+ <ui:TextBlock
+ VerticalAlignment="Center"
+ FontTypography="Caption"
+ Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+ Text="{Binding ConditionDescription}"
+ TextWrapping="Wrap" />
+ </StackPanel>
+ </StackPanel>
+ </ui:CardControl.Header>
+ <StackPanel
+ Margin="0,0,0,0"
+ HorizontalAlignment="Right"
+ Orientation="Horizontal">
+ <!-- Toggle Control -->
+ <ui:ToggleSwitch
+ Command="{Binding ToggleCommand}"
+ Cursor="Hand"
+ IsChecked="{Binding IsEnabled, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}"
+ OffContent="{ext:Loc Common.Toggle.Off}"
+ OnContent="{ext:Loc Common.Toggle.On}"
+ Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.Toggle}}" />
+ <!-- Dropdown Control -->
+ <ComboBox
+ MinWidth="140"
+ VerticalAlignment="Center"
+ Cursor="Hand"
+ DisplayMemberPath="DisplayName"
+ ItemsSource="{Binding Options}"
+ SelectedValue="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+ SelectedValuePath="Value"
+ Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.Dropdown}}" />
+ <!-- Option Control -->
+ <ListBox
+ MinWidth="140"
+ VerticalAlignment="Center"
+ DisplayMemberPath="DisplayName"
+ ItemsSource="{Binding Options}"
+ SelectedValue="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+ SelectedValuePath="Value"
+ Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.Option}}">
+ <ListBox.ItemsPanel>
+ <ItemsPanelTemplate>
+ <StackPanel Orientation="Horizontal" />
+ </ItemsPanelTemplate>
+ </ListBox.ItemsPanel>
+ </ListBox>
+ <!-- Number Control -->
+ <ui:NumberBox
+ MinWidth="120"
+ VerticalAlignment="Center"
+ Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.NumberInt}}"
+ Value="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
+ <ui:NumberBox
+ MinWidth="120"
+ VerticalAlignment="Center"
+ Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.NumberFloat}}"
+ Value="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
+ <!-- String Control -->
+ <TextBox
+ MinWidth="160"
+ VerticalAlignment="Center"
+ Text="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=LostFocus}"
+ Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.String}}" />
+ <ui:Button
+ Margin="8,0,0,0"
+ VerticalAlignment="Center"
+ Background="Transparent"
+ BorderBrush="Transparent"
+ Command="{Binding DataContext.ViewModel.ViewSourceOnGitHubCommand, RelativeSource={RelativeSource AncestorType=Page}}"
+ CommandParameter="{Binding}"
+ Cursor="Hand"
+ Icon="{ui:SymbolIcon Code24}"
+ ToolTip="{ext:Loc Optimizer.Menu.ViewSource}" />
+ </StackPanel>
+ </ui:CardControl>
+ </DataTemplate>
+
+ <!-- Shared section template used by both the main list and the Unsupported Settings expander -->
+ <DataTemplate x:Key="SettingSectionTemplate">
+ <StackPanel Margin="0,0,0,20">
+ <ui:TextBlock Style="{StaticResource SectionHeaderStyle}" Text="{Binding Name}" />
+ <ItemsControl ItemTemplate="{StaticResource SettingCardTemplate}" ItemsSource="{Binding Features}" />
+ </StackPanel>
+ </DataTemplate>
</Page.Resources>
<Grid>
@@ -117,167 +286,61 @@
Grid.Row="2"
HorizontalScrollBarVisibility="Disabled"
VerticalScrollBarVisibility="Auto">
- <ui:VirtualizingItemsControl ItemsSource="{Binding ViewModel.Sections}" Style="{x:Null}">
- <ItemsControl.ItemsPanel>
- <ItemsPanelTemplate>
- <VirtualizingStackPanel
- Margin="0,0,0,-20"
- IsVirtualizing="True" VirtualizationMode="Recycling" />
- </ItemsPanelTemplate>
- </ItemsControl.ItemsPanel>
+ <StackPanel>
+ <!-- Main category content (unsupported settings are excluded) -->
+ <ui:VirtualizingItemsControl
+ ItemTemplate="{StaticResource SettingSectionTemplate}"
+ ItemsSource="{Binding ViewModel.Sections}"
+ Style="{x:Null}">
+ <ItemsControl.ItemsPanel>
+ <ItemsPanelTemplate>
+ <VirtualizingStackPanel
+ Margin="0,0,0,-20"
+ IsVirtualizing="True"
+ VirtualizationMode="Recycling" />
+ </ItemsPanelTemplate>
+ </ItemsControl.ItemsPanel>
+ </ui:VirtualizingItemsControl>
- <ui:VirtualizingItemsControl.ItemTemplate>
- <DataTemplate>
- <StackPanel Margin="0,0,0,20">
- <ui:TextBlock Style="{StaticResource SectionHeaderStyle}" Text="{Binding Name}" />
- <ItemsControl ItemsSource="{Binding Features}">
- <ItemsControl.ItemTemplate>
- <DataTemplate>
- <ui:CardControl Margin="0,0,0,4">
- <ui:CardControl.Icon>
- <ui:SymbolIcon Symbol="{Binding Icon}" />
- </ui:CardControl.Icon>
- <ui:CardControl.Header>
- <StackPanel VerticalAlignment="Center">
- <StackPanel Orientation="Horizontal">
- <ui:TextBlock
- Margin="0,0,10,0"
- FontTypography="Body"
- Text="{Binding Name}"
- TextWrapping="Wrap" />
- <Border
- Padding="6,2"
- HorizontalAlignment="Left"
- CornerRadius="{StaticResource CornerRadiusSmall}"
- ToolTip="{Binding RecommendationReason}"
- ToolTipService.HasDropShadow="True"
- ToolTipService.InitialShowDelay="50"
- ToolTipService.Placement="Top"
- Visibility="{Binding HasRecommendation, Converter={StaticResource BoolToVisibilityConverter}}">
- <Border.Style>
- <Style TargetType="Border">
- <Setter Property="Background" Value="{DynamicResource SystemFillColorSuccessBrush}" />
- <Style.Triggers>
- <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.On}">
- <Setter Property="Background" Value="{DynamicResource SystemFillColorSuccessBrush}" />
- </DataTrigger>
- <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.Off}">
- <Setter Property="Background" Value="{DynamicResource ControlFillColorSecondaryBrush}" />
- </DataTrigger>
- <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.Experimental}">
- <Setter Property="Background" Value="{DynamicResource SystemFillColorCautionBrush}" />
- </DataTrigger>
- <DataTrigger Binding="{Binding Recommendation.State}" Value="{x:Static models:RecommendationState.Depends}">
- <Setter Property="Background" Value="{DynamicResource SystemFillColorAttentionBrush}" />
- </DataTrigger>
- </Style.Triggers>
- </Style>
- </Border.Style>
- <StackPanel Orientation="Horizontal">
- <ui:TextBlock
- Margin="0,0,5,0"
- HorizontalAlignment="Center"
- VerticalAlignment="Center"
- FontTypography="Caption"
- Style="{StaticResource RecommendationForegroundTextBlockStyle}"
- Text="{Binding RecommendationStateDisplay}"
- TextWrapping="Wrap" />
- <ui:SymbolIcon
- Margin="0,0,4,0"
- HorizontalAlignment="Center"
- VerticalAlignment="Center"
- Style="{StaticResource RecommendationForegroundSymbolStyle}"
- Symbol="{Binding RecommendationIcon}" />
- <ui:SymbolIcon
- HorizontalAlignment="Center"
- VerticalAlignment="Center"
- Style="{StaticResource RecommendationForegroundSymbolStyle}"
- Symbol="QuestionCircle24" />
- </StackPanel>
- </Border>
- </StackPanel>
- <ui:TextBlock
- Margin="0,4,0,0"
- FontTypography="Caption"
- Foreground="{DynamicResource TextFillColorSecondaryBrush}"
- Text="{Binding Description}"
- TextTrimming="WordEllipsis"
- TextWrapping="Wrap" />
- </StackPanel>
- </ui:CardControl.Header>
- <StackPanel
- Margin="0,0,0,0"
- HorizontalAlignment="Right"
- Orientation="Horizontal">
- <!-- Toggle Control -->
- <ui:ToggleSwitch
- Command="{Binding ToggleCommand}"
- Cursor="Hand"
- IsChecked="{Binding IsEnabled, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}"
- OffContent="{ext:Loc Common.Toggle.Off}"
- OnContent="{ext:Loc Common.Toggle.On}"
- Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.Toggle}}" />
- <!-- Dropdown Control -->
- <ComboBox
- MinWidth="140"
- VerticalAlignment="Center"
- Cursor="Hand"
- DisplayMemberPath="DisplayName"
- ItemsSource="{Binding Options}"
- SelectedValue="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
- SelectedValuePath="Value"
- Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.Dropdown}}" />
- <!-- Option Control -->
- <ListBox
- MinWidth="140"
- VerticalAlignment="Center"
- DisplayMemberPath="DisplayName"
- ItemsSource="{Binding Options}"
- SelectedValue="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
- SelectedValuePath="Value"
- Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.Option}}">
- <ListBox.ItemsPanel>
- <ItemsPanelTemplate>
- <StackPanel Orientation="Horizontal" />
- </ItemsPanelTemplate>
- </ListBox.ItemsPanel>
- </ListBox>
- <!-- Number Control -->
- <ui:NumberBox
- MinWidth="120"
- VerticalAlignment="Center"
- Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.NumberInt}}"
- Value="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
- <ui:NumberBox
- MinWidth="120"
- VerticalAlignment="Center"
- Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.NumberFloat}}"
- Value="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
- <!-- String Control -->
- <TextBox
- MinWidth="160"
- VerticalAlignment="Center"
- Text="{Binding CurrentValue, Mode=TwoWay, UpdateSourceTrigger=LostFocus}"
- Visibility="{Binding ControlType, Converter={StaticResource EqualityToVisibilityConverter}, ConverterParameter={x:Static models:CustomizeControlType.String}}" />
- <ui:Button
- Margin="8,0,0,0"
- VerticalAlignment="Center"
- Background="Transparent"
- BorderBrush="Transparent"
- Command="{Binding DataContext.ViewModel.ViewSourceOnGitHubCommand, RelativeSource={RelativeSource AncestorType=Page}}"
- CommandParameter="{Binding}"
- Cursor="Hand"
- Icon="{ui:SymbolIcon Code24}"
- ToolTip="{ext:Loc Optimizer.Menu.ViewSource}" />
- </StackPanel>
- </ui:CardControl>
- </DataTemplate>
- </ItemsControl.ItemTemplate>
- </ItemsControl>
+ <!-- Unsupported Settings expander -->
+ <ui:CardExpander Margin="0,0,0,20" Visibility="{Binding ViewModel.HasUnsupportedSettings, Converter={StaticResource BoolToVisibilityConverter}}">
+ <ui:CardExpander.Header>
+ <StackPanel Orientation="Horizontal">
+ <ui:SymbolIcon
+ Margin="0,0,12,0"
+ FontSize="24"
+ Foreground="{DynamicResource SystemFillColorCautionBrush}"
+ Symbol="Warning24" />
+ <StackPanel VerticalAlignment="Center">
+ <ui:TextBlock
+ VerticalAlignment="Center"
+ FontTypography="BodyStrong"
+ Text="{Binding ViewModel.UnsupportedSettingsHeader}"
+ TextWrapping="Wrap" />
+ <ui:TextBlock
+ Margin="0,2,0,0"
+ FontTypography="Caption"
+ Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+ Text="{ext:Loc Customize.UI.UnsupportedSettings.Description}"
+ TextWrapping="Wrap" />
+ </StackPanel>
</StackPanel>
- </DataTemplate>
- </ui:VirtualizingItemsControl.ItemTemplate>
- </ui:VirtualizingItemsControl>
+ </ui:CardExpander.Header>
+ <ui:VirtualizingItemsControl
+ ItemTemplate="{StaticResource SettingSectionTemplate}"
+ ItemsSource="{Binding ViewModel.UnsupportedSections}"
+ Style="{x:Null}">
+ <ItemsControl.ItemsPanel>
+ <ItemsPanelTemplate>
+ <VirtualizingStackPanel
+ Margin="0,0,0,-20"
+ IsVirtualizing="True"
+ VirtualizationMode="Recycling" />
+ </ItemsPanelTemplate>
+ </ItemsControl.ItemsPanel>
+ </ui:VirtualizingItemsControl>
+ </ui:CardExpander>
+ </StackPanel>
</ScrollViewer>
<Border Grid.Row="2" Visibility="{Binding ViewModel.IsLoading, Converter={StaticResource BoolToVisibilityConverter}}">
diff --git a/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPage.xaml b/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPage.xaml
index 3101524..95a34a7 100644
--- a/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPage.xaml
+++ b/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPage.xaml
@@ -224,163 +224,254 @@
BorderBrush="{DynamicResource CardStrokeColorDefaultBrush}"
BorderThickness="1"
CornerRadius="{StaticResource CornerRadiusMedium}">
- <Grid RowDefinitions="Auto,Auto,Auto,Auto,*">
- <ui:TextBlock
- Grid.Row="0"
- FontTypography="Caption"
- Foreground="{DynamicResource TextFillColorDisabledBrush}"
- Text="{Binding Id}"
- TextWrapping="Wrap" />
- <ui:TextBlock
- Grid.Row="1"
- FontTypography="Subtitle"
- Text="{Binding Name}"
- TextWrapping="Wrap" />
-
- <ui:VirtualizingItemsControl
- Grid.Row="2"
- Margin="0,2,0,2"
- ItemsSource="{Binding TagDisplays}">
- <ui:VirtualizingItemsControl.ItemsPanel>
- <ItemsPanelTemplate>
- <WrapPanel HorizontalAlignment="Left" VerticalAlignment="Top" />
- </ItemsPanelTemplate>
- </ui:VirtualizingItemsControl.ItemsPanel>
- <ui:VirtualizingItemsControl.ItemContainerStyle>
- <Style TargetType="ContentPresenter">
- <Setter Property="Margin" Value="0,0,2,2" />
- <Setter Property="HorizontalAlignment" Value="Left" />
- </Style>
- </ui:VirtualizingItemsControl.ItemContainerStyle>
- <ui:VirtualizingItemsControl.ItemTemplate>
- <DataTemplate>
- <Border
- Padding="6,2"
- HorizontalAlignment="Left"
- Background="{DynamicResource CardBackgroundFillColorSecondaryBrush}"
- CornerRadius="{StaticResource CornerRadiusSmall}">
- <StackPanel Orientation="Horizontal">
- <ui:SymbolIcon
- Margin="0,0,6,0"
- Foreground="{DynamicResource TextFillColorSecondaryBrush}"
- Symbol="{Binding Icon}" />
-
- <ui:TextBlock
- HorizontalAlignment="Center"
- VerticalAlignment="Center"
- FontTypography="Caption"
- Foreground="{DynamicResource TextFillColorSecondaryBrush}"
- Text="{Binding Display}"
- TextWrapping="Wrap" />
- </StackPanel>
- </Border>
- </DataTemplate>
- </ui:VirtualizingItemsControl.ItemTemplate>
- </ui:VirtualizingItemsControl>
-
- <ui:TextBlock
- Grid.Row="3"
- Margin="0,10,0,0"
- FontTypography="Body"
- Text="{Binding ShortDescription}"
- TextTrimming="WordEllipsis"
- TextWrapping="Wrap" />
+ <Grid>
+ <!-- Unsupported compatibility state -->
+ <Grid RowDefinitions="Auto, Auto, Auto, Auto, *" Visibility="{Binding IsConditionBlocked, Converter={StaticResource BooleanToVisibilityConverter}}">
+ <StackPanel Margin="0,0,0,8" Orientation="Horizontal">
+ <ui:SymbolIcon
+ Margin="0,0,8,0"
+ VerticalAlignment="Center"
+ FontSize="24"
+ Foreground="{DynamicResource SystemFillColorCautionBrush}"
+ Symbol="Warning24" />
+ <ui:TextBlock
+ VerticalAlignment="Center"
+ FontTypography="Subtitle"
+ Text="{ext:Loc Optimizer.Condition.BlockedTitle}" />
+ </StackPanel>
+ <ui:TextBlock
+ Grid.Row="1"
+ FontTypography="Caption"
+ Foreground="{DynamicResource TextFillColorDisabledBrush}"
+ Text="{Binding Id}"
+ TextWrapping="Wrap" />
+ <ui:TextBlock
+ Grid.Row="2"
+ FontTypography="Subtitle"
+ Text="{Binding Name}"
+ TextWrapping="Wrap" />
- <Grid
- Grid.Row="4"
- Margin="0,10,0,0"
- VerticalAlignment="Bottom"
- ColumnDefinitions="*,Auto">
- <Grid RowDefinitions="Auto,Auto">
- <Border
- Padding="6,2"
- HorizontalAlignment="Left"
- CornerRadius="{StaticResource CornerRadiusSmall}">
- <Border.Style>
- <Style TargetType="Border">
- <Setter Property="Background" Value="{DynamicResource SystemFillColorSuccessBrush}" />
- <Style.Triggers>
- <DataTrigger Binding="{Binding Risk}" Value="Moderate">
- <Setter Property="Background" Value="{DynamicResource SystemFillColorCautionBrush}" />
- </DataTrigger>
- <DataTrigger Binding="{Binding Risk}" Value="Risky">
- <Setter Property="Background" Value="{DynamicResource SystemFillColorCriticalBrush}" />
- </DataTrigger>
- </Style.Triggers>
- </Style>
- </Border.Style>
+ <Border
+ Grid.Row="3"
+ Margin="0,12,0,0"
+ Padding="10,8"
+ Background="{DynamicResource CardBackgroundFillColorSecondaryBrush}"
+ CornerRadius="{StaticResource CornerRadiusSmall}">
+ <StackPanel>
<StackPanel Orientation="Horizontal">
<ui:SymbolIcon
Margin="0,0,6,0"
- Foreground="{DynamicResource TextFillColorInverseBrush}"
- Symbol="{Binding RiskVisual.Icon}" />
-
+ VerticalAlignment="Center"
+ Foreground="{DynamicResource SystemFillColorCautionBrush}"
+ Symbol="Warning24" />
<ui:TextBlock
- HorizontalAlignment="Center"
VerticalAlignment="Center"
FontTypography="Caption"
- Foreground="{DynamicResource TextFillColorInverseBrush}"
- Text="{Binding RiskVisual.Display}"
- TextWrapping="Wrap" />
+ FontWeight="SemiBold"
+ Foreground="{DynamicResource SystemFillColorCautionBrush}"
+ Text="{ext:Loc Optimizer.Condition.FailedTitle}" />
</StackPanel>
- </Border>
+ <ui:TextBlock
+ Margin="0,6,0,0"
+ FontTypography="BodyStrong"
+ Text="{Binding ConditionResult.Title}"
+ TextWrapping="Wrap" />
+ <ui:TextBlock
+ Margin="0,2,0,0"
+ FontTypography="Body"
+ Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+ Text="{Binding ConditionResult.Description}"
+ TextWrapping="Wrap" />
+ </StackPanel>
+ </Border>
+ <StackPanel
+ Grid.Row="4"
+ Margin="0,12,0,0"
+ VerticalAlignment="Bottom"
+ Orientation="Horizontal">
+ <ui:Button
+ Margin="0,0,8,0"
+ Command="{Binding DataContext.ViewModel.HideConditionCommand, RelativeSource={RelativeSource AncestorType=Page}}"
+ CommandParameter="{Binding}"
+ Content="{ext:Loc Optimizer.Condition.Hide}"
+ Cursor="Hand"
+ ToolTip="{ext:Loc Optimizer.Condition.Hide.Tooltip}" />
<Border
- Grid.Row="1"
- Margin="0,8,0,0"
- Padding="6,2"
- HorizontalAlignment="Left"
- Background="{DynamicResource CardBackgroundDisabled}"
- CornerRadius="{StaticResource CornerRadiusSmall}"
- ToolTip="{Binding State.AppliedAt}"
+ Cursor="Help"
+ ToolTip="{ext:Loc Optimizer.Condition.WhatIsThis.Tooltip}"
ToolTipService.InitialShowDelay="150"
- ToolTipService.Placement="Top"
- Visibility="{Binding State.AppliedAt, Converter={StaticResource NullToVisibilityConverter}}">
+ ToolTipService.Placement="Top">
<StackPanel Orientation="Horizontal">
- <ui:SymbolIcon Margin="0,0,6,0" Symbol="CheckmarkCircle24" />
+ <ui:SymbolIcon Margin="0,0,4,0" Symbol="QuestionCircle24" />
<ui:TextBlock
HorizontalAlignment="Center"
VerticalAlignment="Center"
- FontTypography="Caption"
- Text="{Binding State.RelativeTime}"
- TextWrapping="Wrap" />
+ Text="{ext:Loc Optimizer.Condition.WhatIsThis}" />
</StackPanel>
</Border>
- </Grid>
+ </StackPanel>
+ </Grid>
- <StackPanel
- Grid.Column="1"
- Margin="10,0,0,0"
+ <!-- Normal state -->
+ <Grid RowDefinitions="Auto,Auto,Auto,Auto,*" Visibility="{Binding IsConditionBlocked, Converter={StaticResource InverseBooleanToVisibilityConverter}}">
+ <ui:TextBlock
+ Grid.Row="0"
+ FontTypography="Caption"
+ Foreground="{DynamicResource TextFillColorDisabledBrush}"
+ Text="{Binding Id}"
+ TextWrapping="Wrap" />
+ <ui:TextBlock
+ Grid.Row="1"
+ FontTypography="Subtitle"
+ Text="{Binding Name}"
+ TextWrapping="Wrap" />
+
+ <ui:VirtualizingItemsControl
+ Grid.Row="2"
+ Margin="0,2,0,2"
+ ItemsSource="{Binding TagDisplays}">
+ <ui:VirtualizingItemsControl.ItemsPanel>
+ <ItemsPanelTemplate>
+ <WrapPanel HorizontalAlignment="Left" VerticalAlignment="Top" />
+ </ItemsPanelTemplate>
+ </ui:VirtualizingItemsControl.ItemsPanel>
+ <ui:VirtualizingItemsControl.ItemContainerStyle>
+ <Style TargetType="ContentPresenter">
+ <Setter Property="Margin" Value="0,0,2,2" />
+ <Setter Property="HorizontalAlignment" Value="Left" />
+ </Style>
+ </ui:VirtualizingItemsControl.ItemContainerStyle>
+ <ui:VirtualizingItemsControl.ItemTemplate>
+ <DataTemplate>
+ <Border
+ Padding="6,2"
+ HorizontalAlignment="Left"
+ Background="{DynamicResource CardBackgroundFillColorSecondaryBrush}"
+ CornerRadius="{StaticResource CornerRadiusSmall}">
+ <StackPanel Orientation="Horizontal">
+ <ui:SymbolIcon
+ Margin="0,0,6,0"
+ Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+ Symbol="{Binding Icon}" />
+
+ <ui:TextBlock
+ HorizontalAlignment="Center"
+ VerticalAlignment="Center"
+ FontTypography="Caption"
+ Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+ Text="{Binding Display}"
+ TextWrapping="Wrap" />
+ </StackPanel>
+ </Border>
+ </DataTemplate>
+ </ui:VirtualizingItemsControl.ItemTemplate>
+ </ui:VirtualizingItemsControl>
+
+ <ui:TextBlock
+ Grid.Row="3"
+ Margin="0,10,0,0"
+ FontTypography="Body"
+ Text="{Binding ShortDescription}"
+ TextTrimming="WordEllipsis"
+ TextWrapping="Wrap" />
+
+ <Grid
+ Grid.Row="4"
+ Margin="0,10,0,0"
VerticalAlignment="Bottom"
- Orientation="Horizontal">
- <ui:ToggleSwitch
- HorizontalAlignment="Right"
- Command="{Binding DataContext.ViewModel.ToggleOptimizationCommand, RelativeSource={RelativeSource AncestorType=Page}}"
- CommandParameter="{Binding}"
- Cursor="Hand"
- IsChecked="{Binding State.IsApplied, Mode=TwoWay}"
- IsEnabled="{Binding DataContext.ViewModel.IsProcessing, RelativeSource={RelativeSource AncestorType=Page}, Converter={StaticResource InverseBooleanConverter}}" />
- <ui:Button
- HorizontalAlignment="Right"
- VerticalAlignment="Bottom"
- Background="Transparent"
- BorderBrush="Transparent"
- Command="{Binding DataContext.ViewModel.ViewSourceOnGitHubCommand, RelativeSource={RelativeSource AncestorType=Page}}"
- CommandParameter="{Binding}"
- Cursor="Hand"
- Icon="{ui:SymbolIcon Code24}"
- ToolTip="{ext:Loc Optimizer.Menu.ViewSource}" />
- <ui:Button
- HorizontalAlignment="Right"
+ ColumnDefinitions="*,Auto">
+ <Grid RowDefinitions="Auto,Auto">
+ <Border
+ Padding="6,2"
+ HorizontalAlignment="Left"
+ CornerRadius="{StaticResource CornerRadiusSmall}">
+ <Border.Style>
+ <Style TargetType="Border">
+ <Setter Property="Background" Value="{DynamicResource SystemFillColorSuccessBrush}" />
+ <Style.Triggers>
+ <DataTrigger Binding="{Binding Risk}" Value="Moderate">
+ <Setter Property="Background" Value="{DynamicResource SystemFillColorCautionBrush}" />
+ </DataTrigger>
+ <DataTrigger Binding="{Binding Risk}" Value="Risky">
+ <Setter Property="Background" Value="{DynamicResource SystemFillColorCriticalBrush}" />
+ </DataTrigger>
+ </Style.Triggers>
+ </Style>
+ </Border.Style>
+ <StackPanel Orientation="Horizontal">
+ <ui:SymbolIcon
+ Margin="0,0,6,0"
+ Foreground="{DynamicResource TextFillColorInverseBrush}"
+ Symbol="{Binding RiskVisual.Icon}" />
+
+ <ui:TextBlock
+ HorizontalAlignment="Center"
+ VerticalAlignment="Center"
+ FontTypography="Caption"
+ Foreground="{DynamicResource TextFillColorInverseBrush}"
+ Text="{Binding RiskVisual.Display}"
+ TextWrapping="Wrap" />
+ </StackPanel>
+ </Border>
+
+ <Border
+ Grid.Row="1"
+ Margin="0,8,0,0"
+ Padding="6,2"
+ HorizontalAlignment="Left"
+ Background="{DynamicResource CardBackgroundDisabled}"
+ CornerRadius="{StaticResource CornerRadiusSmall}"
+ ToolTip="{Binding State.AppliedAt}"
+ ToolTipService.InitialShowDelay="150"
+ ToolTipService.Placement="Top"
+ Visibility="{Binding State.AppliedAt, Converter={StaticResource NullToVisibilityConverter}}">
+ <StackPanel Orientation="Horizontal">
+ <ui:SymbolIcon Margin="0,0,6,0" Symbol="CheckmarkCircle24" />
+ <ui:TextBlock
+ HorizontalAlignment="Center"
+ VerticalAlignment="Center"
+ FontTypography="Caption"
+ Text="{Binding State.RelativeTime}"
+ TextWrapping="Wrap" />
+ </StackPanel>
+ </Border>
+ </Grid>
+
+ <StackPanel
+ Grid.Column="1"
+ Margin="10,0,0,0"
VerticalAlignment="Bottom"
- Appearance="Transparent"
- Background="Transparent"
- BorderBrush="Transparent"
- Command="{Binding DataContext.ViewModel.ShowDetailsCommand, RelativeSource={RelativeSource AncestorType=Page}}"
- CommandParameter="{Binding}"
- Cursor="Hand"
- Icon="{ui:SymbolIcon MoreVertical24}" />
- </StackPanel>
+ Orientation="Horizontal">
+ <ui:ToggleSwitch
+ HorizontalAlignment="Right"
+ Command="{Binding DataContext.ViewModel.ToggleOptimizationCommand, RelativeSource={RelativeSource AncestorType=Page}}"
+ CommandParameter="{Binding}"
+ Cursor="Hand"
+ IsChecked="{Binding State.IsApplied, Mode=TwoWay}"
+ IsEnabled="{Binding DataContext.ViewModel.IsProcessing, RelativeSource={RelativeSource AncestorType=Page}, Converter={StaticResource InverseBooleanConverter}}" />
+ <ui:Button
+ HorizontalAlignment="Right"
+ VerticalAlignment="Bottom"
+ Background="Transparent"
+ BorderBrush="Transparent"
+ Command="{Binding DataContext.ViewModel.ViewSourceOnGitHubCommand, RelativeSource={RelativeSource AncestorType=Page}}"
+ CommandParameter="{Binding}"
+ Cursor="Hand"
+ Icon="{ui:SymbolIcon Code24}"
+ ToolTip="{ext:Loc Optimizer.Menu.ViewSource}" />
+ <ui:Button
+ HorizontalAlignment="Right"
+ VerticalAlignment="Bottom"
+ Appearance="Transparent"
+ Background="Transparent"
+ BorderBrush="Transparent"
+ Command="{Binding DataContext.ViewModel.ShowDetailsCommand, RelativeSource={RelativeSource AncestorType=Page}}"
+ CommandParameter="{Binding}"
+ Cursor="Hand"
+ Icon="{ui:SymbolIcon MoreVertical24}" />
+ </StackPanel>
+ </Grid>
</Grid>
</Grid>
</Border>
diff --git a/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPages.cs b/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPages.cs
index 477cfd0..0f8dff5 100644
--- a/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPages.cs
+++ b/optimizerDuck/UI/Pages/Optimize/Categories/OptimizationPages.cs
@@ -30,27 +30,27 @@ public sealed class BloatwareAndServicesOptimizerPage : OptimizationPage
}
}
-public sealed class GpuOptimizerPage : OptimizationPage
+public sealed class PerformanceOptimizerPage : OptimizationPage
{
- public GpuOptimizerPage(OptimizationCategoryViewModel viewModel)
+ public PerformanceOptimizerPage(OptimizationCategoryViewModel viewModel)
: base(viewModel)
{
InitializeComponent();
}
}
-public sealed class PerformanceOptimizerPage : OptimizationPage
+public sealed class SecurityAndPrivacyOptimizerPage : OptimizationPage
{
- public PerformanceOptimizerPage(OptimizationCategoryViewModel viewModel)
+ public SecurityAndPrivacyOptimizerPage(OptimizationCategoryViewModel viewModel)
: base(viewModel)
{
InitializeComponent();
}
}
-public sealed class SecurityAndPrivacyOptimizerPage : OptimizationPage
+public sealed class AIOptimizerPage : OptimizationPage
{
- public SecurityAndPrivacyOptimizerPage(OptimizationCategoryViewModel viewModel)
+ public AIOptimizerPage(OptimizationCategoryViewModel viewModel)
: base(viewModel)
{
InitializeComponent();
diff --git a/optimizerDuck/UI/ViewModels/Customize/CustomizeItemViewModel.cs b/optimizerDuck/UI/ViewModels/Customize/CustomizeItemViewModel.cs
index 86d20e8..90767c4 100644
--- a/optimizerDuck/UI/ViewModels/Customize/CustomizeItemViewModel.cs
+++ b/optimizerDuck/UI/ViewModels/Customize/CustomizeItemViewModel.cs
@@ -3,6 +3,8 @@ using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Microsoft.Extensions.Logging;
using optimizerDuck.Domain.Abstractions;
+using optimizerDuck.Domain.Conditions;
+using optimizerDuck.Common.Helpers;
using optimizerDuck.Domain.Customize.Models;
using optimizerDuck.Domain.Execution;
using optimizerDuck.Services.Configuration;
@@ -33,7 +35,12 @@ public partial class CustomizeItemViewModel(
public ICustomizeSetting Setting => setting;
public CustomizeControlType ControlType => setting.ControlType;
- public IReadOnlyList<SettingOption>? Options => setting.Options;
+
+ // Populated by LoadStateAsync: materializing Options here would perform registry
+ // I/O on the UI thread during construction.
+ [ObservableProperty]
+ private IReadOnlyList<SettingOption>? _options;
+
public SymbolRegular Icon => setting.Icon;
[ObservableProperty]
@@ -57,9 +64,25 @@ public partial class CustomizeItemViewModel(
[ObservableProperty]
private object? _currentValue;
+ /// <summary>Gets or sets the evaluated compatibility result for this setting.</summary>
+ [ObservableProperty]
+ [NotifyPropertyChangedFor(nameof(IsUnsupported))]
+ [NotifyPropertyChangedFor(nameof(ConditionTitle))]
+ [NotifyPropertyChangedFor(nameof(ConditionDescription))]
+ private ConditionResult _conditionResult = ConditionResult.Available;
+
public CustomizeRecommendationResult? Recommendation => setting.GetRecommendation();
public bool HasRecommendation => Recommendation != null;
+ /// <summary>Gets whether this setting is unsupported on the current system.</summary>
+ public bool IsUnsupported => ConditionResult.IsBlocking;
+
+ /// <summary>Gets the localized condition failure title, or <c>null</c>.</summary>
+ public string? ConditionTitle => ConditionResult.Title;
+
+ /// <summary>Gets the localized condition failure description, or <c>null</c>.</summary>
+ public string? ConditionDescription => ConditionResult.Description;
+
public string? RecommendationStateDisplay =>
Recommendation?.State switch
{
@@ -83,12 +106,24 @@ public partial class CustomizeItemViewModel(
public string? RecommendationReason =>
Recommendation != null ? Loc.Instance[Recommendation.ReasonTranslationKey] : null;
+ /// <summary>
+ /// Loads the setting's current state, effective options and value, then subscribes
+ /// to registry changes. Registry I/O runs on the thread pool.
+ /// </summary>
public async Task LoadStateAsync()
{
try
{
- IsEnabled = await setting.GetStateAsync();
- CurrentValue = setting.CurrentValue;
+ // Registry I/O (state query, options, current value) runs on the thread pool
+ // so page load never blocks the UI thread.
+ IsEnabled = await Task.Run(() => setting.GetStateAsync());
+
+ // Publish the effective options before the selection value so the ComboBox
+ // item list already contains the value when the SelectedValue binding resolves.
+ var options = await Task.Run(() => setting.Options);
+ UpdateOptions(options);
+
+ CurrentValue = await Task.Run(() => setting.CurrentValue);
_hasLoaded = true;
SubscribeToRegistryChanges();
@@ -99,6 +134,36 @@ public partial class CustomizeItemViewModel(
}
}
+ /// <summary>
+ /// Publishes the given options only when the list actually changed, so the ComboBox
+ /// isn't needlessly rebuilt.
+ /// </summary>
+ private void UpdateOptions(IReadOnlyList<SettingOption>? options)
+ {
+ if (HasSameOptionValues(Options, options))
+ return;
+
+ Options = options;
+ }
+
+ private static bool HasSameOptionValues(
+ IReadOnlyList<SettingOption>? a,
+ IReadOnlyList<SettingOption>? b
+ )
+ {
+ if (a is null || b is null)
+ return a is null && b is null;
+
+ if (a.Count != b.Count)
+ return false;
+
+ for (var i = 0; i < a.Count; i++)
+ if (!Equals(a[i].Value, b[i].Value))
+ return false;
+
+ return true;
+ }
+
private void SubscribeToRegistryChanges()
{
if (_disposed)
@@ -114,7 +179,7 @@ public partial class CustomizeItemViewModel(
registryWatcher.RegistryKeyChanged += OnRegistryKeyChanged;
}
- private async void OnRegistryKeyChanged(object? sender, string path)
+ private void OnRegistryKeyChanged(object? sender, string path)
{
if (_disposed || !_hasLoaded)
return;
@@ -122,29 +187,44 @@ public partial class CustomizeItemViewModel(
if (!_watchedPaths.Contains(path))
return;
- await Application.Current.Dispatcher.InvokeAsync(async () =>
- {
- try
- {
- lock (_applyLock)
- {
- if (_isApplying)
- return;
- }
+ // The watcher raises on a background thread, so run the refresh on the UI thread.
+ // UiThread.InvokeAsync resolves to the Func<Task> overload (the method returns
+ // Task), so the refresh task is observed rather than fire-and-forgotten. When no
+ // WPF Application exists (unit tests), it runs inline instead.
+ _ = UiThread.InvokeAsync(RefreshFromRegistryAsync);
+ }
- var state = await setting.GetStateWithRetryAsync(maxRetries: 4, delayMs: 80);
- IsEnabled = state;
- CurrentValue = setting.CurrentValue;
- }
- catch (Exception ex)
+ /// <summary>
+ /// Re-reads the live registry state and republishes the effective options and the
+ /// selection value. Marshalled to the UI thread by <see cref="OnRegistryKeyChanged"/>
+ /// when a watched key changes; also called directly from tests.
+ /// </summary>
+ internal async Task RefreshFromRegistryAsync()
+ {
+ try
+ {
+ lock (_applyLock)
{
- _logger.LogWarning(
- ex,
- "RegistryWatcher: failed to refresh state for {Setting}",
- setting.Name
- );
+ if (_isApplying)
+ return;
}
- });
+
+ // Only the refresh bookkeeping runs on the UI thread; the reads stay off it.
+ IsEnabled = await Task.Run(
+ () => setting.GetStateWithRetryAsync(maxRetries: 4, delayMs: 80)
+ );
+ var options = await Task.Run(() => setting.Options);
+ UpdateOptions(options);
+ CurrentValue = await Task.Run(() => setting.CurrentValue);
+ }
+ catch (Exception ex)
+ {
+ _logger.LogWarning(
+ ex,
+ "RegistryWatcher: failed to refresh state for {Setting}",
+ setting.Name
+ );
+ }
}
[RelayCommand]
@@ -248,14 +328,19 @@ public partial class CustomizeItemViewModel(
await setting.ApplyAsync(valueToApply);
}
- IsEnabled = await setting.GetStateWithRetryAsync();
+ IsEnabled = await Task.Run(() => setting.GetStateWithRetryAsync());
if (ControlType != CustomizeControlType.Toggle)
{
- CurrentValue = setting.CurrentValue;
+ var (options, current) = await Task.Run(
+ () => (setting.Options, setting.CurrentValue)
+ );
+ UpdateOptions(options);
+ CurrentValue = current;
}
- ((App)Application.Current).HasPendingChanges = true;
+ if (Application.Current is App app)
+ app.HasPendingChanges = true;
}
catch (Exception ex)
{
diff --git a/optimizerDuck/UI/ViewModels/Optimizer/OptimizationCategoryViewModel.cs b/optimizerDuck/UI/ViewModels/Optimizer/OptimizationCategoryViewModel.cs
index 3414149..abfe705 100644
--- a/optimizerDuck/UI/ViewModels/Optimizer/OptimizationCategoryViewModel.cs
+++ b/optimizerDuck/UI/ViewModels/Optimizer/OptimizationCategoryViewModel.cs
@@ -1,6 +1,8 @@
using System.Collections.ObjectModel;
+using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
+using System.Windows.Threading;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Microsoft.Extensions.Logging;
@@ -12,8 +14,11 @@ using optimizerDuck.Domain.Optimizations.Models;
using optimizerDuck.Domain.Revert;
using optimizerDuck.Domain.UI;
using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.Conditions;
+using optimizerDuck.Services.Configuration;
using optimizerDuck.Services.Optimization;
using optimizerDuck.Services.Revert;
+using optimizerDuck.Services.System;
using optimizerDuck.UI.Dialogs;
using optimizerDuck.UI.ViewModels.Dialogs;
using Wpf.Ui;
@@ -40,6 +45,7 @@ public partial class OptimizationCategoryViewModel : ViewModel
private readonly IOptimizationCategory _category;
private readonly IContentDialogService _contentDialogService;
private readonly ILogger<OptimizationCategoryViewModel> _logger;
+ private readonly SystemInfoService _systemInfoService;
private readonly OptimizationService _optimizationService;
private readonly RevertManager _revertManager;
private readonly ISnackbarService _snackbarService;
@@ -50,6 +56,7 @@ public partial class OptimizationCategoryViewModel : ViewModel
RevertManager revertManager,
ISnackbarService snackbarService,
IContentDialogService contentDialogService,
+ SystemInfoService systemInfoService,
ILogger<OptimizationCategoryViewModel> logger,
IOptionsMonitor<AppSettings> appOptionsMonitor
)
@@ -60,6 +67,7 @@ public partial class OptimizationCategoryViewModel : ViewModel
_snackbarService = snackbarService;
_logger = logger;
_contentDialogService = contentDialogService;
+ _systemInfoService = systemInfoService;
_appOptionsMonitor = appOptionsMonitor;
}
@@ -116,14 +124,8 @@ public partial class OptimizationCategoryViewModel : ViewModel
try
{
await Task.Delay(FilterDebounceDelay, token).ConfigureAwait(false);
- await Application.Current.Dispatcher.InvokeAsync(
- () =>
- {
- if (!token.IsCancellationRequested)
- ApplyFilter();
- },
- System.Windows.Threading.DispatcherPriority.Background
- );
+ if (!token.IsCancellationRequested)
+ await UiThread.InvokeAsync(ApplyFilter, DispatcherPriority.Background);
}
catch (OperationCanceledException)
{
@@ -253,7 +255,8 @@ public partial class OptimizationCategoryViewModel : ViewModel
return;
}
- ((App)Application.Current).HasPendingChanges = true;
+ if (Application.Current is App app)
+ app.HasPendingChanges = true;
var retryOutcome = await HandleRetryableFailuresAsync(
optimization,
@@ -296,7 +299,8 @@ public partial class OptimizationCategoryViewModel : ViewModel
p => _optimizationService.RevertAsync(optimization, p)
);
- ((App)Application.Current).HasPendingChanges = true;
+ if (Application.Current is App app)
+ app.HasPendingChanges = true;
var retryOutcome = await HandleRetryableFailuresAsync(
optimization,
@@ -350,6 +354,18 @@ public partial class OptimizationCategoryViewModel : ViewModel
_logger.Log(level, "{Message}: {Name}", message, optimization.OptimizationKey);
}
+ /// <summary>
+ /// Hides the unsupported condition state for this session, returning the
+ /// optimization to its normal card so the user can apply it anyway.
+ /// The hide choice is not persisted.
+ /// </summary>
+ [RelayCommand]
+ private void HideCondition(IOptimization optimization)
+ {
+ if (optimization is BaseOptimization baseOptimization)
+ baseOptimization.IsConditionHidden = true;
+ }
+
[RelayCommand]
private async Task ShowDetailsAsync(IOptimization optimization)
{
@@ -387,29 +403,95 @@ public partial class OptimizationCategoryViewModel : ViewModel
#region Helpers
- protected override Task InitializeOnceAsync()
+ protected override async Task InitializeOnceAsync()
{
IsLoading = true;
try
{
foreach (var optimization in _category.Optimizations)
{
- optimization.State.PropertyChanged += (_, e) =>
- {
- if (e.PropertyName == nameof(OptimizationState.IsApplied))
- OnPropertyChanged(nameof(HasAppliedOptimizations));
- };
+ // Listen to the optimization's own PropertyChanged instead of the nested
+ // State instance so a replaced State (BaseOptimization re-raises the
+ // change) can never orphan this subscription.
+ if (optimization is INotifyPropertyChanged notify)
+ notify.PropertyChanged += OnOptimizationStateChanged;
_allOptimizations.Add(optimization);
}
- ApplyFilter();
+ var snapshot = await _systemInfoService.EnsureSnapshotAsync();
+ if (ReferenceEquals(snapshot, SystemSnapshot.Unknown))
+ _logger.LogWarning(
+ "System snapshot is unavailable; conditions fail open for this session"
+ );
+
+ await UiThread.InvokeAsync(() =>
+ {
+ EvaluateConditions(snapshot);
+ ApplyFilter();
+ });
}
finally
{
IsLoading = false;
}
+ }
+
+ /// <summary>
+ /// Re-evaluates every optimization's condition and re-applies the filter when the
+ /// system snapshot is refreshed (e.g. hardware changed) or the UI language changes.
+ /// Marshalled to the UI thread by <see cref="UiThread"/>.
+ /// </summary>
+ private void OnSnapshotRefreshed(object? sender, SystemSnapshot snapshot) =>
+ ReEvaluateConditions(snapshot);
+
+ private void OnCultureChanged(object? sender, PropertyChangedEventArgs e) =>
+ ReEvaluateConditions(_systemInfoService.Snapshot);
+
+ private void ReEvaluateConditions(SystemSnapshot snapshot)
+ {
+ _ = UiThread.InvokeAsync(() =>
+ {
+ EvaluateConditions(snapshot);
+ ApplyFilter();
+ });
+ }
+
+ /// <summary>
+ /// Keeps <see cref="HasAppliedOptimizations"/> in sync when any optimization's
+ /// <see cref="IOptimization.State"/> changes (applied status or instance swap).
+ /// </summary>
+ private void OnOptimizationStateChanged(object? sender, PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName == nameof(IOptimization.State))
+ OnPropertyChanged(nameof(HasAppliedOptimizations));
+ }
- return Task.CompletedTask;
+ public override Task OnNavigatedToAsync()
+ {
+ _systemInfoService.SnapshotRefreshed += OnSnapshotRefreshed;
+ Loc.Instance.PropertyChanged += OnCultureChanged;
+ return base.OnNavigatedToAsync();
+ }
+
+ public override Task OnNavigatedFromAsync()
+ {
+ _systemInfoService.SnapshotRefreshed -= OnSnapshotRefreshed;
+ Loc.Instance.PropertyChanged -= OnCultureChanged;
+ return base.OnNavigatedFromAsync();
+ }
+
+ /// <summary>
+ /// Re-evaluates every optimization's condition against the system snapshot.
+ /// </summary>
+ private void EvaluateConditions(SystemSnapshot snapshot)
+ {
+ ConditionEvaluator.EvaluateAll(
+ _allOptimizations,
+ o => o.ConditionType,
+ (o, r) => o.ConditionResult = r,
+ snapshot,
+ _logger
+ );
}
/// <summary>
diff --git a/optimizerDuck/UI/ViewModels/Pages/CustomizeCategoryViewModel.cs b/optimizerDuck/UI/ViewModels/Pages/CustomizeCategoryViewModel.cs
index 573bfee..dcdcc8a 100644
--- a/optimizerDuck/UI/ViewModels/Pages/CustomizeCategoryViewModel.cs
+++ b/optimizerDuck/UI/ViewModels/Pages/CustomizeCategoryViewModel.cs
@@ -1,13 +1,16 @@
using System.Collections.ObjectModel;
-using System.Windows;
+using System.ComponentModel;
using System.Windows.Media;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Microsoft.Extensions.Logging;
using optimizerDuck.Common.Helpers;
using optimizerDuck.Domain.Abstractions;
+using optimizerDuck.Domain.Conditions;
using optimizerDuck.Domain.Customize.Models;
using optimizerDuck.Resources.Languages;
+using optimizerDuck.Services.Conditions;
+using optimizerDuck.Services.Configuration;
using optimizerDuck.Services.System;
using optimizerDuck.UI.ViewModels.Customize;
using Wpf.Ui.Appearance;
@@ -40,6 +43,18 @@ public partial class CustomizeCategoryViewModel : ViewModel
[ObservableProperty]
private ObservableCollection<CustomizeSection> _sections = [];
+ [ObservableProperty]
+ private ObservableCollection<CustomizeSection> _unsupportedSections = [];
+
+ [ObservableProperty]
+ private bool _hasUnsupportedSettings;
+
+ [ObservableProperty]
+ private int _unsupportedSettingsCount;
+
+ [ObservableProperty]
+ private string _unsupportedSettingsHeader = string.Empty;
+
[ObservableProperty]
private int _selectedSortByIndex;
@@ -48,15 +63,21 @@ public partial class CustomizeCategoryViewModel : ViewModel
#region Lifecycle
private readonly List<CustomizeItemViewModel> _allSettings = [];
+ private readonly List<CustomizeItemViewModel> _unsupportedSettings = [];
private readonly ICustomizeCategory? _currentCategory;
+ private readonly ILogger<CustomizeCategoryViewModel> _logger;
+ private readonly SystemInfoService _systemInfoService;
public CustomizeCategoryViewModel(
ICustomizeCategory category,
ILoggerFactory loggerFactory,
- IRegistryWatcher registryWatcher
+ IRegistryWatcher registryWatcher,
+ SystemInfoService systemInfoService
)
{
_currentCategory = category;
+ _systemInfoService = systemInfoService;
+ _logger = loggerFactory.CreateLogger<CustomizeCategoryViewModel>();
CategoryName = _currentCategory.Name;
CategoryDescription = _currentCategory.Description;
@@ -71,14 +92,90 @@ public partial class CustomizeCategoryViewModel : ViewModel
protected override async Task InitializeOnceAsync()
{
- await Task.WhenAll(_allSettings.Select(s => s.LoadStateAsync()));
- ApplyFilters();
+ var snapshot = await _systemInfoService.EnsureSnapshotAsync();
+ if (ReferenceEquals(snapshot, SystemSnapshot.Unknown))
+ _logger.LogWarning(
+ "System snapshot is unavailable; conditions fail open for this session"
+ );
+
+ // Keep all collection/UI mutation on the UI thread, consistent with the
+ // optimization category view model.
+ await UiThread.InvokeAsync(async () =>
+ {
+ EvaluateConditions(snapshot);
+ PartitionUnsupportedSettings();
+
+ await Task.WhenAll(_allSettings.Select(s => s.LoadStateAsync()));
+ ApplyFilters();
+ BuildUnsupportedSections();
+ });
IsLoading = false;
}
+ /// <summary>
+ /// Evaluates the compatibility condition of every setting against the system snapshot.
+ /// </summary>
+ private void EvaluateConditions(SystemSnapshot snapshot)
+ {
+ ConditionEvaluator.EvaluateAll(
+ _allSettings,
+ s => s.Setting.ConditionType,
+ (s, r) => s.ConditionResult = r,
+ snapshot,
+ _logger
+ );
+ }
+
+ /// <summary>
+ /// Recomputes the unsupported partition from the master settings list so settings that
+ /// fail their condition are shown under the expander instead of the main category
+ /// content. Idempotent: safe to call repeatedly as conditions are re-evaluated.
+ /// </summary>
+ private void PartitionUnsupportedSettings()
+ {
+ _unsupportedSettings.Clear();
+ _unsupportedSettings.AddRange(_allSettings.Where(static s => s.IsUnsupported));
+ }
+
+ /// <summary>
+ /// Groups the unsupported settings into the same section structure used by the main
+ /// category content, so the expander can reuse the existing card templates.
+ /// </summary>
+ private void BuildUnsupportedSections()
+ {
+ UnsupportedSections = GroupIntoSections(_unsupportedSettings);
+ UnsupportedSettingsCount = _unsupportedSettings.Count;
+ HasUnsupportedSettings = _unsupportedSettings.Count > 0;
+ UnsupportedSettingsHeader = string.Format(
+ Loc.Instance["Customize.UI.UnsupportedSettings.Header"],
+ UnsupportedSettingsCount
+ );
+ }
+
+ /// <summary>
+ /// Groups settings into ordered sections, placing settings without a section under
+ /// the "Other" header. Shared by the main list and the unsupported expander.
+ /// </summary>
+ private static ObservableCollection<CustomizeSection> GroupIntoSections(
+ IEnumerable<CustomizeItemViewModel> settings
+ )
+ {
+ return new ObservableCollection<CustomizeSection>(
+ settings
+ .GroupBy(f => string.IsNullOrEmpty(f.Section) ? Translations.Common_Other : f.Section)
+ .OrderBy(g => g.Key == Translations.Common_Other ? 1 : 0)
+ .ThenBy(g => g.Key)
+ .Select(g => new CustomizeSection
+ {
+ Name = g.Key,
+ Features = new ObservableCollection<CustomizeItemViewModel>([.. g]),
+ })
+ );
+ }
+
private void OnThemeChanged(ApplicationTheme currentApplicationTheme, Color systemAccent)
{
- Application.Current.Dispatcher.Invoke(() =>
+ _ = UiThread.InvokeAsync(() =>
{
if (CurrentApplicationTheme != currentApplicationTheme)
CurrentApplicationTheme = currentApplicationTheme;
@@ -89,9 +186,44 @@ public partial class CustomizeCategoryViewModel : ViewModel
{
ApplicationThemeManager.Changed -= OnThemeChanged;
ApplicationThemeManager.Changed += OnThemeChanged;
+
+ _systemInfoService.SnapshotRefreshed += OnSnapshotRefreshed;
+ Loc.Instance.PropertyChanged += OnCultureChanged;
+
return base.OnNavigatedToAsync();
}
+ public override Task OnNavigatedFromAsync()
+ {
+ ApplicationThemeManager.Changed -= OnThemeChanged;
+ _systemInfoService.SnapshotRefreshed -= OnSnapshotRefreshed;
+ Loc.Instance.PropertyChanged -= OnCultureChanged;
+
+ return base.OnNavigatedFromAsync();
+ }
+
+ /// <summary>
+ /// Re-evaluates every condition and rebuilds the filtered/unsupported partitions
+ /// when the system snapshot is refreshed (e.g. hardware changed) or the UI
+ /// language changes. Marshalled to the UI thread by <see cref="UiThread"/>.
+ /// </summary>
+ private void OnSnapshotRefreshed(object? sender, SystemSnapshot snapshot) =>
+ ReEvaluateConditions(snapshot);
+
+ private void OnCultureChanged(object? sender, PropertyChangedEventArgs e) =>
+ ReEvaluateConditions(_systemInfoService.Snapshot);
+
+ private void ReEvaluateConditions(SystemSnapshot snapshot)
+ {
+ _ = UiThread.InvokeAsync(() =>
+ {
+ EvaluateConditions(snapshot);
+ PartitionUnsupportedSettings();
+ BuildUnsupportedSections();
+ ApplyFilters();
+ });
+ }
+
#endregion
#region Filtering & Sorting
@@ -111,7 +243,8 @@ public partial class CustomizeCategoryViewModel : ViewModel
if (_currentCategory == null)
return;
- var filtered = _allSettings.AsEnumerable();
+ // Master list keeps every setting; unsupported ones are partitioned out below.
+ var filtered = _allSettings.Where(static f => !f.IsUnsupported).AsEnumerable();
if (!string.IsNullOrWhiteSpace(SearchText))
{
@@ -127,23 +260,7 @@ public partial class CustomizeCategoryViewModel : ViewModel
_ => filtered.OrderBy(f => f.Name),
};
- var grouped = sortedSettings
- .GroupBy(f => string.IsNullOrEmpty(f.Section) ? Translations.Common_Other : f.Section)
- .OrderBy(g => g.Key == Translations.Common_Other ? 1 : 0)
- .ThenBy(g => g.Key);
-
- var sections = new ObservableCollection<CustomizeSection>();
- foreach (var group in grouped)
- {
- var section = new CustomizeSection
- {
- Name = group.Key,
- Features = new ObservableCollection<CustomizeItemViewModel>([.. group]),
- };
- sections.Add(section);
- }
-
- Sections = sections;
+ Sections = GroupIntoSections(sortedSettings);
}
#endregion
diff --git a/optimizerDuck/UI/ViewModels/Pages/StartupManagerViewModel.cs b/optimizerDuck/UI/ViewModels/Pages/StartupManagerViewModel.cs
index de50c92..1cc6ff5 100644
--- a/optimizerDuck/UI/ViewModels/Pages/StartupManagerViewModel.cs
+++ b/optimizerDuck/UI/ViewModels/Pages/StartupManagerViewModel.cs
@@ -129,7 +129,7 @@ public partial class StartupManagerViewModel : ViewModel
try
{
- // Canonicalize and sanitize the file path to prevent argument injection
+ // Clean up the file path to prevent argument injection
// into explorer.exe's /select command.
var safePath = app.FilePath.Replace("\"", string.Empty);
safePath = Path.GetFullPath(safePath);