windows-xp/Source/XPSP1/NT/shell/comctl32/v6/button.c

#include "ctlspriv.h"
#pragma hdrstop
#include "usrctl32.h"
#include "button.h"

//
// ButtonCalcRect codes
//
#define CBR_CLIENTRECT 0
#define CBR_CHECKBOX   1
#define CBR_CHECKTEXT  2
#define CBR_GROUPTEXT  3
#define CBR_GROUPFRAME 4
#define CBR_PUSHBUTTON 5
#define CBR_RADIOBUTTON 6


#define Button_IsThemed(pbutn)  ((pbutn)->hTheme && (pbutn)->hImage == NULL)

//---------------------------------------------------------------------------//
CONST BYTE mpStyleCbr[] = 
{
    CBR_PUSHBUTTON,     // BS_PUSHBUTTON
    CBR_PUSHBUTTON,     // BS_DEFPUSHBUTTON
    CBR_CHECKTEXT,      // BS_CHECKBOX
    CBR_CHECKTEXT,      // BS_AUTOCHECKBOX
    CBR_CHECKTEXT,      // BS_RADIOBUTTON
    CBR_CHECKTEXT,      // BS_3STATE
    CBR_CHECKTEXT,      // BS_AUTO3STATE
    CBR_GROUPTEXT,      // BS_GROUPBOX
    CBR_CLIENTRECT,     // BS_USERBUTTON
    CBR_CHECKTEXT,      // BS_AUTORADIOBUTTON
    CBR_CLIENTRECT,     // BS_PUSHBOX
    CBR_CLIENTRECT,     // BS_OWNERDRAW
};

#define IMAGE_BMMAX    IMAGE_CURSOR+1
static CONST BYTE rgbType[IMAGE_BMMAX] = 
{
    BS_BITMAP,          // IMAGE_BITMAP
    BS_ICON,            // IMAGE_CURSOR
    BS_ICON             // IMAGE_ICON
};

#define IsValidImage(imageType, realType, max)   \
    ((imageType < max) && (rgbType[imageType] == realType))

typedef struct tagBTNDATA 
{
    LPTSTR  lpsz;       // Text string
    PBUTN   pbutn;      // Button data
    WORD    wFlags;     // Alignment flags
} BTNDATA, *LPBTNDATA;

//---- to support multiple themes in a single process, move these into PBUTN ----
static SIZE sizeCheckBox = {0};
static SIZE sizeRadioBox = {0};

//---------------------------------------------------------------------------//
//
// Forwards
//
VOID    Button_DrawPush(PBUTN pbutn, HDC hdc, UINT pbfPush);
VOID    GetCheckBoxSize(HDC hdc, PBUTN pbutn, BOOL fCheckBox, LPSIZE psize);
WORD    GetAlignment(PBUTN pbutn);
VOID    Button_CalcRect(PBUTN pbutn, HDC hdc, LPRECT lprc, int iCode, UINT uFlags);
VOID    Button_MultiExtent(WORD wFlags, HDC hdc, LPRECT lprcMax, LPTSTR lpsz, int cch, PINT pcx, PINT pcy);

__inline UINT    IsPushButton(PBUTN pbutn);
__inline ULONG   GetButtonType(ULONG ulWinStyle);


//---------------------------------------------------------------------------//
//
//  InitButtonClass() - Registers the control's window class 
//
BOOL InitButtonClass(HINSTANCE hInstance)
{
    WNDCLASS wc;

    wc.lpfnWndProc   = Button_WndProc;
    wc.lpszClassName = WC_BUTTON;
    wc.style         = CS_GLOBALCLASS | CS_PARENTDC | CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = sizeof(PBUTN);
    wc.hInstance     = hInstance;
    wc.hIcon         = NULL;
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = NULL;
    wc.lpszMenuName  = NULL;

    if (!RegisterClass(&wc) && !GetClassInfo(hInstance, WC_BUTTON, &wc))
        return FALSE;


    return TRUE;
}


//---------------------------------------------------------------------------//
//
// Button_GetThemeIds() - Gets the associated iPartId and iStateId needed for
//                        the theme manager APIs for the button control passed
//                        in pbutn. 
//
HRESULT Button_GetThemeIds(PBUTN pbutn, LPINT piPartId, LPINT piStateId)
{
    if ( piPartId )
    {
        ULONG ulStyle = GET_STYLE(pbutn);

        if (IsPushButton(pbutn))
        {
            *piPartId = BP_PUSHBUTTON;
        }
        else
        {

            switch (GetButtonType(ulStyle)) 
            {
            case BS_CHECKBOX:
            case BS_AUTOCHECKBOX:
            case BS_3STATE:
            case BS_AUTO3STATE:
                *piPartId = BP_CHECKBOX;
                break;

            case BS_RADIOBUTTON:
            case BS_AUTORADIOBUTTON:
                *piPartId = BP_RADIOBUTTON;
                break;

            case BS_GROUPBOX:
                *piPartId = BP_GROUPBOX;
                break;

            case BS_OWNERDRAW:
                //
                // don't do anything with owerdrawn buttons
                //
                return E_FAIL;

            default:
                TraceMsg(TF_STANDARD, "What kind of buttonType is this, %#.2x", GetButtonType(ulStyle));
                *piPartId = BP_PUSHBUTTON;
                break;
            }
        }

        if (piStateId)
        {
            switch (*piPartId)
            {
            case BP_PUSHBUTTON:
                if ((pbutn->buttonState & BST_PUSHED) || 
                    ((pbutn->buttonState & (BST_CHECKED|BST_HOT)) == BST_CHECKED))
                {
                    *piStateId = PBS_PRESSED;
                }
                else if (!IsWindowEnabled(pbutn->ci.hwnd))
                {
                    *piStateId = PBS_DISABLED;
                }
                else if (pbutn->buttonState & BST_HOT)
                {
                    *piStateId = PBS_HOT;
                }
                else if (ulStyle & BS_DEFPUSHBUTTON)
                {
                    *piStateId = PBS_DEFAULTED;
                }
                else
                {
                    *piStateId = PBS_NORMAL;
                }
                break;

            case BP_CHECKBOX:
            case BP_RADIOBUTTON:
                //
                // NOTE (phellyar): We're relying on the order of the RADIOBUTTONSTATES and 
                //                  CHECKBOXSTATES enums in tmdefs.h to calculate the correct 
                //                  StateId. If the ordering of those enums changes, revisit 
                //                  the logic here.
                //                  Note also that CHECKBOXSTATES is a super set of 
                //                  RADIOBUTTONSTATES which is why we're using CBS_* here.
                //
                if ( pbutn->buttonState & BST_CHECKED )
                {
                    //
                    // button is checked
                    //
                    *piStateId = CBS_CHECKEDNORMAL;
                }
                else if ( pbutn->buttonState & BST_INDETERMINATE )
                {
                    //
                    // button is intedeterminate
                    //
                    *piStateId = CBS_MIXEDNORMAL;
                }
                else
                {
                    //
                    // button is unchecked
                    //
                    *piStateId = CBS_UNCHECKEDNORMAL;
                }

                if ( pbutn->buttonState & BST_PUSHED )
                {
                    //
                    // being pressed 
                    //
                    *piStateId += 2;
                }
                else if (!IsWindowEnabled(pbutn->ci.hwnd))
                {
                    //
                    // disabled
                    //
                    *piStateId += 3;
                }
                else if (pbutn->buttonState & BST_HOT )
                {
                    //
                    // mouse over
                    //
                    *piStateId += 1;
                }

                break;

            case BP_GROUPBOX:
                if (!IsWindowEnabled(pbutn->ci.hwnd))
                {
                    *piStateId = GBS_DISABLED;
                }
                else
                {
                    *piStateId = GBS_NORMAL;
                }
                break;
            }
        }
        
    }

    return S_OK;
}


//---------------------------------------------------------------------------//
//
// Button_GetTextFlags() - Returns the DrawTextEx flags that should be used
//                         when rendering text for this control, needed by
//                         DrawThemeText.
//
DWORD Button_GetTextFlags(PBUTN pbutn)
{
    DWORD dwTextFlags = 0;
    WORD  wAlign = GetAlignment(pbutn);
    ULONG ulStyle = GET_STYLE(pbutn);

    //
    // Set up text flags
    //
      
    //
    // horizontal text alignment 
    //
    switch (wAlign & HIBYTE(BS_HORZMASK))
    {
    case HIBYTE(BS_LEFT):
        dwTextFlags |= DT_LEFT;
        break;

    case HIBYTE(BS_RIGHT):
        dwTextFlags |= DT_RIGHT;
        break;

    case HIBYTE(BS_CENTER):
        dwTextFlags |= DT_CENTER;
        break;
    }

    //
    // vertical text alignment
    //
    switch (wAlign & HIBYTE(BS_VERTMASK))
    {
    case HIBYTE(BS_TOP):
        dwTextFlags |= DT_TOP;
        break;

    case HIBYTE(BS_BOTTOM):
        dwTextFlags |= DT_BOTTOM;
        break;

    case HIBYTE(BS_VCENTER):
        dwTextFlags |= DT_VCENTER;
        break;

    }

    //
    // line break
    //
    if (ulStyle & BS_MULTILINE)
    {
        dwTextFlags |= (DT_WORDBREAK | DT_EDITCONTROL);
    }
    else
    {
        dwTextFlags |= DT_SINGLELINE;
    }


    if (ulStyle & SS_NOPREFIX)
    {
        dwTextFlags |= DT_NOPREFIX;
    }
 
    //
    // Draw the underscore for accelorators?
    //
    if (TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIACCELHIDDEN))
    {
        dwTextFlags |= DT_HIDEPREFIX;
    }

    return dwTextFlags;
}

DWORD ButtonStateToCustomDrawState(PBUTN pbutn)
{
    DWORD itemState = 0;
    if (TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIFOCUSHIDDEN))
    {
        itemState |= CDIS_SHOWKEYBOARDCUES;
    }

    if (TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIACCELHIDDEN))
    {
        itemState |= CDIS_SHOWKEYBOARDCUES;
    }

    if (BUTTONSTATE(pbutn) & BST_FOCUS) 
    {
        itemState |= CDIS_FOCUS;
    }

    if (BUTTONSTATE(pbutn) & BST_PUSHED) 
    {
        itemState |= CDIS_SELECTED;
    }

    if (BUTTONSTATE(pbutn) & BST_HOT) 
    {
        itemState |= CDIS_HOT;
    }

    if (!IsWindowEnabled(pbutn->ci.hwnd))
    {
        itemState |= CDIS_DISABLED;
    }

    return itemState;
}


void Button_GetImagePosition(PBUTN pbutn, RECT* prc, int* px, int* py)
{
    int cx = 0;
    int cy = 0;
    CCGetIconSize(&pbutn->ci, pbutn->himl, &cx, &cy);

    cx += pbutn->rcIcon.left + pbutn->rcIcon.right;
    cy += pbutn->rcIcon.top + pbutn->rcIcon.bottom;
    switch (pbutn->uAlign)
    {
    case BUTTON_IMAGELIST_ALIGN_RIGHT:
        *px = prc->right - cx;
        *py = prc->top + (RECTHEIGHT(*prc) - cy) / 2 + pbutn->rcIcon.top;
        prc->right -= cx;
        break;

    case BUTTON_IMAGELIST_ALIGN_CENTER:     // This means no text
        *px = prc->left + (RECTWIDTH(*prc) - cx) / 2 + pbutn->rcIcon.left;
        *py = prc->top + (RECTHEIGHT(*prc) - cy) / 2 + pbutn->rcIcon.top;
        break;

    case BUTTON_IMAGELIST_ALIGN_TOP: 
       *px = prc->left + (RECTWIDTH(*prc) - cx) / 2 + pbutn->rcIcon.left;
        *py = pbutn->rcIcon.top;
        prc->top += cy;
        break;

    case BUTTON_IMAGELIST_ALIGN_BOTTOM:
        *px = (RECTWIDTH(*prc) - cx) / 2 + pbutn->rcIcon.left;
        *py = prc->bottom - cy;
        prc->bottom -= cy;
        break;

    case BUTTON_IMAGELIST_ALIGN_LEFT:
        // Fall
    default:
        *px = prc->left + pbutn->rcIcon.left;
        *py = prc->top + (RECTHEIGHT(*prc) - cy) / 2 + pbutn->rcIcon.top;
        prc->left += cx;
        break;

    }
}


