![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cenumpt.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / spoly|
Return to cenumpt.cpp CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / spoly |
1.1 ! root 1: /*** ! 2: *cenumpt.cpp ! 3: * ! 4: * Copyright (C) 1992-93, Microsoft Corporation. All Rights Reserved. ! 5: * ! 6: *Purpose: ! 7: * This module implements the CEnumPoint class. ! 8: * ! 9: * ! 10: *Implementation Notes: ! 11: * ! 12: *****************************************************************************/ ! 13: ! 14: #include "hostenv.h" ! 15: #include "cenumpt.h" ! 16: ! 17: ! 18: CEnumPoint::CEnumPoint() ! 19: { ! 20: m_refs = 0; ! 21: ! 22: m_psa = NULL; ! 23: m_celts = 0; ! 24: m_iCurrent = 0; ! 25: } ! 26: ! 27: ! 28: /*** ! 29: *HRESULT CEnumPoint::Create(SAFEARRAY*, CEnumPoint**) ! 30: *Purpose: ! 31: * This routine creates a CPoint enumerator from the given ! 32: * (1 X N) SafeArray of CPoint IDispatch pointers. ! 33: * ! 34: *Entry: ! 35: * psa = pointer to a SafeArray of VARIANTs ! 36: * ! 37: *Exit: ! 38: * return value = HRESULT ! 39: * ! 40: * *ppenum = pointer to a CPoint enumerator ! 41: * ! 42: ***********************************************************************/ ! 43: HRESULT ! 44: CEnumPoint::Create(SAFEARRAY FAR* psa, CEnumPoint FAR* FAR* ppenum) ! 45: { ! 46: long lBound; ! 47: HRESULT hresult; ! 48: CEnumPoint FAR* penum; ! 49: ! 50: ! 51: // Verify that the SafeArray is the proper shape. ! 52: // ! 53: if(SafeArrayGetDim(psa) != 1) ! 54: return ResultFromScode(E_INVALIDARG); ! 55: ! 56: hresult = SafeArrayGetLBound(psa, 1, &lBound); ! 57: if(FAILED(hresult)) ! 58: return hresult; ! 59: ! 60: if(lBound != 0) ! 61: return ResultFromScode(E_INVALIDARG); ! 62: ! 63: penum = new FAR CEnumPoint(); ! 64: if(penum == NULL) ! 65: return ResultFromScode(E_OUTOFMEMORY); ! 66: penum->AddRef(); ! 67: ! 68: hresult = SafeArrayGetUBound(psa, 1, &lBound); ! 69: if(FAILED(hresult)) ! 70: goto LError0; ! 71: ! 72: penum->m_psa = psa; ! 73: penum->m_celts = lBound + 1; ! 74: ! 75: *ppenum = penum; ! 76: ! 77: return NOERROR; ! 78: ! 79: LError0:; ! 80: penum->Release(); ! 81: ! 82: return hresult; ! 83: } ! 84: ! 85: ! 86: //--------------------------------------------------------------------- ! 87: // IUnknown methods ! 88: //--------------------------------------------------------------------- ! 89: ! 90: ! 91: STDMETHODIMP ! 92: CEnumPoint::QueryInterface(REFIID riid, void FAR* FAR* ppv) ! 93: { ! 94: if(riid != IID_IUnknown) ! 95: if(riid != IID_IEnumVARIANT) ! 96: return ResultFromScode(E_NOINTERFACE); ! 97: ! 98: *ppv = this; ! 99: AddRef(); ! 100: return NOERROR; ! 101: } ! 102: ! 103: ! 104: STDMETHODIMP_(unsigned long) ! 105: CEnumPoint::AddRef() ! 106: { ! 107: return ++m_refs; ! 108: } ! 109: ! 110: ! 111: STDMETHODIMP_(unsigned long) ! 112: CEnumPoint::Release() ! 113: { ! 114: if(--m_refs == 0){ ! 115: if(m_psa != NULL) ! 116: SafeArrayDestroy(m_psa); ! 117: delete this; ! 118: return 0; ! 119: } ! 120: return m_refs; ! 121: } ! 122: ! 123: ! 124: //--------------------------------------------------------------------- ! 125: // IEnumVARIANT methods ! 126: //--------------------------------------------------------------------- ! 127: ! 128: ! 129: /*** ! 130: *HRESULT CEnumPoint::Next(unsigned long, VARIANT*, unsigned long*) ! 131: *Purpose: ! 132: * Attempt to get the next 'celt' items in the enumeration sequence. ! 133: * ! 134: *Entry: ! 135: * celt = the number of elements to get ! 136: * ! 137: *Exit: ! 138: * return value = HRESULT ! 139: * S_OK ! 140: * S_FALSE - the end of the sequence was reached ! 141: * ! 142: * rgvar = array of the next 'celt' items ! 143: * *pceltFetched = count of the elements actually fetched. ! 144: * ! 145: ***********************************************************************/ ! 146: STDMETHODIMP ! 147: CEnumPoint::Next( ! 148: unsigned long celt, ! 149: VARIANT FAR* rgvar, ! 150: unsigned long FAR* pceltFetched) ! 151: { ! 152: long ix; ! 153: unsigned int i; ! 154: HRESULT hresult; ! 155: ! 156: ! 157: for(i = 0; i < celt; ++i) ! 158: VariantInit(&rgvar[i]); ! 159: ! 160: for(i = 0; i < celt; ++i){ ! 161: if(m_iCurrent == m_celts){ ! 162: hresult = ResultFromScode(S_FALSE); ! 163: goto LDone; ! 164: } ! 165: ! 166: ix = m_iCurrent++; ! 167: hresult = SafeArrayGetElement(m_psa, &ix, &rgvar[i]); ! 168: if(FAILED(hresult)) ! 169: goto LError0; ! 170: } ! 171: ! 172: hresult = NOERROR; ! 173: ! 174: LDone:; ! 175: *pceltFetched = i; ! 176: ! 177: return hresult; ! 178: ! 179: LError0:; ! 180: ! 181: for(i = 0; i < celt; ++i) ! 182: VariantClear(&rgvar[i]); ! 183: ! 184: return hresult; ! 185: } ! 186: ! 187: ! 188: /*** ! 189: *HRESULT CEnumPoint::Skip(unsigned long) ! 190: *Purpose: ! 191: * Attempt to skip over the next 'celt' elements in the enumeration ! 192: * sequence. ! 193: * ! 194: *Entry: ! 195: * celt = the count of elements to skip ! 196: * ! 197: *Exit: ! 198: * return value = HRESULT ! 199: * S_OK ! 200: * S_FALSE - the end of the sequence was reached ! 201: * ! 202: ***********************************************************************/ ! 203: STDMETHODIMP ! 204: CEnumPoint::Skip(unsigned long celt) ! 205: { ! 206: m_iCurrent += celt; ! 207: ! 208: if(m_iCurrent > m_celts) ! 209: m_iCurrent = m_celts; ! 210: ! 211: return (m_iCurrent == m_celts) ! 212: ? ResultFromScode(S_FALSE) : NOERROR; ! 213: } ! 214: ! 215: ! 216: /*** ! 217: *HRESULT CEnumPoint::Reset(void) ! 218: *Purpose: ! 219: * Reset the enumeration sequence back to the beginning. ! 220: * ! 221: *Entry: ! 222: * None ! 223: * ! 224: *Exit: ! 225: * return value = SHRESULT CODE ! 226: * S_OK ! 227: * ! 228: ***********************************************************************/ ! 229: STDMETHODIMP ! 230: CEnumPoint::Reset() ! 231: { ! 232: m_iCurrent = 0; ! 233: ! 234: return NOERROR; ! 235: } ! 236: ! 237: ! 238: /*** ! 239: *HRESULT CEnumPoint::Clone(IEnumVARIANT**) ! 240: *Purpose: ! 241: * Retrun a CPoint enumerator with exactly the same state as the ! 242: * current one. ! 243: * ! 244: *Entry: ! 245: * None ! 246: * ! 247: *Exit: ! 248: * return value = HRESULT ! 249: * S_OK ! 250: * E_OUTOFMEMORY ! 251: * ! 252: ***********************************************************************/ ! 253: STDMETHODIMP ! 254: CEnumPoint::Clone(IEnumVARIANT FAR* FAR* ppenum) ! 255: { ! 256: HRESULT hresult; ! 257: SAFEARRAY FAR* psa; ! 258: CEnumPoint FAR* penum; ! 259: ! 260: hresult = SafeArrayCopy(m_psa, &psa); ! 261: if(FAILED(hresult)) ! 262: return hresult; ! 263: ! 264: hresult = CEnumPoint::Create(psa, &penum); ! 265: if(FAILED(hresult)) ! 266: goto LError0; ! 267: ! 268: // Assert(penum->m_celts == m_celts); ! 269: ! 270: penum->m_iCurrent = m_iCurrent; ! 271: ! 272: *ppenum = penum; ! 273: ! 274: return NOERROR; ! 275: ! 276: LError0: ! 277: SafeArrayDestroy(psa); ! 278: ! 279: return hresult; ! 280: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.