windows-nt/Source/XPSP1/NT/shell/ext/cdfview/cdfidl.cpp

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// cdfidl.cpp 
//
//   Cdf id list helper functions.
//
//   History:
//
//       3/19/97  edwardp   Created.
//
////////////////////////////////////////////////////////////////////////////////

//
// Includes
//

#include "stdinc.h"
#include "cdfidl.h"
#include "xmlutil.h"
#include "winineti.h" // for MAX_CACHE_ENTRY_INFO_SIZE

//
// Helper functions
//


LPTSTR CDFIDL_GetUserName()
{
    static BOOL gunCalled = FALSE;
    static TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH] = TEXT("");

    if (!gunCalled)
    {
        char  szUserNameA[INTERNET_MAX_USER_NAME_LENGTH];
        szUserNameA[0] = 0;
        DWORD size = INTERNET_MAX_USER_NAME_LENGTH;
        GetUserNameA(szUserNameA, &size);
        SHAnsiToTChar(szUserNameA, szUserName, ARRAYSIZE(szUserName));
        gunCalled = TRUE;
    }
    return szUserName;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_Create ***
//
//
// Description:
//     Creates a cdf id list.
//
// Parameters:
//     [In]  pCdfItem - A pointer to cdf item data.
//
// Return:
//     A new cdf id list on success.
//     NULL otherwise.
//
// Comments:
//     This function builds a variable length cdf item id list.  The item id
//     consists of a fixed length initial section followed by two or more null
//     terminated strings.  It has the following form:
//
//         USHORT  cb               - Size in bytes of this cdf item id.
//         WORD    wVersion;        - Version number of this item id structure.
//         DWORD   dwId;            - Used to identify cdf item ids. Set to
//                                    0x0ed1964ed  
//         CDFITEMTYPE cdfItemType  - CDF_Folder, CDF_FolderLink or CDF_Link.
//         LONG    nIndex           - The object model index for this item.
//         TCHAR   szName[1];       - Two or more null terminated strings
//                                    beggining with the name of this item.
//         USHORT  next.cb          - The size of the next item in the list.
//                                    Set to zero to terminate the list.
//
//     It is the callers responsability to free the item id list.  This should
//     be done using the IMalloc returned from SHGetMalloc();
//
////////////////////////////////////////////////////////////////////////////////
PCDFITEMIDLIST
CDFIDL_Create(
    PCDFITEM pCdfItem
)
{
#ifdef ALIGNMENT_MACHINE
    TCHAR *pszTempName;
#endif
    ASSERT(pCdfItem);
    ASSERT(pCdfItem->bstrName);
    ASSERT(pCdfItem->bstrURL);

    PCDFITEMIDLIST pcdfidl = NULL;

    //
    // Get the number of chars of the name of the item including the terminating
    // null character.
    //

    USHORT cbName = StrLenW(pCdfItem->bstrName) + 1;

    //
    // Get the number of chars of the URL of the item including the terminating
    // null character.
    //

    USHORT cbURL = StrLenW(pCdfItem->bstrURL) + 1;

    //
    // Calculate the total size of the cdf item id in bytes.  When calculating the size
    // of a cdf item id one TCHAR should be subtracted to account for the TCHAR
    // szName[1] included in the CDFITEMID struct definition.
    //

    USHORT cbItemId = sizeof(CDFITEMID) + (cbName + cbURL) * sizeof(TCHAR) - sizeof(TCHAR);

#ifdef ALIGNMENT_MACHINE
    cbItemId = ALIGN4(cbItemId);
#endif

    //
    // Item ids must allocated by the shell's IMalloc interface.
    //

    IMalloc* pIMalloc;

    HRESULT hr = SHGetMalloc(&pIMalloc);

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

        //
        // An item id *list* must be NULL terminated so an additional USHORT is
        // allocated to hold the terminating NULL.
        //
        pcdfidl = (PCDFITEMIDLIST)pIMalloc->Alloc(cbItemId + sizeof(USHORT));

        if (pcdfidl)
        {
            //
            // NULL terminate the list.
            //

            *((UNALIGNED USHORT*) ( ((LPBYTE)pcdfidl) + cbItemId )) = 0;

#ifdef ALIGNMENT_MACHINE
            USHORT cbActaulItemId = sizeof(CDFITEMID) + cbName + cbURL - sizeof(TCHAR);
            if(cbActaulItemId < cbItemId)
                memset((LPBYTE)pcdfidl + cbActaulItemId, 0, cbItemId-cbActaulItemId);
#endif


            //
            // Fill in the data shared by all cdf item ids.
            //

            pcdfidl->mkid.cb       = cbItemId;
            pcdfidl->mkid.wVersion = CDFITEMID_VERSION;
            pcdfidl->mkid.dwId     = CDFITEMID_ID;

            //
            // Set the data that is specific to this cdf item id.
            //

            pcdfidl->mkid.cdfItemType = pCdfItem->cdfItemType;
            pcdfidl->mkid.nIndex      = pCdfItem->nIndex;

            //
            // REVIEW: Need WSTR to TSTR conversion.
            //

#ifndef ALIGNMENT_MACHINE
            SHUnicodeToTChar(pCdfItem->bstrName, pcdfidl->mkid.szName, cbName);
            SHUnicodeToTChar(pCdfItem->bstrURL, pcdfidl->mkid.szName + cbName,
                           cbURL);         
#else
        pszTempName = (LPTSTR)ALIGN4((ULONG_PTR)(pcdfidl->mkid.szName));
            SHUnicodeToTChar(pCdfItem->bstrName, pszTempName, cbName);
        pszTempName = (LPTSTR)((ULONG_PTR)(pcdfidl->mkid.szName+cbName));
            SHUnicodeToTChar(pCdfItem->bstrURL, pszTempName,
                           cbURL);
#endif

        }
        else
        {
            pcdfidl = NULL;
        }

        pIMalloc->Release();
    }

    ASSERT(CDFIDL_IsValid(pcdfidl) || NULL == pcdfidl);

    return pcdfidl;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_CreateFromXMLElement ***