//---------------------------------------------------------------------------//
//
//  Button_DrawThemed() - Renders button control according to the current
//                        theme.
//                        pbutn    - the button control to render
//                        hdc      - the hdc to draw on
//                        iPartId  - the button part
//                        iStateId - the button state
//
HRESULT Button_DrawThemed(PBUTN pbutn, HDC hdc, int iPartId, int iStateId)
{
    HRESULT hr;
    RECT    rcClient;
    RECT    rcContent;
    RECT    rcFocus;
    RECT    rcCheck;
    DWORD   dwTextFlags;
    LPWSTR  pszText;
    int     cch;
    NMCUSTOMDRAW nmcd = {0};

    BOOL    fRadioOrCheck = (iPartId == BP_RADIOBUTTON || iPartId == BP_CHECKBOX );

    //
    // Render the button background
    //
    GetClientRect(pbutn->ci.hwnd, &rcClient);
    rcCheck = rcContent = rcClient;
    if ( fRadioOrCheck )
    {
        SIZE sizeChar; 
        SIZE sizeCheck;
        int iCode;

        //
        // Compat....
        //

        GetTextExtentPoint32(hdc, TEXT("0"), 1, &sizeChar); 

        GetCheckBoxSize(hdc, pbutn, (iPartId == BP_CHECKBOX), &sizeCheck);
        
        if (iPartId == BP_CHECKBOX)
            iCode = CBR_CHECKBOX;
        else
            iCode = CBR_RADIOBUTTON;

        Button_CalcRect(pbutn, hdc, &rcCheck, iCode, 0);

        rcCheck.bottom = rcCheck.top + sizeCheck.cx;

        if ((GET_STYLE(pbutn) & BS_RIGHTBUTTON) != 0)
        {
            rcCheck.left = rcContent.right - sizeCheck.cx;
            rcContent.right = rcCheck.left - (sizeChar.cx/2);
        }
        else
        {
            rcCheck.right = rcContent.left + sizeCheck.cx;
            rcContent.left = rcCheck.right + (sizeChar.cx/2);
        }

        //---- shrink radiobutton/checkbox button to fix client rect ----
        if (RECTWIDTH(rcClient) < RECTWIDTH(rcCheck))
        {
            rcCheck.right = rcCheck.left + RECTWIDTH(rcClient);
        }

        if (RECTHEIGHT(rcClient) < RECTHEIGHT(rcCheck))
        {
            rcCheck.bottom = rcCheck.top + RECTHEIGHT(rcClient);
        }
    }

    nmcd.hdc = hdc;
    nmcd.rc = rcClient;
    nmcd.dwItemSpec = GetWindowID(pbutn->ci.hwnd);
    nmcd.uItemState = ButtonStateToCustomDrawState(pbutn);


    pbutn->ci.dwCustom = CICustomDrawNotify(&pbutn->ci, CDDS_PREERASE, &nmcd);

    if (!(pbutn->ci.dwCustom & CDRF_SKIPDEFAULT))
    {
        hr = DrawThemeBackground(pbutn->hTheme, hdc, iPartId, iStateId, &rcCheck, 0);
        if (FAILED(hr))
        {
            TraceMsg(TF_STANDARD, "Failed to render theme background");
            return hr;
        }

        if (pbutn->ci.dwCustom & CDRF_NOTIFYPOSTERASE)
            CICustomDrawNotify(&pbutn->ci, CDDS_POSTERASE, &nmcd);

        pbutn->ci.dwCustom = CICustomDrawNotify(&pbutn->ci, CDDS_PREPAINT, &nmcd);

        if (!(pbutn->ci.dwCustom & CDRF_SKIPDEFAULT))
        {
            //
            // Render the button text
            //
            GetThemeBackgroundContentRect(pbutn->hTheme, hdc, iPartId, iStateId, &rcContent, &rcContent);

            rcFocus = rcContent;

            if (pbutn->himl)
            {
                int x, y;
                int iImage = 0;
                if (ImageList_GetImageCount(pbutn->himl) > 1)
                {
                    iImage = (iStateId - PBS_NORMAL);
                }

                Button_GetImagePosition(pbutn, &rcContent, &x, &y);

                ImageList_Draw(pbutn->himl, iImage, hdc, x, y, ILD_TRANSPARENT | (CCDPIScale(pbutn->ci)?ILD_DPISCALE:0));
            }

            //
            // Get the button text
            //
            cch = GetWindowTextLength(pbutn->ci.hwnd);
            if (cch == 0)
            {
                //
                // Nothing to draw
                //
                return hr;
            }
            pszText = UserLocalAlloc(0, sizeof(WCHAR)*(cch+1));
            if (pszText == NULL) 
            {
                TraceMsg(TF_STANDARD, "Can't allocate buffer");
                return E_FAIL;
            }

            GetWindowTextW(pbutn->ci.hwnd, pszText, cch+1);

            dwTextFlags = Button_GetTextFlags(pbutn);

            if ( TESTFLAG(GET_STYLE(pbutn), BS_MULTILINE) || fRadioOrCheck )
            {
                int  cxWidth, cyHeight;
                TEXTMETRIC tm;

                if ( TESTFLAG(GET_STYLE(pbutn), BS_MULTILINE) )
                {
                    RECT rcTextExtent = rcContent;

                    cyHeight = DrawTextEx(hdc, pszText, cch, &rcTextExtent, dwTextFlags|DT_CALCRECT, NULL);
                    cxWidth  = RECTWIDTH(rcTextExtent);
                }
                else
                {
                    SIZE   size;
                    LPWSTR pszStrip = UserLocalAlloc(0, sizeof(WCHAR)*(cch+1));

                    if ( pszStrip )
                    {
                        int cchStrip = StripAccelerators(pszText, pszStrip, TRUE);
                        GetTextExtentPoint32(hdc, pszStrip, cchStrip, &size);
                        UserLocalFree(pszStrip);
                    }
                    else
                    {
                        GetTextExtentPoint32(hdc, pszText, cch, &size);
                    }

                    cyHeight = size.cy;
                    cxWidth = size.cx;
                }

                if ( fRadioOrCheck && (cyHeight < RECTHEIGHT(rcCheck)))
                {
                    // optimization for single line check/radios, align them with the top
                    // of the check no matter when the vertical alignment
                    rcContent.top = rcCheck.top;
                }
                else
                {
                    if (dwTextFlags & DT_VCENTER)
                    {
                        rcContent.top += (RECTHEIGHT(rcContent) - cyHeight) / 2;
                    }
                    else if (dwTextFlags & DT_BOTTOM)
                    {
                        rcContent.top = rcContent.bottom - cyHeight;
                    }
                }

                if ( GetTextMetrics( hdc, &tm ) && (tm.tmInternalLeading == 0) )
                {
                    // Far East fonts that have no leading. Leave space to prevent
                    // focus rect from obscuring text.
                    rcContent.top += g_cyBorder;
                }
                rcContent.bottom = rcContent.top + cyHeight;

                if (dwTextFlags & DT_CENTER)
                {
                    rcContent.left += (RECTWIDTH(rcContent) - cxWidth) / 2;
                }
                else if (dwTextFlags & DT_RIGHT)
                {
                    rcContent.left = rcContent.right - cxWidth;
                }
                rcContent.right= rcContent.left + cxWidth;
                

                if ( fRadioOrCheck )
                {
                    //
                    // Inflate the bounding rect a litte, but contrained to
                    // within the client area.
                    //
                    rcFocus.top    = max(rcClient.top,    rcContent.top-1);
                    rcFocus.bottom = min(rcClient.bottom, rcContent.bottom+1);

                    rcFocus.left   = max(rcClient.left,  rcContent.left-1);
                    rcFocus.right  = min(rcClient.right, rcContent.right+1);
                }
            }

            hr = DrawThemeText(pbutn->hTheme, hdc, iPartId, iStateId, pszText, cch, dwTextFlags, 0, &rcContent);
            if (FAILED(hr))
            {
                TraceMsg(TF_STANDARD, "Failed to render button text");
            }

            if (!TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIFOCUSHIDDEN) && (BUTTONSTATE(pbutn) & BST_FOCUS))
            {
                DrawFocusRect(hdc, &rcFocus);
            }


            UserLocalFree(pszText);
            if (pbutn->ci.dwCustom & CDRF_NOTIFYPOSTPAINT)
            {
                CICustomDrawNotify(&pbutn->ci, CDDS_POSTPAINT, &nmcd);
            }
        }
    }

    return hr;
}


//---------------------------------------------------------------------------//
//
//  Button_GetTheme() - Get a handle to the theme for this button control 
//
HTHEME Button_GetTheme(PBUTN pbutn)
{
    //
    // Button's with predefined IDs can be 
    // themed differently
    //
    static LPWSTR szButtonClasses[] = 
    {
        L"Button",                  // =0
        L"Button-OK;Button",        // IDOK=1
        L"Button-CANCEL;Button",    // IDCANCEL=2
        L"Button-ABORT;Button",     // IDABORT=3
        L"Button-RETRY;Button",     // IDRETRY=4
        L"Button-IGNORE;Button",    // IDIGNORE=5
        L"Button-YES;Button",       // IDYES=6
        L"Button-NO;Button",        // IDNO=7
        L"Button-CLOSE;Button",     // IDCLOSE=8
        L"Button-HELP;Button",      // IDHELP=9
        L"Button-TRYAGAIN;Button",  // IDTRYAGAIN=10
        L"Button-CONTINUE;Button",  // IDCONTINUE=11
        L"Button-APPLY;Button",     // IDAPPLY=12 (not yet std)
    };
    int iButtonId = GetWindowID(pbutn->ci.hwnd);

    if (iButtonId < 0 || iButtonId >= ARRAYSIZE(szButtonClasses))  // outside range
    {
        iButtonId = 0;
    }

    EnableThemeDialogTexture(GetParent(pbutn->ci.hwnd), ETDT_ENABLE);

    return OpenThemeData(pbutn->ci.hwnd, szButtonClasses[iButtonId]);
}



//---------------------------------------------------------------------------//
//
VOID GetCheckBoxSize(HDC hdc, PBUTN pbutn, BOOL fCheckBox, LPSIZE psize)
{
    SIZE *psz;

    if (fCheckBox)
        psz = &sizeCheckBox;
    else
        psz = &sizeRadioBox;

    if ((! psz->cx) && (! psz->cy))         // not yet calculated
    {
        BOOL fGotSize = FALSE;

        if (pbutn->hTheme)          // get themed size
        {
            int iPartId;
            HRESULT hr;

            if (fCheckBox)
                iPartId = BP_CHECKBOX;
            else
                iPartId = BP_RADIOBUTTON;

            hr = GetThemePartSize(pbutn->hTheme, hdc, iPartId, 1, NULL, TS_DRAW, psz);
            if (FAILED(hr))
            {
                TraceMsg(TF_STANDARD, "Failed to get theme part size for checkbox/radiobutton");
            }
            else
            {
                fGotSize = TRUE;
            }
        }

        if (! fGotSize)            // get classic size (use checkbox for both)
        {
            HBITMAP hbmp = LoadBitmap(NULL, MAKEINTRESOURCE(OBM_CHECKBOXES));

            if (hbmp != NULL) 
            {
                BITMAP  bmp;

                GetObject(hbmp, sizeof(BITMAP), &bmp);

                //
                // Checkbox bitmap is arranged 4 over and three down.  Only need to get
                // the size of a single checkbox, so do the math here.
                //
                psz->cx = bmp.bmWidth / 4;
                psz->cy = bmp.bmHeight / 3;

                DeleteObject(hbmp);
            }
            else
            {
                AssertMsg(hbmp != NULL, TEXT("Unable to load checkbox bitmap"));
            }
        }
    }

    *psize = *psz;
}


//---------------------------------------------------------------------------//
//
__inline BYTE GetButtonStyle(ULONG ulWinStyle)
{
    return (BYTE) LOBYTE(ulWinStyle & BS_TYPEMASK);
}


//---------------------------------------------------------------------------//
//
__inline ULONG GetButtonType(ULONG ulWinStyle)
{
    return ulWinStyle & BS_TYPEMASK;
}


//---------------------------------------------------------------------------//
//
// IsPushButton()
//
// Returns non-zero if the window is a push button.  Returns flags that
// are interesting if it is.  These flags are
//
UINT IsPushButton(PBUTN pbutn)
{
    BYTE bStyle;
    UINT flags;

    ULONG ulStyle = GET_STYLE(pbutn);

    bStyle = GetButtonStyle(ulStyle);
    flags = 0;

    switch (bStyle) 
    {
    case LOBYTE(BS_PUSHBUTTON):
        flags |= PBF_PUSHABLE;
        break;

    case LOBYTE(BS_DEFPUSHBUTTON):
        flags |= PBF_PUSHABLE | PBF_DEFAULT;
        break;

    default:
        if (ulStyle & BS_PUSHLIKE)
        {
            flags |= PBF_PUSHABLE;
        }
    }

    return flags;
}


