[Preview7/Release] Backport 13721 DarkMode: White background in disabled TextBox-composite controls (#13749)

Fixes the `ComboBox` and `RichTextBox` BackColor issue in dark mode,
where the background color was the same as in Classic mode (LightMode).

Both controls either use `TextBox(Base)` as/in a constituent control
approach or inherit from `TextBoxBase` (true for the `RichTextBox`).

While `ReadOnly` and normal edit mode work fine for both with regards to
correct coloring in dark mode, if they are disabled, they used the wrong
colors for the background.

This was pointed out by customers, and is a particular blocker for
GitHub Extensions, which discussed this effect here:


https://github.com/gitextensions/gitextensions/wiki/Dark-Mode#bright-disabled-textboxes

(Note that other issues which they pointed out we already addressed in
earlier .NET Preview versions, as soon as then priorities and
circumstances allowed us.)

We want to accommodate them and other customers who had similar issues
in this area as fast as possible to unblock them, so GitExtensions in
particular can provide their aspired .NET 10 based DarkMode-enabled
GitExtensions version as soon as .NET 10 becomes available.

Note, that `ComboBox` internally uses depending on the `ComboBox`
control's `DropDownStyle` different nested control types for different
modes. So, practically there are inner `ListBox` and `TextBox` controls
which had to be addressed:

<img width="553" height="456" alt="image"
src="https://github.com/user-attachments/assets/61821717-b509-4ecf-b703-89f7a0970c60"
/>

The fixed version has been tested by CTI and they also reassured that
the Classic mode code paths (LightMode rendering) remain unchanged to
further minimize any risks.

###### Microsoft Reviewers: [Open in
CodeFlow](https://microsoft.github.io/open-pr/?codeflow=https://github.com/dotnet/winforms/pull/13749)

Author: KlausLoeffelmann

src/System.Windows.Forms/System/Windows/Forms/Control.cs

@@ -298,11 +298,6 @@ public unsafe partial class Control :
 
     internal byte LayoutSuspendCount { get; private set; }
 
-    // Flag for the youngest control in the descendant-inheritance hierarchy as the
-    // ultimate truth if the control - by having set the ControlStyles. -
-    // indicates to participate in automatic dark mode theming or not.
-    internal bool? _darkModeRequestState;
-
     /// <summary>
     ///  Initializes a new instance of the <see cref="Control"/> class.
     /// </summary>
@@ -491,6 +486,32 @@ internal int OriginalDeviceDpiInternal
         }
     }
 
+    /// <summary>
+    ///  Caches whether the youngest control in the inheritance hierarchy has requested
+    ///  participation in automatic dark mode theming based on its <see cref="ControlStyles"/> settings.
+    /// </summary>
+    /// <remarks>
+    ///  <para>
+    ///   This property acts as a cache for the dark mode theming request state due to the architectural pattern
+    ///   of Control inheritance in WinForms. The constructor of <see cref="Control"/> calls <see cref="CreateParams"/>,
+    ///   which means that <see cref="CreateParams"/> in derived controls is invoked before their respective constructors run.
+    ///  </para>
+    ///  <para>
+    ///   As a result, if a control indicates its intent to participate in dark mode theming by setting
+    ///   <see cref="ControlStyles.ApplyThemingImplicitly"/>, we need to cache this state in this internal property
+    ///   rather than relying on the setting it does in its constructor. This is necessary because theming decisions
+    ///   and related logic may be triggered during the base <see cref="Control"/> construction process, before the
+    ///   derived control's constructor has a chance to execute.
+    ///  </para>
+    ///  <para>
+    ///   Furthermore, since base classes (such as <c>TextBoxBase</c> or <c>ButtonBase</c>) may request dark mode
+    ///   theming, but a more derived control might opt out, this <see cref="DarkModeRequestState"/> property serves
+    ///   as the definitive source of truth for a particular control's dark mode participation. It ensures that the
+    ///   most derived control's preference is respected, regardless of what its ancestors may have set.
+    ///  </para>
+    /// </remarks>
+    internal bool? DarkModeRequestState { get; set; }
+
     /// <summary>
     ///  The Accessibility Object for this Control
     /// </summary>
