//+------------------------------------------------------------------------
//
//  File : Utils.cxx
//
//  purpose : implementation of helpful stuff
//
//-------------------------------------------------------------------------


#include "headers.h"

#pragma MARK_DATA(__FILE__)
#pragma MARK_CODE(__FILE__)
#pragma MARK_CONST(__FILE__)
#include "utils.hxx"

#include <docobj.h>
#include <mshtmcid.h>
#include <mshtmhst.h>

#define BUFFEREDSTR_SIZE 1024

// VARIANT conversion interface exposed by script engines (VBScript/JScript).
EXTERN_C const GUID SID_VariantConversion = 
                { 0x1f101481, 0xbccd, 0x11d0, { 0x93, 0x36,  0x0,  0xa0,  0xc9,  0xd,  0xca,  0xa9 } };

//+------------------------------------------------------------------------
//
//  Function:   GetHTMLDocument
//
//  Synopsis:   Gets the IHTMLDocument2 interface from the client site.
//
//-------------------------------------------------------------------------

STDMETHODIMP 
GetHTMLDocument(IElementBehaviorSite * pSite, IHTMLDocument2 **ppDoc)
{
    HRESULT hr = E_FAIL;

    if (!ppDoc)
        return E_POINTER;

    if (pSite != NULL)
    {
        IHTMLElement *pElement = NULL;
        hr = pSite->GetElement(&pElement);
        if (SUCCEEDED(hr))
        {
            IDispatch * pDispDoc = NULL;
            hr = pElement->get_document(&pDispDoc);
            if (SUCCEEDED(hr))
            {
                hr = pDispDoc->QueryInterface(IID_IHTMLDocument2, (void **)ppDoc);
                pDispDoc->Release();
            }
            pElement->Release();
        }
    }

    return hr;
}

//+------------------------------------------------------------------------
//
//  Function:   GetHTMLWindow
//
//  Synopsis:   Gets the IHTMLWindow2 interface from the client site.
//
//-------------------------------------------------------------------------

STDMETHODIMP 
GetHTMLWindow(IElementBehaviorSite * pSite, IHTMLWindow2 **ppWindow)
{
    HRESULT hr = E_FAIL;
    IHTMLDocument2 *pDoc = NULL;

    hr = GetHTMLDocument(pSite, &pDoc);

    if (SUCCEEDED(hr))
    {
        hr = pDoc->get_parentWindow(ppWindow);
        pDoc->Release();
    }

    return hr;
}

//+------------------------------------------------------------------------
//
//  Function:   GetClientSiteWindow
//
//  Synopsis:   Gets the window handle of the client site passed in.
//
//-------------------------------------------------------------------------

STDMETHODIMP 
GetClientSiteWindow(IElementBehaviorSite *pSite, HWND *phWnd)
{
    HRESULT hr = E_FAIL;
    IWindowForBindingUI *pWindowForBindingUI = NULL;

    if (pSite != NULL) {

        // Get IWindowForBindingUI ptr
        hr = pSite->QueryInterface(IID_IWindowForBindingUI,
                (LPVOID *)&pWindowForBindingUI);

        if (FAILED(hr)) {
            IServiceProvider *pServProv;
            hr = pSite->QueryInterface(IID_IServiceProvider, (LPVOID *)&pServProv);

            if (hr == NOERROR) {
                pServProv->QueryService(IID_IWindowForBindingUI,IID_IWindowForBindingUI,
                    (LPVOID *)&pWindowForBindingUI);
                pServProv->Release();
            }
        }

        if (pWindowForBindingUI) {
            pWindowForBindingUI->GetWindow(IID_IWindowForBindingUI, phWnd);
            pWindowForBindingUI->Release();
        }
    }

    return hr;
}


//+------------------------------------------------------------------------
//
//  Function:   AppendElement
//
//  Synopsis:   Appends a child to an owner
//
//-------------------------------------------------------------------------

STDMETHODIMP
AppendChild(IHTMLElement *pOwner, IHTMLElement *pChild)
{
    HRESULT hr; 

    CComPtr<IHTMLDOMNode> pOwnerNode, pChildNode;

    hr = pOwner->QueryInterface(IID_IHTMLDOMNode, (void **) &pOwnerNode);
    if (FAILED(hr))
        goto Cleanup;

    hr = pChild->QueryInterface(IID_IHTMLDOMNode, (void **) &pChildNode);
    if (FAILED(hr))
        goto Cleanup;

    hr = pOwnerNode->appendChild(pChildNode, NULL);
    if (FAILED(hr))
        goto Cleanup;

Cleanup:

    return hr;
}


//+---------------------------------------------------------------
//
// Function:    IsSameObject
//
// Synopsis:    Checks for COM identity
//
// Arguments:   pUnkLeft, pUnkRight
//
//+---------------------------------------------------------------

BOOL
IsSameObject(IUnknown *pUnkLeft, IUnknown *pUnkRight)
{
    IUnknown *pUnk1, *pUnk2;

    if (pUnkLeft == pUnkRight)
        return TRUE;

    if (pUnkLeft == NULL || pUnkRight == NULL)
        return FALSE;

    if (SUCCEEDED(pUnkLeft->QueryInterface(IID_IUnknown, (LPVOID *)&pUnk1)))
    {
        pUnk1->Release();
        if (pUnk1 == pUnkRight)
            return TRUE;
        if (SUCCEEDED(pUnkRight->QueryInterface(IID_IUnknown, (LPVOID *)&pUnk2)))
        {
            pUnk2->Release();
            return pUnk1 == pUnk2;
        }
    }
    return FALSE;
}

//+------------------------------------------------------------------------
//
//  Function:   ClearInterfaceFn
//
//  Synopsis:   Sets an interface pointer to NULL, after first calling
//              Release if the pointer was not NULL initially
//
//  Arguments:  [ppUnk]     *ppUnk is cleared
//
//-------------------------------------------------------------------------