//---------------------------------------------------------------------------//
//
// GetAlignment()
//
// Gets default alignment of button.  If BS_HORZMASK and/or BS_VERTMASK
// is specified, uses those.  Otherwise, uses default for button.
//
// It's probably a fine time to describe what alignment flags mean for
// each type of button.  Note that the presence of a bitmap/icon affects
// the meaning of alignments.
//
// (1) Push like buttons
//      With one of {bitmap, icon, text}:
//          Just like you'd expect
//      With one of {bitmap, icon} AND text:
//          Image & text are centered as a unit; alignment means where
//          the image shows up.  E.G., left-aligned means the image
//          on the left, text on the right.
// (2) Radio/check like buttons
//      Left aligned means check/radio box is on left, then bitmap/icon
//          and text follows, left justified.
//      Right aligned means checkk/radio box is on right, preceded by
//          text and bitmap/icon, right justified.
//      Centered has no meaning.
//      With one of {bitmap, icon} AND text:
//          Top aligned means bitmap/icon above, text below
//          Bottom aligned means text above, bitmap/icon below
//      With one of {bitmap, icon, text}
//          Alignments mean what you'd expect.
// (3) Group boxes
//      Left aligned means text is left justified on left side
//      Right aligned means text is right justified on right side
//      Center aligned means text is in middle
//
WORD GetAlignment(PBUTN pbutn)
{
    BYTE bHorz;
    BYTE bVert;

    ULONG ulStyle = GET_STYLE(pbutn);

    bHorz = HIBYTE(ulStyle & BS_HORZMASK);
    bVert = HIBYTE(ulStyle & BS_VERTMASK);

    if (!bHorz || !bVert) 
    {
        if (IsPushButton(pbutn)) 
        {
            if (!bHorz)
            {
                bHorz = HIBYTE(BS_CENTER);
            }
        } 
        else 
        {
            if (!bHorz)
            {
                bHorz = HIBYTE(BS_LEFT);
            }
        }

        if (GetButtonStyle(ulStyle) == BS_GROUPBOX)
        {
            if (!bVert)
            {
                bVert = HIBYTE(BS_TOP);
            }
        }
        else
        {
            if (!bVert)
            {
                bVert = HIBYTE(BS_VCENTER);
            }
        }
    }

    return bHorz | bVert;
}


//---------------------------------------------------------------------------//
//
// Button_SetFont()
//
// Changes button font, and decides if we can use real bold font for default
// push buttons or if we have to simulate it.
//
VOID Button_SetFont(PBUTN pbutn, HFONT hFont, BOOL fRedraw)
{
    pbutn->hFont = hFont;

    if (fRedraw && IsWindowVisible(pbutn->ci.hwnd)) 
    {
        InvalidateRect(pbutn->ci.hwnd, NULL, TRUE);
    }
}


//---------------------------------------------------------------------------//
//
HBRUSH Button_InitDC(PBUTN pbutn, HDC hdc)
{
    UINT    uMsg;
    BYTE    bStyle;
    HBRUSH  hBrush;
    ULONG   ulStyle   = GET_STYLE(pbutn);
    ULONG   ulStyleEx = GET_EXSTYLE(pbutn);

    //
    // Set BkMode before getting brush so that the app can change it to
    // transparent if it wants.
    //
    SetBkMode(hdc, OPAQUE);

    bStyle = GetButtonStyle(ulStyle);

    switch (bStyle) 
    {
    default:
        if (TESTFLAG(GET_STATE2(pbutn), WS_S2_WIN40COMPAT) && ((ulStyle & BS_PUSHLIKE) == 0)) 
        {
            uMsg = WM_CTLCOLORSTATIC;
            break;
        }

    case LOBYTE(BS_PUSHBUTTON):
    case LOBYTE(BS_DEFPUSHBUTTON):
    case LOBYTE(BS_OWNERDRAW):
    case LOBYTE(BS_USERBUTTON):
        uMsg = WM_CTLCOLORBTN;
        break;
    }

    hBrush = (HBRUSH)SendMessage(GetParent(pbutn->ci.hwnd), uMsg, (WPARAM)hdc, (LPARAM)pbutn->ci.hwnd);

    //
    // Select in the user's font if set, and save the old font so that we can
    // restore it when we release the dc.
    //
    if (pbutn->hFont) 
    {
        SelectObject(hdc, pbutn->hFont);
    }

    //
    // Clip output to the window rect if needed.
    //
    if (bStyle != LOBYTE(BS_GROUPBOX)) 
    {
        RECT rcClient;

        GetClientRect(pbutn->ci.hwnd, &rcClient);
        IntersectClipRect(hdc, 0, 0,
            rcClient.right,
            rcClient.bottom);
    }

    if ((ulStyleEx & WS_EX_RTLREADING) != 0)
    {
        SetTextAlign(hdc, TA_RTLREADING | GetTextAlign(hdc));
    } 

    return hBrush;
}


//---------------------------------------------------------------------------//
//
HDC Button_GetDC(PBUTN pbutn, HBRUSH *phBrush)
{
    HDC hdc = NULL;

    if (IsWindowVisible(pbutn->ci.hwnd)) 
    {
        HBRUSH  hBrush;

        hdc = GetDC(pbutn->ci.hwnd);
        hBrush = Button_InitDC(pbutn, hdc);

        if ((phBrush != NULL) && hBrush)
        {
            *phBrush = hBrush;
        }
    }

    return hdc;
}


//---------------------------------------------------------------------------//
//
VOID Button_ReleaseDC(PBUTN pbutn, HDC hdc, HBRUSH *phBrush)
{
    ULONG ulStyleEx = GET_EXSTYLE(pbutn);

    if ((ulStyleEx & WS_EX_RTLREADING) != 0)
    {
        SetTextAlign(hdc, GetTextAlign(hdc) & ~TA_RTLREADING);
    }

    if (pbutn->hFont) 
    {
        SelectObject(hdc, GetStockObject(SYSTEM_FONT));
    }

    ReleaseDC(pbutn->ci.hwnd, hdc);
}


//---------------------------------------------------------------------------//
//
VOID Button_OwnerDraw(PBUTN pbutn, HDC hdc, UINT itemAction)
{
    DRAWITEMSTRUCT drawItemStruct;
    UINT itemState = 0;
    int  iButtonId = GetWindowID(pbutn->ci.hwnd);

    if (TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIFOCUSHIDDEN)) 
    {
        itemState |= ODS_NOFOCUSRECT;
    }

    if (TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIACCELHIDDEN)) 
    {
        itemState |= ODS_NOACCEL;
    }

    if (TESTFLAG(BUTTONSTATE(pbutn), BST_FOCUS)) 
    {
        itemState |= ODS_FOCUS;
    }

    if (TESTFLAG(BUTTONSTATE(pbutn), BST_PUSHED)) 
    {
        itemState |= ODS_SELECTED;
    }

    if (!IsWindowEnabled(pbutn->ci.hwnd))
    {
        itemState |= ODS_DISABLED;
    }

    //
    // Populate the draw item struct
    //
    drawItemStruct.CtlType    = ODT_BUTTON;
    drawItemStruct.CtlID      = iButtonId;
    drawItemStruct.itemAction = itemAction;
    drawItemStruct.itemState  = itemState;
    drawItemStruct.hwndItem   = pbutn->ci.hwnd;
    drawItemStruct.hDC        = hdc;
    GetClientRect(pbutn->ci.hwnd, &drawItemStruct.rcItem);
    drawItemStruct.itemData   = 0L;

    //
    // Send a WM_DRAWITEM message to our parent
    //
    SendMessage(GetParent(pbutn->ci.hwnd), 
                WM_DRAWITEM, 
                (WPARAM)iButtonId,
                (LPARAM)&drawItemStruct);
}


//---------------------------------------------------------------------------//
//
VOID Button_CalcRect(PBUTN pbutn, HDC hdc, LPRECT lprc, int iCode, UINT uFlags)
{
    CONST TCHAR szOneChar[] = TEXT("0");

    SIZE   sizeExtent;
    int    dy;
    LPTSTR lpName = NULL;
    WORD   wAlign;
    int    cxEdge, cyEdge;
    int    cxBorder, cyBorder;

    ULONG  ulStyle   = GET_STYLE(pbutn);
    ULONG  ulStyleEx = GET_EXSTYLE(pbutn);

    cxEdge   = GetSystemMetrics(SM_CXEDGE);
    cyEdge   = GetSystemMetrics(SM_CYEDGE);
    cxBorder = GetSystemMetrics(SM_CXBORDER);
    cyBorder = GetSystemMetrics(SM_CYBORDER);

    GetClientRect(pbutn->ci.hwnd, lprc);

    wAlign = GetAlignment(pbutn);

    switch (iCode) 
    {
    case CBR_PUSHBUTTON:
        //
        // Subtract out raised edge all around
        //
        InflateRect(lprc, -cxEdge, -cyEdge);

        if (uFlags & PBF_DEFAULT)
        {
            InflateRect(lprc, -cxBorder, -cyBorder);
        }
        break;

    case CBR_CHECKBOX:
    case CBR_RADIOBUTTON:
    {
        SIZE sizeChk = {0};

        GetCheckBoxSize(hdc, pbutn, (iCode == CBR_CHECKBOX), &sizeChk);

        switch (wAlign & HIBYTE(BS_VERTMASK))
        {
        case HIBYTE(BS_VCENTER):
            lprc->top = (lprc->top + lprc->bottom - sizeChk.cy) / 2;
            break;

        case HIBYTE(BS_TOP):
        case HIBYTE(BS_BOTTOM):
            GetTextExtentPoint32(hdc, (LPTSTR)szOneChar, 1, &sizeExtent);
            dy = sizeExtent.cy + sizeExtent.cy/4;

            //
            // Save vertical extent
            //
            sizeExtent.cx = dy;

            //
            // Get centered amount
            //
            dy = (dy - sizeChk.cy) / 2;
            if ((wAlign & HIBYTE(BS_VERTMASK)) == HIBYTE(BS_TOP))
            {
                lprc->top += dy;
            }
            else
            {
                lprc->top = lprc->bottom - sizeExtent.cx + dy;
            }

            break;
        }

        if ((ulStyle & BS_RIGHTBUTTON) != 0)
        {
            lprc->left = lprc->right - sizeChk.cx;
        }
        else
        {
            lprc->right = lprc->left + sizeChk.cx;
        }

        break;
    }

    case CBR_CHECKTEXT:
    {
        SIZE sizeChk = {0};

        GetCheckBoxSize(hdc, pbutn, TRUE, &sizeChk);

        if ((ulStyle & BS_RIGHTBUTTON) != 0) 
        {
            lprc->right -= sizeChk.cx;

            //
            // More spacing for 4.0 dudes
            //
            if (TESTFLAG(GET_STATE2(pbutn), WS_S2_WIN40COMPAT)) 
            {
                GetTextExtentPoint32(hdc, szOneChar, 1, &sizeExtent);
                lprc->right -= sizeExtent.cx  / 2;
            }

        } 
        else 
        {
            lprc->left += sizeChk.cx;

            //
            // More spacing for 4.0 dudes
            //
            if (TESTFLAG(GET_STATE2(pbutn), WS_S2_WIN40COMPAT)) 
            {
                GetTextExtentPoint32(hdc, szOneChar, 1, &sizeExtent);
                lprc->left +=  sizeExtent.cx / 2;
            }
        }

        break;
    }

    case CBR_GROUPTEXT:
    {
        int  cch = GetWindowTextLength(pbutn->ci.hwnd);

        if (cch != 0)
        {
            //
            // Always use WCHAR for alloc because of MBCS
            //
            lpName = _alloca((cch+1)*sizeof(WCHAR));
        }

        if (cch == 0 || lpName == NULL || GetWindowText(pbutn->ci.hwnd, lpName, cch+1) == 0)
        {
            SetRectEmpty(lprc);
            break;
        }

        //
        // if not themed
        //
        if (!Button_IsThemed(pbutn))
        {
            GetTextExtentPoint32(hdc, lpName, cch, &sizeExtent);
        }
        else
        {
            DWORD dwTextFlags = Button_GetTextFlags(pbutn);
            RECT  rcExtent;
            GetThemeTextExtent(pbutn->hTheme, 
                               hdc, 
                               BP_GROUPBOX, 
                               0, 
                               lpName,
                               cch,
                               dwTextFlags,
                               lprc,
                               &rcExtent);

            sizeExtent.cx = RECTWIDTH(rcExtent);
            sizeExtent.cy = RECTHEIGHT(rcExtent);
                                
        }
        sizeExtent.cx += GetSystemMetrics(SM_CXEDGE) * 2;

        switch (wAlign & HIBYTE(BS_HORZMASK))
        {
        //
        // BFLEFT, nothing
        //
        case HIBYTE(BS_LEFT):
            lprc->left += (SYSFONT_CXCHAR - GetSystemMetrics(SM_CXBORDER));
            lprc->right = lprc->left + (int)(sizeExtent.cx);
            break;

        case HIBYTE(BS_RIGHT):
            lprc->right -= (SYSFONT_CXCHAR - GetSystemMetrics(SM_CXBORDER));
            lprc->left = lprc->right - (int)(sizeExtent.cx);
            break;

        case HIBYTE(BS_CENTER):
            lprc->left = (lprc->left + lprc->right - (int)(sizeExtent.cx)) / 2;
            lprc->right = lprc->left + (int)(sizeExtent.cx);
            break;
        }

        //
        // Center aligned.
        //
        lprc->bottom = lprc->top + sizeExtent.cy + GetSystemMetrics(SM_CYEDGE);
        break;
    }

    case CBR_GROUPFRAME:
        GetTextExtentPoint32(hdc, (LPTSTR)szOneChar, 1, &sizeExtent);
        lprc->top += sizeExtent.cy / 2;
        break;
    }
}