//
//
// Description:
//     Creates a cdf item id list from a xml element.
//
// Parameters:
//     [In]  pIXMLElement - A pointer to the xml element.
//     [In]  nIndex       - The index value used to set the cdfidl index field.
//
// Return:
//     A poniter to a new cdf item id list if successful.
//     NULL otherwise.
//
// Comments:
//     The caller is responsible for freeing the returned id list.
//
////////////////////////////////////////////////////////////////////////////////
PCDFITEMIDLIST
CDFIDL_CreateFromXMLElement(
    IXMLElement* pIXMLElement,
    ULONG nIndex
)
{
    ASSERT(pIXMLElement);

    PCDFITEMIDLIST pcdfidl = NULL;

    CDFITEM cdfItem;

    if (cdfItem.bstrName = XML_GetAttribute(pIXMLElement, XML_TITLE))
    {
        if (cdfItem.bstrURL  = XML_GetAttribute(pIXMLElement, XML_HREF))
        {
            cdfItem.nIndex = nIndex;

            if (INDEX_CHANNEL_LINK == nIndex)
            {
                cdfItem.cdfItemType = CDF_FolderLink;
            }
            else
            {
                cdfItem.cdfItemType = XML_IsFolder(pIXMLElement) ? CDF_Folder :
                                                                   CDF_Link;
            }

            pcdfidl = CDFIDL_Create(&cdfItem);

            SysFreeString(cdfItem.bstrURL);
        }

        SysFreeString(cdfItem.bstrName);
    }

    ASSERT(CDFIDL_IsValid(pcdfidl) || NULL == pcdfidl);

    return pcdfidl;
}


//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_CreateFolderPidl ***
//
//
// Description: creates a special folder pidl
//     
//
// Parameters:
//     [In]  pcdfidl - Pointer to the cdf id list to be created from
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
PCDFITEMIDLIST
CDFIDL_CreateFolderPidl(
    PCDFITEMIDLIST pcdfidl
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl));

    PCDFITEMIDLIST pcdfidlRet = (PCDFITEMIDLIST)ILClone((LPITEMIDLIST)pcdfidl);

    if (pcdfidlRet)
    {
        ((PCDFITEMID)pcdfidlRet)->nIndex = INDEX_CHANNEL_LINK;
        ((PCDFITEMID)pcdfidlRet)->cdfItemType = CDF_FolderLink; //CDF_Link instead?
    }
    ASSERT(CDFIDL_IsValid(pcdfidlRet));
   
    return pcdfidlRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_Free ***
