//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// xmlutil.cpp 
//
//   XML item helper functions.
//
//   History:
//
//       4/1/97  edwardp   Created.
//
////////////////////////////////////////////////////////////////////////////////

//
// Includes
//

#include "stdinc.h"
#include "cdfidl.h"
#include "xmlutil.h"
#include "winineti.h"
#include <ocidl.h>         // IPersistStreamInit.

//
// Function prototypes.
//


//
// XML helper functions.
//

////////////////////////////////////////////////////////////////////////////////
//
// *** XML_MarkCacheEntrySticky ***
//
// Description:
//     Marks the cache entry for the given URL as sticky by setting its
//     expiration delta to be very high
//
// Parameters:
//     [In]  lpszUrl       - url for cache entry to make sticky
//
// Return:
//     S_OK if the url entry was successfully marked sticky
//     E_FAIL otherwise.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT XML_MarkCacheEntrySticky(LPTSTR lpszURL)
{
    char chBuf[MAX_CACHE_ENTRY_INFO_SIZE];
    LPINTERNET_CACHE_ENTRY_INFO lpInfo = (LPINTERNET_CACHE_ENTRY_INFO) chBuf;

    DWORD dwSize = sizeof(chBuf);
    lpInfo->dwStructSize = dwSize;

    if (GetUrlCacheEntryInfo(lpszURL, lpInfo, &dwSize))
    {
        lpInfo->dwExemptDelta = 0xFFFFFFFF; // make VERY sticky
        if (SetUrlCacheEntryInfo(lpszURL, lpInfo, CACHE_ENTRY_EXEMPT_DELTA_FC))
        {
            return S_OK;
        }
    }
    return E_FAIL;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_SynchronousParse ***
//
//
// Description:
//     Synchronously parses the given URL.
//
// Parameters:
//     [In]  pIXMLDocument - An interface pointer to an XML document object.
//     [In]  pidl          - The pidl of the cdf file (contains the full path).
//
// Return:
//     S_OK if the object was parsed successfully.
//     E_FAIL otherwise.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_SynchronousParse(
    IXMLDocument* pIXMLDocument,
    LPTSTR szPath
)
{
    ASSERT(pIXMLDocument);
    ASSERT(szPath);

    HRESULT hr;

    IPersistStreamInit* pIPersistStreamInit;

    hr = pIXMLDocument->QueryInterface(IID_IPersistStreamInit,
                                       (void**)&pIPersistStreamInit);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIPersistStreamInit);

        IStream* pIStream;

        //
        // URLOpenBlockingStream pumps window messages!  Don't use it!
        //

        //hr = URLOpenBlockingStream(NULL, szPath, &pIStream, 0, NULL);

        hr = SHCreateStreamOnFile(szPath, STGM_READ, &pIStream);

        TraceMsg(TF_CDFPARSE, "[%s SHCreateStreamOnFileW %s %s %s]",
                 PathIsURL(szPath) ? TEXT("*** ") : TEXT(""), szPath,
                 SUCCEEDED(hr) ? TEXT("SUCCEEDED") : TEXT("FAILED"),
                 PathIsURL(szPath) ? TEXT("***") : TEXT(""));

        if (SUCCEEDED(hr))
        {
            ASSERT(pIStream);

            //
            // Load loads and parses the file.  If this call succeeds the cdf
            // will be displayed.  If it fails none of the cdf is displayed.
            //

            hr = pIPersistStreamInit->Load(pIStream);

            TraceMsg(TF_CDFPARSE, "[XML Parser %s]", 
                     SUCCEEDED(hr) ? TEXT("SUCCEEDED") : TEXT("FAILED"));

            pIStream->Release();

            //
            // If CDFVIEW is downloading a CDF from the net mark it as sticky
            // in the cache
            //
            if (PathIsURL(szPath))
            {
                XML_MarkCacheEntrySticky(szPath);
            }
        }

        pIPersistStreamInit->Release();
    }

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_DownloadImages ***
//
//
// Description:
//
//
// Parameters:
//
//
// Return:
//
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_DownloadLogo(
    IXMLDocument *pIXMLDocument
)
{
    ASSERT(pIXMLDocument);

    HRESULT hr;

    IXMLElement* pIXMLElement;
    LONG         nIndex;

    hr = XML_GetFirstChannelElement(pIXMLDocument, &pIXMLElement, &nIndex);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIXMLElement);
        
        BSTR bstrURL = XML_GetAttribute(pIXMLElement, XML_LOGO);

        if (bstrURL)
        {
            hr = XML_DownloadImage(bstrURL);

            SysFreeString(bstrURL);
        }

        //
        // Download the wide logo also.
        //

        bstrURL = XML_GetAttribute(pIXMLElement, XML_LOGO_WIDE);

        if (bstrURL)
        {
            hr = XML_DownloadImage(bstrURL);

            SysFreeString(bstrURL);
        }


        pIXMLElement->Release();
    }

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_DownloadImages ***
//
//
// Description:
//
//
// Parameters:
//
//
// Return:
//
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_DownloadImages(
    IXMLDocument *pIXMLDocument
)
{
    ASSERT(pIXMLDocument);

    HRESULT hr;

    IXMLElement* pIXMLElement;
    LONG         nIndex;

    hr = XML_GetFirstChannelElement(pIXMLDocument, &pIXMLElement, &nIndex);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIXMLElement);
        
        hr = XML_RecursiveImageDownload(pIXMLElement);

        pIXMLElement->Release();
    }

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_RecuriveImageDownload ***
//
//
// Description:
//
//
// Parameters:
//
//
// Return:
//
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_RecursiveImageDownload(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    HRESULT hr = S_OK;

    BSTR bstrTagName;

    HRESULT hr2 = pIXMLElement->get_tagName(&bstrTagName);

    if (SUCCEEDED(hr2) && bstrTagName)
    {
        if (StrEqlW(bstrTagName, WSTR_LOGO))
        {
            BSTR bstrURL = XML_GetAttribute(pIXMLElement, XML_HREF);

            if (bstrURL && *bstrURL != 0)
            {
                hr = XML_DownloadImage(bstrURL);

                SysFreeString(bstrURL);
            }
        }
        else if (XML_IsCdfDisplayable(pIXMLElement))
        {
            IXMLElementCollection* pIXMLElementCollection;

            hr2 = pIXMLElement->get_children(&pIXMLElementCollection);

            if (SUCCEEDED(hr2) && pIXMLElementCollection)
            {
                ASSERT(pIXMLElementCollection);

                LONG nCount;

                hr2 = pIXMLElementCollection->get_length(&nCount);

                ASSERT(SUCCEEDED(hr2) || (FAILED(hr2) && 0 == nCount));

                for (int i = 0; i < nCount; i++)
                {
                    IXMLElement* pIXMLElementChild;

                    hr2 = XML_GetElementByIndex(pIXMLElementCollection, i,
                                                &pIXMLElementChild);

                    if (SUCCEEDED(hr2))
                    {
                        ASSERT (pIXMLElementChild);

                        XML_RecursiveImageDownload(pIXMLElementChild);

                        pIXMLElementChild->Release();
                    }
                }

                pIXMLElementCollection->Release();
            }
        }

        SysFreeString(bstrTagName);
    }

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_DownloadImage ***
//
//
// Description:
//
//
// Parameters:
//
//
// Return:
//
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_DownloadImage(
    LPCWSTR pwszURL
)
{
    ASSERT (pwszURL);

    HRESULT hr;

    WCHAR szFileW[MAX_PATH];

    hr = URLDownloadToCacheFileW(NULL, pwszURL, szFileW,
                                 ARRAYSIZE(szFileW), 0, NULL);

    //
    // Mark the logo in the cache as sticky
    //

    if (SUCCEEDED(hr))
    {
        TCHAR szURL[INTERNET_MAX_URL_LENGTH];
        SHUnicodeToTChar(pwszURL, szURL, ARRAYSIZE(szURL));

        XML_MarkCacheEntrySticky(szURL);
    }

    #ifdef DEBUG

        TCHAR szURL[INTERNET_MAX_URL_LENGTH];
        SHUnicodeToTChar(pwszURL, szURL, ARRAYSIZE(szURL));

        TraceMsg(TF_CDFPARSE,
                 "[*** Image URLDownloadToCacheFileW %s %s ***]",
                  szURL, SUCCEEDED(hr) ? TEXT("SUCCEEDED") :
                                         TEXT("FAILED"));

    #endif // DEBUG

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetDocType ***
//
//
// Description:
//     Returns the type of the given xml document.
//
// Parameters:
//     [In]  pIXMLDocument - A pointer to the xml document.
//
// Return:
//     DOC_CHANNEL, DOC_DESKTOPCOMPONENT, DOC_SOFTWAREUPDATE, or DOC_UNKNOWN.
//
// Comments:
//     If at the root level of a channel an ITEM contains a USAGE type of
//     DesktopComponent then the document is a Desktop Component otherwise
//     it is a channel.
//
////////////////////////////////////////////////////////////////////////////////
XMLDOCTYPE
XML_GetDocType(IXMLDocument* pIXMLDocument)
{
    ASSERT(pIXMLDocument);

    XMLDOCTYPE xdtRet;

    IXMLElement* pIXMLElement;
    LONG         nIndex;

    HRESULT hr = XML_GetFirstDesktopComponentElement(pIXMLDocument,
                                                     &pIXMLElement,
                                                     &nIndex);
    
    if (SUCCEEDED(hr))
    {
        ASSERT(pIXMLElement);

        xdtRet = DOC_DESKTOPCOMPONENT;

        pIXMLElement->Release();
    }
    else
    {
        hr = XML_GetFirstChannelElement(pIXMLDocument, &pIXMLElement,
                                        &nIndex);

        if (SUCCEEDED(hr))
        {
            ASSERT(pIXMLElement);

            BSTR bstr = XML_GetAttribute( pIXMLElement, XML_USAGE_SOFTWAREUPDATE );

            if (bstr)
            {
                SysFreeString(bstr);
                xdtRet = DOC_SOFTWAREUPDATE;
            }
            else
            {
                xdtRet = DOC_CHANNEL;
            }


            pIXMLElement->Release();
        }
        else
        {
            xdtRet = DOC_UNKNOWN;
        }
    }

    return xdtRet;
}



//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetChildElementCollection ***
//
//
// Description:
//     Returns an element collection given the parent collection and an index.
//
// Parameters:
//     [In]  pParentIXMLElementCollection - The parent collection.
//     [In]  nIndex                       - Index to the requested collection.
//     [Out] ppIXMLElementCollection      - A pointer that receives the
//                                          requested collection.
//
// Return:
//     S_OK if the collection is returned.
//     E_FAIL otherwise.
//
// Comments:
//     The caller is responsible for calling Release() on the returned interface
//     pointer.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetChildElementCollection(
    IXMLElementCollection *pParentIXMLElementCollection,
    LONG nIndex,
    IXMLElementCollection** ppIXMLElementCollection
)
{
    ASSERT(pParentIXMLElementCollection);
    ASSERT(ppIXMLElementCollection);

    HRESULT hr;

    IXMLElement* pIXMLElement;

    hr = XML_GetElementByIndex(pParentIXMLElementCollection, nIndex,
                               &pIXMLElement);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIXMLElement);

        hr = pIXMLElement->get_children(ppIXMLElementCollection);
        if(SUCCEEDED(hr) && !(*ppIXMLElementCollection))
            hr = E_FAIL;

        pIXMLElement->Release();
    }

    ASSERT((SUCCEEDED(hr) && (*ppIXMLElementCollection)) || FAILED(hr));

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetElementByIndex ***
//
//
// Description:
//     Returns the nIndex'th element of the given collection.
//
// Parameters:
//     [In]  pIXMLElementCollection - A pointer to the collection.
//     [In]  nIndex                 - The index of the item to retrieve.
//     [Out] ppIXMLElement          - A pointer that receives the item.
//
// Return:
//     S_OK if the item was retrieved.
//     E_FAIL otherwise.
//
// Comments:
//     The caller is responsible for calling Release() on the returned interface
//     pointer.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetElementByIndex(
    IXMLElementCollection* pIXMLElementCollection,
    LONG nIndex,
    IXMLElement** ppIXMLElement
)
{
    ASSERT(pIXMLElementCollection);
    ASSERT(ppIXMLElement);

    HRESULT hr;

    VARIANT var1, var2;

    VariantInit(&var1);
    VariantInit(&var2);

    var1.vt   = VT_I4;
    var1.lVal = nIndex;

    IDispatch* pIDispatch;

    hr = pIXMLElementCollection->item(var1, var2, &pIDispatch);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIDispatch);

        hr = pIDispatch->QueryInterface(IID_IXMLElement, (void**)ppIXMLElement);

        pIDispatch->Release();
    }
    else
    {
        *ppIXMLElement = NULL;
    }

    ASSERT((SUCCEEDED(hr) && *ppIXMLElement) || 
           (FAILED(hr) && NULL == *ppIXMLElement));

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetElementByName ***
//
//
// Description:
//     Returns the first element with the given tag name.
//
// Parameters:
//     [In]  pIXMLElementCollection - A pointer to the collection.
//     [In]  nszNameW               - The tag name of the item to retrieve.
//     [Out] ppIXMLElement          - A pointer that receives the item.
//
// Return:
//     S_OK if the item was retrieved.
//     E_OUTOFMEMORY if a sys string could not be allocated.
//     E_FAIL otherwise.
//
// Comments:
//     The caller is responsible for calling Release() on the returned interface
//     pointer.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetElementByName(
    IXMLElementCollection* pIXMLElementCollection,
    LPWSTR szNameW,
    IXMLElement** ppIXMLElement
)
{
    ASSERT(pIXMLElementCollection);
    ASSERT(ppIXMLElement);

    HRESULT hr = E_FAIL;

    LONG nCount;

    HRESULT hr2 = pIXMLElementCollection->get_length(&nCount);

    ASSERT(SUCCEEDED(hr2) || (FAILED(hr2) && 0 == nCount));

    for (int i = 0, bElement = FALSE; (i < nCount) && !bElement; i++)
    {
        IXMLElement* pIXMLElement;

        hr2 = XML_GetElementByIndex(pIXMLElementCollection, i, &pIXMLElement);

        if (SUCCEEDED(hr2))
        {
            ASSERT(pIXMLElement);

            BSTR pStr;

            hr2 = pIXMLElement->get_tagName(&pStr);

            if (SUCCEEDED(hr2) && pStr)
            {
                ASSERT(pStr);

                if (bElement = StrEqlW(pStr, szNameW))
                {
                    pIXMLElement->AddRef();
                    *ppIXMLElement = pIXMLElement;
                    
                    hr = S_OK;
                }

                SysFreeString(pStr);
            }

            pIXMLElement->Release();
        }
    }

    hr = FAILED(hr2) ? hr2 : hr;

    /* Enable this when pIXMLElementCollection->item works with VT_BSTR

    VARIANT var1, var2;

    VariantInit(&var1);
    VariantInit(&var2);

    var1.vt      = VT_BSTR;
    var1.bstrVal = SysAllocString(szNameW);

    var2.vt      = VT_I4
    var2.lVal    = 1;

    if (var1.bstrVal)
    {

        IDispatch* pIDispatch;

        hr = pIXMLElementCollection->item(var1, var2, &pIDispatch);

        if (SUCCEEDED(hr))
        {
            ASSERT(pIDispatch);

            hr = pIDispatch->QueryInterface(IID_IXMLElement,
                                            (void**)ppIXMLElement);

            pIDispatch->Release();
        }

        SysFreeString(var1.bstrVal);
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }

    */

    ASSERT((SUCCEEDED(hr) && ppIXMLElement) || FAILED(hr));

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetFirstChannelElement ***
//
//
// Description:
//     Returns the IXMLElement of the first channel in the XML document.
//
// Parameters:
//     [In]  pIXMLDocument - A pointer to the XML document object.
//     [Out] ppIXMLElement - The pointer that receives the element.
//     [Out] pnIndex       - The index of the element.
//
// Return:
//     S_OK if the first channel element was returned.
//     E_FAIL if the element couldn't be returned.
//
// Comments:
//     This function can't call XML_GetElementByName to find the first channel.
//     XML channels can have a tag name of "Channel" or "CHAN".
//     XML_GetElementByName wouldn't be able to determine which of the items
//     came first if both where present in the XML doc.
//
//     The caller is responsible for calling Release() on the returned interface
//     pointer.  The return pointer is not NULL'ed out on error.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetFirstChannelElement(
    IXMLDocument* pIXMLDocument,
    IXMLElement** ppIXMLElement,
    PLONG pnIndex)
{
    ASSERT(pIXMLDocument);
    ASSERT(ppIXMLElement);
    ASSERT(pnIndex);
    IXMLElement *pRootElem = NULL;
    HRESULT hr = E_FAIL;

    *pnIndex = 0;
    hr = pIXMLDocument->get_root(&pRootElem);

    if (SUCCEEDED(hr) && pRootElem)
    {
        ASSERT(pRootElem);

        if (XML_IsChannel(pRootElem))
        {
            *ppIXMLElement = pRootElem;
            hr = S_OK;
        }
        else
        {
            pRootElem->Release();
            hr = E_FAIL;
        }
            
    }
    else
    {
        hr = E_FAIL;
    }

    ASSERT((SUCCEEDED(hr) && (*ppIXMLElement)) || FAILED(hr));

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetDesktopElementFromChannelElement ***
//
//
// Description:
//     Returns the IXMLElement of the first dekstop component in the channel.
//
// Parameters:
//     [In]  pChannelIXMLElement - A pointer to the XML channel element.
//     [Out] ppIXMLElement       - The pointer that receives the element.
//     [Out] pnIndex             - The index of the element.
//
// Return:
//     S_OK if the first desktop element was returned.
//     E_FAIL if the element couldn't be returned.
//
// Comments:
//     This looks for the first ITEM with a usage of DesktopComponent.
//
////////////////////////////////////////////////////////////////////////////////

HRESULT
XML_GetDesktopElementFromChannelElement(
    IXMLElement* pChannelIXMLElement,
    IXMLElement** ppIXMLElement,
    PLONG pnIndex)
{
    ASSERT(pChannelIXMLElement);
    ASSERT(ppIXMLElement);
    ASSERT(pnIndex);

    HRESULT hr;

    IXMLElementCollection* pIXMLElementCollection;

    hr = pChannelIXMLElement->get_children(&pIXMLElementCollection);

    if (SUCCEEDED(hr) && pIXMLElementCollection)
    {
        ASSERT(pIXMLElementCollection);

        LONG nCount;

        hr = pIXMLElementCollection->get_length(&nCount);

        ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

        hr = E_FAIL;

        for (int i = 0, bComponent = FALSE; (i < nCount) && !bComponent;
             i++)
        {
            IXMLElement* pIXMLElement;

            HRESULT hr2 = XML_GetElementByIndex(pIXMLElementCollection, i,
                                                &pIXMLElement);

            if (SUCCEEDED(hr2))
            {
                ASSERT(pIXMLElement);

                if (bComponent = XML_IsDesktopComponent(pIXMLElement))
                {
                    pIXMLElement->AddRef();
                    *ppIXMLElement = pIXMLElement;
                    *pnIndex = i;

                    hr = S_OK;
                }

                pIXMLElement->Release();
            }

            hr = FAILED(hr2) ? hr2 : hr;
        }

        pIXMLElementCollection->Release();
    }        
    else
    {
        hr = E_FAIL;
    }

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetFirstDesktopComponentElement ***
//
//
// Description:
//     Returns the IXMLElement of the first dekstop component in the channel.
//
// Parameters:
//     [In]  pIXMLDocument - A pointer to the XML document object.
//     [Out] ppIXMLElement - The pointer that receives the element.
//     [Out] pnIndex       - The index of the element.
//
// Return:
//     S_OK if the first channel element was returned.
//     E_FAIL if the element couldn't be returned.
//
// Comments:
//     This function gets the first channel and then looks for the first
//     top-level ITEM with a usage of DesktopComponent.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetFirstDesktopComponentElement(
    IXMLDocument* pIXMLDocument,
    IXMLElement** ppIXMLElement,
    PLONG pnIndex)
{
    ASSERT(pIXMLDocument);
    ASSERT(ppIXMLElement);
    ASSERT(pnIndex);

    HRESULT hr;

    IXMLElement* pChannelIXMLElement;
    LONG         nIndex;

    hr = XML_GetFirstChannelElement(pIXMLDocument, &pChannelIXMLElement,
                                    &nIndex);

    if (SUCCEEDED(hr))
    {
        ASSERT(pChannelIXMLElement);

        hr = XML_GetDesktopElementFromChannelElement(pChannelIXMLElement, 
                                                     ppIXMLElement, 
                                                     pnIndex);

        pChannelIXMLElement->Release();
    }

    ASSERT((SUCCEEDED(hr) && *ppIXMLElement) || FAILED(hr));

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetFirstDesktopComponentUsageElement ***
//
//
// Description:
//     Returns the first USAGE VALUE="DesktopComponent" element of the first
//     desktop component.
//
// Parameters:
//     [In]  pIXMLDocument - A pointer to the the document.
//     [Out] pIXMLElement  - A pointer the receives the element.
//
// Return:
//     S_OK if the element was found.
//     E_FAIL if the element wasn't found.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetFirstDesktopComponentUsageElement(
    IXMLDocument* pIXMLDocument,
    IXMLElement** ppIXMLElement
)
{
    ASSERT(pIXMLDocument);
    ASSERT(ppIXMLElement);

    HRESULT hr;

    IXMLElement* pParentIXMLElement;
    LONG         nIndex;

    hr = XML_GetFirstDesktopComponentElement(pIXMLDocument, &pParentIXMLElement,
                                             &nIndex);

    if (SUCCEEDED(hr))
    {
        IXMLElementCollection* pIXMLElementCollection;

        hr = pParentIXMLElement->get_children(&pIXMLElementCollection);

        if (SUCCEEDED(hr) && pIXMLElementCollection)
        {
            ASSERT(pIXMLElementCollection);

            LONG nCount;

            hr = pIXMLElementCollection->get_length(&nCount);

            ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

            hr = E_FAIL;

            for (int i = 0, bUsage = FALSE; (i < nCount) && !bUsage; i++)
            {
                IXMLElement* pIXMLElement;

                HRESULT hr2 = XML_GetElementByIndex(pIXMLElementCollection, i,
                                                    &pIXMLElement);

                if (SUCCEEDED(hr2))
                {
                    ASSERT(pIXMLElement);

                    if (bUsage = XML_IsDesktopComponentUsage(pIXMLElement))
                    {
                        pIXMLElement->AddRef();
                        *ppIXMLElement = pIXMLElement;
                        //*pnIndex = i;

                        hr = S_OK;
                    }

                    pIXMLElement->Release();
                }

                hr = FAILED(hr2) ? hr2 : hr;
            }

            pIXMLElementCollection->Release();
        } 
        else
        {
            hr = E_FAIL;
        }

        pParentIXMLElement->Release();
    }

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetDesktopComponentInfo ***
//
//
// Description:
//     Fills in the desktop component information structure.
//
// Parameters:
//     [In]  pIXMLDocument - A ponter to the document.
//     [Out] pInfo         - A desktop component information structure.
//
// Return:
//     S_OK if the given document is desktop component document.
//     E_FAIL otherwise.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetDesktopComponentInfo(
    IXMLDocument* pIXMLDocument,
    COMPONENT* pInfo
)
{
    ASSERT(pIXMLDocument);
    ASSERT(pInfo);

    HRESULT hr;

    IXMLElement* pIXMLElement;

    hr = XML_GetFirstDesktopComponentUsageElement(pIXMLDocument, &pIXMLElement);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIXMLElement);

        memset(pInfo, 0, sizeof(COMPONENT));

        pInfo->dwSize        = sizeof(COMPONENT);
        pInfo->fChecked      = TRUE;
        pInfo->fDirty        = TRUE;
        pInfo->fNoScroll     = FALSE;
        pInfo->cpPos.dwSize  = sizeof(COMPPOS);
        pInfo->cpPos.izIndex = COMPONENT_TOP;
        pInfo->dwCurItemState = IS_NORMAL;

        BSTR bstrValue;

        if (bstrValue = XML_GetAttribute(pIXMLElement, XML_OPENAS))
        {
            if (!(0 == StrCmpIW(bstrValue, WSTR_IMAGE)))
            {
                pInfo->iComponentType = COMP_TYPE_WEBSITE;
            }
            else
            {
                pInfo->iComponentType = COMP_TYPE_PICTURE;
            }

            SysFreeString(bstrValue);
        }

        if (bstrValue = XML_GetAttribute(pIXMLElement, XML_WIDTH))
        {
            pInfo->cpPos.dwWidth = StrToIntW(bstrValue);
            SysFreeString(bstrValue);
        }

        if (bstrValue = XML_GetAttribute(pIXMLElement, XML_HEIGHT))
        {
            pInfo->cpPos.dwHeight = StrToIntW(bstrValue);
            SysFreeString(bstrValue);
        }

        if (bstrValue = XML_GetAttribute(pIXMLElement, XML_ITEMSTATE))
        {
            if(!StrCmpIW(bstrValue, WSTR_NORMAL))
                pInfo->dwCurItemState = IS_NORMAL;
            else
            {
                if(!StrCmpIW(bstrValue, WSTR_FULLSCREEN))
                    pInfo->dwCurItemState = IS_FULLSCREEN;
                else
                    pInfo->dwCurItemState = IS_SPLIT;
            }
            SysFreeString(bstrValue);
        }
        
        if (bstrValue = XML_GetAttribute(pIXMLElement, XML_CANRESIZE))
        {
            pInfo->cpPos.fCanResize = StrEqlW(bstrValue, WSTR_YES);
            SysFreeString(bstrValue);
        }
        else
        {
            if (bstrValue = XML_GetAttribute(pIXMLElement, XML_CANRESIZEX))
            {
                pInfo->cpPos.fCanResizeX = StrEqlW(bstrValue, WSTR_YES);
                SysFreeString(bstrValue);
            }

            if (bstrValue = XML_GetAttribute(pIXMLElement, XML_CANRESIZEY))
            {
                pInfo->cpPos.fCanResizeY = StrEqlW(bstrValue, WSTR_YES);
                SysFreeString(bstrValue);
            }
        }

        if (bstrValue = XML_GetAttribute(pIXMLElement, XML_PREFERREDLEFT))
        {
            if (StrChrW(bstrValue, L'%'))
            {
                pInfo->cpPos.iPreferredLeftPercent = StrToIntW(bstrValue);
            }
            else
            {
                pInfo->cpPos.iLeft = StrToIntW(bstrValue);
            }

            SysFreeString(bstrValue);
        }

        if (bstrValue = XML_GetAttribute(pIXMLElement, XML_PREFERREDTOP))
        {
            if (StrChrW(bstrValue, L'%'))
            {
                pInfo->cpPos.iPreferredTopPercent = StrToIntW(bstrValue);
            }
            else
            {
                pInfo->cpPos.iTop = StrToIntW(bstrValue);
            }

            SysFreeString(bstrValue);        
        }

        IXMLElement *pIXMLElementParent;

        hr = pIXMLElement->get_parent(&pIXMLElementParent);
        if(!pIXMLElementParent)
            hr = E_FAIL;
        if (SUCCEEDED(hr))
        {
            ASSERT(pIXMLElementParent);

            if (bstrValue = XML_GetAttribute(pIXMLElementParent, XML_TITLE))
            {
                StrCpyNW(pInfo->wszFriendlyName, bstrValue,
                         ARRAYSIZE(pInfo->wszFriendlyName));
                SysFreeString(bstrValue);
            }

            if (bstrValue = XML_GetAttribute(pIXMLElementParent, XML_HREF))
            {
                if (*bstrValue)
                {
                    StrCpyNW(pInfo->wszSource, bstrValue,
                             ARRAYSIZE(pInfo->wszSource));
                    SysFreeString(bstrValue);
                }
                else
                {
                    hr = E_FAIL;
                }
            }

            if (SUCCEEDED(hr))
            {
                IXMLElement *pIXMLChannel;
                LONG nIndex;

                hr = XML_GetFirstChannelElement(pIXMLDocument, &pIXMLChannel,
                                                &nIndex);
                if (SUCCEEDED(hr))
                {
                    ASSERT(pIXMLChannel);
                    if (bstrValue = XML_GetAttribute(pIXMLChannel, XML_SELF))
                    {
                        StrCpyNW(pInfo->wszSubscribedURL, bstrValue,
                                 ARRAYSIZE(pInfo->wszSubscribedURL));
                        SysFreeString(bstrValue);
                    }

                    pIXMLChannel->Release();
                }
            }

            pIXMLElementParent->Release();
        }

        pIXMLElement->Release();
    }

    return hr;
}