//---------------------------------------------------------------------------//
//
// Button_MultiExtent()
//
// Calculates button text extent, given alignment flags.
//
VOID Button_MultiExtent(WORD wFlags, HDC hdc, LPRECT lprcMax, LPTSTR lpsz, int cch, PINT pcx, PINT pcy)
{
    RECT rc;
    UINT dtFlags = DT_CALCRECT | DT_WORDBREAK | DT_EDITCONTROL;

    CopyRect(&rc, lprcMax);

    //
    // Note that since we're just calculating the maximum dimensions,
    // left-justification and top-justification are not important.
    // Also, remember to leave margins horz and vert that follow our rules
    // in DrawBtnText().
    //

    InflateRect(&rc, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYBORDER));

    if ((wFlags & LOWORD(BS_HORZMASK)) == LOWORD(BS_CENTER))
    {
        dtFlags |= DT_CENTER;
    }

    if ((wFlags & LOWORD(BS_VERTMASK)) == LOWORD(BS_VCENTER))
    {
        dtFlags |= DT_VCENTER;
    }

    DrawTextEx(hdc, lpsz, cch, &rc, dtFlags, NULL);

    if (pcx)
    {
        *pcx = rc.right-rc.left;
    }

    if (pcy)
    {
        *pcy = rc.bottom-rc.top;
    }
}


//---------------------------------------------------------------------------//
//
// Button_MultiDraw()
//
// Draws multiline button text
//
BOOL Button_MultiDraw(HDC hdc, LPBTNDATA lpbd, int cch, int cx, int cy)
{
    RECT  rc;
    UINT  dtFlags = DT_WORDBREAK | DT_EDITCONTROL;
    PBUTN pbutn   = lpbd->pbutn;

    if (TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIACCELHIDDEN)) 
    {
        dtFlags |= DT_HIDEPREFIX;
    } 
    else if (pbutn->fPaintKbdCuesOnly)
    {
        dtFlags |= DT_PREFIXONLY;
    }

    rc.left    = 0;
    rc.top     = 0;
    rc.right   = cx;
    rc.bottom  = cy;

    //
    // Horizontal alignment
    //
    UserAssert(DT_LEFT == 0);
    switch (lpbd->wFlags & LOWORD(BS_HORZMASK)) 
    {
    case LOWORD(BS_CENTER):
        dtFlags |= DT_CENTER;
        break;

    case LOWORD(BS_RIGHT):
        dtFlags |= DT_RIGHT;
        break;
    }

    //
    // Vertical alignment
    //
    UserAssert(DT_TOP == 0);
    switch (lpbd->wFlags & LOWORD(BS_VERTMASK))
    {
        case LOWORD(BS_VCENTER):
            dtFlags |= DT_VCENTER;
            break;

        case LOWORD(BS_BOTTOM):
            dtFlags |= DT_BOTTOM;
            break;
    }

    DrawTextEx(hdc, lpbd->lpsz, cch, &rc, dtFlags, NULL);

    return TRUE;
}

//---------------------------------------------------------------------------//
//
BOOL Button_SetCapture(PBUTN pbutn, UINT uCodeMouse)
{
    BUTTONSTATE(pbutn) |= uCodeMouse;

    if (!(BUTTONSTATE(pbutn) & BST_CAPTURED)) 
    {
        SetCapture(pbutn->ci.hwnd);
        BUTTONSTATE(pbutn) |= BST_CAPTURED;

        //
        // To prevent redundant CLICK messages, we set the INCLICK bit so
        // the WM_SETFOCUS code will not do a Button_NotifyParent(BN_CLICKED).
        //
        BUTTONSTATE(pbutn) |= BST_INCLICK;

        SetFocus(pbutn->ci.hwnd);

        BUTTONSTATE(pbutn) &= ~BST_INCLICK;
    }

    return BUTTONSTATE(pbutn) & BST_CAPTURED;
}


//---------------------------------------------------------------------------//
//
VOID Button_NotifyParent(PBUTN pbutn, UINT uCode)
{
    HWND hwndParent = GetParent(pbutn->ci.hwnd);
    int  iButtonId = GetWindowID(pbutn->ci.hwnd);

    if ( !hwndParent )
    {
        hwndParent = pbutn->ci.hwnd;
    }

    SendMessage(hwndParent, 
                WM_COMMAND,
                MAKELONG(iButtonId, uCode), 
                (LPARAM)pbutn->ci.hwnd);
}


//---------------------------------------------------------------------------//
//
VOID Button_ReleaseCapture(PBUTN pbutn, BOOL fCheck)
{
    UINT  uCheck;
    BOOL  fNotifyParent = FALSE;
    ULONG ulStyle = GET_STYLE(pbutn);

    if (BUTTONSTATE(pbutn) & BST_PUSHED) 
    {

        SendMessage(pbutn->ci.hwnd, BM_SETSTATE, FALSE, 0);

        if (fCheck) 
        {
            switch (GetButtonType(ulStyle)) 
            {
            case BS_AUTOCHECKBOX:
            case BS_AUTO3STATE:

                uCheck = (UINT)((BUTTONSTATE(pbutn) & BST_CHECKMASK) + 1);

                if (uCheck > (UINT)(GetButtonType(ulStyle) == BS_AUTO3STATE ? BST_INDETERMINATE : BST_CHECKED)) 
                {
                    uCheck = BST_UNCHECKED;
                }

                SendMessage(pbutn->ci.hwnd, BM_SETCHECK, uCheck, 0);

                break;

            case BS_AUTORADIOBUTTON:
                {
                    //
                    // Walk the radio buttons in the same group as us. Check ourself
                    // and uncheck everyone else. 
                    //
                    HWND hwndNext   = pbutn->ci.hwnd;
                    HWND hwndParent = GetParent(pbutn->ci.hwnd);

                    do 
                    {
                        if ((UINT)SendMessage(hwndNext, WM_GETDLGCODE, 0, 0L) & DLGC_RADIOBUTTON) 
                        {
                            SendMessage(hwndNext, BM_SETCHECK, hwndNext == pbutn->ci.hwnd, 0L);
                        }

                        hwndNext = GetNextDlgGroupItem(hwndParent, hwndNext, FALSE);
                    } 
                    //
                    // Loop until we see ourself again
                    //
                    while (hwndNext != pbutn->ci.hwnd);

                    break;
                }
            }

            fNotifyParent = TRUE;
        }
    }

    if (BUTTONSTATE(pbutn) & BST_CAPTURED) 
    {
        BUTTONSTATE(pbutn) &= ~(BST_CAPTURED | BST_MOUSE);
        ReleaseCapture();
    }

    if (fNotifyParent) 
    {
        //
        // We have to do the notification after setting the buttonstate bits.
        //
        Button_NotifyParent(pbutn, BN_CLICKED);
    }
}


//---------------------------------------------------------------------------//
//
// Button_DrawText()
//
// Draws text of button.
//
VOID Button_DrawText(PBUTN pbutn, HDC hdc, BOOL dbt, BOOL fDepress)
{

    RECT    rc;
    HBRUSH  hbr;
    LPTSTR  lpName;
    int     x = 0, y = 0;
    int     cx = 0, cy = 0;
    BYTE    bStyle;
    UINT    dsFlags;
    BTNDATA bdt;
    UINT    pbfPush;
    ULONG   ulStyle = GET_STYLE(pbutn);
    int     cch;

    bStyle = GetButtonStyle(ulStyle);

    if ((bStyle == LOBYTE(BS_GROUPBOX)) && (dbt == DBT_FOCUS))
    {
        return;
    }

    pbfPush = IsPushButton(pbutn);

    cch = GetWindowTextLength(pbutn->ci.hwnd);

    lpName = _alloca((cch + 1) * sizeof(wchar_t));
    if (lpName == NULL) 
    {
        return;
    }

    GetWindowText(pbutn->ci.hwnd, lpName, cch + 1);

    //
    // if not themed
    //
    if (!Button_IsThemed(pbutn))
    {
        if (pbfPush) 
        {
            Button_CalcRect(pbutn, hdc, &rc, CBR_PUSHBUTTON, pbfPush);
            IntersectClipRect(hdc, rc.left, rc.top, rc.right, rc.bottom);

            //
            // This is because we didn't have WM_CTLCOLOR,
            // CTLCOLOR_BTN actually set up the button colors.  For
            // old apps, CTLCOLOR_BTN needs to work like CTLCOLOR_STATIC.
            //
            SetBkColor(hdc, GetSysColor(COLOR_3DFACE));
            SetTextColor(hdc, GetSysColor(COLOR_BTNTEXT));
            hbr = GetSysColorBrush(COLOR_BTNTEXT);

        } 
        else 
        {
            Button_CalcRect(pbutn, hdc, &rc, mpStyleCbr[bStyle], pbfPush);

            //
            // Skip stuff for ownerdraw buttons, since we aren't going to
            // draw text/image.
            //
            if (bStyle == LOBYTE(BS_OWNERDRAW))
            {
                goto DrawFocus;
            }
            else
            {
                hbr = GetSysColorBrush(COLOR_WINDOWTEXT);
            }
        }

        if (pbutn->himl)
        {
            int x, y;
            Button_GetImagePosition(pbutn, &rc, &x, &y);

            if (fDepress) 
            {
                x += GetSystemMetrics(SM_CXBORDER);
                y += GetSystemMetrics(SM_CYBORDER);
            }

            ImageList_Draw(pbutn->himl, 0, hdc, x, y, ILD_TRANSPARENT | (CCDPIScale(pbutn->ci)?ILD_DPISCALE:0));
        }

        //
        // Alignment
        //
        bdt.wFlags = GetAlignment(pbutn);
        bdt.pbutn = pbutn;

        //
        // Bail if we have nothing to draw
        //
        if ((ulStyle & BS_BITMAP) != 0) 
        {
            BITMAP bmp;

            //
            // Bitmap button
            //
            if (!pbutn->hImage)
            {
                return;
            }

            GetObject(pbutn->hImage, sizeof(BITMAP), &bmp);
            cx = bmp.bmWidth;
            cy = bmp.bmHeight;

            dsFlags = DST_BITMAP;
            goto UseImageForName;

        } 
        else if ((ulStyle & BS_ICON) != 0) 
        {
            SIZE sizeIcon;

            //
            // Icon button
            //
            if (!pbutn->hImage)
            {
                return;
            }

            GetIconSize(pbutn->hImage, &sizeIcon);
            cx = sizeIcon.cx;
            cy = sizeIcon.cy;

            dsFlags = DST_ICON;
    UseImageForName:
            lpName = (LPTSTR)pbutn->hImage;
            cch = TRUE;
        } 
        else 
        {
            //
            // Text button
            //
            if (cch == 0) 
            {
                return;
            }

            if ((ulStyle & BS_MULTILINE) != 0) 
            {

                bdt.lpsz = lpName;

                Button_MultiExtent(bdt.wFlags, hdc, &rc, lpName, cch, &cx, &cy);

                lpName = (LPTSTR)(LPBTNDATA)&bdt;
                dsFlags = DST_COMPLEX;

            } 
            else 
            {
                SIZE   size;
                LPWSTR lpwstr = UserLocalAlloc(0, sizeof(WCHAR)*(cch+1));

                //
                // Try to get the text extent with mnemonics stripped.
                //
                if (lpwstr != NULL)
                {
                    int iLen = StripAccelerators(lpName, lpwstr, TRUE);
                    GetTextExtentPoint32(hdc, lpwstr, iLen, &size);
                    UserLocalFree(lpwstr);
                }
                else
                {
                    GetTextExtentPoint32(hdc, lpName, cch, &size);
                }

                cx = size.cx;
                cy = size.cy;

                //
                // If the control doesn't need underlines, set DST_HIDEPREFIX and
                // also do not show the focus indicator
                //
                dsFlags = DST_PREFIXTEXT;
                if (TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIACCELHIDDEN)) 
                {
                    dsFlags |= DSS_HIDEPREFIX;
                } 
                else if (pbutn->fPaintKbdCuesOnly) 
                {
                    dsFlags |= DSS_PREFIXONLY;
                }
            }


            //
            // Add on a pixel or two of vertical space to make centering
            // happier.  That way underline won't abut focus rect unless
            // spacing is really tight.
            //
            cy++;
        }

        //
        // ALIGNMENT
        //

        //
        // Horizontal
        //
        switch (bdt.wFlags & HIBYTE(BS_HORZMASK)) 
        {
        //
        // For left & right justified, we leave a margin of CXEDGE on either
        // side for eye-pleasing space.
        //
        case HIBYTE(BS_LEFT):
            x = rc.left + GetSystemMetrics(SM_CXEDGE);
            break;

        case HIBYTE(BS_RIGHT):
            x = rc.right - cx - GetSystemMetrics(SM_CXEDGE);
            break;

        default:
            x = (rc.left + rc.right - cx) / 2;
            break;
        }

        //
        // Vertical
        //
        switch (bdt.wFlags & HIBYTE(BS_VERTMASK)) 
        {
        //
        // For top & bottom justified, we leave a margin of CYBORDER on
        // either side for more eye-pleasing space.
        //
        case HIBYTE(BS_TOP):
            y = rc.top + GetSystemMetrics(SM_CYBORDER);
            break;

        case HIBYTE(BS_BOTTOM):
            y = rc.bottom - cy - GetSystemMetrics(SM_CYBORDER);
            break;

        default:
            y = (rc.top + rc.bottom - cy) / 2;
            break;
        }

        //
        // Draw the text
        //
        if (dbt & DBT_TEXT) 
        {
            //
            // This isn't called for USER buttons.
            //
            UserAssert(bStyle != LOBYTE(BS_USERBUTTON));

            if (fDepress) 
            {
                x += GetSystemMetrics(SM_CXBORDER);
                y += GetSystemMetrics(SM_CYBORDER);
            }

            if ( !IsWindowEnabled(pbutn->ci.hwnd) ) 
            {
                UserAssert(HIBYTE(BS_ICON) == HIBYTE(BS_BITMAP));
                if (GetSystemMetrics(SM_SLOWMACHINE)  &&
                    ((ulStyle & (BS_ICON | BS_BITMAP)) != 0) &&
                    (GetBkColor(hdc) != GetSysColor(COLOR_GRAYTEXT)))
                {
                    //
                    // Perf && consistency with menus, statics
                    //
                    SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
                }
                else
                {
                    dsFlags |= DSS_DISABLED;
                }
            }

            //
            // Use transparent mode for checked push buttons since we're going to
            // fill background with dither.
            //
            if (pbfPush) 
            {
                switch (BUTTONSTATE(pbutn) & BST_CHECKMASK) 
                {
                case BST_INDETERMINATE:
                    hbr = GetSysColorBrush(COLOR_GRAYTEXT);
                    dsFlags |= DSS_MONO;
                    //
                    // FALL THRU
                    //

                case BST_CHECKED:
                    //
                    // Drawing on dithered background...
                    //
                    SetBkMode(hdc, TRANSPARENT);
                    break;
                }
            }

            //
            // Use brush and colors currently selected into hdc when we grabbed
            // color
            //
            DrawState(hdc, hbr, (DRAWSTATEPROC)Button_MultiDraw, (LPARAM)lpName,
                (WPARAM)cch, x, y, cx, cy,
                dsFlags);
        }

    }

    // Draw focus rect.
    //
    // This can get called for OWNERDRAW and USERDRAW buttons. However, only
    // OWNERDRAW buttons let the owner change the drawing of the focus button.
