#include "shellprv.h"
#include "ids.h"
#include <oleacc.h>

#ifndef POINTSPERRECT
#define POINTSPERRECT       (sizeof(RECT)/sizeof(POINT))
#endif

#define TESTKEYSTATE(vk)   ((GetKeyState(vk) & 0x8000)!=0)

#define LINKCOLOR_BKGND     COLOR_WINDOW
#define LINKCOLOR_ENABLED   GetSysColor(COLOR_HOTLIGHT)
#define LINKCOLOR_DISABLED  GetSysColor(COLOR_GRAYTEXT)

#define CF_SETCAPTURE  0x0001
#define CF_SETFOCUS    0x0002

void _InitializeUISTATE(IN HWND hwnd, IN OUT UINT* puFlags);
BOOL _HandleWM_UPDATEUISTATE(IN WPARAM wParam, IN LPARAM lParam, IN OUT UINT* puFlags);


//  common IAccessible implementation.

class CAccessibleBase : public IAccessible, public IOleWindow
{
public:
    CAccessibleBase(const HWND& hwnd)
        :   _cRef(1), _ptiAcc(NULL), _hwnd(hwnd)
    { 
        DllAddRef();
    }
    
    virtual ~CAccessibleBase()
    { 
        DllRelease();
        ATOMICRELEASE(_ptiAcc);
    }

    //  IUnknown
    STDMETHODIMP         QueryInterface(REFIID riid, void** ppvObj);
    STDMETHODIMP_(ULONG) AddRef();
    STDMETHODIMP_(ULONG) Release();

    //  IOleWindow
    STDMETHODIMP GetWindow(HWND* phwnd);
    STDMETHODIMP ContextSensitiveHelp(BOOL fEnterMode) { return E_NOTIMPL; }

    // IDispatch
    STDMETHODIMP GetTypeInfoCount(UINT * pctinfo);
    STDMETHODIMP GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo);
    STDMETHODIMP GetIDsOfNames(REFIID riid, OLECHAR** rgszNames, UINT cNames,
                                LCID lcid, DISPID * rgdispid);
    STDMETHODIMP Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags,
                         DISPPARAMS * pdispparams, VARIANT * pvarResult, 
                         EXCEPINFO * pexcepinfo, UINT * puArgErr);
    //  IAccessible
    STDMETHODIMP get_accParent(IDispatch ** ppdispParent);
    STDMETHODIMP get_accChildCount(long * pcChildren);
    STDMETHODIMP get_accChild(VARIANT varChildIndex, IDispatch ** ppdispChild);
    STDMETHODIMP get_accValue(VARIANT varChild, BSTR* pbstrValue);
    STDMETHODIMP get_accDescription(VARIANT varChild, BSTR * pbstrDescription);
    STDMETHODIMP get_accRole(VARIANT varChild, VARIANT *pvarRole);
    STDMETHODIMP get_accState(VARIANT varChild, VARIANT *pvarState);
    STDMETHODIMP get_accHelp(VARIANT varChild, BSTR* pbstrHelp);
    STDMETHODIMP get_accHelpTopic(BSTR* pbstrHelpFile, VARIANT varChild, long* pidTopic);
    STDMETHODIMP get_accKeyboardShortcut(VARIANT varChild, BSTR* pbstrKeyboardShortcut);
    STDMETHODIMP get_accFocus(VARIANT FAR * pvarFocusChild);
    STDMETHODIMP get_accSelection(VARIANT FAR * pvarSelectedChildren);
    STDMETHODIMP get_accDefaultAction(VARIANT varChild, BSTR* pbstrDefaultAction);
    STDMETHODIMP accSelect(long flagsSelect, VARIANT varChild);
    STDMETHODIMP accLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild);
    STDMETHODIMP accNavigate(long navDir, VARIANT varStart, VARIANT * pvarEndUpAt);
    STDMETHODIMP accHitTest(long xLeft, long yTop, VARIANT * pvarChildAtPoint);
    STDMETHODIMP put_accName(VARIANT varChild, BSTR bstrName);
    STDMETHODIMP put_accValue(VARIANT varChild, BSTR bstrValue);

protected:
    virtual UINT GetDefaultActionStringID() const = 0;
    
private:
    LONG _cRef;
    ITypeInfo*  _ptiAcc;
    const HWND& _hwnd;

#define VALIDATEACCCHILD(varChild, idChild, hrFail) \
        if (!(VT_I4 == varChild.vt && idChild == varChild.lVal)) {return hrFail;}

};


#define TEST_CAPTURE(fTest)           ((_fCapture & fTest) != 0)
#define MODIFY_CAPTURE(fSet, fRemove) {if (fSet){_fCapture |= fSet;} if (fRemove){_fCapture &= ~fRemove;}}
#define RESET_CAPTURE()               {_fCapture=0;}

// this API for compat with old clients of the shell32 link window. that is now
// in comctl32.dll

BOOL WINAPI LinkWindow_RegisterClass()
{
    // get the comctl32 linkwindow, and point the old classname at it
    INITCOMMONCONTROLSEX iccs = {sizeof(iccs), ICC_LINK_CLASS};
    InitCommonControlsEx(&iccs);

    WNDCLASS wc;
    ULONG_PTR dwCookie = 0;
    SHActivateContext(&dwCookie);

    BOOL bRet = GetClassInfo(NULL, WC_LINK, &wc);
    SHDeactivateContext(dwCookie);
    if (bRet)
    {
        wc.lpszClassName = TEXT("Link Window"); // old class name for old clients
        RegisterClass(&wc);
    }
    return bRet;
}

BOOL WINAPI LinkWindow_UnregisterClass(HINSTANCE)
{
    return TRUE;
}

#define GROUPBTN_BKCOLOR    COLOR_WINDOW
#define CAPTION_VPADDING    3
#define CAPTION_HPADDING    2
#define GBM_SENDNOTIFY      (GBM_LAST + 1)

//  class CGroupBtn
class CGroupBtn : public CAccessibleBase

{ // all members private:

    CGroupBtn(HWND hwnd);
    ~CGroupBtn();

    //  IAccessible specialization
    STDMETHODIMP get_accName(VARIANT varChild, BSTR* pbstrName);
    STDMETHODIMP accDoDefaultAction(VARIANT varChild);

    //  CAccessibleBase overrides
    UINT GetDefaultActionStringID() const   { return IDS_GROUPBTN_DEFAULTACTION; }

    //  window procedures
    static  LRESULT WINAPI s_GroupBtnWndProc(HWND, UINT, WPARAM, LPARAM);
    LRESULT WINAPI WndProc(HWND, UINT, WPARAM, LPARAM);


    static LRESULT WINAPI s_BuddyProc(HWND, UINT, WPARAM, LPARAM);