void
ClearInterfaceFn(IUnknown ** ppUnk)
{
    IUnknown * pUnk;

    pUnk = *ppUnk;
    *ppUnk = NULL;
    if (pUnk)
        pUnk->Release();
}



//+------------------------------------------------------------------------
//
//  Function:   ReplaceInterfaceFn
//
//  Synopsis:   Replaces an interface pointer with a new interface,
//              following proper ref counting rules:
//
//              = *ppUnk is set to pUnk
//              = if *ppUnk was not NULL initially, it is Release'd
//              = if pUnk is not NULL, it is AddRef'd
//
//              Effectively, this allows pointer assignment for ref-counted
//              pointers.
//
//  Arguments:  [ppUnk]
//              [pUnk]
//
//-------------------------------------------------------------------------

void
ReplaceInterfaceFn(IUnknown ** ppUnk, IUnknown * pUnk)
{
    IUnknown * pUnkOld = *ppUnk;

    *ppUnk = pUnk;

    //  Note that we do AddRef before Release; this avoids
    //    accidentally destroying an object if this function
    //    is passed two aliases to it

    if (pUnk)
        pUnk->AddRef();

    if (pUnkOld)
        pUnkOld->Release();
}



//+------------------------------------------------------------------------
//
//  Function:   ReleaseInterface
//
//  Synopsis:   Releases an interface pointer if it is non-NULL
//
//  Arguments:  [pUnk]
//
//-------------------------------------------------------------------------

void
ReleaseInterface(IUnknown * pUnk)
{
    if (pUnk)
        pUnk->Release();
}


//+------------------------------------------------------------------------
//
//  Member:     CBufferedStr::Set
//
//  Synopsis:   Initilizes a CBufferedStr
//
//-------------------------------------------------------------------------
HRESULT
CBufferedStr::Set (LPCTSTR pch, UINT uiCch)
{
    HRESULT hr = S_OK;

    Free();

    if (!uiCch)
        _cchIndex = pch ? _tcslen (pch) : 0;
    else
        _cchIndex = uiCch;

    _cchBufSize = _cchIndex > BUFFEREDSTR_SIZE ? _cchIndex : BUFFEREDSTR_SIZE;
    _pchBuf = new TCHAR [ _cchBufSize ];
    if (!_pchBuf)
    {
        hr = E_OUTOFMEMORY;
        goto Cleanup;
    }

    if (pch)
    {
        _tcsncpy (_pchBuf, pch, _cchIndex);
    }

    _pchBuf[_cchIndex] = '\0';

Cleanup:
    return (hr);
}


//+------------------------------------------------------------------------
//
//  Member:     CBufferedStr::QuickAppend
//
//  Parameters: pchNewStr   string to be added to _pchBuf
//
//  Synopsis:   Appends pNewStr into _pchBuf starting at
//              _pchBuf[uIndex].  Increments index to reference
//              new end of string.  If _pchBuf is not large enough,
//              reallocs _pchBuf and updates _cchBufSize.
//
//-------------------------------------------------------------------------
HRESULT
CBufferedStr::QuickAppend (const TCHAR* pchNewStr, ULONG newLen)
{
    HRESULT hr = S_OK;

    if (!_pchBuf)
    {
        hr = Set();
        if (hr)
            goto Cleanup;
    }

    if (_cchIndex + newLen >= _cchBufSize)    // we can't fit the new string in the current buffer
    {                                         // so allocate a new buffer, and copy the old string
        _cchBufSize += (newLen > BUFFEREDSTR_SIZE) ? newLen : BUFFEREDSTR_SIZE;
        TCHAR * pchTemp = new TCHAR [ _cchBufSize ];
        if (!pchTemp)
        {
            hr = E_OUTOFMEMORY;
            goto Cleanup;
        }
        _tcsncpy (pchTemp, _pchBuf, _cchIndex);

        Free();
        _pchBuf = pchTemp;
    }

    // append the new string
    _tcsncpy (_pchBuf + _cchIndex, pchNewStr, newLen);
    _cchIndex += newLen;
    _pchBuf[_cchIndex] = '\0';

Cleanup:
    return (hr);
}
HRESULT
CBufferedStr::QuickAppend(long lValue)
{
    TCHAR   strValue[40];

#ifdef UNICODE
    return QuickAppend( _ltow(lValue, strValue, 10) );
#else
    return QuickAppend( _ltoa(lValue, strValue, 10) );
#endif
}

//+---------------------------------------------------------------------------
//
//  method : ConvertGmtTimeToString
//
//  Synopsis: This function produces a standard(?) format date, of the form
// Tue, 02 Apr 1996 02:04:57 UTC  The date format *will not* be tailored
// for the locale.  This is for cookie use and Netscape compatibility
//
//----------------------------------------------------------------------------
static const TCHAR* achMonth[] = {
    _T("Jan"),_T("Feb"),_T("Mar"),_T("Apr"),_T("May"),_T("Jun"),
        _T("Jul"),_T("Aug"),_T("Sep"),_T("Oct"),_T("Nov"),_T("Dec") 
};
static const TCHAR* achDay[] = {
    _T("Sun"), _T("Mon"),_T("Tue"),_T("Wed"),_T("Thu"),_T("Fri"),_T("Sat")
};