@@ -7384,7 +7405,7 @@ protected virtual void OnHandleCreated(EventArgs e)
 
 #pragma warning disable WFO5001 // Type is for evaluation purposes only and is subject to change or removal in future updates.
             if (Application.IsDarkModeEnabled
-                && _darkModeRequestState is true
+                && DarkModeRequestState is true
                 && !RecreatingHandle)
             {
                 _ = PInvoke.SetWindowTheme(
@@ -9349,7 +9370,7 @@ internal virtual void RecreateHandleCore()
             // ensure that the theming is applied to all child controls as well.
 #pragma warning disable WFO5001
             if (Application.IsDarkModeEnabled
-                && _darkModeRequestState is true)
+                && DarkModeRequestState is true)
             {
                 _ = PInvoke.SetWindowTheme(
                     hwnd: HWND,
@@ -10345,9 +10366,9 @@ protected void SetStyle(ControlStyles flag, bool value)
         // reset those settings - the source of truth ultimately is the value which gets set
         // for the first time a control sets or clears this style explicitly in CreateParams.
         if ((flag & ControlStyles.ApplyThemingImplicitly) == ControlStyles.ApplyThemingImplicitly
-            && !_darkModeRequestState.HasValue)
+            && !DarkModeRequestState.HasValue)
         {
-            _darkModeRequestState = value;
+            DarkModeRequestState = value;
         }
     }
 #pragma warning restore WFO5001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
@@ -10412,7 +10433,7 @@ protected virtual void SetVisibleCore(bool value)
                     // We shouldn't mess with the color mode if users haven't specifically set it.
                     // https://github.com/dotnet/winforms/issues/12014
                     // And we shouldn't prepare dark mode, if the form opted out.
-                    if (value && Application.ColorModeSet && _darkModeRequestState is true)
+                    if (value && Application.ColorModeSet && DarkModeRequestState is true)
                     {
                         PrepareDarkMode(HWND, Application.IsDarkModeEnabled);
                     }

src/System.Windows.Forms/System/Windows/Forms/Controls/Buttons/Button.cs

@@ -168,7 +168,7 @@ private protected override bool OwnerDraw
                 && Image is null
 
                 // ...the user wants to opt out of implicit DarkMode rendering.
-                && _darkModeRequestState is true
+                && DarkModeRequestState is true
 
                 // And all of this only counts for FlatStyle.Standard. For the
                 // rest, we're using specific renderers anyway, which check

src/System.Windows.Forms/System/Windows/Forms/Controls/ComboBox/ComboBox.cs

@@ -249,15 +249,31 @@ public AutoCompleteStringCollection AutoCompleteCustomSource
         }
     }
 
+#pragma warning disable WFO5001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
     /// <summary>
     ///  The background color of this control. This is an ambient property and
     ///  will always return a non-null value.
     /// </summary>
     public override Color BackColor
     {
-        get => ShouldSerializeBackColor() ? base.BackColor : SystemColors.Window;
+        get
+        {
+            if (ShouldSerializeBackColor())
+            {
+                return base.BackColor;
+            }
+            else
+            {
+                return Application.IsDarkModeEnabled
+                    && DarkModeRequestState is true
+                        ? SystemColors.ControlDarkDark
+                        : SystemColors.Window;
+            }
+        }
+
         set => base.BackColor = value;
     }
+#pragma warning restore WFO5001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
 
     [Browsable(false)]
     [EditorBrowsable(EditorBrowsableState.Never)]
@@ -1841,11 +1857,8 @@ protected override void Dispose(bool disposing)
                 _autoCompleteCustomSource.CollectionChanged -= OnAutoCompleteCustomSourceChanged;
             }
 
-            if (_stringSource is not null)
-            {
-                _stringSource.ReleaseAutoComplete();
-                _stringSource = null;
-            }
+            _stringSource?.ReleaseAutoComplete();
+            _stringSource = null;
         }
 
         base.Dispose(disposing);
@@ -2384,11 +2397,8 @@ protected override void OnHandleDestroyed(EventArgs e)
             _selectedIndex = SelectedIndex;
         }
 
-        if (_stringSource is not null)
-        {
-            _stringSource.ReleaseAutoComplete();
-            _stringSource = null;
-        }
+        _stringSource?.ReleaseAutoComplete();
+        _stringSource = null;
 
         base.OnHandleDestroyed(e);
     }
@@ -3042,23 +3052,14 @@ protected override void RefreshItem(int index)
     /// </summary>
     private void ReleaseChildWindow()
     {
-        if (_childEdit is not null)
-        {
-            _childEdit.ReleaseHandle();
-            _childEdit = null;
-        }
+        _childEdit?.ReleaseHandle();
+        _childEdit = null;
 
-        if (_childListBox is not null)
-        {
-            _childListBox.ReleaseHandle();
-            _childListBox = null;
-        }
+        _childListBox?.ReleaseHandle();
+        _childListBox = null;
 
-        if (_childDropDown is not null)
-        {
-            _childDropDown.ReleaseHandle();
-            _childDropDown = null;
-        }
+        _childDropDown?.ReleaseHandle();
+        _childDropDown = null;
     }
 
     internal override void ReleaseUiaProvider(HWND handle)