    //  message handlers
    void    NcCreate(LPCREATESTRUCT lpcs);
    LRESULT NcCalcSize(BOOL, LPNCCALCSIZE_PARAMS);
    void    NcPaint(HRGN);
    LRESULT NcMouseMove(WPARAM, LONG, LONG);
    LRESULT NcHitTest(LONG, LONG);
    LRESULT NcButtonDown(UINT nMsg, WPARAM nHittest, const POINTS& pts);
    LRESULT NcDblClick(UINT nMsg, WPARAM nHittest, LPARAM lParam);
    LRESULT ButtonUp(UINT nMsg, WPARAM nHittest, const POINTS& pts);
    void    OnCaptureLost(HWND hwndNew) {RESET_CAPTURE();}
    LRESULT WindowPosChanging(LPWINDOWPOS);
    LRESULT OnSize(WPARAM, LONG, LONG);
    BOOL    SetPlacement(PGBPLACEMENT);
    BOOL    SetBuddy(HWND, ULONG);
    BOOL    SetDropState(BOOL);
    void    SetText(LPCTSTR);
    int     GetText(LPTSTR, int);
    int     GetTextW(LPWSTR, int);
    int     GetTextLength();
    void    SetFont(HFONT);
    HFONT   GetFont();

    //  utility methods
    static void _MapWindowRect(HWND hwnd, HWND hwndRelative, OUT LPRECT prcWindow);
    void        _MapWindowRect(HWND hwndRelative, OUT LPRECT prcWindow);
    HCURSOR     GetHandCursor();
    void        CalcCaptionSize();
    BOOL        CalcClientRect(IN OPTIONAL LPCRECT prcWindow, OUT LPRECT prcClient);
    BOOL        CalcWindowSizeForClient(IN OPTIONAL LPCRECT prcClient, 
                                         IN OPTIONAL LPCRECT prcWindow, 
                                         IN LPCRECT prcNewClient, 
                                         OUT LPSIZE psizeWindow);

    void    DoLayout(BOOL bNewBuddy = FALSE);

    LONG    EnableNotifications(BOOL bEnable);
    LRESULT SendNotify(int nCode, IN OPTIONAL NMHDR* pnmh = NULL);
    void    PostNotify(int nCode);
    
    
    //  instance and static data
    HWND        _hwnd;
    HWND        _hwndBuddy;
    WNDPROC     _pfnBuddy;
    ULONG       _dwBuddyFlags;
    SIZE        _sizeBuddyMargin;
    HFONT       _hf;
    static ATOM _atom;
    LPTSTR      _pszCaption;
    SIZE        _sizeCaption;
    int         _yDrop;
    BOOL        _fDropped : 1,
                _fInLayout : 1;
    UINT        _fCapture;
    UINT        _fKeyboardCues;
    HCURSOR     _hcurHand;
    LONG        _cNotifyLocks;

    friend ATOM GroupButton_RegisterClass();
    friend HWND CreateGroupBtn(DWORD, LPCTSTR, DWORD, 
                                int x, int y, HWND hwndParent, UINT nID);
};

ATOM WINAPI GroupButton_RegisterClass()
{
    WNDCLASSEX wc = {0};
    wc.cbSize         = sizeof(wc);
    wc.style          = CS_GLOBALCLASS;
    wc.lpfnWndProc    = CGroupBtn::s_GroupBtnWndProc;
    wc.hInstance      = HINST_THISDLL;
    wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground  = (HBRUSH)(GROUPBTN_BKCOLOR+1);
    wc.lpszClassName  = GROUPBUTTON_CLASS;
    RegisterClassEx(&wc);
    return (ATOM)TRUE;
}

CGroupBtn::CGroupBtn(HWND hwnd) 
    :   CAccessibleBase(_hwnd),
        _hwnd(hwnd), 
        _hwndBuddy(NULL), 
        _pfnBuddy(NULL),
        _dwBuddyFlags(GBBF_HRESIZE|GBBF_VRESIZE),
        _fInLayout(FALSE),
        _hf(NULL), 
        _pszCaption(NULL),
        _fDropped(TRUE),
        _fKeyboardCues(0),
        _yDrop(0),
        _fCapture(0),
        _hcurHand(NULL),
        _cNotifyLocks(0)
{
    _sizeCaption.cx = _sizeCaption.cy = 0;
    _sizeBuddyMargin.cx = _sizeBuddyMargin.cy = 0;
}

ATOM    CGroupBtn::_atom = 0;


CGroupBtn::~CGroupBtn() 
{
    SetFont(NULL);
    SetText(NULL);
}


//  CGroupBtn IAccessible impl
STDMETHODIMP CGroupBtn::get_accName(VARIANT varChild, BSTR* pbstrName)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);

    if (NULL == pbstrName)
        return E_POINTER;
    *pbstrName = 0;

    int cch = GetTextLength();
    if ((*pbstrName = SysAllocStringLen(NULL, cch + 1)) != NULL)
    {
        GetTextW(*pbstrName, cch + 1);
        return S_OK;
    }
    return E_OUTOFMEMORY;
}

STDMETHODIMP CGroupBtn::accDoDefaultAction(VARIANT varChild)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    SendNotify(NM_RETURN);
    return S_OK;
}



//  CGroupBtn window impl



//  WM_SETTEXT handler
void CGroupBtn::SetText(LPCTSTR pszText)
{
    if (_pszCaption)
    {
        if (pszText && 0==lstrcmp(_pszCaption, pszText))
            return;
        delete [] _pszCaption;
        _pszCaption = NULL;
    }

    if (pszText && *pszText)
    {
        if ((_pszCaption = new TCHAR[lstrlen(pszText)+1]) != NULL)
            lstrcpy(_pszCaption, pszText);
    }
    
    if (IsWindow(_hwnd))
        CalcCaptionSize();
}


//  WM_GETTEXT handler
int CGroupBtn::GetText(LPTSTR pszText, int cchText)
{
    int cch = 0;
    if (pszText && cchText > 0)
    {
        *pszText = 0;
        if (_pszCaption && lstrcpyn(pszText, _pszCaption, cchText))
            cch = min(lstrlen(_pszCaption), cchText);
    }
    return cch;
}


int CGroupBtn::GetTextW(LPWSTR pwszText, int cchText)
{
#ifdef UNICODE
    return GetText(pwszText, cchText);
#else //UNICODE

    int   cchRet = 0;
    LPSTR pszText = new CHAR[cchText];
    
    if (pszText)
    {
        cchRet = GetText(pszText, cchText);
        if (cchRet)
        {
            SHAnsiToUnicode(pszText, pwszText, cchText);
        }
        delete [] pszText;
    }
    return cchRet;

#endif //UNICODE
}


//  WM_GETTEXTLENGTH handler
int CGroupBtn::GetTextLength()
{
    return (_pszCaption && *_pszCaption) ? lstrlen(_pszCaption) : 0 ;
}