HRESULT 
ConvertGmtTimeToString(FILETIME Time, TCHAR * pchDateStr, DWORD cchDateStr)
{
    SYSTEMTIME SystemTime;
    CBufferedStr strBuf;

    if (cchDateStr < DATE_STR_LENGTH)
        return E_INVALIDARG;

    FileTimeToSystemTime(&Time, &SystemTime);

    strBuf.QuickAppend(achDay[SystemTime.wDayOfWeek]);
    strBuf.QuickAppend(_T(", "));
    strBuf.QuickAppend(SystemTime.wDay);
    strBuf.QuickAppend(_T(" ") );
    strBuf.QuickAppend(achMonth[SystemTime.wMonth - 1] );
    strBuf.QuickAppend(_T(" ") );
    strBuf.QuickAppend(SystemTime.wYear );
    strBuf.QuickAppend(_T(" ") );
    strBuf.QuickAppend(SystemTime.wHour );
    strBuf.QuickAppend(_T(":") );
    strBuf.QuickAppend(SystemTime.wMinute );
    strBuf.QuickAppend(_T(":") );
    strBuf.QuickAppend(SystemTime.wSecond );
    strBuf.QuickAppend(_T(" UTC") );

    if (strBuf.Length() >cchDateStr)
        return E_FAIL;

    _tcscpy(pchDateStr, strBuf);

    return S_OK;
}

HRESULT 
ParseDate(BSTR strDate, FILETIME * pftTime)
{
    HRESULT      hr = S_FALSE;
    SYSTEMTIME   stTime ={0};
    LPCTSTR      pszToken = NULL;
    BOOL         fFound;
    int          idx, cch;
    CDataListEnumerator  dle(strDate, _T(':'));

    if (!pftTime)
    {
        hr = E_POINTER;
        goto Cleanup;
    }

    // get the dayOfTheWeek:  3 digits max plus comma
    //--------------------------------------------------
    if (! dle.GetNext(&pszToken, &cch) || cch > 4)
        goto Cleanup;
    else
    {
        for (idx=0; idx < ARRAY_SIZE(achDay); idx++)
        {
            fFound = !_tcsnicmp( pszToken, achDay[idx], 3);
            if (fFound)
            {
                stTime.wDayOfWeek = (WORD)idx;
                break;
            }
        }

        if (!fFound)
        {
            hr = E_FAIL;
            goto Cleanup;
        }
    }

    // get the Day 2 digits max
    //--------------------------------------------------
    if (! dle.GetNext(&pszToken, &cch) || cch > 2)
        goto Cleanup;

    stTime.wDay = (WORD)_ttoi(pszToken);

    // get the Month: 3 characters
    //--------------------------------------------------
    if (! dle.GetNext(&pszToken, &cch) || cch > 3)
        goto Cleanup;
    else
    {
        for (idx=0; idx < ARRAY_SIZE(achMonth); idx++)
        {
            fFound = !_tcsnicmp( pszToken, achMonth[idx], 3);
            if (fFound)
            {
                stTime.wMonth = (WORD)idx + 1;
                break;
            }
        }

        if (!fFound)
        {
            hr = E_FAIL;
            goto Cleanup;
        }
    }

    // get the Year 4 digits max
    //--------------------------------------------------
    if (! dle.GetNext(&pszToken, &cch) || cch > 4)
        goto Cleanup;

    stTime.wYear = (WORD)_ttoi(pszToken);

    // get the Hour 2 digits max
    //--------------------------------------------------
    if (! dle.GetNext(&pszToken, &cch) || cch > 2)
        goto Cleanup;

    stTime.wHour = (WORD)_ttoi(pszToken);

    // get the Minute 2 digits max
    //--------------------------------------------------
    if (! dle.GetNext(&pszToken, &cch) || cch > 2)
        goto Cleanup;

    stTime.wMinute = (WORD)_ttoi(pszToken);

    // get the Second 2 digits max
    //--------------------------------------------------
    if (! dle.GetNext(&pszToken, &cch) || cch > 2)
        goto Cleanup;

    stTime.wSecond = (WORD)_ttoi(pszToken);

    // now we have SYSTEMTIME, lets return the FILETIME
    if (!SystemTimeToFileTime(&stTime, pftTime))
        hr = GetLastError();
    else
        hr = S_OK;

Cleanup:
    return hr;
}


//+---------------------------------------------------------------------------
//
//  Function:   MbcsFromUnicode
//
//  Synopsis:   Converts a string to MBCS from Unicode.
//
//  Arguments:  [pstr]  -- The buffer for the MBCS string.
//              [cch]   -- The size of the MBCS buffer, including space for
//                              NULL terminator.
//
//              [pwstr] -- The Unicode string to convert.
//              [cwch]  -- The number of characters in the Unicode string to
//                              convert, including NULL terminator.  If this
//                              number is -1, the string is assumed to be
//                              NULL terminated.  -1 is supplied as a
//                              default argument.
//
//  Returns:    If [pstr] is NULL or [cch] is 0, 0 is returned.  Otherwise,
//              the number of characters converted, including the terminating
//              NULL, is returned (note that converting the empty string will
//              return 1).  If the conversion fails, 0 is returned.
//
//  Modifies:   [pstr].
//
//----------------------------------------------------------------------------

int
MbcsFromUnicode(LPSTR pstr, int cch, LPCWSTR pwstr, int cwch)
{
    int ret;

#if DBG == 1 /* { */
    int errcode;
#endif /* } */

    if (!pstr || cch <= 0 || !pwstr || cwch<-1)
        return 0;

    ret = WideCharToMultiByte(CP_ACP, 0, pwstr, cwch, pstr, cch, NULL, NULL);

#if DBG == 1 /* { */
    if (ret <= 0)
    {
        errcode = GetLastError();
    }
#endif /* } */

    return ret;
}


//+---------------------------------------------------------------------------
//
//  Function:   UnicodeFromMbcs
//
//  Synopsis:   Converts a string to Unicode from MBCS.
//
//  Arguments:  [pwstr] -- The buffer for the Unicode string.
//              [cwch]  -- The size of the Unicode buffer, including space for
//                              NULL terminator.
//
//              [pstr]  -- The MBCS string to convert.
//              [cch]  -- The number of characters in the MBCS string to
//                              convert, including NULL terminator.  If this
//                              number is -1, the string is assumed to be
//                              NULL terminated.  -1 is supplied as a
//                              default argument.
//
//  Returns:    If [pwstr] is NULL or [cwch] is 0, 0 is returned.  Otherwise,
//              the number of characters converted, including the terminating
//              NULL, is returned (note that converting the empty string will
//              return 1).  If the conversion fails, 0 is returned.
//
//  Modifies:   [pwstr].
//
//----------------------------------------------------------------------------

