Great question! You’ve hit on a intentional quirk of the standard Windows ComboBox API: the SendMessage(Handle, CB_SETDROPPEDWIDTH, 100, 0); call will only widen the dropdown list, not shrink it below the width of the parent ComboBox. Windows enforces that the dropdown’s minimum width matches the control’s own width by default.

But don’t worry—you can make the dropdown narrower with a bit of direct window manipulation. Here’s how it works:

The Core Idea #

Instead of relying on CB_SETDROPPEDWIDTH, we’ll target the dropdown list window itself (a hidden child window of the ComboBox with the class name ComboLBox). When the dropdown is about to appear, we’ll adjust its size and position manually using Win32 APIs.

Example Implementation (C++) #

First, subclass the ComboBox to intercept the WM_DROPDOWN message (triggered right before the dropdown pops up):

#include <windows.h>
#include <commctrl.h>

LRESULT CALLBACK ComboSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
    switch (uMsg)
    {
        case WM_DROPDOWN:
        {
            // Let default behavior run first to ensure the dropdown window exists
            LRESULT result = DefSubclassProc(hwnd, uMsg, wParam, lParam);
            
            // Get the ComboBox's current width
            RECT comboRect;
            GetClientRect(hwnd, &comboRect);
            int comboWidth = comboRect.right - comboRect.left;
            
            // Find the dropdown list child window
            HWND hwndDropDown = FindWindowEx(hwnd, NULL, L"ComboLBox", NULL);
            if (hwndDropDown != NULL)
            {
                // Set desired narrower width (e.g., 20px smaller than the ComboBox)
                int desiredWidth = comboWidth - 20;
                
                // Get the dropdown's current screen position and size
                RECT dropDownRect;
                GetWindowRect(hwndDropDown, &dropDownRect);
                
                // Adjust position to center the narrower dropdown under the ComboBox
                int centeredX = dropDownRect.left + (comboWidth - desiredWidth) / 2;
                
                // Resize and reposition the dropdown
                SetWindowPos(
                    hwndDropDown, 
                    NULL, 
                    centeredX, 
                    dropDownRect.top, 
                    desiredWidth, 
                    dropDownRect.bottom - dropDownRect.top, 
                    SWP_NOZORDER | SWP_NOACTIVATE
                );
            }
            
            return result;
        }
        case WM_NCDESTROY:
            // Clean up subclassing when the window is destroyed
            RemoveWindowSubclass(hwnd, ComboSubclassProc, uIdSubclass);
            return DefSubclassProc(hwnd, uMsg, wParam, lParam);
        default:
            return DefSubclassProc(hwnd, uMsg, wParam, lParam);
    }
}

// After creating your ComboBox, apply the subclass:
// SetWindowSubclass(hwndYourComboBox, ComboSubclassProc, 0, 0);

Example Implementation (C# WinForms) #

If you’re using .NET WinForms, hook into the DropDown event and adjust the dropdown window directly:

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;

public partial class YourForm : Form
{
    [DllImport("user32.dll")]
    private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);

    [DllImport("user32.dll")]
    private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

    private const uint SWP_NOZORDER = 0x0004;
    private const uint SWP_NOACTIVATE = 0x0010;

    public YourForm()
    {
        InitializeComponent();
        comboBox1.DropDown += ComboBox1_DropDown;
    }

    private void ComboBox1_DropDown(object sender, EventArgs e)
    {
        var combo = sender as ComboBox;
        if (combo == null) return;

        // Get the dropdown list window handle
        IntPtr dropDownHwnd = FindWindowEx(combo.Handle, IntPtr.Zero, "ComboLBox", null);
        if (dropDownHwnd == IntPtr.Zero) return;

        // Set desired width (e.g., 30px narrower than the ComboBox)
        int desiredWidth = combo.Width - 30;
        var dropDownBounds = combo.GetDropDownBounds();

        // Center the narrower dropdown under the ComboBox
        int centeredX = dropDownBounds.X + (combo.Width - desiredWidth) / 2;

        // Apply the size and position change
        SetWindowPos(
            dropDownHwnd, 
            IntPtr.Zero, 
            centeredX, 
            dropDownBounds.Y, 
            desiredWidth, 
            dropDownBounds.Height, 
            SWP_NOZORDER | SWP_NOACTIVATE
        );
    }
}

Key Notes #

• This works by bypassing the CB_SETDROPPEDWIDTH restriction and directly modifying the dropdown window’s properties.
• You can adjust the desiredWidth value to any size smaller than the ComboBox, and tweak the centeredX calculation to align the dropdown left, right, or centered relative to the control.
• Subclassing (in C++) ensures the adjustment happens every time the dropdown pops up, for consistent behavior.

内容的提问来源于stack exchange，提问作者Henry Crun