DrawFocus:
    if (dbt & DBT_FOCUS) 
    {
        if (bStyle == LOBYTE(BS_OWNERDRAW)) 
        {
            //
            // For ownerdraw buttons, this is only called in response to a
            // WM_SETFOCUS or WM_KILL FOCUS message.  So, we can check the
            // new state of the focus by looking at the BUTTONSTATE bits
            // which are set before this procedure is called.
            //
            Button_OwnerDraw(pbutn, hdc, ODA_FOCUS);
        } 
        else 
        {
            //
            // Don't draw the focus if underlines are not turned on
            //
            if (!TESTFLAG(GET_EXSTYLE(pbutn), WS_EXP_UIFOCUSHIDDEN)) 
            {
                //
                // Let focus rect always hug edge of push buttons.  We already
                // have the client area setup for push buttons, so we don't have
                // to do anything.
                //
                if (!pbfPush) 
                {
                    RECT rcClient;

                    GetClientRect(pbutn->ci.hwnd, &rcClient);
                    
                    if (bStyle == LOBYTE(BS_USERBUTTON))
                    {
                        CopyRect(&rc, &rcClient);
                    } 
                    else if (Button_IsThemed(pbutn))
                    {
                        //
                        // if themed
                        //
                        int iPartId = 0;
                        int iStateId = 0;

                        Button_GetThemeIds(pbutn, &iPartId, &iStateId);
                        GetThemeBackgroundContentRect(pbutn->hTheme,
                                                      hdc,
                                                      iPartId,
                                                      iStateId,
                                                      &rcClient,
                                                      &rc);

                        GetThemeTextExtent(pbutn->hTheme, 
                                           hdc, 
                                           iPartId, 
                                           iStateId, 
                                           lpName, 
                                           -1,
                                           Button_GetTextFlags(pbutn), 
                                           &rc, 
                                           &rc);

                        //
                        // Inflate the bounding rect a litte, but contrained to
                        // within the client area.
                        //
                        rc.top = max(rcClient.top, rc.top-1);
                        rc.bottom = min(rcClient.bottom, rc.bottom+1);

                        rc.left = max(rcClient.left, rc.left-1);
                        rc.right = min(rcClient.right, rc.right+1);
                    }
                    else 
                    {
                        //
                        // Try to leave a border all around text.  That causes
                        // focus to hug text.
                        //
                        rc.top = max(rcClient.top, y-GetSystemMetrics(SM_CYBORDER));
                        rc.bottom = min(rcClient.bottom, rc.top + GetSystemMetrics(SM_CYEDGE) + cy);

                        rc.left = max(rcClient.left, x-GetSystemMetrics(SM_CXBORDER));
                        rc.right = min(rcClient.right, rc.left + GetSystemMetrics(SM_CXEDGE) + cx);
                    }
                } 
                else
                {
                    InflateRect(&rc, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
                }

                //
                // Are back & fore colors set properly?
                //
                DrawFocusRect(hdc, &rc);
            }
        }
    }
}


//---------------------------------------------------------------------------//
//
//  DrawCheck()
//
VOID Button_DrawCheck(PBUTN pbutn, HDC hdc, HBRUSH hBrush)
{
    //
    // if not themed
    //
    if (!Button_IsThemed(pbutn))       // Images don't have a mask so look ugly. Need to use old painting
    {
        RECT  rc;
        UINT  uFlags;
        BOOL  fDoubleBlt = FALSE;
        ULONG ulStyle = GET_STYLE(pbutn);
        SIZE  sizeChk = {0};

        Button_CalcRect(pbutn, hdc, &rc, CBR_CHECKBOX, 0);

        uFlags = 0;

        if ( BUTTONSTATE(pbutn) & BST_CHECKMASK )
        {
            uFlags |= DFCS_CHECKED;
        }

        if ( BUTTONSTATE(pbutn) & BST_PUSHED )
        {
            uFlags |= DFCS_PUSHED;
        }

        if ( !IsWindowEnabled(pbutn->ci.hwnd) )
        {
            uFlags |= DFCS_INACTIVE;
        }

        switch (GetButtonType(ulStyle)) 
        {
        case BS_AUTORADIOBUTTON:
        case BS_RADIOBUTTON:
            fDoubleBlt = TRUE;
            uFlags |= DFCS_BUTTONRADIO;
            break;

        case BS_3STATE:
        case BS_AUTO3STATE:
            if ((BUTTONSTATE(pbutn) & BST_CHECKMASK) == BST_INDETERMINATE) 
            {
                uFlags |= DFCS_BUTTON3STATE;
                break;
            }
            //
            // FALL THRU
            //

        default:
            uFlags |= DFCS_BUTTONCHECK;
            break;
        }

        if ((ulStyle & BS_FLAT) != 0)
        {
            uFlags |= DFCS_FLAT | DFCS_MONO;
        }

        GetCheckBoxSize(hdc, pbutn, TRUE, &sizeChk);

        rc.right = rc.left + sizeChk.cx;
        rc.bottom = rc.top + sizeChk.cy;

        FillRect(hdc, &rc, hBrush);

        DrawFrameControl(hdc, &rc, DFC_BUTTON, uFlags);
    }
    else
    {
        int iStateId = 0;
        int iPartId = 0;

        Button_GetThemeIds(pbutn, &iPartId, &iStateId);

        if ((iPartId != BP_RADIOBUTTON) && (iPartId != BP_CHECKBOX))
        {
            TraceMsg(TF_STANDARD, "Button_DrawCheck: Not a radio or check, iPartId = %d", iPartId);
            return;
        }
        

        Button_DrawThemed(pbutn, hdc, iPartId, iStateId);

    }
}


//---------------------------------------------------------------------------//
//
VOID Button_DrawNewState(PBUTN pbutn, HDC hdc, HBRUSH hbr, UINT sOld)
{
    if (sOld != (UINT)(BUTTONSTATE(pbutn) & BST_PUSHED)) 
    {
        UINT    pbfPush;
        ULONG   ulStyle = GET_STYLE(pbutn);

        pbfPush = IsPushButton(pbutn);

        switch (GetButtonType(ulStyle)) 
        {
        case BS_GROUPBOX:
        case BS_OWNERDRAW:
            break;

        default:
            if (!pbfPush) 
            {
                Button_DrawCheck(pbutn, hdc, hbr);
                break;
            }

        case BS_PUSHBUTTON:
        case BS_DEFPUSHBUTTON:
        case BS_PUSHBOX:
            Button_DrawPush(pbutn, hdc, pbfPush);
            break;
        }
    }
}


//---------------------------------------------------------------------------//
//
// Button_DrawPush()
//
// Draws push-like button with text
//
VOID Button_DrawPush(PBUTN pbutn, HDC hdc, UINT pbfPush)
{

    //
    // if not themed
    //
    if (!Button_IsThemed(pbutn))
    {

        RECT  rc;
        UINT  uFlags = 0;
        UINT  uState = 0;
        ULONG ulStyle = GET_STYLE(pbutn);
        NMCUSTOMDRAW nmcd = {0};

        //
        // Always a push button if calling this function
        //
        uState = DFCS_BUTTONPUSH;

        GetClientRect(pbutn->ci.hwnd, &rc);
        nmcd.hdc = hdc;
        nmcd.rc = rc;
        nmcd.dwItemSpec = GetWindowID(pbutn->ci.hwnd);
        nmcd.uItemState = ButtonStateToCustomDrawState(pbutn);

        if (BUTTONSTATE(pbutn) & BST_PUSHED)
        {
            uState |= DFCS_PUSHED;
        }

        pbutn->ci.dwCustom = CICustomDrawNotify(&pbutn->ci, CDDS_PREERASE, &nmcd);

        if (!(pbutn->ci.dwCustom & CDRF_SKIPDEFAULT))
        {
            if (!pbutn->fPaintKbdCuesOnly) 
            {

                if (BUTTONSTATE(pbutn) & BST_CHECKMASK)
                {
                    uState |= DFCS_CHECKED;
                }

                if (TESTFLAG(GET_STATE2(pbutn), WS_S2_WIN40COMPAT)) 
                {
                    uFlags = BF_SOFT;
                }

                if ((ulStyle & BS_FLAT) != 0)
                {
                    uFlags |= DFCS_FLAT | DFCS_MONO;
                }

                if (pbfPush & PBF_DEFAULT) 
                {
                    int cxBorder = GetSystemMetrics(SM_CXBORDER);
                    int cyBorder = GetSystemMetrics(SM_CYBORDER);

                    int clFrame = 1;

                    int x = rc.left;
                    int y = rc.top;
        
                    int cxWidth = cxBorder * clFrame;
                    int cyWidth = cyBorder * clFrame;
        
                    int cx = rc.right - x - cxWidth;
                    int cy = rc.bottom - y - cyWidth;

                    HBRUSH hbrFill = GetSysColorBrush(COLOR_WINDOWFRAME);
                    HBRUSH hbrSave = SelectObject(hdc, hbrFill);

                    PatBlt(hdc, x, y, cxWidth, cy, PATCOPY);
                    PatBlt(hdc, x + cxWidth, y, cx, cyWidth, PATCOPY);
                    PatBlt(hdc, x, y + cy, cx, cyWidth, PATCOPY);
                    PatBlt(hdc, x + cx, y + cyWidth, cxWidth, cy, PATCOPY);

                    SelectObject(hdc, hbrSave);

                    InflateRect(&rc, -cxBorder, -cyBorder);

                    if (uState & DFCS_PUSHED)
                    {
                        uFlags |= DFCS_FLAT;
                    }
                }

                DrawFrameControl(hdc, &rc, DFC_BUTTON, uState | uFlags);
            }
            if (pbutn->ci.dwCustom & CDRF_NOTIFYPOSTERASE)
                CICustomDrawNotify(&pbutn->ci, CDDS_POSTERASE, &nmcd);

            pbutn->ci.dwCustom = CICustomDrawNotify(&pbutn->ci, CDDS_PREPAINT, &nmcd);

            if (!(pbutn->ci.dwCustom & CDRF_SKIPDEFAULT))
            {
                Button_DrawText(pbutn, hdc, DBT_TEXT | (BUTTONSTATE(pbutn) &
                       BST_FOCUS ? DBT_FOCUS : 0), (uState & DFCS_PUSHED));

                if (pbutn->ci.dwCustom & CDRF_NOTIFYPOSTPAINT)
                    CICustomDrawNotify(&pbutn->ci, CDDS_POSTPAINT, &nmcd);
            }

        }
    }
    else
    {
        int iStateId = 0;
        int iPartId = 0;

        Button_GetThemeIds(pbutn, &iPartId, &iStateId);
        if (iPartId != BP_PUSHBUTTON)
        {
            TraceMsg(TF_STANDARD, "Not a Pushbutton");
            return;
        }
        Button_DrawThemed(pbutn, hdc, iPartId, iStateId);

    }
}