int
UnicodeFromMbcs(LPWSTR pwstr, int cwch, LPCSTR pstr, int cch)
{
    int ret;

#if DBG == 1 /* { */
    int errcode;
#endif /* } */

    if (!pstr || cwch <= 0 || !pwstr || cch<-1)
        return 0;

    ret = MultiByteToWideChar(CP_ACP, 0, pstr, cch, pwstr, cwch);

#if DBG == 1 /* { */
    if (ret <= 0)
    {
        errcode = GetLastError();
    }
#endif /* } */

    return ret;
}


//+--------------------------------------------------------------------
//
//  Function:    _tcsistr
//
//---------------------------------------------------------------------

const TCHAR * __cdecl _tcsistr (const TCHAR * tcs1,const TCHAR * tcs2)
{
    const TCHAR *cp;
    int cc,count;
    int n2Len = _tcslen ( tcs2 );
    int n1Len = _tcslen ( tcs1 );

    if ( n1Len >= n2Len )
    {
        for ( cp = tcs1, count = n1Len - n2Len; count>=0 ; cp++,count-- )
        {
            cc = CompareString(LCID_SCRIPTING,
                NORM_IGNORECASE | NORM_IGNOREWIDTH | NORM_IGNOREKANATYPE,
                cp, n2Len,tcs2, n2Len);
            if ( cc > 0 )
                cc-=2;
            if ( !cc )
                return cp;
        }
    }
    return NULL;
}

//+--------------------------------------------------------------------
//
//  Function:    AccessAllowed
//
//---------------------------------------------------------------------
BOOL
AccessAllowed(BSTR bstrUrl, IUnknown * pUnkSite)
{
    BOOL                fAccessAllowed = FALSE;
    HRESULT             hr;
    CComPtr<IBindHost>	pBindHost;
    CComPtr<IMoniker>	pMoniker;
    LPTSTR              pchUrl = NULL;
    BYTE                abSID1[MAX_SIZE_SECURITY_ID];
    BYTE                abSID2[MAX_SIZE_SECURITY_ID];
    DWORD               cbSID1 = ARRAY_SIZE(abSID1);
    DWORD               cbSID2 = ARRAY_SIZE(abSID2);
    CComPtr<IInternetSecurityManager>                   pSecurityManager;
    CComPtr<IInternetHostSecurityManager>               pHostSecurityManager;
    CComQIPtr<IServiceProvider, &IID_IServiceProvider>  pServiceProvider(pUnkSite);

    if (!pServiceProvider)
        goto Cleanup;

    //
    // expand url
    //

    hr = pServiceProvider->QueryService(SID_IBindHost, IID_IBindHost, (void**)&pBindHost);
    if (hr)
        goto Cleanup;

    hr = pBindHost->CreateMoniker(bstrUrl, NULL, &pMoniker, NULL);
    if (hr)
        goto Cleanup;

    hr = pMoniker->GetDisplayName(NULL, NULL, &pchUrl);
    if (hr)
        goto Cleanup;

    //
    // get security id of the url
    //

    hr = CoInternetCreateSecurityManager(NULL, &pSecurityManager, 0);
    if (hr)
        goto Cleanup;

    hr = pSecurityManager->GetSecurityId(pchUrl, abSID1, &cbSID1, NULL);
    if (hr)
        goto Cleanup;

    //
    // get security id of the document
    //

    hr = pServiceProvider->QueryService(
        IID_IInternetHostSecurityManager, IID_IInternetHostSecurityManager, (void**)&pHostSecurityManager);
    if (hr)
        goto Cleanup;

    hr = pHostSecurityManager->GetSecurityId(abSID2, &cbSID2, NULL);

    //
    // the security check itself
    //

    fAccessAllowed = (cbSID1 == cbSID2 && (0 == memcmp(abSID1, abSID2, cbSID1)));

Cleanup:
    if (pchUrl)
        CoTaskMemFree(pchUrl);

    return fAccessAllowed;
}
//+------------------------------------------------------------------------
//
//  CDataObject : Member function implmentations
//
//-------------------------------------------------------------------------
HRESULT 
CDataObject::Set (BSTR bstrValue)
{
    VariantClear(&_varValue);
    _fDirty = TRUE;

    V_VT(&_varValue)   = VT_BSTR;
    if (!bstrValue)
    {
        V_BSTR(&_varValue) = NULL;
        return S_OK;
    }
    else
    {
        V_BSTR(&_varValue) = SysAllocStringLen(bstrValue, SysStringLen(bstrValue));

        return (V_BSTR(&_varValue)) ? S_OK : E_OUTOFMEMORY;
    }
}

HRESULT 
CDataObject::Set (VARIANT_BOOL vBool)
{
    VariantClear(&_varValue);
    _fDirty = TRUE;

    V_VT(&_varValue)   = VT_BOOL;
    V_BOOL(&_varValue) = vBool;

    return S_OK;
}

HRESULT
CDataObject::Set(IDispatch * pDisp)
{
    VariantClear(&_varValue);
    _fDirty = TRUE;

    V_VT(&_varValue)   = VT_DISPATCH;
    V_DISPATCH(&_varValue) = pDisp;

    if (pDisp)
        pDisp->AddRef();

    return S_OK;
}