//  WM_SETFONT handler
void CGroupBtn::SetFont(HFONT hf)
{
    if (_hf)
    {
        DeleteObject(_hf);
        _hf = NULL;
    }
    _hf = hf;
}


//  WM_GETFONT handler
HFONT CGroupBtn::GetFont()
{
    if (_hf == NULL)
    {
        //  if we don't have a font, use the parent's font
        HFONT hfParent = (HFONT)SendMessage(GetParent(_hwnd), WM_GETFONT, 0, 0);
        if (hfParent)
        {
            LOGFONT lf;
            if (GetObject(hfParent, sizeof(LOGFONT), &lf) >0)
                _hf = CreateFontIndirect(&lf);
        }
    }
    return _hf;
}


//  Hand cursor load
HCURSOR CGroupBtn::GetHandCursor()
{
    if (!_hcurHand)
        _hcurHand = LoadCursor(NULL, IDC_HAND);

    return _hcurHand;
}


//  Retrieves the window rect in relative coords.
void CGroupBtn::_MapWindowRect(HWND hwnd, HWND hwndRelative, OUT LPRECT prcWindow)
{
    ASSERT(IsWindow(hwnd));
    GetWindowRect(hwnd, prcWindow);
    MapWindowPoints(HWND_DESKTOP, hwndRelative, (LPPOINT)prcWindow, 2);
}


//  Retrieves the window rect in relative coords.
inline void CGroupBtn::_MapWindowRect(HWND hwndRelative, OUT LPRECT prcWindow)
{
    _MapWindowRect(_hwnd, hwndRelative, prcWindow);
}


//  Caches the size of the caption 'bar'.
void CGroupBtn::CalcCaptionSize()
{
    SIZE    sizeCaption = {0,0};
    LPCTSTR pszCaption = (_pszCaption && *_pszCaption) ? _pszCaption : TEXT("|");
    HDC     hdc;

    //  compute caption size based on window text:
    if ((hdc = GetDC(_hwnd)))
    {
        HFONT hf = GetFont(),
              hfPrev = (HFONT)SelectObject(hdc, hf);
        
        if (GetTextExtentPoint32(hdc, pszCaption, lstrlen(pszCaption),
                                  &sizeCaption))
            sizeCaption.cy += CAPTION_VPADDING; // add some vertical padding

        SelectObject(hdc, hfPrev);
        ReleaseDC(_hwnd, hdc);
    }

    _sizeCaption = sizeCaption;
}


//  Computes the size and position of the client area
BOOL CGroupBtn::CalcClientRect(IN OPTIONAL LPCRECT prcWindow, OUT LPRECT prcClient)
{
    DWORD dwStyle = GetWindowLong(_hwnd, GWL_STYLE);
    RECT  rcWindow;

    if (!prcWindow)
    {
        //  Get parent-relative coords
        _MapWindowRect(GetParent(_hwnd), &rcWindow);
        prcWindow = &rcWindow;
    }

    *prcClient = *prcWindow;

    //  compute client rectangle:

    //  allow for border
    if (dwStyle & WS_BORDER)
        InflateRect(prcClient, -1, -1);

    //  allow for caption 'bar'
    prcClient->top += _sizeCaption.cy;

    //  Normalize for NULL rect.
    if (RECTWIDTH(*prcWindow) <=0)
        prcClient->left = prcClient->right = prcWindow->left;
    if (RECTHEIGHT(*prcWindow) <=0)
        prcClient->bottom = prcClient->top = prcWindow->top;

    return TRUE;
}


BOOL CGroupBtn::CalcWindowSizeForClient(
    IN OPTIONAL LPCRECT prcClient, 
    IN OPTIONAL LPCRECT prcWindow, 
    IN LPCRECT prcNewClient, 
    OUT LPSIZE psizeWindow)
{
    if (!(prcNewClient && psizeWindow))
    {
        ASSERT(FALSE);
        return FALSE;
    }

    RECT rcWindow, rcClient;
    if (NULL == prcWindow)
    {
        GetWindowRect(_hwnd, &rcWindow);
        prcWindow = &rcWindow;
    }

    if (NULL == prcClient)
    {
        GetClientRect(_hwnd, &rcClient);
        prcClient = &rcClient;
    }

    SIZE sizeDelta;
    sizeDelta.cx = RECTWIDTH(*prcWindow) - RECTWIDTH(*prcClient);
    sizeDelta.cy = RECTHEIGHT(*prcWindow) - RECTHEIGHT(*prcClient);

    psizeWindow->cx = RECTWIDTH(*prcNewClient)  + sizeDelta.cx;
    psizeWindow->cy = RECTHEIGHT(*prcNewClient) + sizeDelta.cy;
    
    return TRUE;
}