BOOL Button_OnSetImageList(PBUTN pbutn, BUTTON_IMAGELIST* biml)
{
    BOOL fRet = FALSE;

    if (biml)
    {
        if (biml->himl)
        {
            pbutn->rcIcon = biml->margin;
            pbutn->himl = biml->himl;
            pbutn->uAlign = biml->uAlign;

            fRet = TRUE;
        }
    }
    return fRet;
}

void ApplyMarginsToRect(RECT* prcm, RECT* prc)
{
    prc->left -= prcm->left;
    prc->top -= prcm->top;
    prc->right += prcm->right;
    prc->bottom += prcm->bottom;
}

BOOL Button_OnGetIdealSize(PBUTN pbutn, PSIZE psize)
{
    UINT   bsWnd;
    RECT   rc = {0};
    HBRUSH hBrush;
    HDC hdc;

    if (psize == NULL)
        return FALSE;

    GetWindowRect(pbutn->ci.hwnd, &rc);

    hdc = GetDC (pbutn->ci.hwnd);
    if (hdc)
    {
        ULONG  ulStyle = GET_STYLE(pbutn);

        bsWnd = GetButtonType(ulStyle);
        hBrush = Button_InitDC(pbutn, hdc);

        switch (bsWnd) 
        {
        case BS_PUSHBUTTON:
        case BS_DEFPUSHBUTTON:
            {
                PWSTR pName;
                int cch = GetWindowTextLength(pbutn->ci.hwnd);

                pName = _alloca((cch + 1) * sizeof(wchar_t));
                if (pName) 
                {
                    RECT rcText={0};
                    RECT rcIcon={0};
                    int cx = 0, cy = 0;
                    int iStateId = 0;
                    int iPartId = 0;


                    GetWindowText(pbutn->ci.hwnd, pName, cch + 1);

                    if (Button_IsThemed(pbutn))
                    {
                        Button_GetThemeIds(pbutn, &iPartId, &iStateId);

                        // First: Get the text rect
                        GetThemeTextExtent(pbutn->hTheme, hdc, iPartId, iStateId, pName, cch, 0, &rcText, &rcText);
                        ApplyMarginsToRect(&pbutn->rcText, &rcText);

                        rc = rcText;

                        // We should now have The button with text.
                    }
                    else
                    {
                        int cxWidth = 2 * GetSystemMetrics(SM_CXEDGE);
                        int cyWidth = 3 * GetSystemMetrics(SM_CYEDGE);
                        if (IsPushButton(pbutn) & PBF_DEFAULT)
                        {
                            cxWidth += 2 * GetSystemMetrics(SM_CXBORDER);
                            cyWidth += 2 * GetSystemMetrics(SM_CXBORDER);
                        }

                        DrawText(hdc, pName, cch, &rcText, DT_CALCRECT);
                        ApplyMarginsToRect(&pbutn->rcText, &rcText);

                        rcText.bottom += cyWidth + 1;   // +1 because draw text adds a single pixel to the first char, but not the last...
                        rcText.right += cxWidth + 1;
                    }

                    if (pbutn->himl)
                    {
                        rc.top = rc.left = 0;       // We turn this into a width not a position
                        CCGetIconSize(&pbutn->ci, pbutn->himl, &cx, &cy);
                        rcIcon.bottom = cy;
                        rcIcon.right = cx;
                        ApplyMarginsToRect(&pbutn->rcIcon, &rcIcon);
                        switch (pbutn->uAlign)
                        {
                        case BUTTON_IMAGELIST_ALIGN_TOP: 
                        case BUTTON_IMAGELIST_ALIGN_BOTTOM:
                            rc.bottom = RECTHEIGHT(rcIcon) + RECTHEIGHT(rcText);
                            rc.right = max(RECTWIDTH(rcIcon), RECTWIDTH(rcText));
                            break;

                        case BUTTON_IMAGELIST_ALIGN_CENTER:     // This means no text
                            rc.bottom = RECTHEIGHT(rcIcon);
                            rc.right = RECTWIDTH(rcIcon);
                            break;

                        case BUTTON_IMAGELIST_ALIGN_RIGHT:
                        case BUTTON_IMAGELIST_ALIGN_LEFT:
                            // Fall
                        default:
                            rc.right = RECTWIDTH(rcIcon) + RECTWIDTH(rcText);
                            rc.bottom = max(RECTHEIGHT(rcIcon), RECTHEIGHT(rcText));
                            break;

                        }
                    }
                    else
                    {
                        rc = rcText;
                    }

                    if (Button_IsThemed(pbutn))
                    {
                        GetThemeBackgroundExtent(pbutn->hTheme, hdc, iPartId, iStateId, &rc, &rc);
                    }

                }
            }
            break;
        }

        //
        // Release the font which may have been loaded by ButtonInitDC.
        //
        if (pbutn->hFont) 
        {
            SelectObject(hdc, GetStockObject(SYSTEM_FONT));
        }
        ReleaseDC(pbutn->ci.hwnd, hdc);
    }

    psize->cx = RECTWIDTH(rc);
    psize->cy = RECTHEIGHT(rc);

    return TRUE;
}


//---------------------------------------------------------------------------//
//
VOID Button_Paint(PBUTN pbutn, HDC hdc)
{
    RECT   rc;
    RECT   rcText;
    HBRUSH hBrush;
    HBRUSH hBrushSave = NULL;
    BOOL   fDrawBackground = TRUE;
    ULONG  ulStyle = GET_STYLE(pbutn);
    CCDBUFFER db = {0};
    UINT bsWnd = GetButtonType(ulStyle);
    UINT   pbfPush = IsPushButton(pbutn);
    BOOL fTransparent = FALSE;
    int    iPartId = 0;
    int    iStateId = 0;

    GetClientRect(pbutn->ci.hwnd, &rc);


    if (Button_IsThemed(pbutn) && 
        (bsWnd != LOBYTE(BS_GROUPBOX)) && 
        (bsWnd != LOBYTE(BS_OWNERDRAW)) && 
        !pbutn->fPaintKbdCuesOnly)
    {
        hdc = CCBeginDoubleBuffer(hdc, &rc, &db); 
        
        Button_GetThemeIds(pbutn, &iPartId, &iStateId);
        fTransparent = CCShouldAskForBits(&pbutn->ci, pbutn->hTheme, iPartId, iStateId);
        if (fTransparent)
        {
            fDrawBackground = (TRUE != CCSendPrint(&pbutn->ci, hdc));
        }
    }

    hBrush = Button_InitDC(pbutn, hdc);


    if ((!pbfPush || fTransparent) && !pbutn->fPaintKbdCuesOnly &&
        fDrawBackground)
    {
        if ((bsWnd != LOBYTE(BS_OWNERDRAW)) &&
            (bsWnd != LOBYTE(BS_GROUPBOX)))
        {
            //
            // Fill the client area with the background brush
            // before we begin painting.
            //
            FillRect(hdc, &rc, hBrush);
        }

        hBrushSave = SelectObject(hdc, hBrush);
    }

    switch (bsWnd) 
    {
    case BS_CHECKBOX:
    case BS_RADIOBUTTON:
    case BS_AUTORADIOBUTTON:
    case BS_3STATE:
    case BS_AUTOCHECKBOX:
    case BS_AUTO3STATE:
        if (!pbfPush) 
        {
            if (!Button_IsThemed(pbutn))
            {
                Button_DrawText(pbutn, hdc,
                    DBT_TEXT | (BUTTONSTATE(pbutn) & BST_FOCUS ? DBT_FOCUS : 0), FALSE);
            }

            if (!pbutn->fPaintKbdCuesOnly || Button_IsThemed(pbutn)) 
            {
                Button_DrawCheck(pbutn, hdc, hBrush);
            }
            break;
        }
        //
        // Fall through for PUSHLIKE buttons
        //

    case BS_PUSHBUTTON:
    case BS_DEFPUSHBUTTON:
        Button_DrawPush(pbutn, hdc, pbfPush);
        break;

    case BS_PUSHBOX:
        Button_DrawText(pbutn, hdc,
            DBT_TEXT | (BUTTONSTATE(pbutn) & BST_FOCUS ? DBT_FOCUS : 0), FALSE);

        Button_DrawNewState(pbutn, hdc, hBrush, 0);
        break;

    case BS_USERBUTTON:
        // Don't support USERBUTTON in v6. This has been superceded by OWNERDRAW in win32.
        break;

    case BS_OWNERDRAW:
        Button_OwnerDraw(pbutn, hdc, ODA_DRAWENTIRE);
        break;

    case BS_GROUPBOX:
        Button_CalcRect(pbutn, hdc, &rcText, CBR_GROUPTEXT, 0);

        //----- get theme part, state for groupbox ----
        if (Button_IsThemed(pbutn))
        {
            Button_GetThemeIds(pbutn, &iPartId, &iStateId);
        }

        if (!pbutn->fPaintKbdCuesOnly) 
        {
            UINT uFlags;
            BOOL fFillMyself = TRUE;

            Button_CalcRect(pbutn, hdc, &rc, CBR_GROUPFRAME, 0);

            uFlags = ((ulStyle & BS_FLAT) != 0) ? BF_FLAT | BF_MONO : 0;
            if (!Button_IsThemed(pbutn))
            {
                DrawEdge(hdc, &rc, EDGE_ETCHED, BF_RECT | uFlags);
            }
            else
            {
                DrawThemeBackground(pbutn->hTheme, hdc, iPartId, iStateId, &rc, 0);
                fFillMyself = (FALSE == CCSendPrintRect(&pbutn->ci, hdc, &rcText));
            }

            if (fFillMyself)
            {
                FillRect(hdc, &rcText, hBrush);
            }
        }

        // FillRect(hdc, &rc, hBrush);
        if (!Button_IsThemed(pbutn))
        {
            Button_DrawText(pbutn, hdc, DBT_TEXT, FALSE);
        }
        else
        {
            DWORD    dwTextFlags;
            HRESULT  hr;
            int      cch;
            LPWSTR   lpName;

            cch = GetWindowTextLength(pbutn->ci.hwnd);
            lpName = UserLocalAlloc(0, sizeof(WCHAR)*(cch+1));
            if ( !lpName )
            {
                TraceMsg(TF_STANDARD, "Button_Paint couldn't allocate buffer");
                return;
            }
            GetWindowTextW(pbutn->ci.hwnd, lpName, cch+1);
            
            dwTextFlags = Button_GetTextFlags(pbutn);

            //
            // Button_CalcRect padded by a CXEDGE so the groupbox frame wouldn't
            // be flush with the Group text 
            //
            rcText.left += GetSystemMetrics(SM_CXEDGE);



            hr = DrawThemeText(pbutn->hTheme,
                               hdc,
                               iPartId,
                               iStateId,
                               lpName,
                               cch,
                               dwTextFlags,
                               0,
                               &rcText);

            if (FAILED(hr))
            {
                TraceMsg(TF_STANDARD, "Button_Paint failed to render groupbox text");
            }
            UserLocalFree(lpName);
        }
        break;
    }

    if (!pbfPush && hBrushSave)
    {
        SelectObject(hdc, hBrushSave);
    }

    //
    // Release the font which may have been loaded by ButtonInitDC.
    //
    if (pbutn->hFont) 
    {
        SelectObject(hdc, GetStockObject(SYSTEM_FONT));
    }

    CCEndDoubleBuffer(&db);


}


//---------------------------------------------------------------------------//
//
VOID Button_Repaint(PBUTN pbutn)
{
    HDC hdc = Button_GetDC(pbutn, NULL);

    if (hdc != NULL) 
    {
        Button_Paint(pbutn, hdc);
        Button_ReleaseDC(pbutn, hdc, NULL);
    }
}