HRESULT 
CDataObject::GetAsBSTR (BSTR * pbstr)
{
    HRESULT hr = S_OK;

    if (!pbstr) 
    {
        hr = E_POINTER;
        goto Cleanup;
    }

    *pbstr = NULL;

    if (V_VT(&_varValue) == VT_BSTR)
    {
        *pbstr = SysAllocStringLen(V_BSTR(&_varValue), 
                                   SysStringLen(V_BSTR(&_varValue)));

        if (!*pbstr)
            hr = E_OUTOFMEMORY;
    }

Cleanup:
    return hr;
};


HRESULT 
CDataObject::GetAsBOOL (VARIANT_BOOL * pVB)
{
    HRESULT hr = S_OK;

    if (!pVB) 
    {
        hr = E_POINTER;
        goto Cleanup;
    }

    if (V_VT(&_varValue) != VT_BOOL)
    {
        *pVB = VB_FALSE;
        hr = S_FALSE;
    }
    else
    {
        *pVB =  V_BOOL(&_varValue);
    }

Cleanup:
    return hr;
};

HRESULT
CDataObject::GetAsDispatch(IDispatch ** ppDisp)
{
    HRESULT hr = S_OK;

    if (!ppDisp)
    {
        hr = E_POINTER;
        goto Cleanup;
    }

    *ppDisp = NULL;

    if (V_VT(&_varValue)!= VT_DISPATCH)
    {
        hr = S_FALSE;
    }
    else
    {
        *ppDisp = V_DISPATCH(&_varValue);
        if (*ppDisp)
            (*ppDisp)->AddRef();
    }

Cleanup:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
//
// Helper Class:    CContextAccess
//                  access to behavior site, element and style
//
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////

CContextAccess::CContextAccess(IElementBehaviorSite * pSite)
{
    memset (this, 0, sizeof(*this));

    _pSite = pSite;
    _pSite->AddRef();
}

CContextAccess::CContextAccess(IHTMLElement * pElement)
{
    memset (this, 0, sizeof(*this));

    _dwAccess = CA_ELEM;

    _pElem = pElement;
    _pElem->AddRef();
}

/////////////////////////////////////////////////////////////////////////////

CContextAccess::~CContextAccess()
{
    DWORD   dw;

    ReleaseInterface (_pSite);

    // the point of this loop is to avoid doing as many ReleaseInterface-s as we have possible values in CONTEXT_ACCESS enum.
    // instead, we do as many ReleaseInterface-s as number of bits actually set in dwAccess.

    while (_dwAccess)
    {
        dw = (_dwAccess - 1) & _dwAccess;
        switch (_dwAccess - dw)
        {
        case CA_SITEOM:     _pSiteOM->Release();            break;
        case CA_SITERENDER: _pSiteRender->Release();        break;
        case CA_ELEM:       _pElem->Release();              break;
        case CA_ELEM2:      _pElem2->Release();             break;
        case CA_ELEM3:      _pElem3->Release();             break;
        case CA_STYLE:      _pStyle->Release();             break;
        case CA_STYLE2:     _pStyle2->Release();            break;
        case CA_STYLE3:     _pStyle3->Release();            break;
        case CA_DEFAULTS:   _pDefaults->Release();          break;
        case CA_DEFSTYLE:   _pDefStyle->Release();          break;
        case CA_DEFSTYLE2:  _pDefStyle2->Release();         break;
        case CA_DEFSTYLE3:  _pDefStyle3->Release();         break;
        default:            Assert (FALSE && "invalid _dwAccess");  break;
        }
        _dwAccess = dw;
    }
}

/////////////////////////////////////////////////////////////////////////////

HRESULT
CContextAccess::Open(DWORD dwAccess)
{
    HRESULT     hr = S_OK;
    DWORD       dw, dw2, dw3;

    // NOTE order of these ifs is important

    // STYLE2 or STYLE3 require us to get STYLE
    if (dwAccess & (CA_STYLE2 | CA_STYLE3))
        dwAccess |= CA_STYLE;

    // ELEM2, ELEM3, or CA_STYLE require us to get ELEM
    if (dwAccess & (CA_ELEM2 | CA_ELEM3 | CA_STYLE))
        dwAccess |= CA_ELEM;

    // DEFSTYLE2 or DEFSTYLE3 require us to get STYLE
    if (dwAccess & (CA_DEFSTYLE2 | CA_DEFSTYLE3))
        dwAccess |= CA_DEFSTYLE;

    // any DEFSTYLE require us to get PELEM
    if (dwAccess & (CA_DEFSTYLE))
        dwAccess |= CA_DEFAULTS;

    // PELEM requires us to get SITEOM
    if (dwAccess & (CA_DEFAULTS))
        dwAccess |= CA_SITEOM;

    // the point of this loop is to avoid doing as many ifs as we have possible values in CONTEXT_ACCESS enum.
    // instead, we do as many ifs as number of bits actually set in dwAccess.

    dw = dwAccess;

    while (dw)
    {
        dw2 = (dw - 1) & dw;
        dw3 = dw - dw2;
        if (0 == (dw3 & _dwAccess))
        {
            switch (dw3)
            {
            case CA_SITEOM:
                Assert (_pSite && !_pSiteOM);
                hr = _pSite->QueryInterface(IID_IElementBehaviorSiteOM2, (void**)&_pSiteOM);
                if (hr)
                    goto Cleanup;
                break;

            case CA_SITERENDER:
                Assert (_pSite && !_pSiteRender);
                hr = _pSite->QueryInterface(IID_IElementBehaviorSiteRender, (void**)&_pSiteRender);
                if (hr)
                    goto Cleanup;
                break;

            case CA_ELEM:
                Assert (_pSite && !_pElem);
                hr = _pSite->GetElement(&_pElem);
                if (hr)
                    goto Cleanup;
                break;

            case CA_ELEM2:
                Assert (_pElem && !_pElem2);
                hr = _pElem->QueryInterface(IID_IHTMLElement2, (void**)&_pElem2);
                if (hr)
                    goto Cleanup;
                break;

            case CA_ELEM3:
                Assert (_pElem && !_pElem3);
                hr = _pElem->QueryInterface(IID_IHTMLElement3, (void**)&_pElem3);
                if (hr)
                    goto Cleanup;
                break;

            case CA_STYLE:
                Assert (_pElem && !_pStyle);
                hr = _pElem->get_style(&_pStyle);
                if (hr)
                    goto Cleanup;
                break;

            case CA_STYLE2:
                Assert (_pStyle && !_pStyle2);
                hr = _pStyle->QueryInterface(IID_IHTMLStyle2, (void**)&_pStyle2);
                if (hr)
                    goto Cleanup;
                break;

            case CA_STYLE3:
                Assert (_pStyle && !_pStyle3);
                hr = _pStyle->QueryInterface(IID_IHTMLStyle3, (void**)&_pStyle3);
                if (hr)
                    goto Cleanup;
                break;

            case CA_DEFAULTS:
                Assert (_pSiteOM && !_pDefaults);
                hr = _pSiteOM->GetDefaults(&_pDefaults);
                if (hr)
                    goto Cleanup;
                break;

            case CA_DEFSTYLE:
                Assert (_pDefaults && !_pDefStyle);
                hr = _pDefaults->get_style(&_pDefStyle);
                if (hr)
                    goto Cleanup;
                break;

            case CA_DEFSTYLE2:
                Assert (_pDefStyle && !_pDefStyle2);
                hr = _pDefStyle->QueryInterface(IID_IHTMLStyle2, (void**)&_pDefStyle2);
                if (hr)
                    goto Cleanup;
                break;

            case CA_DEFSTYLE3:
                Assert (_pDefStyle && !_pDefStyle3);
                hr = _pDefStyle->QueryInterface(IID_IHTMLStyle3, (void**)&_pDefStyle3);
                if (hr)
                    goto Cleanup;
                break;

            default:
                Assert (FALSE && "invalid dwAccess");
                break;
            }
        }

        dw = dw2;
    }

    _dwAccess |= dwAccess;

Cleanup:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////

#if DBG == 1

HRESULT
CContextAccess::DbgTest(IElementBehaviorSite * pSite)
{
    HRESULT     hr;

    // CA_NONE
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_NONE);
        if (hr)
            goto Cleanup;
    }

    // CA_ELEM
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_ELEM);
        if (hr)
            goto Cleanup;

        a.Elem()->AddRef();
        a.Elem()->Release();
    }

    // CA_ELEM2
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_ELEM2);
        if (hr)
            goto Cleanup;

        a.Elem2()->AddRef();
        a.Elem2()->Release();
    }

    // CA_ELEM3
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_ELEM3);
        if (hr)
            goto Cleanup;

        a.Elem3()->AddRef();
        a.Elem3()->Release();
    }

    // CA_STYLE
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_STYLE);
        if (hr)
            goto Cleanup;

        a.Style()->AddRef();
        a.Style()->Release();
    }

    // CA_STYLE2
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_STYLE2);
        if (hr)
            goto Cleanup;

        a.Style2()->AddRef();
        a.Style2()->Release();
    }

    // CA_STYLE3
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_STYLE3);
        if (hr)
            goto Cleanup;

        a.Style3()->AddRef();
        a.Style3()->Release();
    }

    // CA_DEFSTYLE
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_DEFSTYLE);
        if (hr)
            goto Cleanup;

        a.DefStyle()->AddRef();
        a.DefStyle()->Release();
    }

    // CA_DEFSTYLE2
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_DEFSTYLE2);
        if (hr)
            goto Cleanup;

        a.DefStyle2()->AddRef();
        a.DefStyle2()->Release();
    }

    // CA_DEFSTYLE3
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_DEFSTYLE3);
        if (hr)
            goto Cleanup;

        a.DefStyle3()->AddRef();
        a.DefStyle3()->Release();
    }

    // CA_SITEOM
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_SITEOM);
        if (hr)
            goto Cleanup;

        a.SiteOM()->AddRef();
        a.SiteOM()->Release();
    }

    // sequencing of Opens
    {
        CContextAccess  a(pSite);

        hr = a.Open(CA_SITEOM);
        if (hr)
            goto Cleanup;

        a.SiteOM()->AddRef();
        a.SiteOM()->Release();

        hr = a.Open(CA_ELEM);
        if (hr)
            goto Cleanup;

        a.Elem()->AddRef();
        a.Elem()->Release();

        hr = a.Open(CA_DEFSTYLE3);
        if (hr)
            goto Cleanup;

        a.DefStyle3()->AddRef();
        a.DefStyle3()->Release();
    }