@@ -3620,6 +3621,9 @@ private unsafe void WmReflectMeasureItem(ref Message m)
         m.ResultInternal = (LRESULT)1;
     }
 
+    private static readonly IntPtr s_darkEditBrush
+        = PInvokeCore.CreateSolidBrush(ColorTranslator.ToWin32(Color.FromArgb(64, 64, 64)));
+
     /// <summary>
     ///  The ComboBox's window procedure. Inheriting classes can override this
     ///  to add extra functionality, but should not forget to call
@@ -3672,6 +3676,47 @@ protected override unsafe void WndProc(ref Message m)
                 }
 
                 break;
+
+#pragma warning disable WFO5001
+            case PInvokeCore.WM_CTLCOLORSTATIC:
+
+                HWND hwndChild = (HWND)m.LParamInternal;
+                if (hwndChild == _childEdit?.HWND && Application.IsDarkModeEnabled)
+                {
+                    PInvokeCore.SetBkColor(
+                        (HDC)m.WParamInternal,
+                        ColorTranslator.ToWin32(Color.FromArgb(64, 64, 64)));
+
+                    PInvokeCore.SetTextColor(
+                        (HDC)m.WParamInternal,
+                        ColorTranslator.ToWin32(Color.FromArgb(180, 180, 180)));
+
+                    m.ResultInternal = (LRESULT)s_darkEditBrush;
+                    return;
+                }
+
+                // Additional handling for Simple style listbox when disabled
+                if (DropDownStyle == ComboBoxStyle.Simple
+                    && Application.IsDarkModeEnabled
+                    && !Enabled
+                    && hwndChild == _childListBox?.HWND)
+                {
+                    PInvokeCore.SetBkColor(
+                        (HDC)m.WParamInternal,
+                        ColorTranslator.ToWin32(Color.FromArgb(64, 64, 64)));
+
+                    PInvokeCore.SetTextColor(
+                        (HDC)m.WParamInternal,
+                        ColorTranslator.ToWin32(Color.FromArgb(180, 180, 180)));
+
+                    m.ResultInternal = (LRESULT)s_darkEditBrush;
+
+                    return;
+                }
+#pragma warning restore WFO5001
+
+                break;
+
             case PInvokeCore.WM_CTLCOLOREDIT:
             case PInvokeCore.WM_CTLCOLORLISTBOX:
                 m.ResultInternal = (LRESULT)(nint)InitializeDCForWmCtlColor((HDC)(nint)m.WParamInternal, m.MsgInternal);
@@ -3767,6 +3812,29 @@ protected override unsafe void WndProc(ref Message m)
                     using Graphics g = Graphics.FromHdcInternal((IntPtr)dc);
                     FlatComboBoxAdapter.DrawFlatCombo(this, g);
 
+#pragma warning disable WFO5001
+                    // Special handling for disabled DropDownList in dark mode
+                    if (Application.IsDarkModeEnabled && !Enabled && DropDownStyle == ComboBoxStyle.DropDownList)
+                    {
+                        // The text area for DropDownList (excluding the dropdown button)
+                        Rectangle textBounds = ClientRectangle;
+                        textBounds.Width -= SystemInformation.VerticalScrollBarWidth;
+
+                        // Fill the background
+                        using var bgBrush = new SolidBrush(Color.FromArgb(64, 64, 64));
+                        g.FillRectangle(bgBrush, textBounds);
+
+                        // Draw the text
+                        TextRenderer.DrawText(
+                            g,
+                            Text,
+                            Font,
+                            textBounds,
+                            Color.FromArgb(180, 180, 180),
+                            TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis);
+                    }
+#pragma warning restore WFO5001
+
                     return;
                 }
 

src/System.Windows.Forms/System/Windows/Forms/Controls/ListView/ListView.cs

@@ -4673,7 +4673,7 @@ protected override void OnHandleCreated(EventArgs e)
     private void ApplyDarkModeOnDemand()
     {
         if (Application.IsDarkModeEnabled
-            && _darkModeRequestState is true)
+            && DarkModeRequestState is true)
         {
             // Enable double buffering when in dark mode to reduce flicker.
             uint exMask = PInvoke.LVS_EX_ONECLICKACTIVATE | PInvoke.LVS_EX_TWOCLICKACTIVATE |