//  WM_WINDOWPOSCHANGING handler
LRESULT CGroupBtn::WindowPosChanging(LPWINDOWPOS pwp)
{
    if (pwp->flags & SWP_NOSIZE)
        return DefWindowProc(_hwnd, WM_WINDOWPOSCHANGING, 0, (LPARAM)pwp);

    //  disallow sizing in buddy slave dimension(s).
    if (IsWindow(_hwndBuddy) && _dwBuddyFlags & (GBBF_HSLAVE|GBBF_VSLAVE) && !_fInLayout)
    {
        RECT rcWindow, rcClient;
        BOOL fResizeBuddy = FALSE;

        GetWindowRect(_hwnd, &rcWindow);
        GetClientRect(_hwnd, &rcClient);

        //  Prepare a buddy size data block
        GBNQUERYBUDDYSIZE qbs;
        qbs.cy = pwp->cy - (RECTHEIGHT(rcWindow) - RECTHEIGHT(rcClient));
        qbs.cx = pwp->cx - (RECTWIDTH(rcWindow) - RECTWIDTH(rcClient));
        
        if (_dwBuddyFlags & GBBF_HSLAVE) // prevent external horz resizing
        {
            pwp->cx = RECTWIDTH(rcWindow);
            //  If we're being resized in the vert dir, query for
            //  optimal buddy width for this height and adjust
            if (_dwBuddyFlags & GBBF_VRESIZE && RECTHEIGHT(rcWindow) != pwp->cy)
            {
                if (SendNotify(GBN_QUERYBUDDYWIDTH, (NMHDR*)&qbs) && qbs.cx >= 0)
                {
                    //  if the owner wants the buddy width to change, do it now.
                    LONG cxNew = qbs.cx + (RECTWIDTH(rcWindow) - RECTWIDTH(rcClient));
                    fResizeBuddy = cxNew != pwp->cx;
                    pwp->cx = cxNew;
                }
            }
        }
        
        if (_dwBuddyFlags & GBBF_VSLAVE) // prevent external vert resizing
        {
            pwp->cy = RECTHEIGHT(rcWindow);
            //  If we're being resized in the horz dir, query for
            //  optimal buddy height for this horizontal and adjust
            if (_dwBuddyFlags & GBBF_HRESIZE && RECTWIDTH(rcWindow) != pwp->cx)
            {
                if (SendNotify(GBN_QUERYBUDDYHEIGHT, (NMHDR*)&qbs) && qbs.cy >= 0)
                {
                    LONG cyNew = qbs.cy + (RECTHEIGHT(rcWindow) - RECTHEIGHT(rcClient));
                    fResizeBuddy = cyNew != pwp->cy;
                    pwp->cy = cyNew;
                }
            }
        }

        if (fResizeBuddy)
        {
            _fInLayout = TRUE;
            SetWindowPos(_hwndBuddy, NULL, 0, 0, qbs.cx, qbs.cy,
                          SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
            _fInLayout = FALSE;
        }
    }

    //  enforce minimum height:
    if (pwp->cy < _sizeCaption.cy)
        pwp->cy = _sizeCaption.cy;

    return 0;
}


LRESULT CGroupBtn::OnSize(WPARAM flags, LONG cx, LONG cy)
{
    DoLayout();
    return 0;
} 


void CGroupBtn::DoLayout(BOOL bNewBuddy)
{
    if (!_fInLayout && IsWindow(_hwndBuddy))
    {
        RECT  rcWindow, rcThis, rcBuddy;
        DWORD dwSwpBuddy = SWP_NOACTIVATE,
              dwSwpThis  = SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE;
        BOOL  fReposThis = FALSE;
        SIZE  sizeNew;

        GetClientRect(_hwnd, &rcThis);
        GetWindowRect(_hwnd, &rcWindow);

        //  get rectangles in parent coords
        MapWindowPoints(_hwnd, GetParent(_hwnd), (LPPOINT)&rcThis,    POINTSPERRECT); 
        MapWindowPoints(HWND_DESKTOP, GetParent(_hwnd), (LPPOINT)&rcWindow,  POINTSPERRECT); 
        _MapWindowRect(_hwndBuddy, GetParent(_hwnd), &rcBuddy);

        //  If we need to reposition ourself to the buddy, 
        //  calculate the new size now.
        if (_dwBuddyFlags & (GBBF_HSLAVE|GBBF_VSLAVE))
            CalcWindowSizeForClient(&rcThis, &rcWindow, &rcBuddy, &sizeNew);

        //  Resize buddy according to size.
        if (_dwBuddyFlags & GBBF_HRESIZE)
        {
            rcBuddy.right = rcBuddy.left + RECTWIDTH(rcThis);

            if (bNewBuddy && 0 == (_dwBuddyFlags & GBBF_VRESIZE)) 
            {
                // query height
                GBNQUERYBUDDYSIZE qbs;
                qbs.cx = RECTWIDTH(rcThis);
                qbs.cy = -1;
                if (SendNotify(GBN_QUERYBUDDYHEIGHT, (NMHDR*)&qbs) && qbs.cy >= 0)
                    rcBuddy.bottom = rcBuddy.top + qbs.cy;
            }
        }
        else if (_dwBuddyFlags & GBBF_HSLAVE)
        { 
            rcWindow.right = rcWindow.left + sizeNew.cx;
            fReposThis = TRUE;
        }
        if (_dwBuddyFlags & GBBF_VRESIZE)
        {
            rcBuddy.bottom = rcBuddy.top + RECTHEIGHT(rcThis);

            if (bNewBuddy && 0 == (_dwBuddyFlags & GBBF_HRESIZE)) 
            {
                // query width
                GBNQUERYBUDDYSIZE qbs;
                qbs.cx = -1;
                qbs.cy = RECTHEIGHT(rcThis);
                if (SendNotify(GBN_QUERYBUDDYWIDTH, (NMHDR*)&qbs) && qbs.cx >= 0)
                    rcBuddy.right = rcBuddy.left + qbs.cx;
            }
        }
        else if (_dwBuddyFlags & GBBF_VSLAVE)
        { 
            rcWindow.bottom = rcWindow.top + sizeNew.cy;
            fReposThis = TRUE;
        }
        
        if (_dwBuddyFlags & GBBF_HSCROLL) 
        { 
            /* not implemented */
        }

        if (_dwBuddyFlags & GBBF_VSCROLL)
        { 
            /* not implemented */
        }

        //  reposition ourself and update our client rect.
        if (fReposThis)
         {
            _fInLayout = TRUE;
            SetWindowPos(_hwnd, NULL, 0, 0, 
                          RECTWIDTH(rcWindow), RECTHEIGHT(rcWindow), dwSwpThis);
            _fInLayout = FALSE;
            GetClientRect(_hwnd, &rcThis);
            MapWindowPoints(_hwnd, GetParent(_hwnd), (LPPOINT)&rcThis,  POINTSPERRECT); 
        }
        
        //  slide buddy into client area and reposition
        OffsetRect(&rcBuddy, rcThis.left - rcBuddy.left, rcThis.top - rcBuddy.top);
        
        _fInLayout = TRUE;
        SetWindowPos(_hwndBuddy, _hwnd, rcBuddy.left, rcBuddy.top,
                      RECTWIDTH(rcBuddy), RECTHEIGHT(rcBuddy), dwSwpBuddy);
        _fInLayout = FALSE;
    }
}


//  GBM_SETPLACEMENT handler
BOOL CGroupBtn::SetPlacement(PGBPLACEMENT pgbp)
{
    RECT  rcWindow, rcClient;
    SIZE  sizeDelta = {0};
    DWORD dwFlags = SWP_NOZORDER|SWP_NOACTIVATE;

    _MapWindowRect(GetParent(_hwnd), &rcWindow);
    CalcClientRect(&rcWindow, &rcClient);

    //  establish whether we need to resize
    if ((pgbp->x < 0 || pgbp->x == rcWindow.left) && 
        (pgbp->y < 0 || pgbp->y == rcWindow.top))
        dwFlags |= SWP_NOMOVE;

    //  compute horizontal placement
    if (pgbp->x >= 0)  // fixed horz origin requested
        OffsetRect(&rcWindow, pgbp->x - rcWindow.left, 0);

    if (pgbp->cx >= 0) // fixed width requested
        rcWindow.right = rcWindow.left + pgbp->cx;
    else
    {
        if (pgbp->cxBuddy >= 0) // client width requested
            sizeDelta.cx = pgbp->cxBuddy - RECTWIDTH(rcClient);
        rcWindow.right  += sizeDelta.cx;
    }
                          
    //  compute vertical placement
    if (pgbp->y >= 0)  // fixed vert origin requested
        OffsetRect(&rcWindow, 0, pgbp->y - rcWindow.top);

    if (pgbp->cy >= 0) // fixed height requested
        rcWindow.bottom = rcWindow.top + pgbp->cy;
    else
    {
        if (pgbp->cyBuddy >= 0) // client height requested
            sizeDelta.cy = pgbp->cyBuddy - RECTHEIGHT(rcClient);
        rcWindow.bottom += sizeDelta.cy;
    }

    if (pgbp->hdwp && (-1 != (LONG_PTR)pgbp->hdwp))
        DeferWindowPos(pgbp->hdwp, _hwnd, NULL, rcWindow.left, rcWindow.top, 
                        RECTWIDTH(rcWindow), RECTHEIGHT(rcWindow),
                        dwFlags);
    else
        SetWindowPos(_hwnd, NULL, rcWindow.left, rcWindow.top, 
                      RECTWIDTH(rcWindow), RECTHEIGHT(rcWindow),
                      dwFlags);

    //  stuff resulting rects
    pgbp->rcWindow = rcWindow;
    return CalcClientRect(&rcWindow, &pgbp->rcBuddy);
}


BOOL CGroupBtn::SetBuddy(HWND hwnd, ULONG dwFlags)
{
    // If we already have a buddy, unhook ourselves
    //
    if (_hwndBuddy)
    {
        if (IsWindow(_hwndBuddy) && _pfnBuddy)
        {
            SetWindowLongPtr(_hwndBuddy, GWLP_USERDATA, (LONG_PTR)NULL);
            SetWindowLongPtr(_hwndBuddy, GWLP_WNDPROC, (LONG_PTR)_pfnBuddy);
        }
        _hwndBuddy = NULL;
        _pfnBuddy = NULL;
    }

    // Handle an invalid window...
    if (!IsWindow(hwnd))
        hwnd = NULL;

    // If we're being buddy'd with a window, hook it
    //
    if (hwnd)
    {
        if (dwFlags & (GBBF_HSLAVE|GBBF_VSLAVE))
        {
            //  subclass the buddy 
            _pfnBuddy = (WNDPROC)SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)s_BuddyProc);
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)this);
        }

        _hwndBuddy = hwnd;
        _dwBuddyFlags = dwFlags;
        DoLayout(TRUE);
    }

    return TRUE;
}