Cleanup:
    return hr;
}

#endif

/////////////////////////////////////////////////////////////////////////////
//
// Helper Class:    CEventObjectAccess
//                  access to event object
//
/////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////

CEventObjectAccess::CEventObjectAccess(DISPPARAMS * pDispParams)
{
    memset (this, 0, sizeof(*this));
    _pDispParams = pDispParams;
}

///////////////////////////////////////////////////////////////////////////////

CEventObjectAccess::~CEventObjectAccess()
{
    ReleaseInterface (_pEventObj);
    ReleaseInterface (_pEventObj2);
}

///////////////////////////////////////////////////////////////////////////////

HRESULT
CEventObjectAccess::Open(DWORD dwAccess)
{
    HRESULT     hr = S_OK;
    VARIANT *   pvarArg;

    Assert (_pDispParams);

    if (!_pDispParams ||
        !_pDispParams->rgvarg ||
         _pDispParams->cArgs != 1)
    {
        hr = E_INVALIDARG;
        goto Cleanup;
    }

    pvarArg = &_pDispParams->rgvarg[0];

    if (!V_UNKNOWN(pvarArg) ||
        (VT_DISPATCH != V_VT(pvarArg) &&
         VT_UNKNOWN  != V_VT(pvarArg)))
    {
        hr = E_INVALIDARG;
        goto Cleanup;
    }

    if (0 != (dwAccess & EOA_EVENTOBJ) &&
        !_pEventObj)
    {
        hr = V_UNKNOWN(pvarArg)->QueryInterface(IID_IHTMLEventObj, (void **)&_pEventObj);
        if (hr)
            goto Cleanup;
    }

    if (dwAccess & EOA_EVENTOBJ2 &&
        !_pEventObj2)
    {
        hr =  V_UNKNOWN(pvarArg)->QueryInterface(IID_IHTMLEventObj2, (void **)&_pEventObj2);
        if (hr)
            goto Cleanup;
    }

Cleanup:
    return hr;
}