//
//
// Description:
//     Free the given cdf item id list.
//
// Parameters:
//     [In]  pcdfidl - Pointer to the cdf id list to be freed.
//
// Return:
//     No return value.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
void
CDFIDL_Free(
    PCDFITEMIDLIST pcdfidl
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl));

    IMalloc *pIMalloc;

    if (SUCCEEDED(SHGetMalloc(&pIMalloc)))
    {
        ASSERT(pIMalloc);
        ASSERT(pIMalloc->DidAlloc(pcdfidl));
        
        pIMalloc->Free(pcdfidl);

        pIMalloc->Release();
    }
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_GetDisplayName ***
//
//
// Description:
//     Gets the name stored in the given cdf item id list.
//
// Parameters:
//     [In]  pcdfidl - A pointer to a cdf item id list.
//     [Out] pName - A pointer to a STRRET structure.  STRRET has the following
//                   structure:
//                       UINT uType             - STRRET_CSTR, _OFFSET or _WSTR
//                       union {
//                           LPWSTR pOleStr;
//                           UINT   uOffset;
//                           char   cStr[MAX_PATH];
//                       }
//
// Return:
//     S_OK on success.  E_Fail otherwise.
//
// Comments:
//     This function returns the name as an offset of the string from the start
//     of the cdf item id list.
//
////////////////////////////////////////////////////////////////////////////////
HRESULT
CDFIDL_GetDisplayName(
    PCDFITEMIDLIST pcdfidl,
    LPSTRRET pName
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl));
    ASSERT(pName);

#ifdef UNICODE
#ifdef SHDOCVW_UNICODE     //open this when shdocvw becomes unicode
    IMalloc* pIMalloc;

    HRESULT hr = SHGetMalloc(&pIMalloc);

    if (SUCCEEDED(hr))
    {
        ASSERT(pIMalloc);
        pName->uType = STRRET_WSTR;
        LPTSTR pszName = CDFIDL_GetName(pcdfidl);

        pName->pOleStr = (LPWSTR)pIMalloc->Alloc(ARRAYSIZE(pszName));
        if (pName->pOleStr)
            lstrcpyW(pName->pOleStr, pszName);
        pIMalloc->Release();
    }
#else
    pName->uType = STRRET_CSTR;
    LPTSTR pszName = CDFIDL_GetName(pcdfidl);

    SHTCharToAnsi(pszName, pName->cStr, ARRAYSIZE(pName->cStr));
#endif
#else
    pName->uType = STRRET_OFFSET;
    pName->uOffset = (UINT)((LPBYTE)CDFIDL_GetName(pcdfidl) - (LPBYTE)pcdfidl);
#endif
    return S_OK;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_GetName ***
//
//
// Description:
//     Gets a pointer to the URL stored in the given cdf item id list.
//
// Parameters:
//     [In]  pcdfidl - A pointer to a cdf item id list.
//
// Return:
//     A LPTSTR to the Name stored in the pidl.
//
// Comments:
//     This function returns a pointer to the Name in the cdf item id list.
//     The pointer is valid for the life of the item id list.  The caller is
//     resposible for maintaining the item id list and for not using the
//     the returned pointer after the id list is freed.
//
//     The name returned is the name of the last item in the list. 
//
////////////////////////////////////////////////////////////////////////////////
LPTSTR
CDFIDL_GetName(
    PCDFITEMIDLIST pcdfidl
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl));

    pcdfidl = (PCDFITEMIDLIST)ILFindLastID((LPITEMIDLIST)pcdfidl);
    
    return CDFIDL_GetNameId(&pcdfidl->mkid);
}