VOID Button_SetHot(PBUTN pbutn, BOOL fHot, DWORD dwReason)
{
    NMBCHOTITEM nmhot = {0};

    // Send a notification about the hot item change
    if (fHot)
    {
        nmhot.dwFlags = HICF_ENTERING;
        pbutn->buttonState |= BST_HOT;
    }
    else
    {
        nmhot.dwFlags = HICF_LEAVING;
        pbutn->buttonState &= ~BST_HOT;
    }

    nmhot.dwFlags |= dwReason;

    CCSendNotify(&pbutn->ci, BCN_HOTITEMCHANGE, &nmhot.hdr);
}

void Button_EraseOwnerDraw(PBUTN pbutn, HDC hdc)
{
    if (GetButtonType(GET_STYLE(pbutn)) == LOBYTE(BS_OWNERDRAW))
    {
        RECT rc;
        HBRUSH hbr;
        //
        // Handle erase background for owner draw buttons.
        //
        GetClientRect(pbutn->ci.hwnd, &rc);
        hbr = (HBRUSH)SendMessage(GetParent(pbutn->ci.hwnd), WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)pbutn->ci.hwnd);
        FillRect(hdc, &rc, hbr);
    }
}

//---------------------------------------------------------------------------//
//
// Button_WndProc
//
// WndProc for buttons, check boxes, etc.
//
LRESULT APIENTRY Button_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    UINT        wOldState;
    RECT        rc;
    HDC         hdc;
    HBRUSH      hbr;
    PAINTSTRUCT ps;
    PBUTN       pbutn;
    LRESULT     lResult = FALSE;

    //
    // Get the instance data for this button control
    //
    pbutn = Button_GetPtr(hwnd);
    if (!pbutn && uMsg != WM_NCCREATE)
    {
        goto CallDWP;
    }


    switch (uMsg) 
    {
    case WM_NCHITTEST:
        if (GetButtonType(GET_STYLE(pbutn)) == LOBYTE(BS_GROUPBOX)) 
        {
            lResult = (LONG)HTTRANSPARENT;
        } 
        else 
        {
            lResult = DefWindowProc(hwnd, uMsg, wParam, lParam);

            if ( lResult == HTCLIENT && Button_IsThemed(pbutn))
            {
                HRESULT hr;
                int     iPartId = 0;
                int     iStateId = 0;
                POINT   pt;
                WORD    wHitTestCode;

                hr = Button_GetThemeIds(pbutn, &iPartId, &iStateId);
                if ( SUCCEEDED(hr) )
                    GetWindowRect(pbutn->ci.hwnd, &rc);
                    pt.x = GET_X_LPARAM(lParam);
                    pt.y = GET_Y_LPARAM(lParam);
                    hr = HitTestThemeBackground(pbutn->hTheme, 
                                                NULL,
                                                iPartId, 
                                                iStateId, 
                                                0,
                                                &rc, 
                                                NULL,
                                                pt, 
                                                &wHitTestCode);
                    if ( SUCCEEDED(hr) && wHitTestCode == HTTRANSPARENT)
                    {
                        lResult = (LRESULT)HTTRANSPARENT;
                    }
            }
        }

        break;

    case WM_ERASEBKGND:
        Button_EraseOwnerDraw(pbutn, (HDC)wParam);
        //
        // Do nothing for other buttons, but don't let DefWndProc() do it
        // either.  It will be erased in Button_Paint().
        //
        lResult = (LONG)TRUE;
        break;

    case WM_PRINTCLIENT:
        Button_EraseOwnerDraw(pbutn, (HDC)wParam);
        Button_Paint(pbutn, (HDC)wParam);
        break;

    case WM_CREATE:
        pbutn->hTheme = Button_GetTheme(pbutn);
        CIInitialize(&pbutn->ci, hwnd, (LPCREATESTRUCT)lParam);

        SendMessage(hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0);
        break;

    case WM_PAINT:
        {
            //
            // If wParam != NULL, then this is a subclassed paint.
            //
            if (wParam)
            {
                hdc = (HDC)wParam;
            }
            else
            {
                hdc = BeginPaint(hwnd, &ps);
            }

            if (IsWindowVisible(pbutn->ci.hwnd))
            {
                Button_Paint(pbutn, hdc);
            }

            if (!wParam)
            {
                EndPaint(hwnd, &ps);
            }
        }

        break;

    case WM_SETFOCUS:

        BUTTONSTATE(pbutn) |= BST_FOCUS;
        if (GetButtonType(GET_STYLE(pbutn)) == LOBYTE(BS_OWNERDRAW))
        {
            HDC hdc = Button_GetDC(pbutn, NULL);
            if (hdc)
            {
                Button_DrawText(pbutn, hdc, DBT_FOCUS, FALSE);
                Button_ReleaseDC(pbutn, hdc, NULL);
            }
        }
        else
        {
            InvalidateRect(pbutn->ci.hwnd, NULL, FALSE);
        }

        if ((GET_STYLE(pbutn)& BS_NOTIFY) != 0)
        {
            Button_NotifyParent(pbutn, BN_SETFOCUS);
        }

        if (!(BUTTONSTATE(pbutn) & BST_INCLICK)) 
        {
            switch (GetButtonType(GET_STYLE(pbutn))) 
            {
            case LOBYTE(BS_RADIOBUTTON):
            case LOBYTE(BS_AUTORADIOBUTTON):

                if (!(BUTTONSTATE(pbutn) & BST_DONTCLICK)) 
                {
                    if (!(BUTTONSTATE(pbutn) & BST_CHECKMASK)) 
                    {
                        Button_NotifyParent(pbutn, BN_CLICKED);
                    }
                }
                break;
            }
        }
        break;

    case WM_GETDLGCODE:

        lResult = DLGC_BUTTON;

        switch (GetButtonType(GET_STYLE(pbutn))) 
        {
        case LOBYTE(BS_DEFPUSHBUTTON):
            lResult |= DLGC_DEFPUSHBUTTON;
            break;

        case LOBYTE(BS_PUSHBUTTON):
        case LOBYTE(BS_PUSHBOX):
            lResult |= DLGC_UNDEFPUSHBUTTON;
            break;

        case LOBYTE(BS_AUTORADIOBUTTON):
        case LOBYTE(BS_RADIOBUTTON):
            lResult |= DLGC_RADIOBUTTON;
            break;

        case LOBYTE(BS_GROUPBOX):
            //
            // remove DLGC_BUTTON
            //
            lResult = DLGC_STATIC;
            break;

        case LOBYTE(BS_CHECKBOX):
        case LOBYTE(BS_AUTOCHECKBOX):

            //
            // If this is a char that is a '=/+', or '-', we want it
            //
            if (lParam && ((LPMSG)lParam)->message == WM_CHAR) 
            {
                switch (wParam) 
                {
                case TEXT('='):
                case TEXT('+'):
                case TEXT('-'):
                    lResult |= DLGC_WANTCHARS;
                    break;

                }
            } 

            break;
        }

        break;

    case WM_CAPTURECHANGED:

        if (BUTTONSTATE(pbutn) & BST_CAPTURED) 
        {
            //
            // Unwittingly, we've been kicked out of capture,
            // so undepress etc.
            //
            if (BUTTONSTATE(pbutn) & BST_MOUSE)
            {
                SendMessage(pbutn->ci.hwnd, BM_SETSTATE, FALSE, 0);
            }
            BUTTONSTATE(pbutn) &= ~(BST_CAPTURED | BST_MOUSE);

        }
        break;

    case WM_KILLFOCUS:

        //
        // If we are losing the focus and we are in "capture mode", click
        // the button.  This allows tab and space keys to overlap for
        // fast toggle of a series of buttons.
        //
        if (BUTTONSTATE(pbutn) & BST_MOUSE) 
        {
            //
            // If for some reason we are killing the focus, and we have the
            // mouse captured, don't notify the parent we got clicked.  This
            // breaks Omnis Quartz otherwise.
            //
            SendMessage(pbutn->ci.hwnd, BM_SETSTATE, FALSE, 0);
        }

        Button_ReleaseCapture(pbutn, TRUE);

        BUTTONSTATE(pbutn) &= ~BST_FOCUS;

        if ((GET_STYLE(pbutn) & BS_NOTIFY) != 0)
        {
            Button_NotifyParent(pbutn, BN_KILLFOCUS);
        }

        //
        // Since the bold border around the defpushbutton is done by
        // someone else, we need to invalidate the rect so that the
        // focus rect is repainted properly.
        //
        InvalidateRect(hwnd, NULL, FALSE);
        break;

    case WM_LBUTTONDBLCLK:

        //
        // Double click messages are recognized for BS_RADIOBUTTON,
        // BS_USERBUTTON, and BS_OWNERDRAW styles.  For all other buttons,
        // double click is handled like a normal button down.
        //
        switch (GetButtonType(GET_STYLE(pbutn))) 
        {
        default:
            if ((GET_STYLE(pbutn) & BS_NOTIFY) == 0)
                goto btnclick;

        case LOBYTE(BS_USERBUTTON):
        case LOBYTE(BS_RADIOBUTTON):
        case LOBYTE(BS_OWNERDRAW):
            Button_NotifyParent(pbutn, BN_DOUBLECLICKED);
            break;
        }

        break;

    case WM_LBUTTONUP:
        if (BUTTONSTATE(pbutn) & BST_MOUSE) 
        {
            Button_ReleaseCapture(pbutn, TRUE);
        }
        break;

    case WM_MOUSELEAVE:
        {
            //
            // We should only be requesting mouseleave messages
            // if we are themed but check anyway
            //
            if (pbutn->buttonState & BST_HOT)
            {
                Button_SetHot(pbutn, FALSE, HICF_MOUSE);
                InvalidateRect(pbutn->ci.hwnd, NULL, TRUE);
            }
        }
        break;

    case WM_MOUSEMOVE:
        {
            //
            // If the hot bit is not already set
            //
            // 300925: Can't hottrack ownerdraw buttons for app compat reasons
            //
            if (!TESTFLAG(pbutn->buttonState, BST_HOT) &&
                GetButtonType(GET_STYLE(pbutn)) != LOBYTE(BS_OWNERDRAW))
            {
                TRACKMOUSEEVENT tme;

                //
                // Set the hot bit and request that
                // we be notified when the mouse leaves
                //
                Button_SetHot(pbutn, TRUE, HICF_MOUSE);

                tme.cbSize      = sizeof(tme);
                tme.dwFlags     = TME_LEAVE;
                tme.hwndTrack   = pbutn->ci.hwnd;
                tme.dwHoverTime = 0;

                TrackMouseEvent(&tme);
                InvalidateRect(pbutn->ci.hwnd, NULL, TRUE);
            }

            if (!(BUTTONSTATE(pbutn) & BST_MOUSE)) 
            {
                break;
            }
        }

        //
        // FALL THRU 
        //

    case WM_LBUTTONDOWN:
btnclick:
        if (Button_SetCapture(pbutn, BST_MOUSE)) 
        {
            POINT pt;
            GetClientRect(pbutn->ci.hwnd, &rc);
            POINTSTOPOINT(pt, lParam);
            SendMessage(pbutn->ci.hwnd, BM_SETSTATE, PtInRect(&rc, pt), 0);
        }

        break;

    case WM_CHAR:
        if (BUTTONSTATE(pbutn) & BST_MOUSE)
        {
            goto CallDWP;
        }

        if (GetButtonType(GET_STYLE(pbutn)) != LOBYTE(BS_CHECKBOX) &&
            GetButtonType(GET_STYLE(pbutn)) != LOBYTE(BS_AUTOCHECKBOX))
        {
            goto CallDWP;
        }

        switch (wParam) 
        {
        case TEXT('+'):
        case TEXT('='):
            //
            // we must Set the check mark on.
            //
            wParam = 1;    

            goto SetCheck;

        case TEXT('-'):
            //
            // Set the check mark off.
            //
            wParam = 0;
SetCheck:
            //
            // Must notify only if the check status changes
            //
            if ((WORD)(BUTTONSTATE(pbutn) & BST_CHECKMASK) != (WORD)wParam)
            {
                //
                // We must check/uncheck only if it is AUTO
                //
                if (GetButtonType(GET_STYLE(pbutn)) == LOBYTE(BS_AUTOCHECKBOX))
                {
                    if (Button_SetCapture(pbutn, 0))
                    {
                        SendMessage(pbutn->ci.hwnd, BM_SETCHECK, wParam, 0);
                        Button_ReleaseCapture(pbutn, TRUE);
                    }
                }

                Button_NotifyParent(pbutn, BN_CLICKED);
            }

            break;

        default:
            goto CallDWP;
        }

        break;

    case BCM_GETIDEALSIZE:
        return Button_OnGetIdealSize(pbutn, (PSIZE)lParam);

    case BCM_SETIMAGELIST:
        return Button_OnSetImageList(pbutn, (BUTTON_IMAGELIST*)lParam);

    case BCM_GETIMAGELIST:
        {
            BUTTON_IMAGELIST* biml = (BUTTON_IMAGELIST*)lParam;
            if (biml)
            {
                biml->himl = pbutn->himl;
                biml->uAlign = pbutn->uAlign;
                biml->margin = pbutn->rcIcon;
                return TRUE;
            }
        }
        break;

    case BCM_SETTEXTMARGIN:
        {
            RECT* prc = (RECT*)lParam;
            if (prc)
            {
                pbutn->rcText = *prc;
                return TRUE;
            }
        }
        break;

    case BCM_GETTEXTMARGIN:
        {
            RECT* prc = (RECT*)lParam;
            if (prc)
            {
                *prc = pbutn->rcText;
                return TRUE;
            }
        }
        break;

    case BM_CLICK:

        //
        // Don't recurse into this code!
        //
        if (BUTTONSTATE(pbutn) & BST_INBMCLICK)
        {
            break;
        }

        BUTTONSTATE(pbutn) |= BST_INBMCLICK;
        SendMessage(pbutn->ci.hwnd, WM_LBUTTONDOWN, 0, 0);
        SendMessage(pbutn->ci.hwnd, WM_LBUTTONUP, 0, 0);
        BUTTONSTATE(pbutn) &= ~BST_INBMCLICK;

        //
        // FALL THRU
        //

    case WM_KEYDOWN:

        if (BUTTONSTATE(pbutn) & BST_MOUSE)
        {
            break;
        }

        if (wParam == VK_SPACE) 
        {
            if (Button_SetCapture(pbutn, 0)) 
            {
                SendMessage(pbutn->ci.hwnd, BM_SETSTATE, TRUE, 0);
            }
        } 
        else 
        {
            Button_ReleaseCapture(pbutn, FALSE);
        }

        break;

    case WM_KEYUP:
    case WM_SYSKEYUP:

        if (BUTTONSTATE(pbutn) & BST_MOUSE) 
        {
            goto CallDWP;
        }

        //
        // Don't cancel the capture mode on the up of the tab in case the
        // guy is overlapping tab and space keys.
        //
        if (wParam == VK_TAB) 
        {
            goto CallDWP;
        }

        //
        // WARNING: pbutn->ci.hwnd is history after this call!
        //
        Button_ReleaseCapture(pbutn, (wParam == VK_SPACE));

        if (uMsg == WM_SYSKEYUP) 
        {
            goto CallDWP;
        }

        break;

    case BM_GETSTATE:

        lResult = (LONG)BUTTONSTATE(pbutn);
        break;

    case BM_SETSTATE:

        wOldState = (UINT)(BUTTONSTATE(pbutn) & BST_PUSHED);

        if (wParam) 
        {
            BUTTONSTATE(pbutn) |= BST_PUSHED;
        } 
        else 
        {
            BUTTONSTATE(pbutn) &= ~BST_PUSHED;
        }

        if (GetButtonType(GET_STYLE(pbutn)) == LOBYTE(BS_USERBUTTON)) 
        {
            Button_NotifyParent(pbutn, (UINT)(wParam ? BN_PUSHED : BN_UNPUSHED));
        } 

        if (wOldState != (BOOL)(BUTTONSTATE(pbutn) & BST_PUSHED))
        {
            // Only invalidate if the state changed.
            InvalidateRect(pbutn->ci.hwnd, NULL, FALSE);
            NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_CLIENT, INDEXID_CONTAINER);
        }

        break;

    case BM_GETCHECK:

        lResult = (LONG)(BUTTONSTATE(pbutn) & BST_CHECKMASK);
        break;

    case BM_SETCHECK:

        switch (GetButtonType(GET_STYLE(pbutn))) 
        {
        case LOBYTE(BS_RADIOBUTTON):
        case LOBYTE(BS_AUTORADIOBUTTON):

            if (wParam) 
            {
                SetWindowState(pbutn->ci.hwnd, WS_TABSTOP);
            } 
            else 
            {
                ClearWindowState(pbutn->ci.hwnd, WS_TABSTOP);
            }

            //
            // FALL THRU
            //

        case LOBYTE(BS_CHECKBOX):
        case LOBYTE(BS_AUTOCHECKBOX):

            if (wParam) 
            {
                wParam = 1;
            }
            goto CheckIt;

        case LOBYTE(BS_3STATE):
        case LOBYTE(BS_AUTO3STATE):

            if (wParam > BST_INDETERMINATE) 
            {
                wParam = BST_INDETERMINATE;
            }

CheckIt:
            if ((UINT)(BUTTONSTATE(pbutn) & BST_CHECKMASK) != (UINT)wParam) 
            {
                BUTTONSTATE(pbutn) &= ~BST_CHECKMASK;
                BUTTONSTATE(pbutn) |= (UINT)wParam;

                if (!IsWindowVisible(pbutn->ci.hwnd))
                {
                    break;
                }

                InvalidateRect(pbutn->ci.hwnd, NULL, FALSE);

                NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_CLIENT, INDEXID_CONTAINER);
            }

            break;
        }

        break;

    case BM_SETSTYLE:

        AlterWindowStyle(hwnd, BS_TYPEMASK, (DWORD)wParam);

        if (lParam) 
        {
            InvalidateRect(hwnd, NULL, TRUE);
        }

        NotifyWinEvent(EVENT_OBJECT_STATECHANGE, hwnd, OBJID_CLIENT, INDEXID_CONTAINER);
        break;

    case WM_SETTEXT:

        //
        // In case the new group name is longer than the old name,
        // this paints over the old name before repainting the group
        // box with the new name.
        //
        if (GetButtonType(GET_STYLE(pbutn)) == LOBYTE(BS_GROUPBOX)) 
        {
            hdc = Button_GetDC(pbutn, &hbr);
            if (hdc != NULL) 
            {
                Button_CalcRect(pbutn, hdc, &rc, CBR_GROUPTEXT, 0);
                InvalidateRect(hwnd, &rc, TRUE);
                FillRect(hdc, &rc, hbr);
                Button_ReleaseDC(pbutn, hdc, &hbr);
            }
        }

        lResult = DefWindowProc(hwnd, uMsg, wParam, lParam);

        NotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_WINDOW, INDEXID_CONTAINER);
        goto DoEnable;

    case WM_ENABLE:
        lResult = 0L;