HRESULT
CEventObjectAccess::GetScreenCoordinates(POINT * ppt)
{
    HRESULT hr = S_OK;

    if (!_fEventPropertiesInitialized)
    {
        hr = InitializeEventProperties();
        if (hr)
            goto Cleanup;
    }

    *ppt = _EventProperties.ptScreen;

Cleanup:
    return hr;
}

HRESULT
CEventObjectAccess::GetWindowCoordinates(POINT * ppt)
{
    HRESULT hr = S_OK;

    if (!_fEventPropertiesInitialized)
    {
        hr = InitializeEventProperties();
        if (hr)
            goto Cleanup;
    }

    *ppt = _EventProperties.ptClient;

Cleanup:
    return hr;
}

HRESULT
CEventObjectAccess::GetParentCoordinates(POINT * ppt)
{
    HRESULT hr = S_OK;

    if (!_fEventPropertiesInitialized)
    {
        hr = InitializeEventProperties();
        if (hr)
            goto Cleanup;
    }

    *ppt = _EventProperties.ptElem;

Cleanup:
    return hr;
}

HRESULT
CEventObjectAccess::GetKeyCode(long * pl)
{
    HRESULT hr = S_OK;

    if (!_fEventPropertiesInitialized)
    {
        hr = InitializeEventProperties();
        if (hr)
            goto Cleanup;
    }

    *pl = _EventProperties.lKey;

Cleanup:
    return hr;
}

HRESULT
CEventObjectAccess::GetMouseButtons(long * pl)
{
    HRESULT hr      = S_OK;

    if (!_fEventPropertiesInitialized)
    {
        hr = InitializeEventProperties();
        if (hr)
            goto Cleanup;
    }

    *pl = _EventProperties.lMouseButtons;

Cleanup:
    return hr;
}

HRESULT
CEventObjectAccess::GetKeyboardStatus(long * pl)
{
    HRESULT hr = S_OK;

    if (!_fEventPropertiesInitialized)
    {
        hr = InitializeEventProperties();
        if (hr)
            goto Cleanup;
    }

    *pl = _EventProperties.lKeys;

Cleanup:
    return hr;
}

HRESULT
CEventObjectAccess::InitializeEventProperties()
{
    HRESULT hr = S_OK;

    VARIANT_BOOL b;

    BOOL fAltKey = FALSE;
    BOOL fCtrlKey = FALSE;
    BOOL fShiftKey = FALSE;

    BOOL    fLeft   = FALSE;
    BOOL    fRight  = FALSE;
    BOOL    fMiddle = FALSE;
    long    lMouseButtons;

    if (!_pEventObj)
    {
        hr = Open(EOA_EVENTOBJ);
        if (hr)
            goto Cleanup;
    }

    // KeyboardStatus

    hr = _pEventObj->get_altKey(&b);
    if (hr)
        goto Cleanup;
    fAltKey = (b == VARIANT_TRUE);

    hr = _pEventObj->get_ctrlKey(&b);
    if (hr)
        goto Cleanup;
    fCtrlKey = (b == VARIANT_TRUE);

    hr = _pEventObj->get_shiftKey(&b);
    if (hr)
        goto Cleanup;
    fShiftKey = (b == VARIANT_TRUE);

    _EventProperties.lKeys = (fAltKey ? EVENT_ALTKEY : 0) | (fCtrlKey ? EVENT_CTRLKEY : 0) | (fShiftKey ? EVENT_SHIFTKEY : 0);

    // MouseButtons

    hr = _pEventObj->get_button(&lMouseButtons);
    if (hr)
        goto Cleanup;

    fLeft = (lMouseButtons == 1) || (lMouseButtons == 3) || (lMouseButtons == 5) || (lMouseButtons == 7);
    fRight = (lMouseButtons == 2) || (lMouseButtons == 3) || (lMouseButtons == 6) || (lMouseButtons == 7);
    fMiddle = (lMouseButtons == 4) || (lMouseButtons == 5) || (lMouseButtons == 6) || (lMouseButtons == 7);

    _EventProperties.lMouseButtons = ( fLeft  ? EVENT_LEFTBUTTON   : 0) 
                                   | (fRight  ? EVENT_RIGHTBUTTON  : 0) 
                                   | (fMiddle ? EVENT_MIDDLEBUTTON : 0);

    // KeyCode
    
    hr = _pEventObj->get_keyCode(&_EventProperties.lKey);
    if (hr)
        goto Cleanup;

    // ParentCoordinates

    hr = _pEventObj->get_x(&_EventProperties.ptElem.x);
    if (hr)
        goto Cleanup;
    hr = _pEventObj->get_y(&_EventProperties.ptElem.y);
    if (hr)
        goto Cleanup;

    // WindowCoordinates

    hr = _pEventObj->get_clientX(&_EventProperties.ptClient.x);
    if (hr)
        goto Cleanup;
    hr = _pEventObj->get_clientY(&_EventProperties.ptClient.y);
    if (hr)
        goto Cleanup;

    // ScreenCoordinates

    hr = _pEventObj->get_screenX(&_EventProperties.ptScreen.x);
    if (hr)
        goto Cleanup;
    hr = _pEventObj->get_screenY(&_EventProperties.ptScreen.y);
    if (hr)
        goto Cleanup;
    
    _fEventPropertiesInitialized = TRUE;

Cleanup:
    return hr;
}