BOOL CGroupBtn::SetDropState(BOOL bDropped)
{
    _fDropped = bDropped;
    return TRUE;
}


//  WM_NCCREATE handler
void CGroupBtn::NcCreate(LPCREATESTRUCT lpcs)
{
    //  assign user data
    SetWindowLongPtr(_hwnd, GWLP_USERDATA, (LONG_PTR)this);
    
    //  enforce window style bits
    lpcs->style     |= WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
    lpcs->dwExStyle |= WS_EX_TRANSPARENT;
    SetWindowLong(_hwnd, GWL_STYLE, lpcs->style);
    SetWindowLong(_hwnd, GWL_EXSTYLE, lpcs->dwExStyle);

    //  enforce min height
    SetText(lpcs->lpszName);
    if (lpcs->cy < _sizeCaption.cy)
    { 
        lpcs->cy = _sizeCaption.cy;
        SetWindowPos(_hwnd, NULL, 0,0, lpcs->cx, lpcs->cy,
                      SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
    }
}


//  WM_NCCALCSIZE handler
LRESULT CGroupBtn::NcCalcSize(BOOL fCalcValidRects, LPNCCALCSIZE_PARAMS pnccs)
{
    LRESULT lRet = FALSE;
    RECT   rcClient;

    if (fCalcValidRects && CalcClientRect(&pnccs->rgrc[0], &rcClient))
    {
        pnccs->rgrc[1] = pnccs->rgrc[2];
        pnccs->rgrc[0] = pnccs->rgrc[2] = rcClient;
        return WVR_VALIDRECTS;
    }
    
    return lRet;
}


//  WM_NCPAINT handler
void CGroupBtn::NcPaint(HRGN hrgn)
{
    RECT    rcWindow;
    DWORD   dwStyle = GetWindowLong(_hwnd, GWL_STYLE);
    HDC     hdc;

    GetWindowRect(_hwnd, &rcWindow);
    OffsetRect(&rcWindow, -rcWindow.left, -rcWindow.top);

    if ((hdc = GetWindowDC(_hwnd)) != NULL)
    {
        if (dwStyle & WS_BORDER)
        {
            HBRUSH hbr = CreateSolidBrush(COLOR_WINDOWFRAME);
            if (hbr)
            {
                FrameRect(hdc, &rcWindow, hbr);
                DeleteObject(hbr);
            }
        }

        rcWindow.bottom = rcWindow.top + _sizeCaption.cy;

        SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
        SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));

        ExtTextOut(hdc, rcWindow.left, rcWindow.top, 
                    ETO_OPAQUE, &rcWindow, NULL, 0, NULL);

        InflateRect(&rcWindow, -CAPTION_HPADDING, -(CAPTION_VPADDING/2));
        HFONT hfPrev = (HFONT)SelectObject(hdc, GetFont());
        ExtTextOut(hdc, rcWindow.left, rcWindow.top, 
                    ETO_OPAQUE, &rcWindow, _pszCaption, 
                    _pszCaption ? lstrlen(_pszCaption) : 0, NULL);
        SelectObject(hdc, hfPrev);

        if (0 == (_fKeyboardCues & UISF_HIDEFOCUS))
        {
            if (GetFocus() == _hwnd)
            {
                rcWindow.right = rcWindow.left + _sizeCaption.cx + 1;
                InflateRect(&rcWindow, 1, 0);
                DrawFocusRect(hdc, &rcWindow);
            }
        }

        ReleaseDC(_hwnd, hdc);
    }
}


//  WM_NCMOUSEMOVE handler

LRESULT CGroupBtn::NcMouseMove(WPARAM nHittest, LONG x, LONG y)
{
    if (HTCAPTION == nHittest)
    {
        RECT  rc;
        POINT pt;
        GetWindowRect(_hwnd, &rc);
        rc.bottom = rc.top + _sizeCaption.cy;
        rc.right  = rc.left + _sizeCaption.cx;
        InflateRect(&rc, 0, -(CAPTION_VPADDING/2));
        pt.x = x;
        pt.y = y;

        if (PtInRect(&rc, pt))
        {
            HCURSOR hc = GetHandCursor();
            if (hc != NULL)
            {
                SetCursor(hc);
                return 0;
            }
        }
    }
    return DefWindowProc(_hwnd, WM_NCMOUSEMOVE, nHittest, MAKELPARAM(x, y));
}