LPTSTR
CDFIDL_GetNameId(
    PCDFITEMID pcdfid
)
{
    ASSERT(pcdfid);

#if defined(ALIGNMENT_MACHINE)
    return (LPTSTR)(ALIGN4((ULONG_PTR)pcdfid->szName));
#else
    return pcdfid->szName;
#endif

}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_GetURL ***
//
//
// Description:
//     Gets a pointer to the URL stored in the given cdf item id list.
//
// Parameters:
//     [In]  pcdfidl - A pointer to a cdf item id list.
//
// Return:
//     A LPTSTR to the URL value for the given pcdfidl.
//
// Comments:
//     This function returns a pointer to the URL in the cdf item id list.  The
//     pointer is valid for the life of the item id list.  The caller is
//     resposible for maintaining the item id list and for not using the
//     the returned pointer after the id list is freed. 
//
//     The URL returned is the URL of the last item in the list.
//
////////////////////////////////////////////////////////////////////////////////
LPTSTR
CDFIDL_GetURL(
    PCDFITEMIDLIST pcdfidl
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl));

    //
    // Get the first string after the name.
    //

    LPTSTR szURL = CDFIDL_GetName(pcdfidl);

    while (*szURL++);

    return szURL;
}

LPTSTR
CDFIDL_GetURLId(
    PCDFITEMID pcdfid
)
{
    ASSERT(pcdfid);

    //
    // Get the first string after the name.
    //

    LPTSTR szURL = CDFIDL_GetNameId(pcdfid);

    while (*szURL++);

    return szURL;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_GetIndex ***
//
//
// Description:
//     Returns the index item of the given cdf id list.
//
// Parameters:
//     [In]  pcdfidl - Pointer to the cdf item id list.
//
// Return:
//     Returns the index item of the given id list.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
ULONG
CDFIDL_GetIndex(
    PCDFITEMIDLIST pcdfidl
)
{
    pcdfidl = (PCDFITEMIDLIST)ILFindLastID((LPITEMIDLIST)pcdfidl);

    return CDFIDL_GetIndexId(&pcdfidl->mkid);
}

ULONG
CDFIDL_GetIndexId(
    PCDFITEMID pcdfid
)
{
    return pcdfid->nIndex;
}

#define ASTR_HISTORY_PREFIX TEXT("Visited: ")

//
// Looks the URL up in the cache to see if the user has ever read this url
//
// REVIEW
// REVIEW - Should probably use IUrlStorage instead of constructing the 
// REVIEW
// history cache URL on the fly
//
BOOL
CDFIDL_IsUnreadURL(
    LPTSTR szUrl
)
{
    DWORD dwLen;
    
    //
    //  Canonicalize the input url.
    // 
    TCHAR szCanonicalizedUrl[INTERNET_MAX_URL_LENGTH];
    dwLen = INTERNET_MAX_URL_LENGTH;
    if (!InternetCanonicalizeUrl(szUrl, szCanonicalizedUrl, &dwLen, 0))
        StrCpyN(szCanonicalizedUrl, szUrl, ARRAYSIZE(szCanonicalizedUrl));
    
    //
    // Build a string that is the URL prefixed with VISITED: and the UserName
    //
    TCHAR szVisited[
        INTERNET_MAX_USER_NAME_LENGTH+
        1+
        INTERNET_MAX_URL_LENGTH+
        ARRAYSIZE(ASTR_HISTORY_PREFIX)];
 
    StrCpy(szVisited, ASTR_HISTORY_PREFIX);
    StrCatN(szVisited, CDFIDL_GetUserName(), ARRAYSIZE(szVisited));
    int len = StrLen(szVisited);
    StrCpyN(szVisited + len++, TEXT("@"), ARRAYSIZE(szVisited) - len);
    //len++;        //bug, this will introduce a null char...
    StrCpyN(szVisited + len++, szCanonicalizedUrl, ARRAYSIZE(szVisited) - len);          

    // Check for trailing slash and eliminate, copied from shdocvw\urlhist.cpp
    LPTSTR pszT = CharPrev(szVisited, szVisited + lstrlen(szVisited));
    if (*pszT == TEXT('/'))
    {
        ASSERT(lstrlen(pszT) == 1);
        *pszT = 0;
    }

    //
    // If the VISITED: entry does not exist in the cache assume url is unread
    //
#ifndef ALIGNMENT_MACHINE
    BYTE visitedCEI[MAX_CACHE_ENTRY_INFO_SIZE];
    LPINTERNET_CACHE_ENTRY_INFO pVisitedCEI = (LPINTERNET_CACHE_ENTRY_INFO)visitedCEI;
#else
    union
    {
        double align8;
        BYTE visitedCEI[MAX_CACHE_ENTRY_INFO_SIZE];
    } alignedvisitedCEI;
    LPINTERNET_CACHE_ENTRY_INFO pVisitedCEI = (LPINTERNET_CACHE_ENTRY_INFO)&alignedvisitedCEI;
#endif /* ALIGNMENT_MACHINE */
    dwLen = MAX_CACHE_ENTRY_INFO_SIZE;

    if (GetUrlCacheEntryInfo(szVisited, pVisitedCEI, &dwLen) == FALSE)
    {
        return TRUE;
    }
    else
    {
        //
        // URL has been visited, but it still may be unread if the page has
        // been placed in the cache by the infodelivery mechanism
        //
#ifndef ALIGNMENT_MACHINE
        BYTE urlCEI[MAX_CACHE_ENTRY_INFO_SIZE];
        LPINTERNET_CACHE_ENTRY_INFO pUrlCEI = (LPINTERNET_CACHE_ENTRY_INFO)urlCEI;
#else
        union
        {
            double align8;
            BYTE urlCEI[MAX_CACHE_ENTRY_INFO_SIZE];
        } alignedurlCEI;
        LPINTERNET_CACHE_ENTRY_INFO pUrlCEI = (LPINTERNET_CACHE_ENTRY_INFO)&alignedurlCEI;
#endif /* ALIGNMENT_MACHINE */

        dwLen = MAX_CACHE_ENTRY_INFO_SIZE;

        if (GetUrlCacheEntryInfo(szCanonicalizedUrl, pUrlCEI, &dwLen) == FALSE)
        {
            return FALSE; // no url cache entry but url was visited so mark read
        }
        else
        {
            //
            // If the url has been modified after the time of the visited 
            // record then url is unread
            //
            if (CompareFileTime(&pUrlCEI->LastModifiedTime,
                                &pVisitedCEI->LastModifiedTime) > 0)
            {
                return TRUE;
            }
            else
            {
                return FALSE;
            }
        }
    }
}

//
// Looks the URL up in the cache. TRUE if it is and FALSE otherwise
//
BOOL
CDFIDL_IsCachedURL(
    LPWSTR wszUrl
)
{

    BOOL  fCached;
    TCHAR szUrlT[INTERNET_MAX_URL_LENGTH];


    //
    //  Canonicalize the input url.
    // 
    
    if (SHUnicodeToTChar(wszUrl, szUrlT, ARRAYSIZE(szUrlT)))
    {
        URL_COMPONENTS uc;
 
        memset(&uc, 0, sizeof(uc));
        uc.dwStructSize = sizeof(URL_COMPONENTS);
        uc.dwSchemeLength = 1;
        if (InternetCrackUrl(szUrlT, 0, 0, &uc))
        {
            // zekel should look at this
            TCHAR *pchLoc = StrChr(szUrlT, TEXT('#'));
            if (pchLoc)
                *pchLoc = TEXT('\0');
        

            fCached = GetUrlCacheEntryInfoEx(szUrlT, NULL, NULL, NULL, NULL, NULL, 0);
            if(fCached)
            {
                return TRUE;
            }
            else
            {
                TCHAR szCanonicalizedUrlT[INTERNET_MAX_URL_LENGTH];
                DWORD dwLen = INTERNET_MAX_URL_LENGTH;
                InternetCanonicalizeUrl(szUrlT, szCanonicalizedUrlT, &dwLen, 0);

                fCached = GetUrlCacheEntryInfoEx(szCanonicalizedUrlT, NULL, NULL, NULL, NULL, NULL, 0);

                if(fCached)
                    return TRUE;
            }
        }
    }
    
    return FALSE;


}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_GetAttributes ***
//
//
// Description:
//     Returns the attributes item of the given cdf item id list.
//
// Parameters:
//     [In]  pIXMLElementCollectionparent - The containing element collection.
//     [In]  pcdfidl                      - A pointer to the cdf item id list.
//     [In]  fAttributesFilter            - Determines which flags to bother 
//                                          looking at
//
// Return:
//     The attributes of the given id list.
//     Zero on failure.  Note: Zero is a valid attribute value.
//
// Comments:
//     The attribute flags returned by this function can be used directly as a
//     return value by IShellFolder->GetAttributesOf().
//
////////////////////////////////////////////////////////////////////////////////
ULONG
CDFIDL_GetAttributes(
    IXMLElementCollection* pIXMLElementCollectionParent,
    PCDFITEMIDLIST pcdfidl,
    ULONG fAttributesFilter
)
{
    ASSERT(pIXMLElementCollectionParent);
    ASSERT(CDFIDL_IsValid(pcdfidl));
    ASSERT(ILIsEmpty(_ILNext((LPITEMIDLIST)pcdfidl)));

    //
    // REVIEW:  Need to properly determine shell attributes of cdf items.
    //

    ULONG uRet;

    if (CDFIDL_IsFolderId(&pcdfidl->mkid))
    {
        uRet = SFGAO_FOLDER | SFGAO_CANLINK;

        //  If we weren't asked for HASSUBFOLDER don't bother looking for it
        //  This should be a win in non tree views (ie. std open mode)
        if ((SFGAO_HASSUBFOLDER & fAttributesFilter) &&
            pIXMLElementCollectionParent && 
            XML_ChildContainsFolder(pIXMLElementCollectionParent,
                                    CDFIDL_GetIndex(pcdfidl)))
        {
            uRet |= SFGAO_HASSUBFOLDER;
        }
    }
    else
    {
        uRet = SFGAO_CANLINK;
        //  If we weren't asked for NEWCONTENT don't bother looking for it
        //  This will be a win in non channel pane views.
        //  Can't test for SFGAO_NEWCONTENT since shell is never
        //  expressing interest in it!
        if (/*(SFGAO_NEWCONTENT & fAttributeFilter) && */
            CDFIDL_IsUnreadURL(CDFIDL_GetURL(pcdfidl)))
        {
            uRet |= SFGAO_NEWCONTENT;
        }
    }

    return uRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_Compare ***
//
//
// Description:
//     Compares two cdf item id lists
//
// Parameters:
//     [In]  pcdfidl1 - A pointer to the first item id list to compare.
//     [In]  pcdfidl2 - A pointer to the second item id list to compare.
//
// Return:
//     -1 if item 1 comes before item 2.
//      0 if the items are equal.
//      1 if item 2 comes before item 1.
//
// Comments:
//      Sort Order:
//          1) Use the CompareId result of the first items in the lists.
//          2) If 1) returns 0.  Compare the next two items in the lists.
//          3) If both list are empty. They are equal.
//          4) The shorter id list comes first.
//
////////////////////////////////////////////////////////////////////////////////
SHORT
CDFIDL_Compare(
    PCDFITEMIDLIST pcdfidl1,
    PCDFITEMIDLIST pcdfidl2
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl1));
    ASSERT(CDFIDL_IsValid(pcdfidl2));

    SHORT sRet;

    sRet = CDFIDL_CompareId(&pcdfidl1->mkid, &pcdfidl2->mkid);

    if (0 == sRet)
    {
        if (!ILIsEmpty(_ILNext(pcdfidl1)) && !ILIsEmpty(_ILNext(pcdfidl2)))
        {
            sRet = CDFIDL_Compare((PCDFITEMIDLIST)_ILNext(pcdfidl1), 
                                  (PCDFITEMIDLIST)_ILNext(pcdfidl2));
        }
        else if(!ILIsEmpty(_ILNext(pcdfidl1)) && ILIsEmpty(_ILNext(pcdfidl2)))
        {
            sRet = 1;
        }
        else if (ILIsEmpty(_ILNext(pcdfidl1)) && !ILIsEmpty(_ILNext(pcdfidl2)))
        {
            sRet = -1;
        }
    }

    return sRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_CompareId ***
//
//
// Description:
//     Compares two item cdf item ids.
//
// Parameters:
//     [In]  pcdfid1 - A pointer to the first item id to compare.
//     [In]  pcdfid2 - A pointer to the second item id to compare.
//
// Return:
//     -1 if item 1 comes before item 2.
//      0 if the items are the same.
//      1 if item 2 comes before item 1.
//
// Comments:
//     Sort Order:
//         1) CDF_FolderLink (Essentially an URL for the current folder). These
//            have an index of -1.
//         2) Everything else accoring to its order in the CDF.  These have
//            a zero-based index.
//         3) Non CDF items  (should't have any).
//
////////////////////////////////////////////////////////////////////////////////
SHORT
CDFIDL_CompareId(
    PCDFITEMID pcdfid1,
    PCDFITEMID pcdfid2
)
{
    ASSERT(CDFIDL_IsValidId(pcdfid1));
    ASSERT(CDFIDL_IsValidId(pcdfid2));

    SHORT sRet;

    if (pcdfid1->nIndex < pcdfid2->nIndex)
    {
        sRet = -1;
    }
    else if (pcdfid1->nIndex > pcdfid2->nIndex)
    {
        sRet = 1;
    }
    else
    {
        sRet =  (short) CompareString(LOCALE_USER_DEFAULT, 0, CDFIDL_GetNameId(pcdfid1),
                                      -1, CDFIDL_GetNameId(pcdfid2), -1);

        //
        // Note: CompareString returns 1 if S1 comes before S2, 2 if S1 is equal
        // to S2, 3 if S2 comes before S1 and 0 on error.
        //

        sRet = sRet ? sRet - 2 : 0;

        if (0 == sRet)
        {
            //
            // If the URLs aren't equal just pick one at random.
            //

            sRet = !StrEql(CDFIDL_GetURLId(pcdfid1), CDFIDL_GetURLId(pcdfid2));
            
            ASSERT((pcdfid1->cb == pcdfid2->cb) || 0 != sRet);
            ASSERT((pcdfid1->cdfItemType == pcdfid1->cdfItemType) || 0 != sRet);
        }
    }

    return sRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_IsValid ***
//
//
// Description:
//     Determines if the given pcdfidl is valid.
//
// Parameters:
//     pcdfid - A pointer to the cdf id to check.
//
// Return:
//     TRUE if the id is a cdf id.
//     FALSE otherwise.
//
// Comments:
//     An empty list is not valid.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
CDFIDL_IsValid(
    PCDFITEMIDLIST pcdfidl
)
{
    BOOL bRet;

    if (pcdfidl && (pcdfidl->mkid.cb > 0))
    {
        bRet = TRUE;

        while (pcdfidl->mkid.cb && bRet)
        {
            bRet = CDFIDL_IsValidId(&pcdfidl->mkid);
            pcdfidl = (PCDFITEMIDLIST)_ILNext((LPITEMIDLIST)pcdfidl);
        }
    }
    else
    {
        bRet = FALSE;
    }

    return bRet;
}


//
// Inline helper functions.
//

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_IsValidId ***
//
//
// Description:
//     Inline function that returns TRUE if the given id is a pointer to a cdf
//     item id.
//
// Parameters:
//     pcdfid - A pointer to the cdf id to check.
//
// Return:
//     TRUE if the id is a cdf id.
//     FALSE otherwise.
//
// Comments:
//     This function is not completely safe.  If the first word pointed to 
//     is large but the memory block pointed to is smaller than a 8 bytes an
//     access violation will occur.  Also, if the first word is large enough and
//     the second DWORD is equal to CDFITEM_ID but the item isn't a cdf id a
//     false positive will occur.
//
////////////////////////////////////////////////////////////////////////////////
BOOL
CDFIDL_IsValidId(
    PCDFITEMID pcdfid
)
{
    ASSERT(pcdfid);

    return (pcdfid->cb >= (sizeof(CDFITEMID) +  sizeof(TCHAR)) && 
            pcdfid->dwId == CDFITEMID_ID                       &&
            CDFIDL_IsValidSize(pcdfid)                         &&
            CDFIDL_IsValidType(pcdfid)                         &&
            CDFIDL_IsValidIndex(pcdfid)                        &&
            CDFIDL_IsValidStrings(pcdfid)                         );
}

inline
BOOL
CDFIDL_IsValidSize(
    PCDFITEMID pcdfid
)
{
    int cbName = (StrLen(CDFIDL_GetNameId(pcdfid)) + 1) * 
                 sizeof(TCHAR);

    int cbURL  = (StrLen(CDFIDL_GetURLId(pcdfid)) + 1) *
                 sizeof(TCHAR);

#ifndef ALIGNMENT_MACHINE
    return (sizeof(CDFITEMID) - sizeof(TCHAR) + cbName + cbURL == pcdfid->cb);
#else
    return ((ALIGN4(sizeof(CDFITEMID) - sizeof(TCHAR) + cbName + cbURL)) == pcdfid->cb);
#endif
}

inline
BOOL
CDFIDL_IsValidType(
    PCDFITEMID pcdfid
)
{
    return ((CDF_Folder     == (CDFITEMTYPE)pcdfid->cdfItemType) ||
            (CDF_Link       == (CDFITEMTYPE)pcdfid->cdfItemType) ||
            (CDF_FolderLink == (CDFITEMTYPE)pcdfid->cdfItemType)   );
}

inline
BOOL
CDFIDL_IsValidIndex(
    PCDFITEMID pcdfid
)
{
    return (  pcdfid->nIndex >= 0
            || 
              (INDEX_CHANNEL_LINK == pcdfid->nIndex &&
              CDF_FolderLink == (CDFITEMTYPE)pcdfid->cdfItemType));
}

inline
BOOL
CDFIDL_IsValidStrings(
    PCDFITEMID pcdfid
)
{
    //
    // REVIEW: Validate pidl strings.
    //

    return TRUE;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_IsFolder ***
//
//
// Description:
//     Inline function that returns TRUE if the given cdfidl is a folder as far
//     as the shel is concerned.
//
// Parameters:
//     pcdfidl - The cdf item id list to check.
//
// Return:
//     TRUE if the cdf item id list is a folder.
//
// Comments:
//
//
////////////////////////////////////////////////////////////////////////////////
BOOL
CDFIDL_IsFolder(
    PCDFITEMIDLIST pcdfidl
)
{
    ASSERT(CDFIDL_IsValid(pcdfidl));

    pcdfidl = (PCDFITEMIDLIST)ILFindLastID((LPITEMIDLIST)pcdfidl);

    return CDFIDL_IsFolderId(&pcdfidl->mkid);
}

BOOL
CDFIDL_IsFolderId(
    PCDFITEMID pcdfid
)
{
    ASSERT(CDFIDL_IsValidId(pcdfid));

    return (CDF_Folder == (CDFITEMTYPE)pcdfid->cdfItemType);
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//
// *** CDFIDL_NonCdfGetName ***
//
//
// Description:
//     Gets the name stored in the given non-cdf item id list.
//
// Parameters:
//     [In]  pcdfidl - A pointer to a cdf item id list.  Can be NULL.
//     [Out] pName - A pointer to a STRRET structure.  STRRET has the following
//                   structure:
//                       UINT uType             - STRRET_CSTR, _OFFSET or _WSTR
//                       union {
//                           LPWSTR pOleStr;
//                           UINT   uOffset;
//                           char   cStr[MAX_PATH];
//                       }
//
// Return:
//     S_OK on success.  E_Fail otherwise.
//
// Comments:
//     This function returns the name as a cString in the STRRET structure.
//
//     ILGetDisplayName returns the full path.  This function strips out the
//     filename sans extension.
//
////////////////////////////////////////////////////////////////////////////////
#if 0
HRESULT
CDFIDL_NonCdfGetDisplayName(
    LPCITEMIDLIST pidl,
    LPSTRRET pName
)
{
    ASSERT(pName);

    HRESULT hr;

    //
    // REVIEW:  Hack to get the name of a shell pidl.
    //

    if (ILGetDisplayName(pidl, pName->cStr))
    {
        TCHAR* p1 = pName->cStr;
        TCHAR* p2 = p1;

        while (*p1++);                          // Go to the end. 
        while (*--p1 != TEXT('\\'));            // Back to last backslash.
        while (TEXT('.') != (*p2++ = *++p1));   // Copy the name.
        *--p2 = TEXT('\0');                     // NULL terminate.

        pName->uType = STRRET_CSTR;

        hr = S_OK;
    }
    else
    {
        hr = E_FAIL;
    }

    return hr;
}
#endif