/////////////////////////////////////////////////////////////////////////////
//
// Misc helpers
//
/////////////////////////////////////////////////////////////////////////////

void *
MemAllocClear(size_t cb)
{
    void * pv = malloc(cb);

    if (pv)
    {
        memset (pv, 0, cb);
    }

    return pv;
}

HRESULT
LoadLibrary(char *achLibraryName, HINSTANCE *hInst)
{
    DWORD       dwError;
    Assert(achLibraryName);
    Assert(hInst);
    *hInst = NULL;

    // Try to load the library using the normal mechanism.
    *hInst = ::LoadLibraryA(achLibraryName);

#ifdef WIN16
    if ( (UINT) *hInst < 32 )
        goto Error;
#endif

#if !defined(WIN16) && !defined(WINCE)
    // If that failed because the module was not be found,
    // then try to find the module in the directory we were
    // loaded from.
    if (!*hInst)
    {
        dwError = ::GetLastError();

        if (   dwError == ERROR_MOD_NOT_FOUND
            || dwError == ERROR_DLL_NOT_FOUND)
        {
            char achBuf1[MAX_PATH];
            char achBuf2[MAX_PATH];
            char *pch;

            // Get path name of this module.
            if (::GetModuleFileNameA(NULL, achBuf1, ARRAY_SIZE(achBuf1)) == 0)
                goto Error;

            // Find where the file name starts in the module path.
            if (::GetFullPathNameA(achBuf1, ARRAY_SIZE(achBuf2), achBuf2, &pch) == 0)
                goto Error;

            // Chop off the file name to get a directory name.
            *pch = 0;

            // See if there's a dll with the given name in the directory.
            if (::SearchPathA(
                    achBuf2,
                    achLibraryName,
                    NULL,
                    ARRAY_SIZE(achBuf1),
                    achBuf1,
                    NULL) != 0)
            {
                // Yes, there's a dll. Load it.
                *hInst = ::LoadLibraryExA(
                            achBuf1,
                            NULL,
                            LOAD_WITH_ALTERED_SEARCH_PATH);
            }
        }
    }
#endif // !defined(WIN16) && !defined(WINCE)

    if (!*hInst)
    {
        goto Error;
    }

    return S_OK;

Error:
    dwError = GetLastError();
    return dwError ? HRESULT_FROM_WIN32(dwError) : E_FAIL;
}

//+----------------------------------------------------------------------------
//
//  Member : AccessAllowed
//
//  Synopsis : Internal helper. this function is part of the behavior security
//      model for this tag.  We only allow layout rects to be trusted if they're
//      within a trusted dialog.
//
//-----------------------------------------------------------------------------

BOOL
TemplateAccessAllowed(IElementBehaviorSite *pISite)
{
#ifdef TEMPLATE_TESTING
    return TRUE;
#else
    HRESULT             hr;
    IHTMLElement      * pElem = NULL;
    IDispatch         * pDoc  = NULL;
    IOleCommandTarget * pioct = NULL;
    VARIANT             varRet;
    MSOCMD              msocmd;

    if (!pISite)
        return FALSE;

    VariantInit(&varRet);
    msocmd.cmdID = IDM_ISTRUSTEDDLG;
    msocmd.cmdf  = 0;

    hr = pISite->GetElement(&pElem);
    if (FAILED(hr))
        goto Cleanup;

    hr = pElem->get_document(&pDoc); 
    if (FAILED(hr))
        goto Cleanup;

    hr = pDoc->QueryInterface(IID_IOleCommandTarget, (void**)&pioct);
    if (hr)
        goto Cleanup;

    hr = pioct->Exec(&CGID_MSHTML, IDM_GETPRINTTEMPLATE, NULL, NULL, &varRet);

Cleanup:
    ReleaseInterface(pElem);
    ReleaseInterface(pDoc);
    ReleaseInterface(pioct);

    return  (hr || V_VT(&varRet) != VT_BOOL  || V_BOOL(&varRet) != VB_TRUE) ? FALSE : TRUE;
#endif
}

//------------------------------------------------------------------------------
//---------------------------------- Wrappers ----------------------------------
//------------------------------------------------------------------------------

STDAPI
SHGetFolderPathA(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPSTR pchPath)
{
    HMODULE hDLL = NULL;
    void *  pfnSHGetFolderPath = NULL ;

    if (g_fUseShell32InsteadOfSHFolder)
    {
        hDLL = LoadLibraryA("shell32.dll");
        if (hDLL)
        {
            pfnSHGetFolderPath = GetProcAddress(hDLL, "SHGetFolderPathA");

            if(!pfnSHGetFolderPath)
            {
                FreeLibrary(hDLL);
                hDLL = NULL;
            }
        }
    }

    if (!hDLL)
    {
        hDLL = LoadLibraryA("shfolder.dll");
        if (hDLL)
        {
            pfnSHGetFolderPath = GetProcAddress(hDLL, "SHGetFolderPathA");

            if(!pfnSHGetFolderPath)
            {
                FreeLibrary(hDLL);
                hDLL = NULL;
            }
        }

    }

    if (pfnSHGetFolderPath)
    {
        HRESULT hr = (*(HRESULT (STDAPICALLTYPE *)(HWND, int, HANDLE, DWORD, LPSTR))pfnSHGetFolderPath)
                        (hwnd, csidl, hToken, dwFlags, pchPath);

        FreeLibrary(hDLL);

        return hr;
    }

    return E_FAIL;

}