JAVAPROP.CPP

/*++ 
 
Copyright (c) 1996  Microsoft Corporation 
 
Module Name: 
 
    cresprop.cpp 
 
Abstract: 
 
    Implements the CEnumResourceJAVAPROPERTY class. 
 
--*/ 
 
#pragma hdrstop 
 
#include <windows.h> 
#include "javaprop.hpp" 
 
// Construct a new, empty property enumerator. 
 
CEnumJAVAPROPERTY::CEnumJAVAPROPERTY() 
{ 
    m_cRef = 1; 
 
    m_pPropList   = NULL; 
    m_pCurProp    = NULL; 
    m_cProperties = 0; 
} 
 
CEnumJAVAPROPERTY::~CEnumJAVAPROPERTY() 
{ 
    LPJAVAPROPLink pProp = m_pPropList; 
    LPJAVAPROPLink pPropTmp; 
     
    // Walk down the list of properties freeing each node. 
 
    while (pProp) 
    { 
        if (pProp->pszKey)   delete(pProp->pszKey); 
        if (pProp->pszValue) delete(pProp->pszValue); 
         
        pPropTmp = pProp; 
        pProp    = pProp->pNext; 
 
        delete(pPropTmp); 
    } 
} 
 
STDMETHODIMP 
CEnumJAVAPROPERTY::QueryInterface(REFIID riid, LPVOID *ppvObj) 
{ 
    HRESULT hr; 
 
    if (riid == IID_IEnumJAVAPROPERTY || riid == IID_IUnknown) { 
        *ppvObj = (LPENUMJAVAPROPERTY) this; 
        m_cRef++; 
        hr = S_OK; 
    } else { 
        *ppvObj = NULL; 
        hr = E_NOINTERFACE; 
    } 
 
    return hr; 
} 
 
STDMETHODIMP_(ULONG) 
CEnumJAVAPROPERTY::AddRef() 
{ 
    m_cRef++; 
 
    return m_cRef; 
} 
 
STDMETHODIMP_(ULONG) 
CEnumJAVAPROPERTY::Release() 
{ 
    m_cRef--; 
 
    if (m_cRef > 0) 
        return m_cRef; 
 
    delete this; 
    return 0; 
} 
 
STDMETHODIMP 
CEnumJAVAPROPERTY::Next(ULONG celt, LPJAVAPROPERTY rgelt, ULONG 
    *pceltFetched) 
{ 
    HRESULT hr; 
    ULONG celtFetched; 
 
    hr = S_OK; 
    celtFetched = 0; 
 
    while (hr == S_OK && celtFetched < celt) { 
 
        if (m_pCurProp == NULL) { 
            hr = S_FALSE; 
            break; 
        } 
 
        // Copy the value. 
 
        rgelt->pszValue = (LPOLESTR) 
            CoTaskMemAlloc((lstrlenW(m_pCurProp->pszValue) + 1) * 
            sizeof(OLECHAR)); 
 
        if (rgelt->pszValue != NULL) { 
            wcscpy(rgelt->pszValue, m_pCurProp->pszValue); 
        } else { 
            hr = E_OUTOFMEMORY; 
        } 
 
        // Copy the key. 
 
        if (hr == S_OK)  
        { 
 
            rgelt->pszKey = (LPOLESTR) 
                CoTaskMemAlloc((lstrlenW(m_pCurProp->pszKey) + 1) * 
                sizeof(OLECHAR)); 
 
            if (rgelt->pszKey != NULL) { 
 
                wcscpy(rgelt->pszKey, m_pCurProp->pszKey); 
 
                rgelt++; 
                m_pCurProp = m_pCurProp->pNext; 
                celtFetched++; 
 
            } else { 
                CoTaskMemFree(rgelt->pszValue); 
                hr = E_OUTOFMEMORY; 
            } 
        } 
    } 
 
    if (pceltFetched != NULL) 
        *pceltFetched = celtFetched; 
 
    return hr; 
} 
 
STDMETHODIMP 
CEnumJAVAPROPERTY::Skip(ULONG celt) 
{ 
    HRESULT hr = S_OK; 
 
    while ( celt > 0 ) 
    { 
        if ( m_pCurProp->pNext == NULL ) 
        { 
            hr = S_FALSE; 
            break; 
        } 
 
        m_pCurProp = m_pCurProp->pNext; 
        celt--; 
    } 
 
    return hr; 
} 
 
STDMETHODIMP 
CEnumJAVAPROPERTY::Reset() 
{ 
    m_pCurProp = m_pPropList; 
    return S_OK; 
} 
 
STDMETHODIMP 
CEnumJAVAPROPERTY::Clone(LPENUMJAVAPROPERTY *ppenum) 
{ 
    return E_NOTIMPL; 
} 
 
// Add a property to the list of properties.  The string parameter is 
// expected to be of the form <key>=<value>. 
 
BOOL CEnumJAVAPROPERTY::Add(char *pszKeyAndValue) 
{ 
    char *pszKey = pszKeyAndValue; 
    char *pszVal = pszKey; 
    int   cchUnicode; 
 
    if ( *pszKey == '\0' ) 
        return FALSE; 
 
    // Walk down the string looking for the '=' that seperates the key 
    // and value. 
    while ( *pszVal && *pszVal != '=' ) 
        pszVal++; 
 
    if ( *pszVal == '=' ) { 
       *pszVal = '\0'; 
       pszVal++; 
    } 
 
    // Create a new node for our linked list. 
    LPJAVAPROPLink pProp = new(JAVAPROPLink); 
 
    if ( !pProp ) 
        return FALSE; 
 
    // We want to keep track of the key and value strings as unicode.   
    // Convert them and stash them off into the property node. 
     
    // Convert the key. 
 
    cchUnicode = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pszKey, -1,  
                                     NULL, 0); 
 
    pProp->pszKey = new(OLECHAR[cchUnicode]); 
 
    if ( !pProp->pszKey ) 
    { 
        delete(pProp); 
        return FALSE; 
    } 
 
    MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,pszKey,-1,pProp->pszKey, 
                        cchUnicode); 
 
    // Convert the value. 
 
    cchUnicode = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pszVal,  
                                     -1, NULL, 0); 
 
    pProp->pszValue = new(OLECHAR[cchUnicode]); 
 
    if ( !pProp->pszValue ) 
    { 
        delete(pProp->pszKey); 
        delete(pProp); 
        return FALSE; 
    } 
 
    MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,pszVal,-1,pProp->pszValue, 
                        cchUnicode); 
 
    // Link the new node into the list. 
 
    pProp->pNext = m_pPropList; 
    m_pPropList  = pProp; 
    m_pCurProp   = m_pPropList; 
 
    return TRUE; 
}