//  WM_NCHITTEST handler
LRESULT CGroupBtn::NcHitTest(LONG x, LONG y)
{
    POINT pt;
    RECT  rc, rcClient;
    DWORD dwStyle = GetWindowLong(_hwnd, GWL_STYLE);
    
    pt.x = x;
    pt.y = y;

    GetWindowRect(_hwnd, &rc);
    CalcClientRect(&rc, &rcClient);

    if (PtInRect(&rcClient, pt))
        return HTTRANSPARENT;

    if (PtInRect(&rc, pt))
    {
        if (dwStyle & WS_BORDER)
        {
            if (pt.x == rc.left ||
                pt.x == rc.right ||
                pt.y == rc.bottom)
                return HTBORDER;
        }
        return HTCAPTION;
    }
    return HTNOWHERE;
}


LRESULT CGroupBtn::NcButtonDown(UINT nMsg, WPARAM nHittest, const POINTS& pts)
{
    LRESULT lRet = 0;

    if (HTCAPTION == nHittest)
    {
        SetCursor(GetHandCursor());
        MODIFY_CAPTURE(CF_SETCAPTURE, 0);

        if (GetFocus() != _hwnd)
        {
            MODIFY_CAPTURE(CF_SETFOCUS, 0);
            EnableNotifications(FALSE); // so the host doesn't reposition the link.
            SetFocus(_hwnd);
            EnableNotifications(TRUE);
        }

        SetCapture(_hwnd);
    }
    else
        lRet = DefWindowProc(_hwnd, nMsg, nHittest, MAKELONG(pts.x, pts.y));
        
    return lRet;
}


LRESULT CGroupBtn::ButtonUp(UINT nMsg, WPARAM nHittest, const POINTS& pts)
{
    if (TEST_CAPTURE(CF_SETCAPTURE))
    {
        ReleaseCapture();
        MODIFY_CAPTURE(0, CF_SETCAPTURE);

        POINT ptScrn;
        ptScrn.x = pts.x;
        ptScrn.y = pts.y;
        MapWindowPoints(_hwnd, HWND_DESKTOP, &ptScrn, 1);

        LRESULT nHittest = SendMessage(_hwnd, WM_NCHITTEST, 0, MAKELONG(ptScrn.x, ptScrn.y));

        if (HTCAPTION == nHittest)
        {
            switch (nMsg)
            {
            case WM_LBUTTONUP:
                SendNotify(NM_CLICK);
                break;
            case WM_RBUTTONUP:
                SendNotify(NM_RCLICK);
                break;
            }
        }
    }

    if (TEST_CAPTURE(CF_SETFOCUS))
    {
        MODIFY_CAPTURE(0, CF_SETFOCUS);
        if (GetFocus() == _hwnd) // if we still have the focus...
            SendNotify(NM_SETFOCUS);
    }
    return 0;
}


//  Non-client mouse click/dblclk handler
LRESULT CGroupBtn::NcDblClick(UINT nMsg, WPARAM nHittest, LPARAM lParam)
{
    LRESULT lRet = 0;
    
    if (HTCAPTION == nHittest)
    {
        SetFocus(_hwnd);

        lRet = DefWindowProc(_hwnd, nMsg, HTCLIENT, lParam);

        switch (nMsg)
        {
            case WM_NCLBUTTONDBLCLK:
                SendNotify(NM_DBLCLK);
                break;
            case WM_NCRBUTTONDBLCLK:
                SendNotify(NM_RDBLCLK);
                break;
        }
    }
    else
        lRet = DefWindowProc(_hwnd, nMsg, nHittest, lParam);

    return lRet;
}


LONG CGroupBtn::EnableNotifications(BOOL bEnable)
{
    if (bEnable)
    {
        if (_cNotifyLocks > 0)
            _cNotifyLocks--;
    }
    else
        _cNotifyLocks++;
    
    return _cNotifyLocks;
}


//  WM_NOTIFY transmit helper
LRESULT CGroupBtn::SendNotify(int nCode, IN OPTIONAL NMHDR* pnmh)
{
    if (0 == _cNotifyLocks)
    {
        NMHDR hdr;
        if (NULL == pnmh)
            pnmh = &hdr; 

        pnmh->hwndFrom = _hwnd;
        pnmh->idFrom   = GetDlgCtrlID(_hwnd);
        pnmh->code     = nCode;
        return SendMessage(GetParent(_hwnd), WM_NOTIFY, hdr.idFrom, (LPARAM)pnmh);
    }
    return 0;
}


//  WM_NOTIFY transmit helper
void CGroupBtn::PostNotify(int nCode)
{
    if (0 == _cNotifyLocks)
        PostMessage(_hwnd, GBM_SENDNOTIFY, nCode, 0);
}

LRESULT CALLBACK CGroupBtn::s_GroupBtnWndProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
    CGroupBtn *pThis = (CGroupBtn *)GetWindowLongPtr(hDlg, GWLP_USERDATA);

    if (!pThis && (WM_NCCREATE == wMsg))
    {
        pThis = new CGroupBtn(hDlg);
        SetWindowLongPtr(hDlg, GWLP_USERDATA, (LPARAM)pThis);
    }

    if (pThis)
        return pThis->WndProc(hDlg, wMsg, wParam, lParam);

    return DefWindowProc(hDlg, wMsg, wParam, lParam);
}