//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetAttribute ***
//
//
// Description:
//     Returns a bstr representing the requested attribute of the given element.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the XML element.
//     [In]  attribute    - The requested attribute.
//
// Return:
//     A bstr with the attribute value.
//     NULL if there wasn't enough memory to allocated the bstr.
//
// Comments:
//     This function keeps a table of attributes and their properties.  It bases
//     attribute look up on this table.
//
////////////////////////////////////////////////////////////////////////////////
BSTR
XML_GetAttribute(
    IXMLElement* pIXMLElement,
    XML_ATTRIBUTE attrIndex
)
{
    //
    // A table is used to read values associated with a given xml element.  The
    // xml element can have attributes (values inside the elements tag) or child
    // elements (elements between tags).
    //
    // Rules:
    //        1) If child is NULL. Read the Attribute from the current item.
    //        2) If child is not NULL, read the Attribute from the child
    //           item.
    //        3) If AttributeType is NULL, use the Attribute value to read the
    //           attribute.
    //        4) If AttributeType is not NULL, verify that the item contains
    //           the AttributeType attribute before using Attribute to read
    //           the value.
    //        5) If the value is not found use Default as the return value.
    //

    static const struct _tagXML_ATTRIBUTE_ARRAY
    {
        LPWSTR                  szChildW;
        LPWSTR                  szAttributeW;
        LPWSTR                  szQualifierW;
        LPWSTR                  szQualifierValueW;
        XML_ATTRIBUTE           attrSecondary;
        LPWSTR                  szDefaultW;
        BOOL                    fUseBaseURL;
        XML_ATTRIBUTE           attribute;  // Only used in ASSERT.
    }
    aAttribTable[] =
    {
/*
Child           Attribute      Qualifier   Qual. Value   Secondary Lookup   Default     Base URL Enum Check
--------------  -------------- ----------- ------------  -----------------  ----------  -------- -----------------*/
{WSTR_TITLE,    NULL,          NULL,       NULL,         XML_TITLE_ATTR,    WSTR_EMPTY, FALSE,   XML_TITLE        },
{NULL,          WSTR_TITLE,    NULL,       NULL,         XML_HREF,          WSTR_EMPTY, FALSE,   XML_TITLE_ATTR   },
{NULL,          WSTR_HREF,     NULL,       NULL,         XML_A_HREF,        WSTR_EMPTY, TRUE,    XML_HREF         },
{WSTR_ABSTRACT, NULL,          NULL,       NULL,         XML_ABSTRACT_ATTR, WSTR_EMPTY, FALSE,   XML_ABSTRACT     },
{NULL,          WSTR_ABSTRACT, NULL,       NULL,         XML_HREF,          WSTR_EMPTY, FALSE,   XML_ABSTRACT_ATTR},
{WSTR_LOGO,     WSTR_HREF,     WSTR_STYLE, WSTR_ICON,    XML_NULL,          NULL,       TRUE,    XML_ICON         },
{WSTR_LOGO,     WSTR_HREF,     WSTR_STYLE, WSTR_IMAGE,   XML_LOGO_DEFAULT,  NULL,       TRUE,    XML_LOGO         },
{WSTR_LOGO,     WSTR_HREF,     NULL,       NULL,         XML_NULL,          NULL,       TRUE,    XML_LOGO_DEFAULT },
{NULL,          WSTR_SELF,     NULL,       NULL,         XML_SELF_OLD,      NULL,       TRUE,    XML_SELF         },
{WSTR_SELF,     WSTR_HREF,     NULL,       NULL,         XML_NULL,          NULL,       TRUE,    XML_SELF_OLD     },
{NULL,          WSTR_BASE,     NULL,       NULL,         XML_NULL,          NULL,       FALSE,   XML_BASE         },
{WSTR_USAGE,    WSTR_VALUE,    NULL,       NULL,         XML_SHOW,          NULL,       FALSE,   XML_USAGE        },
{WSTR_USAGE,    WSTR_VALUE,    WSTR_VALUE, WSTR_CHANNEL, XML_SHOW_CHANNEL,  NULL,       FALSE,   XML_USAGE_CHANNEL},
{WSTR_USAGE,    WSTR_VALUE,    WSTR_VALUE, WSTR_DSKCMP,  XML_SHOW_DSKCMP,   NULL,       FALSE,   XML_USAGE_DSKCMP },
{WSTR_WIDTH,    WSTR_VALUE,    NULL,       NULL,         XML_NULL,          WSTR_ZERO,  FALSE,   XML_WIDTH        },
{WSTR_HEIGHT,   WSTR_VALUE,    NULL,       NULL,         XML_NULL,          WSTR_ZERO,  FALSE,   XML_HEIGHT       },
{WSTR_RESIZE,   WSTR_VALUE,    NULL,       NULL,         XML_NULL,          NULL,       FALSE,   XML_CANRESIZE    },
{WSTR_RESIZEX,  WSTR_VALUE,    NULL,       NULL,         XML_NULL,          WSTR_YES,   FALSE,   XML_CANRESIZEX   },
{WSTR_RESIZEY,  WSTR_VALUE,    NULL,       NULL,         XML_NULL,          WSTR_YES,   FALSE,   XML_CANRESIZEY   },
{WSTR_PREFLEFT, WSTR_VALUE,    NULL,       NULL,         XML_NULL,          NULL,       FALSE,   XML_PREFERREDLEFT},
{WSTR_PREFTOP,  WSTR_VALUE,    NULL,       NULL,         XML_NULL,          NULL,       FALSE,   XML_PREFERREDTOP },
{WSTR_OPENAS,   WSTR_VALUE,    NULL,       NULL,         XML_NULL,          WSTR_HTML,  FALSE,   XML_OPENAS       },
{NULL,          WSTR_SHOW,     NULL,       NULL,         XML_NULL,          NULL,       FALSE,   XML_SHOW         },
{NULL,          WSTR_SHOW,     WSTR_SHOW,  WSTR_CHANNEL, XML_NULL,          NULL,       FALSE,   XML_SHOW_CHANNEL },
{NULL,          WSTR_SHOW,     WSTR_SHOW,  WSTR_DSKCMP,  XML_NULL,          NULL,       FALSE,   XML_SHOW_DSKCMP  },
{WSTR_A,        WSTR_HREF,     NULL,       NULL,         XML_INFOURI,       WSTR_EMPTY, TRUE,    XML_A_HREF       },
{NULL,          WSTR_INFOURI,  NULL,       NULL,         XML_NULL,          WSTR_EMPTY, TRUE,    XML_INFOURI      },
{WSTR_LOGO,     WSTR_HREF,     WSTR_STYLE, WSTR_IMAGEW,  XML_NULL,          NULL,       TRUE,    XML_LOGO_WIDE    },
{WSTR_LOGIN,    NULL,          NULL,       NULL,         XML_NULL,          NULL,       FALSE,   XML_LOGIN        },

{WSTR_USAGE,    WSTR_VALUE,    WSTR_VALUE, WSTR_SOFTWAREUPDATE, XML_SHOW_SOFTWAREUPDATE,  NULL,       FALSE,   XML_USAGE_SOFTWAREUPDATE},
{NULL,          WSTR_SHOW,     WSTR_SHOW,  WSTR_SOFTWAREUPDATE, XML_NULL,                 NULL,       FALSE,   XML_SHOW_SOFTWAREUPDATE },
{WSTR_ITEMSTATE,WSTR_VALUE,    NULL,       NULL,         XML_NULL,          WSTR_NORMAL,FALSE,   XML_ITEMSTATE   },
    };

    ASSERT(pIXMLElement);

    //
    // REVIEW: aAttribTable attribute field only used in debug builds.
    //

    ASSERT(attrIndex == aAttribTable[attrIndex].attribute);

    BSTR bstrRet = NULL;

    if (NULL == aAttribTable[attrIndex].szAttributeW)
    {
        bstrRet = XML_GetGrandChildContent(pIXMLElement,
                                      aAttribTable[attrIndex].szChildW);
    
    }
    else if (NULL != aAttribTable[attrIndex].szChildW)
    {
        bstrRet = XML_GetChildAttribute(pIXMLElement,
                                     aAttribTable[attrIndex].szChildW,
                                     aAttribTable[attrIndex].szAttributeW, 
                                     aAttribTable[attrIndex].szQualifierW,
                                     aAttribTable[attrIndex].szQualifierValueW);
    }
    else
    {
        bstrRet = XML_GetElementAttribute(pIXMLElement,
                                     aAttribTable[attrIndex].szAttributeW,
                                     aAttribTable[attrIndex].szQualifierW,
                                     aAttribTable[attrIndex].szQualifierValueW);
    }

    //
    // If the title or tooltip aren't displayable on the local system use the
    // URL in their place.
    //

    if (bstrRet && (XML_TITLE == attrIndex || XML_TITLE_ATTR == attrIndex ||
                    XML_ABSTRACT == attrIndex))
    {
        if (!StrLocallyDisplayable(bstrRet))
        {
            SysFreeString(bstrRet);
            bstrRet = NULL;
        }
    }
    
    //
    // Special cases:
    //     TITLE can also be an attribute.
    //     ABSTRACT can also be an attribute.
    //     LOGO elements don't have to have the TYPE="IMAGE"
    //     SELF is now an attribute SELF_OLD can be removed in the future.
    //     USAGE can also be specified via the SHOW attribute.
    //     USAGE_CHANNEL should also check for SHOW="Channel".
    //     USAGE_DSKCMP should also check for SHOW="DesktopComponent"
    //

    if (NULL == bstrRet && XML_NULL != aAttribTable[attrIndex].attrSecondary)
    {
        bstrRet = XML_GetAttribute(pIXMLElement,
                                   aAttribTable[attrIndex].attrSecondary);
    }

    //
    // Combine URL if required.
    //

    if (bstrRet && aAttribTable[attrIndex].fUseBaseURL)
    {
        BSTR bstrBaseURL = XML_GetBaseURL(pIXMLElement);

        if (bstrBaseURL)
        {
            
            BSTR bstrCombinedURL = XML_CombineURL(bstrBaseURL, bstrRet);

            if (bstrCombinedURL)
            {
                SysFreeString(bstrRet);
                bstrRet = bstrCombinedURL;
            }

            SysFreeString(bstrBaseURL);
        }
    }

    /* The following prevent long urls from over-running the pidl buffer */

    if (bstrRet &&
        (attrIndex == XML_HREF) &&
        (SysStringLen(bstrRet) > INTERNET_MAX_URL_LENGTH))
    {
       SysReAllocStringLen(&bstrRet, bstrRet, INTERNET_MAX_URL_LENGTH-1);
    }

    //
    // Set default return value.
    //

    if (NULL == bstrRet && aAttribTable[attrIndex].szDefaultW)
        bstrRet = SysAllocString(aAttribTable[attrIndex].szDefaultW);

    
    return bstrRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetFirstChildContent ***
//
// Description:
//     Returns a bstr value from first child of the given element.
//
// Parameters:
//     [In]  pIXMLElement     - A pointer to the element.
//     The caller is responsible for freeing the returned bstr.
//
// Comments:
//     If pIElement represents
//
//         <Title>Harvey is a Cool Cat<B>this will be ignored</B></Title>
//
//         Then this function will return
//
//             "Harvey is a Cool Cat"
//
// REVIEW THIS IS A TEMPORARY ROUTINE UNTIL THE XML PARSER SUPPORTS THIS DIRECTLY
//
////////////////////////////////////////////////////////////////////////////////
BSTR
XML_GetFirstChildContent(
    IXMLElement* pIXMLElement
)
{    
    ASSERT(pIXMLElement);

    BSTR bstrRet = NULL;

    IXMLElementCollection* pIXMLElementCollection;

    if ((SUCCEEDED(pIXMLElement->get_children(&pIXMLElementCollection)))
            && pIXMLElementCollection)
    {
        ASSERT(pIXMLElementCollection);

        LONG nCount;

        HRESULT hr = pIXMLElementCollection->get_length(&nCount);

        ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

        if (nCount >= 1)
        {
            IXMLElement* pChildIXMLElement;

            if (SUCCEEDED(XML_GetElementByIndex(pIXMLElementCollection, 0,
                                                &pChildIXMLElement)))
            {
                ASSERT(pChildIXMLElement);

                if (FAILED(pChildIXMLElement->get_text(&bstrRet)))
                {
                    bstrRet = NULL;
                }

                pChildIXMLElement->Release();
            }
        }

        pIXMLElementCollection->Release();
    }
    
    return bstrRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetGrandChildContent ***
//
// Description:
//     Returns a bstr value from the requested child of the given element.
//
// Parameters:
//     [In]  pIXMLElement     - A pointer to the element.
//     [In]  szChildW         - The name of the child element.
//     The caller is responsible for freeing the returned bstr.
//
// Comments:
//     If pIElement represents
//
//             <Channel>
//                 <Title>Harvey is a Cool Cat</Title>
//             </Channel>
//
//         Then this function will return
//
//             "Harvey is a Cool Cat" for "TITLE",  
//
////////////////////////////////////////////////////////////////////////////////

BSTR
XML_GetGrandChildContent(
    IXMLElement* pIXMLElement,
    LPWSTR szChildW
)
{    
    ASSERT(pIXMLElement);
    ASSERT(szChildW);    

    BSTR bstrRet = NULL;

    IXMLElementCollection* pIXMLElementCollection;

    if ((SUCCEEDED(pIXMLElement->get_children(&pIXMLElementCollection)))
         && pIXMLElementCollection)
    {
        ASSERT(pIXMLElementCollection);

        LONG nCount;

        HRESULT hr = pIXMLElementCollection->get_length(&nCount);

        ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

        for (int i = 0; (i < nCount) && !bstrRet; i++)
        {
            IXMLElement* pChildIXMLElement;

            if (SUCCEEDED(XML_GetElementByIndex(pIXMLElementCollection, i,
                                                &pChildIXMLElement)))
            {
                ASSERT(pChildIXMLElement);

                BSTR bstrTagName;

                if (SUCCEEDED(pChildIXMLElement->get_tagName(&bstrTagName)) && bstrTagName)
                {
                    ASSERT(bstrTagName);

                    if (StrEqlW(bstrTagName, szChildW))
                    {
                        bstrRet = XML_GetFirstChildContent(pChildIXMLElement);

                        //
                        // If the tag exists, but it is empty, return the empty
                        // string.
                        //

                        if (NULL == bstrRet)
                            bstrRet = SysAllocString(L"");
                    }

                    SysFreeString(bstrTagName);
                }


                pChildIXMLElement->Release();
            }
        }

        pIXMLElementCollection->Release();
    }
    
    return bstrRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetChildAttribute ***
//
//
// Description:
//     Returns a bstr value from the requested child of the given element.
//
// Parameters:
//     [In]  pIXMLElement      - A pointer to the element.
//     [In]  szChildW          - The name of the child element.
//     [In]  szAttributeW      - The name of the attribute.
//     [In]  szQualifierW      - The name of the attribute qualifier.
//     [In]  szQualifierValueW - The required value of the qaulifier.
//
// Return:
//     A bstr of the value contained in the child element if it is found.
//     NULL if the child element or its value isn't found.
//
// Comments:
//     This function will return atributes found in the child elements of the
//     given element.  For example:
//
//         If pIElement represents
//
//             <Channel>
//                 <Title VALUE="foo">
//                 <Author VALUE="bar">
//                 <Logo HRREF="url" TYPE="ICON">
//             </Channel>
//
//         Then this function will return
//
//             "foo" for "TITLE",  "VALUE", "", ""
//             "bar" for "AUTHOR", "VALUE", "", ""
//             "url" for "LOGO",   "HREF",  "TYPE", "ICON" 
//
//             NULL  when the names have any other values.
//
//     The caller is responsible for freeing the returned bstr.
//
////////////////////////////////////////////////////////////////////////////////
BSTR
XML_GetChildAttribute(
    IXMLElement* pIXMLElement,
    LPWSTR szChildW,
    LPWSTR szAttributeW,
    LPWSTR szQualifierW,
    LPWSTR szQualifierValueW
)
{
    ASSERT(pIXMLElement);
    ASSERT(szChildW);
    ASSERT(szAttributeW);

    BSTR bstrRet = NULL;

    IXMLElementCollection* pIXMLElementCollection;

    if ((SUCCEEDED(pIXMLElement->get_children(&pIXMLElementCollection)))
        && pIXMLElementCollection)
    {
        ASSERT(pIXMLElementCollection);

        LONG nCount;

        //
        // REVIEW:  hr only used in debug builds.
        //

        HRESULT hr = pIXMLElementCollection->get_length(&nCount);

        ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

        for (int i = 0; (i < nCount) && !bstrRet; i++)
        {
            IXMLElement* pChildIXMLElement;

            if (SUCCEEDED(XML_GetElementByIndex(pIXMLElementCollection, i,
                                                &pChildIXMLElement)))
            {
                ASSERT(pChildIXMLElement);

                BSTR bstrTagName;

                if (SUCCEEDED(pChildIXMLElement->get_tagName(&bstrTagName)) && bstrTagName)
                {
                    ASSERT(bstrTagName);

                    if (StrEqlW(bstrTagName, szChildW))
                    {
                        bstrRet = XML_GetElementAttribute(pChildIXMLElement,
                                                          szAttributeW,
                                                          szQualifierW,
                                                          szQualifierValueW);
                    }

                    SysFreeString(bstrTagName);
                }


                pChildIXMLElement->Release();
            }
        }

        pIXMLElementCollection->Release();
    }
    
    return bstrRet;
}
    
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetElementAttribute ***
//
//
// Description:
//     Returns the bstr value of of the requested attribute if it is found.
//
// Parameters:
//     [In]  pIXMLElement      - The element that contains the attribute.
//     [In]  szAttributeW      - The name of the attribute.
//     [In]  szQualifierW      - The type qualifier for the atribute.
//     [In]  szQualifierValueW - The required value of the qaulifier.
//
// Return:
//     A bstr containig the attributes value if it was found.
//     NULL if the attribute wasn't found.
//
// Comments:
//     The function will return attributes found inside of tags.  For
//     example:
//
//         If pIXMLElement represents
//
//             <Channel HREF="foo" Cloneable="NO">
//             <USAGE VALUE="Channel">
//             <USAGE VALUE="Screen Saver">
//
//         Then this function will return
//
//             "foo"     for "HREF",      "",          ""
//             "NO"      for "Cloneable", "",          ""
//             "CHANNEL" for "VALUE",     "VALUE",     "CHANNEL"
//             NULL      for "VALUE",     "VALUE",     "NONE"
//             "foo"     for "HREF",      "CLONEABLE", "NO"
//
//     The caller is responsible for freeing the returned bstr.
//
////////////////////////////////////////////////////////////////////////////////
BSTR
XML_GetElementAttribute(
    IXMLElement* pIXMLElement,
    LPWSTR szAttributeW,
    LPWSTR szQualifierW,
    LPWSTR szQualifierValueW
)
{
    ASSERT(pIXMLElement);
    ASSERT(szAttributeW);
    ASSERT((NULL == szQualifierW && NULL == szQualifierValueW) ||
           (szQualifierW && szQualifierValueW));

    BSTR bstrRet = NULL;

    VARIANT var;

    VariantInit(&var);

    if (NULL == szQualifierW)
    {
        if (SUCCEEDED(pIXMLElement->getAttribute(szAttributeW, &var)))
        {
            ASSERT(var.vt == VT_BSTR || NULL == var.bstrVal);

            bstrRet = var.bstrVal;
        }
    }
    else
    {
        if (SUCCEEDED(pIXMLElement->getAttribute(szQualifierW, &var)))
        {
            ASSERT(var.vt == VT_BSTR || NULL == var.bstrVal);

            if(var.bstrVal)
            {
                if (0 == StrCmpIW(var.bstrVal, szQualifierValueW))
                {
                    bstrRet = XML_GetElementAttribute(pIXMLElement, szAttributeW,
                                                      NULL, NULL);
                }
            }
            VariantClear(&var);
        }
    }

    return bstrRet;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetScreenSaverURL ***
//
//
// Description:
//     Returns the screen saver URL of the first screen saver component in the channel.
//
// Parameters:
//     [In]  pXMLDocument  - An XML document
//     [Out] pbstrSSURL    - The pointer that receives the screen saver URL.
//
// Return:
//     S_OK if the screen saver URL was returned.
//     E_FAIL if the screen saver URL couldn't be returned.
//
// Comments:
//     This function gets the first screen saver element and then looks
//     for the first top-level ITEM with a usage of ScreenSaver.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetScreenSaverURL(
    IXMLDocument *  pXMLDocument,
    BSTR *          pbstrSSURL)
{
    HRESULT hr;

    ASSERT(pXMLDocument);
    ASSERT(pbstrSSURL);
    
    IXMLElement* pIXMLElement;
    LONG lDontCare;

    hr = XML_GetFirstChannelElement(pXMLDocument, &pIXMLElement, &lDontCare);
    if (SUCCEEDED(hr))
    {
        IXMLElement* pSSElement;

        ASSERT(pIXMLElement);

        hr = XML_GetScreenSaverElement(pIXMLElement, &pSSElement);

        if (SUCCEEDED(hr))
        {
            ASSERT(pSSElement);

            *pbstrSSURL = XML_GetAttribute(pSSElement, XML_HREF);

            hr = *pbstrSSURL ? S_OK : E_FAIL;
            
            pSSElement->Release();
        }
        pIXMLElement->Release();
    }

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetScreenSaverElement ***
//
//
// Description:
//     Returns the IXMLElement of the first screen saver component in the channel.
//
// Parameters:
//     [In]  pXMLElemet    - An XML element
//     [Out] ppIXMLElement - The pointer that receives the screen saver element.
//
// Return:
//     S_OK if the first screen saver element was returned.
//     E_FAIL if the element couldn't be returned.
//
// Comments:
//     This function gets the first screen saver element and then looks
//     for the first top-level ITEM with a usage of ScreenSaver.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetScreenSaverElement(
    IXMLElement *   pXMLElement,
    IXMLElement **  ppScreenSaverElement)
{
    ASSERT(pXMLElement);
    ASSERT(ppScreenSaverElement);

    IXMLElementCollection * pIXMLElementCollection;
    HRESULT                 hr;

    hr = pXMLElement->get_children(&pIXMLElementCollection);
    if (SUCCEEDED(hr) && pIXMLElementCollection)
    {
        LONG nCount;

        hr = pIXMLElementCollection->get_length(&nCount);

        ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

        hr = E_FAIL;

        BOOL bScreenSaver = FALSE;
        for (int i = 0; (i < nCount) && !bScreenSaver; i++)
        {
            IXMLElement * pIXMLElement;

            HRESULT hr2 = XML_GetElementByIndex(pIXMLElementCollection,
                                                i,
                                                &pIXMLElement);

            if (SUCCEEDED(hr2))
            {
                ASSERT(pIXMLElement != NULL);

                if (bScreenSaver = XML_IsScreenSaver(pIXMLElement))
                {
                    pIXMLElement->AddRef();
                    *ppScreenSaverElement = pIXMLElement;

                    hr = S_OK;
                }

                pIXMLElement->Release();
            }

            hr = FAILED(hr2) ? hr2 : hr;
        }

        pIXMLElementCollection->Release();
    }        
    else
        hr = E_FAIL;

    ASSERT((SUCCEEDED(hr) && *ppScreenSaverElement) || FAILED(hr));

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetSubscriptionInfo ***
//
//
// Description:
//     Fills a structure with the subscription info for the given element.
//
// Parameters:
//     [In]  pIXMLElement - An xml element.  The element doesn't have to be a
//                          subscription element.
//     [Out] psi          - The subscription info structure used by the
//                          subscription manager.
//
// Return:
//     S_OK if any information was obtained.
//
// Comments:
//     This function uses a webcheck API that fills a task trigger with
//     subscription information.
//
//     This function assumes that the psi->pTrigger points to a TASK_TRIGGER.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
XML_GetSubscriptionInfo(
    IXMLElement* pIXMLElement,
    SUBSCRIPTIONINFO* psi
)
{
    ASSERT(pIXMLElement);
    ASSERT(psi);
    ASSERT(psi->pTrigger);

    HRESULT hr = E_FAIL;

#ifndef UNIX
    HINSTANCE hinst = LoadLibrary(TEXT("webcheck.dll"));

    if (hinst)
    {
        typedef (*PFTRIGGERFUNCTION)(IXMLElement* pIXMLElement,
                                     TASK_TRIGGER* ptt);

        PFTRIGGERFUNCTION XMLSheduleElementToTaskTrigger;

        XMLSheduleElementToTaskTrigger = (PFTRIGGERFUNCTION)
                                         GetProcAddress(hinst,
                                             "XMLScheduleElementToTaskTrigger");

        if (XMLSheduleElementToTaskTrigger)
        {
            ((TASK_TRIGGER*)(psi->pTrigger))->cbTriggerSize = 
                                                           sizeof(TASK_TRIGGER);

            hr = XMLSheduleElementToTaskTrigger(pIXMLElement,
                                                (TASK_TRIGGER*)psi->pTrigger);

            if (FAILED(hr))
                psi->pTrigger = NULL;
        }

        FreeLibrary(hinst);
    }

    // See if there is a screen saver available.
    IXMLElement * pScreenSaverElement;
    if (SUCCEEDED(XML_GetScreenSaverElement(   pIXMLElement,
                                                    &pScreenSaverElement)))
    {
        psi->fUpdateFlags |= SUBSINFO_CHANNELFLAGS;
        psi->fChannelFlags |= CHANNEL_AGENT_PRECACHE_SCRNSAVER;
        pScreenSaverElement->Release();
    }

    BSTR bstrLogin = XML_GetAttribute(pIXMLElement, XML_LOGIN);

    if (bstrLogin)
    {
        psi->bNeedPassword = TRUE;
        psi->fUpdateFlags |= SUBSINFO_NEEDPASSWORD;     //this member is now valid
        SysFreeString(bstrLogin);
    }

#endif /* !UNIX */

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_GetBaseURL ***
//
//
// Description:
//     Returns the base url for the given collection.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to an XML element.
//
// Return:
//     A bstr containing the base URL if there is one.
//     NULL if ther isn't a base URL.
//
// Comments:
//     If the current element has a BASE attribute return this attributes value.
//     Else return the BASE attribute of its parent.
//
////////////////////////////////////////////////////////////////////////////////
BSTR
XML_GetBaseURL(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    BSTR bstrRet = XML_GetAttribute(pIXMLElement, XML_BASE);

    if (NULL == bstrRet)
    {
        IXMLElement* pParentIXMLElement;

        if (SUCCEEDED(pIXMLElement->get_parent(&pParentIXMLElement)) && pParentIXMLElement)
        {
            ASSERT(pParentIXMLElement);

            bstrRet = XML_GetBaseURL(pParentIXMLElement);

            pParentIXMLElement->Release();
        }
    }

    return bstrRet;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_CombineURL ***
//
//
// Description:
//     Combine the given URL with the base URL.
//
// Parameters:
//     [In]  bstrBaseURL - The base URL.
//     [In]  bstrRelURL  - The relative URL.
//
// Return:
//     A combination of the base and relative URL.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BSTR
XML_CombineURL(
    BSTR bstrBaseURL,
    BSTR bstrRelURL
)
{
    ASSERT(bstrBaseURL);
    ASSERT(bstrRelURL);

    BSTR bstrRet = NULL;

    WCHAR wszCombinedURL[INTERNET_MAX_URL_LENGTH];
    DWORD cch = ARRAYSIZE(wszCombinedURL);

    if (InternetCombineUrlW(bstrBaseURL, bstrRelURL, wszCombinedURL, &cch, 0))
        bstrRet = SysAllocString(wszCombinedURL);

    return bstrRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsCdfDisplayable ***
//
//
// Description:
//     Determines if the given item should be displayed in the cdf view.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the IXMLElement interface of an object.
//
// Return:
//     TRUE if the object should be displayed.
//     FALSE otherwise.
//
// Comments:
//     aCDFTypes contains the tag names of XML items that the cdf shell
//     shell extension displays.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsCdfDisplayable(
    IXMLElement* pIXMLElement
)
{
    #define     KEYWORDS  (sizeof(aCDFTypes) / sizeof(aCDFTypes[0]))

    static const LPWSTR aCDFTypes[] = { 
                                        WSTR_ITEM,
                                        WSTR_CHANNEL,
                                        WSTR_SOFTDIST
                                      };

    ASSERT(pIXMLElement);

    BOOL bRet = FALSE;

    BSTR pStr;

    HRESULT hr = pIXMLElement->get_tagName(&pStr);

    if (SUCCEEDED(hr) && pStr)
    {
        ASSERT(pStr);

        for(int i = 0; (i < KEYWORDS) && !bRet; i++)
            bRet = StrEqlW(pStr, aCDFTypes[i]);

        if (bRet)
            bRet = XML_IsUsageChannel(pIXMLElement);

        //
        // Special processing.
        //

        if (bRet && StrEqlW(pStr, WSTR_SOFTDIST))
            bRet = XML_IsSoftDistDisplayable(pIXMLElement);

        SysFreeString(pStr);
    }

    return bRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsSoftDistDisplayable ***
//
//
// Description:
//     Determins if the given software distribution element should be displayed.
//
// Parameters:
//     [In]  pIXMLElement - Pointer to the software distribution xml element.
//
// Return:
//     TRUE if the element should be displayed.
//     FALSE if the element shouldn't be displayed.
//
// Comments:
//     This function asks the software disribution COM object if this software
//     distribution tag should be displayed on this users machine.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsSoftDistDisplayable(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    ISoftDistExt* pISoftDistExt;

    HRESULT hr = CoCreateInstance(CLSID_SoftDistExt, NULL, CLSCTX_INPROC_SERVER,
                                  IID_ISoftDistExt, (void**)&pISoftDistExt);

    if (SUCCEEDED(hr))
    {
        ASSERT(pISoftDistExt);

        hr = pISoftDistExt->ProcessSoftDist(NULL, pIXMLElement, 0);

        pISoftDistExt->Release();
    }

    return SUCCEEDED(hr) ? TRUE : FALSE;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsUsageChannel ***
//
//
// Description:
//     Determines if this item should be displayed in channel view based on its
//     usage tag.
//
// Parameters:
//     [In]  pIXMLelement - A pointer to the element.
//
// Return:
//     TRUE if the item should be displayed in the channel view.
//     FALSE otherwise.
//
// Comments:
//     If an element doesn't have a USAGE tag then it gets displayed.  If an
//     element has any numberf of usage tags one of them must have a value of
//     CHANNEL or will not get displayed.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsUsageChannel(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    BOOL bRet;

    //
    // First check if there are any USAGE elements.
    //

    BSTR bstrUsage = XML_GetAttribute(pIXMLElement, XML_USAGE);

    if (bstrUsage)
    {
        //
        // See if USAGE is CHANNEL.
        //

        if (StrEqlW(bstrUsage, WSTR_CHANNEL))
        {
            bRet = TRUE;
        }
        else
        {
            //
            // Check if there are any other USAGE tags with value CHANNEL.
            //

            BSTR bstrChannel = XML_GetAttribute(pIXMLElement,
                                                XML_USAGE_CHANNEL);

            if (bstrChannel)
            {
                SysFreeString(bstrChannel);
                bRet = TRUE;
            }
            else
            {
                bRet = FALSE;
            }
        }

        SysFreeString(bstrUsage);
    }
    else
    {
        bRet = TRUE;  // No USAGE tag defaults channel usage.
    }

    return bRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsChannel ***
//
//
// Description:
//     Determines if the given XML item is a channel.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the IXMLElement interface of an object.
//
// Return:
//     TRUE if the object is a channel.
//     FALSE otherwise.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsChannel(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    BOOL bRet = FALSE;

    BSTR pStr;

    HRESULT hr = pIXMLElement->get_tagName(&pStr);

    if (SUCCEEDED(hr) && pStr)
    {
        ASSERT(pStr);

        bRet = StrEqlW(pStr, WSTR_CHANNEL);

        SysFreeString(pStr);
    }

    return bRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsDesktopComponent ***
//
//
// Description:
//     Determines if the given XML item is a desktop component.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the IXMLElement interface of an object.
//
// Return:
//     TRUE if the object is a desktop component.
//     FALSE otherwise.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsDesktopComponent(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    BOOL bRet;

    BSTR bstr = XML_GetAttribute(pIXMLElement, XML_USAGE_DSKCMP);

    if (bstr)
    {
        SysFreeString(bstr);
        bRet = TRUE;
    }
    else
    {
        bRet = FALSE;
    }

    return bRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsScreenSaver ***
//
//
// Description:
//     Determines if the given XML item is a screen saver.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the IXMLElement interface of an object.
//
// Return:
//     TRUE if the object is a screen saver
//     FALSE otherwise.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsScreenSaver(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    BOOL bRet;

    BSTR bstrUsage = XML_GetAttribute(pIXMLElement, XML_USAGE);

    if (bstrUsage)
    {
        bRet =  (
                (StrCmpIW(bstrUsage, WSTR_SCRNSAVE) == 0)
                ||
                (StrCmpIW(bstrUsage, WSTR_SMARTSCRN) == 0)
                );

        SysFreeString(bstrUsage);
    }
    else
    {
        bRet = FALSE;
    }

    return bRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsDesktopComponentUsage ***
//
//
// Description:
//     Determines if the given XML item is a desktop component usage element.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the IXMLElement interface of an object.
//
// Return:
//     TRUE if the object is a desktop component usage element.
//     FALSE otherwise.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsDesktopComponentUsage(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    BOOL bRet = FALSE;

    BSTR bstrName;

    if (SUCCEEDED(pIXMLElement->get_tagName(&bstrName)) && bstrName)
    {
        ASSERT(bstrName);

        if (StrEqlW(bstrName, WSTR_USAGE))
        {
            BSTR bstrValue = XML_GetElementAttribute(pIXMLElement, WSTR_VALUE, NULL,
                                                NULL);

            if (bstrValue)
            {
                bRet = (0 == StrCmpIW(bstrValue, WSTR_DSKCMP));

                SysFreeString(bstrValue);
            }
        }

        SysFreeString(bstrName);
    }

    return bRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsFolder ***
//
//
// Description:
//     Determines if the given item is a folder.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the IXMLElement interface of an object.
//
// Return:
//     TRUE if the object contains other cdf displayable objects.
//     FALSE otherwise.
//
// Comments:
//     An item is a folder if at least one of its children is displayable as a
//     cdf item.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsFolder(
    IXMLElement* pIXMLElement
)
{
    ASSERT(pIXMLElement);

    BOOL bRet = FALSE;

    IXMLElementCollection* pIXMLElementCollection;

    HRESULT hr = pIXMLElement->get_children(&pIXMLElementCollection);

    if (SUCCEEDED(hr) && pIXMLElementCollection)
    {
        ASSERT(pIXMLElementCollection);

        LONG nCount;

        hr = pIXMLElementCollection->get_length(&nCount);

        ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

        for (int i = 0; (i < nCount) && !bRet; i++)
        {
            IXMLElement* pIXMLElementTemp;

            hr = XML_GetElementByIndex(pIXMLElementCollection, i, &pIXMLElementTemp);

            if (SUCCEEDED(hr))
            {
                ASSERT(pIXMLElementTemp);

                if (XML_IsCdfDisplayable(pIXMLElementTemp))
                    bRet = TRUE;

                pIXMLElementTemp->Release();
            }
        }

        pIXMLElementCollection->Release();
    }

    return bRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_ContainsFolder ***
//
//
// Description:
//     Determines if there are any cdf folders in the given collection.
//
// Parameters:
//     [In]  pIXMLElementCollection - A pointer to the collection.
//
// Return:
//     TRUE if the collection contains a cf folder.
//     FALSE otherwise.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_ContainsFolder(
    IXMLElementCollection* pIXMLElementCollection
)
{
    ASSERT(pIXMLElementCollection);

    BOOL bContainsFolder = FALSE;

    LONG nCount;

    HRESULT hr = pIXMLElementCollection->get_length(&nCount);

    ASSERT(SUCCEEDED(hr) || (FAILED(hr) && 0 == nCount));

    for (int i = 0; (i < nCount) && !bContainsFolder; i++)
    {
        IXMLElement* pIXMLElement;

        hr = XML_GetElementByIndex(pIXMLElementCollection, i, &pIXMLElement);

        if (SUCCEEDED(hr))
        {
            ASSERT(pIXMLElement);

            bContainsFolder = XML_IsFolder(pIXMLElement);

            pIXMLElement->Release();
        }
    }

    return bContainsFolder;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_ChildContainsFolder ***
//
//
// Description:
//
//
// Parameters:
//
//
// Return:
//
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_ChildContainsFolder(
    IXMLElementCollection *pIXMLElementCollectionParent,
    ULONG nIndexChild
)
{
    BOOL bRet = FALSE;

    IXMLElement* pIXMLElement;

    HRESULT hr = XML_GetElementByIndex(pIXMLElementCollectionParent,
                                       nIndexChild, &pIXMLElement);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIXMLElement);

        IXMLElementCollection* pIXMLElementCollection;

        hr = pIXMLElement->get_children(&pIXMLElementCollection);

        if (SUCCEEDED(hr) && pIXMLElementCollection)
        {
            ASSERT(pIXMLElementCollection);

            bRet = XML_ContainsFolder(pIXMLElementCollection);

            pIXMLElementCollection->Release();
        }

        pIXMLElement->Release();
    }

    return bRet;
}

#ifdef DEBUG

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** XML_IsCdfidlMemberOf ***
//
//
// Description:
//     Checks if the cdf item id list is associated with a member of the given
//     element collection.
//
// Parameters:
//     [In]  pIXMLElementCollection - The element collection to check.
//     [In]  pcdfidl                - A pointer to cdf item id list
//
// Return:
//     TRUE if the given id list can be associated with an elemnt of the given 
//     collection.
//     FALSE otherwise.
//
// Comments:
//     This function checks if the last id in the list could have been
//     generated from its corresponding element in the element collection.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
XML_IsCdfidlMemberOf(
    IXMLElementCollection* pIXMLElementCollection,
    PCDFITEMIDLIST pcdfidl
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl));

    BOOL bRet = FALSE;

    //
    // pIXMLElementCollection is NULL when a Folder hasn't been initialized.
    // It isn't always neccessary to parse the cdf to get pidl info from
    // the pidl.  pIXMLElement collection will be NULL in low memory situations
    // also.  Don't return FALSE for these cases.  Also check for special
    // pidls that aren't in element collections.
    //

    if (pIXMLElementCollection &&
        CDFIDL_GetIndexId(&pcdfidl->mkid) != INDEX_CHANNEL_LINK)
    {
        IXMLElement* pIXMLElement;

        HRESULT hr = XML_GetElementByIndex(pIXMLElementCollection,
                                           CDFIDL_GetIndexId(&pcdfidl->mkid),
                                           &pIXMLElement);

        if (SUCCEEDED(hr))
        {
            ASSERT(pIXMLElement);

            PCDFITEMIDLIST pcdfidlElement;

            pcdfidlElement = CDFIDL_CreateFromXMLElement(pIXMLElement,
                                             CDFIDL_GetIndexId(&pcdfidl->mkid));

            if (pcdfidlElement)
            {
                ASSERT(CDFIDL_IsValid(pcdfidlElement));

                bRet = (0 == CDFIDL_CompareId(&pcdfidl->mkid,
                                              &pcdfidlElement->mkid));

                CDFIDL_Free(pcdfidlElement);
            }

            pIXMLElement->Release();
        }
    }
    else
    {
        bRet = TRUE;
    }

    return bRet;
}

#endif //DEBUG

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//                                                           
// *** XML_IsStrEqualW ***
//
//
// Description:
//     Determines if two WCHAR strings are equal.
//
// Parameters:
//     [In]  p1 - The first string to compare.
//     [In]  p2 - The second string to compare.
//
// Return:
//     TRUE if the strings are equal.
//     FALSE otherwise.
//
// Comments:
//     lstrcmpW doesn't work on W95 so this function has its own strcmp logic.
//
////////////////////////////////////////////////////////////////////////////////
#if 0
inline
BOOL
XML_IsStrEqualW(
    LPWSTR p1,
    LPWSTR p2
)
{
    ASSERT(p1);
    ASSERT(p2);

    while ((*p1 == *p2) && *p1 && *p2)
    {
        p1++; p2++;
    }

    return (*p1 == *p2);
}
#endif