Address first batch of review suggestions.

Also:

Fix edge cases where dark mode did not get applied for ...

* CheckBoxes,
* RadioButtons
* Tabs.

* Move ApplyThemingImplicitly flag definition to CreateParams.
* Update approach to set ApplyThemingImplicitly control style.
* Delegate FlatStyle.Standard Button rendering to the System due to HighDpi
issues in the VisualStyle-based renderers.

Author: KlausLoeffelmann

.github/AI-Prompts/GDI-Refactoring/AIP-cache_pens-and_brushes.md

@@ -65,6 +65,8 @@ Available cached objects:
 
 Always use `var` for brevity and always apply `using` to ensure proper disposal.
 
+IMPORTANT: You cannot use pen- or brush-scoped, when the pen needs additional features, for example, when during its lifetime, the pen needs to be modified (e.g., `Inset`, `DashStyle`, `CustomStartCap`, etc.). In these cases, you need to use the non-cached version of the pen or brush.
+
 ### 1.3 Transforming Helper Methods
 
 When refactoring existing code:

.github/Copilot/GDIPlus-copilot-instructions.md

@@ -215,8 +215,11 @@
 
 - **Use `var` only for complex types when type is apparent from context**
   ```csharp
-  var control = new Button();              // OK - type is obvious
-  var items = GetComplexCollection();      // OK - long type name
+  var control = new Button();              // OK - type is obvious, but better is:
+  Button control = new();                  // Preferred
+  
+  // OK - long type name
+  var items = GetComplexCollectionWithRidiculousLongTypeName();
   int primitiveValue = 42;                 // Required for primitives
   ```
 
@@ -239,6 +242,11 @@
   ```csharp
   private static readonly int s_defaultBorderWidth = 1;
   ```
+An exception to this rule is when the field is attributed with `[ThreadStatic]`, in which case the prefix should be `t_`:
+  ```csharp
+  [ThreadStatic]
+  private static int t_threadLocalValue;
+  ```
 
 - **Prefix private/internal instance fields with `_`** (suggestion level)
   ```csharp
@@ -286,7 +294,7 @@
   private bool IsVisible() => Visible && Parent?.Visible == true;
   ```
 
-- For longer expressions, use line breaks with proper alignment:
+For longer expressions, use line breaks with proper alignment:
   ```csharp
   internal int SomeFooIntegerProperty =>
       _someFooIntegerProperty;
@@ -295,6 +303,19 @@
       size.Width > 0 
       && size.Height > 0;
   ```
+**IMPORTANT**
+
+In C#, `public Foo FooInstance => new Foo();` and `public Foo FooInstance { get; } = new Foo();` are NOT interchangeable.
+
+* The first is an expression-bodied property that returns a new value each time it is accessed.
+* The second is a read-only auto-property with initializer that returns the same value every time, created once.
+
+When editing, generating, or suggesting C# properties, always maintain the original intent:
+
+* Use an expression-bodied property (`=>`) for computed or dynamic values.
+* Use an auto-property with initializer (`{ get; } = ...`) for stored, initialized-once values.
+
+Never "correct" or convert one style to the other unless you are certain the semantic behavior is intended to change because it was wrong with 100% confidence to begin with. If you encounter a case, where you have a expression-bodied property that returns a new instance, and you encounter this in a code review, you should add a comment explaining why this is intended, and that it is not a mistake.
 
 ### 1.5 Error Handling and Argument Validation
 
@@ -345,19 +366,38 @@
 - **Handle platform-specific code appropriately**
   ```csharp
   [SupportedOSPlatform("windows")]
-  private void WindowsSpecificMethod() { ... }
+  private void WindowsSpecificMethod() 
+  { 
+      ... 
+  }
   ```
 
 - **Use proper disposal patterns**
-  ```csharp
-  using var brush = new SolidBrush(Color.Red);  // Simple using for single resources
-  
-  // Traditional using for complex scenarios
-  using (Graphics g = CreateGraphics())
-  {
-      // Drawing operations
-  }
-  ```
+Prefer the modern C# "using declaration" syntax (using var ...) over the traditional using statement block.
+Use:
+
+```csharp
+using var brush = backColor.GetCachedSolidBrushScope();
+```
+
+instead of:
+
+```csharp
+using (SolidBrushCache.Scope brush = backColor.GetCachedSolidBrushScope())
+{
+    // ...
+}
+```
+
+This makes code more concise, reduces nesting, and improves readability. Only use the older style if you need to limit the scope of the variable to a smaller section within a larger method, or when the using var pattern is not supported. **Note**, that if you use `using` with the type name over `var` for new instances that you can omit the type name after the `new` like:
+
+```csharp
+using Pen focusPen = new(focusColor) // Use 'using' with type name and omit type after 'new'
+{
+    Width = 1.0f,
+    DashStyle = DashStyle.Dot
+};
+```
 
 ### 1.8 XML Documentation Standards
 
@@ -402,6 +442,7 @@
 ### 1.10 Magic Numbers
 
 - **Avoid magic numbers**: Use named constants or enums instead of hard-coded values. This improves readability and maintainability.
+
   ```csharp
   // Avoid magic numbers
   const int MaxItems = 100;
@@ -451,6 +492,9 @@
   }
   ```
 
+  Note: If a code line for which these empty-line rules apply has a comment on top of it, the empty line should be placed before the comment, if there isn't one. And of course, NEVER comment that an empty lines need to be inserted at a spot, which would defeat the purpose of the empty line.
+  
+
 ### 1.12 Refactoring of existing comments
 
 - **Refactor existing comments**: When refactoring code, also consider updating or removing outdated comments. Comments should accurately reflect the current state of the code and its purpose. Avoid/rephrase inappropriate comments or microaggressions.

.github/copilot-instructions.md

@@ -75,13 +75,11 @@ public AutoSizeMode AutoSizeMode
 
     protected override AccessibleObject CreateAccessibilityInstance() => new ButtonAccessibleObject(this);
 
-    internal override ButtonBaseAdapter CreateFlatAdapter() => new ButtonFlatAdapter(this);
+    internal override ButtonBaseAdapter CreateFlatAdapter() => DarkModeAdapterFactory.CreateFlatAdapter(this);
 
-    internal override ButtonBaseAdapter CreatePopupAdapter() => new ButtonPopupAdapter(this);
+    internal override ButtonBaseAdapter CreatePopupAdapter() => DarkModeAdapterFactory.CreatePopupAdapter(this);
 
-    internal override ButtonBaseAdapter CreateStandardAdapter() => new ButtonStandardAdapter(this);
-
-    internal override ButtonBaseAdapter CreateDarkModeAdapter() => new ButtonDarkModeAdapter(this);
+    internal override ButtonBaseAdapter CreateStandardAdapter() => DarkModeAdapterFactory.CreateStandardAdapter(this);
 
     internal override Size GetPreferredSizeCore(Size proposedConstraints)
     {
@@ -115,13 +113,15 @@ protected override CreateParams CreateParams
         {
             CreateParams cp = base.CreateParams;
             cp.ClassName = PInvoke.WC_BUTTON;
+
             if (GetStyle(ControlStyles.UserPaint))
             {
                 cp.Style |= PInvoke.BS_OWNERDRAW;
             }
             else
             {
                 cp.Style |= PInvoke.BS_PUSHBUTTON;
+
                 if (IsDefault)
                 {
                     cp.Style |= PInvoke.BS_DEFPUSHBUTTON;