Return to enumfetc.c CVS log

Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui

Annotation of mstools/ole20/samples/ole2ui/enumfetc.c, revision 1.1

1.1     ! root        1: /*************************************************************************
        !             2: ** 
        !             3: **    OLE 2 Utility Code
        !             4: **    
        !             5: **    enumfetc.c
        !             6: **    
        !             7: **    This file contains a standard implementation of IEnumFormatEtc
        !             8: **    interface.  
        !             9: **    This file is part of the OLE 2.0 User Interface support library.
        !            10: **    
        !            11: **    (c) Copyright Microsoft Corp. 1990 - 1992 All Rights Reserved
        !            12: **
        !            13: *************************************************************************/
        !            14: 
        !            15: #define STRICT  1
        !            16: #include "ole2ui.h"
        !            17: #include "enumfetc.h"
        !            18: 
        !            19: 
        !            20: typedef struct tagOleStdEnumFmtEtc {
        !            21:   IEnumFORMATETCVtbl FAR* lpVtbl;
        !            22:   ULONG m_dwRefs;       /* referance count */
        !            23:   ULONG m_nIndex;       /* current index in list */
        !            24:   ULONG m_nCount;       /* how many items in list */
        !            25:   LPFORMATETC m_lpEtc;  /* list of formatetc */
        !            26: } OLESTDENUMFMTETC, FAR* LPOLESTDENUMFMTETC;
        !            27: 
        !            28: VOID  OleStdEnumFmtEtc_Destroy(LPOLESTDENUMFMTETC pEtc);
        !            29: 
        !            30: STDMETHODIMP OleStdEnumFmtEtc_QueryInterface(
        !            31:         LPENUMFORMATETC lpThis, REFIID riid, LPVOID FAR* ppobj);
        !            32: STDMETHODIMP_(ULONG)  OleStdEnumFmtEtc_AddRef(LPENUMFORMATETC lpThis);
        !            33: STDMETHODIMP_(ULONG)  OleStdEnumFmtEtc_Release(LPENUMFORMATETC lpThis);
        !            34: STDMETHODIMP  OleStdEnumFmtEtc_Next(LPENUMFORMATETC lpThis, ULONG celt,
        !            35:                                   LPFORMATETC rgelt, ULONG FAR* pceltFetched);
        !            36: STDMETHODIMP  OleStdEnumFmtEtc_Skip(LPENUMFORMATETC lpThis, ULONG celt);
        !            37: STDMETHODIMP  OleStdEnumFmtEtc_Reset(LPENUMFORMATETC lpThis);
        !            38: STDMETHODIMP  OleStdEnumFmtEtc_Clone(LPENUMFORMATETC lpThis,
        !            39:                                      LPENUMFORMATETC FAR* ppenum);
        !            40:                        
        !            41: static IEnumFORMATETCVtbl g_EnumFORMATETCVtbl = {
        !            42:         OleStdEnumFmtEtc_QueryInterface,
        !            43:         OleStdEnumFmtEtc_AddRef,
        !            44:         OleStdEnumFmtEtc_Release,
        !            45:         OleStdEnumFmtEtc_Next,
        !            46:         OleStdEnumFmtEtc_Skip,
        !            47:         OleStdEnumFmtEtc_Reset,
        !            48:         OleStdEnumFmtEtc_Clone,
        !            49: };
        !            50: 
        !            51: /////////////////////////////////////////////////////////////////////////////
        !            52: 
        !            53:         
        !            54: STDAPI_(LPENUMFORMATETC)        
        !            55:   OleStdEnumFmtEtc_Create(ULONG nCount, LPFORMATETC lpEtc)
        !            56: //----------------------------------------------------------------------------
        !            57: //
        !            58: //----------------------------------------------------------------------------
        !            59: {
        !            60:   LPMALLOC lpMalloc=NULL;
        !            61:   LPOLESTDENUMFMTETC lpEF=NULL;
        !            62:   DWORD dwSize;
        !            63:   WORD i;
        !            64:   HRESULT hRes;
        !            65: 
        !            66:   hRes = CoGetMalloc(MEMCTX_TASK, &lpMalloc);
        !            67:   if (hRes != NOERROR) {
        !            68:     return NULL;
        !            69:   }
        !            70: 
        !            71:   lpEF = (LPOLESTDENUMFMTETC)lpMalloc->lpVtbl->Alloc(lpMalloc,
        !            72:                                                  sizeof(OLESTDENUMFMTETC));
        !            73:   if (lpEF == NULL) {
        !            74:     goto errReturn;
        !            75:   }
        !            76: 
        !            77:   lpEF->lpVtbl = &g_EnumFORMATETCVtbl;
        !            78:   lpEF->m_dwRefs = 1;
        !            79:   lpEF->m_nCount = nCount;
        !            80:   lpEF->m_nIndex = 0;
        !            81:   
        !            82:   dwSize = sizeof(FORMATETC) * lpEF->m_nCount;
        !            83: 
        !            84:   lpEF->m_lpEtc = (LPFORMATETC)lpMalloc->lpVtbl->Alloc(lpMalloc, dwSize);
        !            85:   if (lpEF->m_lpEtc == NULL) {
        !            86:     goto errReturn;
        !            87:   }
        !            88: 
        !            89:   for (i=0; i<nCount; i++) {
        !            90:     OleStdCopyFormatEtc(
        !            91:             (LPFORMATETC)&(lpEF->m_lpEtc[i]), (LPFORMATETC)&(lpEtc[i]));
        !            92:   }
        !            93: 
        !            94:   return (LPENUMFORMATETC)lpEF;
        !            95:   
        !            96: errReturn:
        !            97:   if (lpEF != NULL) {
        !            98:     lpMalloc->lpVtbl->Free(lpMalloc, lpEF);
        !            99:   }
        !           100:   
        !           101:   if (lpMalloc != NULL) {
        !           102:     lpMalloc->lpVtbl->Release(lpMalloc);
        !           103:   }
        !           104:   
        !           105:   return NULL;
        !           106: 
        !           107: } /* OleStdEnumFmtEtc_Create()
        !           108:    */
        !           109: 
        !           110: 
        !           111: VOID
        !           112:   OleStdEnumFmtEtc_Destroy(LPOLESTDENUMFMTETC lpEF)
        !           113: //----------------------------------------------------------------------------
        !           114: // 
        !           115: //----------------------------------------------------------------------------
        !           116: {
        !           117:     LPMALLOC lpMalloc=NULL;
        !           118:     WORD i;
        !           119: 
        !           120:     if (lpEF != NULL) {
        !           121: 
        !           122:         if (CoGetMalloc(MEMCTX_TASK, &lpMalloc) == NOERROR) {
        !           123: 
        !           124:             /* OLE2NOTE: we MUST free any memory that was allocated for
        !           125:             **    TARGETDEVICES contained within the FORMATETC elements.
        !           126:             */
        !           127:             for (i=0; i<lpEF->m_nCount; i++) {
        !           128:                 OleStdFree(lpEF->m_lpEtc[i].ptd);
        !           129:             }
        !           130: 
        !           131:             if (lpEF->m_lpEtc != NULL) {
        !           132:                 lpMalloc->lpVtbl->Free(lpMalloc, lpEF->m_lpEtc);
        !           133:             }
        !           134: 
        !           135:             lpMalloc->lpVtbl->Free(lpMalloc, lpEF);
        !           136:             lpMalloc->lpVtbl->Release(lpMalloc);
        !           137:         }
        !           138:     }
        !           139: } /* OleStdEnumFmtEtc_Destroy()
        !           140:    */
        !           141: 
        !           142: 
        !           143: STDMETHODIMP
        !           144:   OleStdEnumFmtEtc_QueryInterface(
        !           145:                 LPENUMFORMATETC lpThis, REFIID riid, LPVOID FAR* ppobj)
        !           146: //----------------------------------------------------------------------------
        !           147: //
        !           148: //----------------------------------------------------------------------------
        !           149: {
        !           150:   LPOLESTDENUMFMTETC lpEF = (LPOLESTDENUMFMTETC)lpThis;
        !           151:   *ppobj = NULL;
        !           152:   
        !           153:   if (IsEqualIID(riid,&IID_IUnknown) || IsEqualIID(riid,&IID_IEnumFORMATETC)){
        !           154:     *ppobj = (LPVOID)lpEF;
        !           155:   }
        !           156: 
        !           157:   if (*ppobj == NULL) return ResultFromScode(S_FALSE);
        !           158:   else{
        !           159:     OleStdEnumFmtEtc_AddRef(lpThis);
        !           160:     return NOERROR;
        !           161:   }
        !           162:   
        !           163: } /* OleStdEnumFmtEtc_QueryInterface()
        !           164:    */
        !           165: 
        !           166: 
        !           167: STDMETHODIMP_(ULONG)
        !           168:   OleStdEnumFmtEtc_AddRef(LPENUMFORMATETC lpThis)
        !           169: //----------------------------------------------------------------------------
        !           170: //
        !           171: //----------------------------------------------------------------------------
        !           172: {
        !           173:   LPOLESTDENUMFMTETC lpEF = (LPOLESTDENUMFMTETC)lpThis;
        !           174:   return lpEF->m_dwRefs++;
        !           175: 
        !           176: } /* OleStdEnumFmtEtc_AddRef()
        !           177:    */
        !           178: 
        !           179: 
        !           180: STDMETHODIMP_(ULONG)
        !           181:   OleStdEnumFmtEtc_Release(LPENUMFORMATETC lpThis)
        !           182: //----------------------------------------------------------------------------
        !           183: //
        !           184: //----------------------------------------------------------------------------
        !           185: {
        !           186:   LPOLESTDENUMFMTETC lpEF = (LPOLESTDENUMFMTETC)lpThis;
        !           187:   DWORD dwRefs = --lpEF->m_dwRefs;
        !           188: 
        !           189:   if (dwRefs == 0) 
        !           190:     OleStdEnumFmtEtc_Destroy(lpEF);
        !           191: 
        !           192:   return dwRefs;
        !           193: 
        !           194: } /* OleStdEnumFmtEtc_Release()
        !           195:    */
        !           196: 
        !           197: 
        !           198: STDMETHODIMP 
        !           199:   OleStdEnumFmtEtc_Next(LPENUMFORMATETC lpThis, ULONG celt, LPFORMATETC rgelt,
        !           200:                       ULONG FAR* pceltFetched)
        !           201: //----------------------------------------------------------------------------
        !           202: //
        !           203: //----------------------------------------------------------------------------
        !           204: {
        !           205:   LPOLESTDENUMFMTETC lpEF = (LPOLESTDENUMFMTETC)lpThis;
        !           206:   ULONG i=0;
        !           207:   ULONG nOffset;
        !           208: 
        !           209:   if (rgelt == NULL) {
        !           210:     return ResultFromScode(E_INVALIDARG);
        !           211:   }
        !           212:   
        !           213:   while (i < celt) {
        !           214:     nOffset = lpEF->m_nIndex + i;
        !           215: 
        !           216:     if (nOffset < lpEF->m_nCount) {
        !           217:       OleStdCopyFormatEtc(
        !           218:             (LPFORMATETC)&(rgelt[i]), (LPFORMATETC)&(lpEF->m_lpEtc[nOffset]));
        !           219:       i++;
        !           220:     }else{
        !           221:       break;
        !           222:     }
        !           223:   }
        !           224: 
        !           225:   lpEF->m_nIndex += (WORD)i;
        !           226:   
        !           227:   if (pceltFetched != NULL) {
        !           228:     *pceltFetched = i;
        !           229:   }
        !           230: 
        !           231:   if (i != celt) {
        !           232:     return ResultFromScode(S_FALSE);
        !           233:   }
        !           234: 
        !           235:   return NOERROR;
        !           236: } /* OleStdEnumFmtEtc_Next()
        !           237:    */
        !           238: 
        !           239: 
        !           240: STDMETHODIMP 
        !           241:   OleStdEnumFmtEtc_Skip(LPENUMFORMATETC lpThis, ULONG celt)
        !           242: //----------------------------------------------------------------------------
        !           243: //
        !           244: //----------------------------------------------------------------------------
        !           245: {
        !           246:   LPOLESTDENUMFMTETC lpEF = (LPOLESTDENUMFMTETC)lpThis;
        !           247:   ULONG i=0;
        !           248:   ULONG nOffset;
        !           249: 
        !           250:   while (i < celt) {
        !           251:     nOffset = lpEF->m_nIndex + i;
        !           252: 
        !           253:     if (nOffset < lpEF->m_nCount) {
        !           254:       i++;
        !           255:     }else{
        !           256:       break;
        !           257:     }
        !           258:   }
        !           259: 
        !           260:   lpEF->m_nIndex += (WORD)i;
        !           261: 
        !           262:   if (i != celt) {
        !           263:     return ResultFromScode(S_FALSE);
        !           264:   }
        !           265: 
        !           266:   return NOERROR;
        !           267: } /* OleStdEnumFmtEtc_Skip()
        !           268:    */
        !           269: 
        !           270: 
        !           271: STDMETHODIMP 
        !           272:   OleStdEnumFmtEtc_Reset(LPENUMFORMATETC lpThis)
        !           273: //----------------------------------------------------------------------------
        !           274: //
        !           275: //----------------------------------------------------------------------------
        !           276: {
        !           277:   LPOLESTDENUMFMTETC lpEF = (LPOLESTDENUMFMTETC)lpThis;
        !           278:   lpEF->m_nIndex = 0;
        !           279: 
        !           280:   return NOERROR;
        !           281: } /* OleStdEnumFmtEtc_Reset()
        !           282:    */
        !           283: 
        !           284: 
        !           285: STDMETHODIMP 
        !           286:   OleStdEnumFmtEtc_Clone(LPENUMFORMATETC lpThis, LPENUMFORMATETC FAR* ppenum)
        !           287: //----------------------------------------------------------------------------
        !           288: //
        !           289: //----------------------------------------------------------------------------
        !           290: {
        !           291:   LPOLESTDENUMFMTETC lpEF = (LPOLESTDENUMFMTETC)lpThis;
        !           292: 
        !           293:   if (ppenum == NULL) {
        !           294:     return ResultFromScode(E_INVALIDARG);
        !           295:   }
        !           296:   
        !           297:   *ppenum = OleStdEnumFmtEtc_Create(lpEF->m_nCount, lpEF->m_lpEtc);
        !           298: 
        !           299:   return (*ppenum != NULL ? NOERROR : ResultFromScode(E_OUTOFMEMORY));
        !           300: 
        !           301: } /* OleStdEnumFmtEtc_Clone()
        !           302:    */
        !           303: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.