Override border color for disabled FlatStyle ComboBox

Question

I have a custom ComboBox in a C# WinForms application, and I have been successful in overriding the background color when its both enabled and disabled, and overriding the border when its enabled, but when the control is disabled I cannot figure out how to change the color of its border.

Currently, I am catching the WndProc messages being sent to the custom control, something like this:

protected override void WndProc (ref Message m)
{
    base.WndProc(ref m);

    if (m.Msg == WM_PAINT)
    {
        // set the enabled border color here, and it works
        using (var g = Graphics.FromHwnd(Handle)
        {
            using (var p = new Pen(Color.Black))
            {
                g.DrawRectangle(p, 0, 0, Width - 1, Height - 1);
            }
        }
    }
    if (m.Msg == WM_CTLCOLORSTATIC)
    {
        // set the disabled background color here
    ]
    if (m.Msg == WM_NCPAINT)
    {
        // try to set the disabled border color here, but its not working
        using (var g = Graphics.FromHwnd(Handle)
        {
            using (var p = new Pen(Color.Black))
            {
                g.DrawRectangle(p, 0, 0, Width - 1, Height - 1);
            }
        }
    }
}

Here are some images to help understand the problem, I have chosen colors that specifically highlight the problem area, these are not the actual colors I would use:

Enabled comboBox:

Disabled comboBox:

Notice the thick SystemGrey border being applied when the comboBox is disabled. This is what I want to remove, it looks worse on older windows systems, these screenshots were taken on Windows 10 but I'm targeting Windows Server 2012 where it produces a strange "halo" type effect that extends outside the control.

Looking at the MSDN, it seems like WM_NCPAINT is the message I want, but stepping through the code the border appears to have already been drawn at this point. I also tried looking at the MSDN for WM_CTLCOLORSTATIC, since the name seems promising, but it doesnt seem like it triggers anything but background colors to be set.

Is there another message I should be looking at, or am I approaching this the wrong way? I tried stepping through and looking at each message, but I just cant tell which one is triggering the call for the border to be set.

Edit: See below for the solution, this is a quick and dirty example of what I wanted to achieve, and what the solution code will do:

Answer 1

This answer relies on Change ComboBox Border Color in Windows Forms.

This post added a few criteria to remove the white inner border from the control when the control have DropDown or DropDownList as DropDownStyle and in all FlatStyle values and both for enabled and disables. This is done by handling WM_PAINT message and drawing the outer and inner border for combo box, like following image.

For demo purpose, all the controls in the image have BackColor = Color.Black and BorderColor = Color.Red and you can see their DropDownStyle, FlatStyle and Enabled as their selected item:

using System;
using System.Drawing;
using System.Windows.Forms;
public class FlatCombo : ComboBox
{
    private const int WM_PAINT = 0xF;
    private int buttonWidth = SystemInformation.HorizontalScrollBarArrowWidth;
    Color borderColor = Color.Blue;
    public Color BorderColor
    {
        get { return borderColor; }
        set { borderColor = value; Invalidate(); }
    }
    protected override void WndProc(ref Message m)
    {
        base.WndProc(ref m);
        if (m.Msg == WM_PAINT && DropDownStyle != ComboBoxStyle.Simple)
        {
            using (var g = Graphics.FromHwnd(Handle))
            {
                var adjustMent = 0;
                if (FlatStyle == FlatStyle.Popup ||
                   (FlatStyle == FlatStyle.Flat &&
                   DropDownStyle == ComboBoxStyle.DropDownList))
                    adjustMent = 1;
                var innerBorderWisth = 3;
                var innerBorderColor = BackColor;
                if (DropDownStyle == ComboBoxStyle.DropDownList &&
                    (FlatStyle == FlatStyle.System || FlatStyle == FlatStyle.Standard))
                    innerBorderColor = Color.FromArgb(0xCCCCCC);
                if (DropDownStyle == ComboBoxStyle.DropDown && !Enabled)
                    innerBorderColor = SystemColors.Control;

                if (DropDownStyle == ComboBoxStyle.DropDown || Enabled == false)
                {
                    using (var p = new Pen(innerBorderColor, innerBorderWisth))
                    {
                        p.Alignment = System.Drawing.Drawing2D.PenAlignment.Inset;
                        g.DrawRectangle(p, 1, 1, 
                            Width - buttonWidth - adjustMent - 1, Height - 1);
                    }
                }
                using (var p = new Pen(BorderColor))
                {
                    g.DrawRectangle(p, 0, 0, Width - 1, Height - 1);
                    g.DrawLine(p, Width - buttonWidth - adjustMent, 
                        0, Width - buttonWidth - adjustMent, Height);
                }
            }
        }
    }
}

Note:

To learn more about how to render a flat combo box, you can take a look at source code of internal ComboBox.FlatComboAdapter class of .Net Framework.

If you see flickers, for a flicker-free solution you can use BeginPaint and EndPaint. Or as a workaround, in your form add the following code:

private const int WS_EX_COMPOSITED = 0x02000000;
protected override CreateParams CreateParams
{
    get
    {
        var c = base.CreateParams;
        c.ExStyle |= WS_EX_COMPOSITED;
        return c;
    }
}

Answer 2

Edit: since there seems to be some confusion about why the various other answers out there are not appropriate, I will explain the issue. When a combobox is disabled, the framework generates a 3 pixel wide border around it, using the default windows background color of "Grey". If you are using the default windows form background color, you will never see this border, and simply drawing over the 1 pixel wide black "border" (its not actually the border, its part of the control area) will solve the problem. However, if your form background is, for example, Black, you will see this default form color border. This is what the below solution solves, and I hope this helps someone.

Turns out sometimes you just need to step away for 10 minutes, I figured out how to do this. Its probably not ideal, and its definitely not graceful, but it works.

You can in fact draw a new border while handling the WM_CTLCOLORSTATIC message, i thought you couldnt because the rectangle is so small, but it does in fact get drawn, and while this is definitely not the message thats handling the original border drawing, this comes after it so you can draw right over top.

This code will draw over top of the existing light grey border with a dark grey border:

if (m.Msg == WM_CTLCOLORSTATIC)
{
    // set your other colors for disabled controls

    using (var g = Graphics.FromHwnd(Handle)
    {
        using (var p = new Pen(Color.FromArgb(93, 100, 103))
        {
            // its a fat border so we need to draw 3 rectangles to cover it
            g.DrawRectangle(p, 0, 0, Width - 1, Height - 1);
            g.DrawRectangle(p, 1, 1, Width - 3, Height - 3);
            g.DrawRectangle(p, 2, 2, Width - 5, Height - 5);
        }
    }
]

I know this is disgusting, but I am on hour 4 of trying to draw a border around a control... so if anyone has a cleaner solution, I am more than open to accepting it.