LRESULT CGroupBtn::WndProc(HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
    LRESULT lRet = 0;
    
    switch (nMsg)
    {
        case WM_NCHITTEST:
        {
            POINTS pts = MAKEPOINTS(lParam);
            return NcHitTest(pts.x, pts.y);
        }

        case WM_NCMOUSEMOVE:
        {
            POINTS pts = MAKEPOINTS(lParam);
            return NcMouseMove(wParam, pts.x, pts.y);
        }

        case WM_NCCALCSIZE:
            return NcCalcSize((BOOL)wParam, (LPNCCALCSIZE_PARAMS)lParam);

        case WM_NCPAINT:
            NcPaint((HRGN)wParam);
            return 0;

        case WM_WINDOWPOSCHANGING:
            return WindowPosChanging((LPWINDOWPOS)lParam);

        case WM_SIZE:
        {
            POINTS pts = MAKEPOINTS(lParam);
            return OnSize(wParam, pts.x, pts.y);
        }

        case WM_DESTROY:
            if (IsWindow(_hwndBuddy))
                DestroyWindow(_hwndBuddy);
            break;

        case WM_ERASEBKGND:
            return TRUE; // transparent: no erase bkgnd

        case WM_NCLBUTTONDOWN:
        case WM_NCRBUTTONDOWN:
        {
            POINTS pts = MAKEPOINTS(lParam);
            return NcButtonDown(nMsg, wParam, pts);
        }

        case WM_LBUTTONUP:
        case WM_RBUTTONUP:
        {
            POINTS pts = MAKEPOINTS(lParam);
            return ButtonUp(nMsg, wParam, pts);
        }

        case WM_NCLBUTTONDBLCLK:
        case WM_NCRBUTTONDBLCLK:
            return NcDblClick(nMsg, wParam, lParam);

        case WM_SHOWWINDOW:
            if (IsWindow(_hwndBuddy))
                ShowWindow(_hwndBuddy, wParam ? SW_SHOW : SW_HIDE);
            break;

        case WM_SETTEXT:
            SetText((LPCTSTR)lParam);
            return TRUE;

        case WM_GETTEXT:
            return GetText((LPTSTR)lParam, (int)wParam);

        case WM_SETFONT:
            SetFont((HFONT)wParam);
            if (lParam /* fRedraw */)
                InvalidateRect(hwnd, NULL, TRUE);
            break;

        case WM_CAPTURECHANGED:
            if (lParam /* NULL if we called ReleaseCapture() */)
                OnCaptureLost((HWND)lParam);
            break;

        case WM_SETFOCUS:
            NcPaint((HRGN)1);
            SendNotify(NM_SETFOCUS);
            break;
             
        case WM_KILLFOCUS:
            NcPaint((HRGN)1);
            SendNotify(NM_KILLFOCUS);
            break;

        case WM_GETDLGCODE:
        {
            MSG* pmsg;
            lRet = DLGC_BUTTON|DLGC_UNDEFPUSHBUTTON;

            if ((pmsg = (MSG*)lParam))
            {
                if ((WM_KEYDOWN == pmsg->message || WM_KEYUP == pmsg->message))
                {
                    switch (pmsg->wParam)
                    {
                    case VK_RETURN:
                    case VK_SPACE:
                        lRet |= DLGC_WANTALLKEYS;
                        break;
                    }
                }
                else if (WM_CHAR == pmsg->message && VK_RETURN == pmsg->wParam)
                {
                    //  Eat VK_RETURN WM_CHARs; we don't want
                    //  Dialog manager to beep when IsDialogMessage gets it.
                    return lRet |= DLGC_WANTMESSAGE;
                }
            }

            return lRet;
        }

        case WM_KEYDOWN:
        case WM_KEYUP:
        case WM_CHAR:
            switch (wParam)
            {
                case VK_RETURN:
                case VK_SPACE:
                    if (WM_KEYDOWN == nMsg)
                        SendNotify(NM_RETURN);
                    return 0;
            }
            break;

        case WM_UPDATEUISTATE:
            if (_HandleWM_UPDATEUISTATE(wParam, lParam, &_fKeyboardCues))
                SendMessage(hwnd, WM_NCPAINT, 1, 0);
            break;

        case GBM_SETPLACEMENT:
            if (lParam)
                return SetPlacement((PGBPLACEMENT)lParam);
            return 0;

        case GBM_SETDROPSTATE: // WPARAM: BOOL fDropped, LPARAM: n/a, return: BOOL
            return 0;

        case GBM_GETDROPSTATE: // WPARAM: n/a, LPARAM: n/a, return: BOOL fDropped
            return 0;

        case GBM_SENDNOTIFY:
            SendNotify((int)wParam);
            break;

        case WM_NCCREATE:
            NcCreate((LPCREATESTRUCT)lParam);
            break;

        case WM_NCDESTROY:
            lRet = DefWindowProc(hwnd, nMsg, wParam, lParam);
            SetWindowPtr(hwnd, GWLP_USERDATA, NULL);
            _hwnd = NULL;
            Release();
            return lRet;

        case WM_CREATE:
            _InitializeUISTATE(hwnd, &_fKeyboardCues);
            SetText(((LPCREATESTRUCT)lParam)->lpszName);
            break;

        case GBM_SETBUDDY:     // WPARAM: HWND hwndBuddy, LPARAM: MAKELPARAM(cxMargin, cyMargin), return: BOOL
            return SetBuddy((HWND)wParam, (ULONG)lParam);

        case GBM_GETBUDDY:     // WPARAM: n/a, LPARAM: n/a, return: HWND
            return (LRESULT)_hwndBuddy;

        default:
            // oleacc defs thunked for WINVER < 0x0500
            if ((WM_GETOBJECT == nMsg) && (OBJID_CLIENT == lParam || OBJID_TITLEBAR == lParam)) 
                return LresultFromObject(IID_IAccessible, wParam, SAFECAST(this, IAccessible*));

            break;
    }

    return DefWindowProc(hwnd, nMsg, wParam, lParam);
}
                                                   

LRESULT CGroupBtn::s_BuddyProc(HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
    CGroupBtn *pBtn = (CGroupBtn*)GetWindowLongPtr(hwnd, GWLP_USERDATA);

    switch (nMsg)
    {
    case WM_SIZE:
        {
            LRESULT lRet = CallWindowProc(pBtn->_pfnBuddy, hwnd, nMsg, wParam, lParam);
            if (!pBtn->_fInLayout)
                pBtn->DoLayout();
            return lRet;
        }

    case WM_DESTROY:
        {
            WNDPROC pfn = pBtn->_pfnBuddy;
            pBtn->SetBuddy(NULL, 0);
            return CallWindowProc(pfn, hwnd, nMsg, wParam, lParam);
        }
    }
    return pBtn->_pfnBuddy ? CallWindowProc(pBtn->_pfnBuddy, hwnd, nMsg, wParam, lParam) : 0;
}


//  CAccessibleBase IUnknown impl
STDMETHODIMP CAccessibleBase::QueryInterface(REFIID riid, void** ppvObj)
{
    static const QITAB qit[] = 
    {
        QITABENT(CAccessibleBase, IDispatch),
        QITABENT(CAccessibleBase, IAccessible),
        QITABENT(CAccessibleBase, IOleWindow),
        { 0 },
    };
    return QISearch(this, qit, riid, ppvObj);
}

STDMETHODIMP_(ULONG) CAccessibleBase::AddRef()
{
    return InterlockedIncrement(&_cRef);
}

STDMETHODIMP_(ULONG) CAccessibleBase::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}


//  CAccessibleBase IOleWindow impl
STDMETHODIMP CAccessibleBase::GetWindow(HWND* phwnd)
{
    *phwnd = _hwnd;
    return IsWindow(_hwnd) ? S_OK : S_FALSE;
}


//  CAccessibleBase IDispatch impl


static HRESULT _accLoadTypeInfo(ITypeInfo** ppti)
{
    ITypeLib* ptl;
    HRESULT hr = LoadTypeLib(L"oleacc.dll", &ptl);

    if (SUCCEEDED(hr))
    {
        hr = ptl->GetTypeInfoOfGuid(IID_IAccessible, ppti);
        ATOMICRELEASE(ptl);
    }
    return hr;
}

STDMETHODIMP CAccessibleBase::GetTypeInfoCount(UINT * pctinfo) 
{ 
    *pctinfo = 1;
    return S_OK;
}

STDMETHODIMP CAccessibleBase::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo)
{ 
    HRESULT hr = E_FAIL;
    if (NULL == _ptiAcc && FAILED((hr = _accLoadTypeInfo(&_ptiAcc))))
        return hr;

    *pptinfo = _ptiAcc;
    (*pptinfo)->AddRef();
    return S_OK;
}