DoEnable:
        Button_Repaint(pbutn);
        break;

    case WM_SETFONT:

        //
        // wParam - handle to the font
        // lParam - if true, redraw else don't
        //
        Button_SetFont(pbutn, (HFONT)wParam, (BOOL)(lParam != 0));
        break;

    case WM_GETFONT:
        lResult = (LRESULT)pbutn->hFont;
        break;

    case BM_GETIMAGE:
    case BM_SETIMAGE:

        if (!IsValidImage(wParam, (GET_STYLE(pbutn) & BS_IMAGEMASK) != 0, IMAGE_BMMAX)) 
        {
            TraceMsg(TF_STANDARD, "UxButton: Invalid button image type");
            SetLastError(ERROR_INVALID_PARAMETER);
        } 
        else 
        {
            HANDLE hOld = pbutn->hImage;

            if (uMsg == BM_SETIMAGE) 
            {
                pbutn->hImage = (HANDLE)lParam;
                if (IsWindowVisible(pbutn->ci.hwnd)) 
                {
                    InvalidateRect(hwnd, NULL, TRUE);
                }
            }

            lResult = (LRESULT)hOld;
        }

        break;

    case WM_NCDESTROY:

        if (pbutn->hTheme)
        {
            CloseThemeData(pbutn->hTheme);
        }
        UserLocalFree(pbutn);

        TraceMsg(TF_STANDARD, "BUTTON: Clearing button instance pointer.");
        Button_SetPtr(hwnd, NULL);

        break;

    case WM_NCCREATE:

        pbutn = (PBUTN)UserLocalAlloc(HEAP_ZERO_MEMORY, sizeof(BUTN));
        if (pbutn)
        {
            //
            // Success... store the instance pointer.
            //
            TraceMsg(TF_STANDARD, "BUTTON: Setting button instance pointer.");
            Button_SetPtr(hwnd, pbutn);
            pbutn->ci.hwnd = hwnd;
            pbutn->pww = (PWW)GetWindowLongPtr(hwnd, GWLP_WOWWORDS);

            SetRect(&pbutn->rcText, GetSystemMetrics(SM_CXEDGE) / 2, GetSystemMetrics(SM_CYEDGE) / 2,
                GetSystemMetrics(SM_CXEDGE) / 2, GetSystemMetrics(SM_CYEDGE) / 2);

            //
            // Borland's OBEX has a button with style 0x98; We didn't strip
            // these bits in win3.1 because we checked for 0x08.
            // Stripping these bits cause a GP Fault in OBEX.
            // For win3.1 guys, I use the old code to strip the style bits.
            //
            if (TESTFLAG(GET_STATE2(pbutn), WS_S2_WIN31COMPAT)) 
            {
                if ((!TESTFLAG(GET_STATE2(pbutn), WS_S2_WIN40COMPAT) &&
                    (((LOBYTE(GET_STYLE(pbutn))) & (LOBYTE(~BS_LEFTTEXT))) == LOBYTE(BS_USERBUTTON))) ||
                    (TESTFLAG(GET_STATE2(pbutn), WS_S2_WIN40COMPAT) &&
                    (GetButtonType(GET_STYLE(pbutn)) == LOBYTE(BS_USERBUTTON))))
                {
                    //
                    // BS_USERBUTTON is no longer allowed for 3.1 and beyond.
                    // Just turn to normal push button.
                    //
                    AlterWindowStyle(hwnd, BS_TYPEMASK, 0);
                    TraceMsg(TF_STANDARD, "UxButton: BS_USERBUTTON no longer supported");
                }
            }

            if ((GET_EXSTYLE(pbutn) & WS_EX_RIGHT) != 0) 
            {
                AlterWindowStyle(hwnd, BS_RIGHT | BS_RIGHTBUTTON, BS_RIGHT | BS_RIGHTBUTTON);
            }

            goto CallDWP;
        }
        else
        {
            //
            // Failed... return FALSE.
            //
            // From a WM_NCCREATE msg, this will cause the
            // CreateWindow call to fail.
            //
            TraceMsg(TF_STANDARD, "BUTTON: Unable to allocate button instance structure.");
            lResult = FALSE;
        }

        break;

    case WM_INPUTLANGCHANGEREQUEST:

        //
        // #115190
        // If the window is one of controls on top of dialogbox,
        // let the parent dialog handle it.
        //

#if 0  // Need to expose TestwndChild()
        if (TestwndChild(pbutn->ci.hwnd) && pbutn->ci.hwnd->spbutn->ci.hwndParent) 
        {
            PWND pbutn->ci.hwndParent = REBASEPWND(pbutn->ci.hwnd, spbutn->ci.hwndParent);
            if (pbutn->ci.hwndParent) 
            {
                PCLS pclsParent = REBASEALWAYS(pbutn->ci.hwndParent, pcls);

                UserAssert(pclsParent != NULL);
                if (pclsParent->atomClassName == gpsi->atomSysClass[ICLS_DIALOG]) 
                {
                    TraceMsg(TF_STANDARD, "UxButton: WM_INPUTLANGCHANGEREQUEST is sent to parent.");
                    return SendMessage(pbutn->ci.hwndParent, uMsg, wParam, lParam);
                }
            }
        }
#endif

        goto CallDWP;

    case WM_UPDATEUISTATE:

        DefWindowProc(hwnd, uMsg, wParam, lParam);
        if (ISBSTEXTOROD(GET_STYLE(pbutn))) 
        {
            pbutn->fPaintKbdCuesOnly = !IsUsingCleartype();
            Button_Repaint(pbutn);
            pbutn->fPaintKbdCuesOnly = FALSE;
        }

        break;

    case WM_GETOBJECT:

        if(lParam == OBJID_QUERYCLASSNAMEIDX)
        {
            lResult = MSAA_CLASSNAMEIDX_BUTTON;
        }
        else
        {
            lResult = FALSE;
        }

        break;

    case WM_THEMECHANGED:
        if ( pbutn->hTheme )
        {
            CloseThemeData(pbutn->hTheme);
        }

        //---- reset cached sizes that may change with a theme change ----
        sizeCheckBox.cx = 0;
        sizeCheckBox.cy = 0;
        sizeRadioBox.cx = 0;
        sizeRadioBox.cy = 0;

        pbutn->hTheme = Button_GetTheme(pbutn);

        InvalidateRect(pbutn->ci.hwnd, NULL, TRUE);

        CCSendNotify(&pbutn->ci, NM_THEMECHANGED, NULL);

        lResult = TRUE;

        break;

    default:

        if (CCWndProc(&pbutn->ci, uMsg, wParam, lParam, &lResult))
            return lResult;

CallDWP:
        lResult = DefWindowProc(hwnd, uMsg, wParam, lParam);

    }

    return lResult;
}