STDMETHODIMP CAccessibleBase::GetIDsOfNames(
    REFIID riid, 
    OLECHAR** rgszNames, 
    UINT cNames,
    LCID lcid, DISPID * rgdispid)
{
    HRESULT hr = E_FAIL;

    if (IID_NULL != riid && IID_IAccessible != riid)
        return DISP_E_UNKNOWNINTERFACE;

    if (NULL == _ptiAcc && FAILED((hr = _accLoadTypeInfo(&_ptiAcc))))
        return hr;

    return _ptiAcc->GetIDsOfNames(rgszNames, cNames, rgdispid);
}

STDMETHODIMP CAccessibleBase::Invoke(
    DISPID  dispidMember, 
    REFIID  riid, 
    LCID    lcid, 
    WORD    wFlags,
    DISPPARAMS * pdispparams, 
    VARIANT * pvarResult, 
    EXCEPINFO * pexcepinfo, 
    UINT * puArgErr)
{
    HRESULT hr = E_FAIL;
    if (IID_NULL != riid && IID_IAccessible != riid)
        return DISP_E_UNKNOWNINTERFACE;

    if (NULL == _ptiAcc && FAILED((hr = _accLoadTypeInfo(&_ptiAcc))))
        return hr;

    return _ptiAcc->Invoke(this, dispidMember, wFlags, pdispparams, 
                            pvarResult, pexcepinfo, puArgErr);
}

STDMETHODIMP CAccessibleBase::get_accParent(IDispatch ** ppdispParent)
{
    *ppdispParent = NULL;
    if (IsWindow(_hwnd))
        return AccessibleObjectFromWindow(_hwnd, OBJID_WINDOW,
                                           IID_PPV_ARG(IDispatch, ppdispParent));
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accChildCount(long * pcChildren)
{
    *pcChildren = 0;
    return S_OK;
}

STDMETHODIMP CAccessibleBase::get_accChild(VARIANT varChildIndex, IDispatch ** ppdispChild)
{
    *ppdispChild = NULL;
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accValue(VARIANT varChild, BSTR* pbstrValue)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    *pbstrValue = NULL;
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accDescription(VARIANT varChild, BSTR * pbstrDescription)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    *pbstrDescription = NULL;
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accRole(VARIANT varChild, VARIANT *pvarRole)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    pvarRole->vt    = VT_I4;
    pvarRole->lVal  = ROLE_SYSTEM_LINK;
    return S_OK;
}

STDMETHODIMP CAccessibleBase::get_accState(VARIANT varChild, VARIANT *pvarState)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);

    pvarState->vt = VT_I4;
    pvarState->lVal = STATE_SYSTEM_DEFAULT ;

    if (GetFocus() == _hwnd)
        pvarState->lVal |= STATE_SYSTEM_FOCUSED;
    else if (IsWindowEnabled(_hwnd))
        pvarState->lVal |= STATE_SYSTEM_FOCUSABLE;

    if (!IsWindowVisible(_hwnd))
        pvarState->lVal |= STATE_SYSTEM_INVISIBLE;

    return S_OK;
}

STDMETHODIMP CAccessibleBase::get_accHelp(VARIANT varChild, BSTR* pbstrHelp)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    *pbstrHelp = NULL;
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accHelpTopic(BSTR* pbstrHelpFile, VARIANT varChild, long* pidTopic)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    *pbstrHelpFile = NULL;
    *pidTopic    = -1;
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accKeyboardShortcut(VARIANT varChild, BSTR* pbstrKeyboardShortcut)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    *pbstrKeyboardShortcut = NULL;
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accFocus(VARIANT FAR * pvarFocusChild)
{
    HWND hwndFocus;
    if ((hwndFocus = GetFocus()) == _hwnd || IsChild(_hwnd, hwndFocus))
    {
        pvarFocusChild->vt = VT_I4;
        pvarFocusChild->lVal = CHILDID_SELF;
        return S_OK;
    }
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::get_accSelection(VARIANT FAR * pvarSelectedChildren)
{
    return get_accFocus(pvarSelectedChildren);  // implemented same as focus.
}

STDMETHODIMP CAccessibleBase::get_accDefaultAction(VARIANT varChild, BSTR* pbstrDefaultAction)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);

    WCHAR wsz[128];
    if (LoadStringW(HINST_THISDLL, GetDefaultActionStringID(), wsz, ARRAYSIZE(wsz)))
    {
        if (NULL == (*pbstrDefaultAction = SysAllocString(wsz)))
            return E_OUTOFMEMORY;
        return S_OK;
    }
    return E_FAIL;
}

STDMETHODIMP CAccessibleBase::accSelect(long flagsSelect, VARIANT varChild)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);

    if (flagsSelect & SELFLAG_TAKEFOCUS)
    {
        SetFocus(_hwnd);
        return S_OK;
    }
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::accLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
{
    RECT rc;
    GetWindowRect(_hwnd, &rc);
    *pxLeft = rc.left;
    *pyTop  = rc.top;
    *pcxWidth  = RECTWIDTH(rc);
    *pcyHeight = RECTHEIGHT(rc);

    varChild.vt = VT_I4;
    varChild.lVal = CHILDID_SELF;
    return S_OK;
}

STDMETHODIMP CAccessibleBase::accNavigate(long navDir, VARIANT varStart, VARIANT * pvarEndUpAt)
{
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::accHitTest(long xLeft, long yTop, VARIANT * pvarChildAtPoint)
{
    pvarChildAtPoint->vt   = VT_I4;
    pvarChildAtPoint->lVal = CHILDID_SELF;
    return S_OK;
}

STDMETHODIMP CAccessibleBase::put_accName(VARIANT varChild, BSTR bstrName)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    return S_FALSE;
}

STDMETHODIMP CAccessibleBase::put_accValue(VARIANT varChild, BSTR bstrValue)
{
    VALIDATEACCCHILD(varChild, CHILDID_SELF, E_INVALIDARG);
    return S_FALSE;
}

BOOL _HandleWM_UPDATEUISTATE(WPARAM wParam, LPARAM lParam, OUT UINT* puFlags)
{
    UINT uFlags = *puFlags;

    switch (LOWORD(wParam))
    {
    case UIS_CLEAR:
        *puFlags &= ~(HIWORD(wParam));
        break;

    case UIS_SET:
        *puFlags |= HIWORD(wParam);
        break;
    }

    return uFlags != *puFlags;
}

void _InitializeUISTATE(IN HWND hwnd, IN OUT UINT* puFlags)
{
    HWND hwndParent = GetParent(hwnd);
    *puFlags = (UINT)SendMessage(hwndParent, WM_QUERYUISTATE, 0, 0);
}