dlls/quartz/enumregfilters.c

   1 /*
   2  * Implementation of IEnumRegFilters Interface
   3  *
   4  * Copyright 2004 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "quartz_private.h"
  22
  23
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  27
  28 typedef struct IEnumRegFiltersImpl
  29 {
  30     IEnumRegFilters IEnumRegFilters_iface;
  31     LONG refCount;
  32     ULONG size;
  33     REGFILTER* RegFilters;
  34     ULONG uIndex;
  35 } IEnumRegFiltersImpl;
  36
  37 static inline IEnumRegFiltersImpl *impl_from_IEnumRegFilters(IEnumRegFilters *iface)
  38 {
  39     return CONTAINING_RECORD(iface, IEnumRegFiltersImpl, IEnumRegFilters_iface);
  40 }
  41
  42 static const struct IEnumRegFiltersVtbl IEnumRegFiltersImpl_Vtbl;
  43
  44 HRESULT IEnumRegFiltersImpl_Construct(REGFILTER* pInRegFilters, const ULONG size, IEnumRegFilters ** ppEnum)
  45 {
  46     IEnumRegFiltersImpl* pEnumRegFilters;
  47     REGFILTER* pRegFilters = NULL;
  48     unsigned int i;
  49
  50     TRACE("(%p, %d, %p)\n", pInRegFilters, size, ppEnum);
  51
  52     pEnumRegFilters = CoTaskMemAlloc(sizeof(IEnumRegFiltersImpl));
  53     if (!pEnumRegFilters)
  54     {
  55         *ppEnum = NULL;
  56         return E_OUTOFMEMORY;
  57     }
  58
  59     /* Accept size of 0 */
  60     if (size)
  61     {
  62         pRegFilters = CoTaskMemAlloc(sizeof(REGFILTER)*size);
  63         if (!pRegFilters)
  64         {
  65             CoTaskMemFree(pEnumRegFilters);
  66             *ppEnum = NULL;
  67            return E_OUTOFMEMORY;
  68         }
  69     }
  70
  71     for(i = 0; i < size; i++)
  72     {
  73         pRegFilters[i].Clsid = pInRegFilters[i].Clsid;
  74         pRegFilters[i].Name = CoTaskMemAlloc((lstrlenW(pInRegFilters[i].Name)+1)*sizeof(WCHAR));
  75         if (!pRegFilters[i].Name)
  76         {
  77             while(i)
  78                 CoTaskMemFree(pRegFilters[--i].Name);
  79             CoTaskMemFree(pRegFilters);
  80             CoTaskMemFree(pEnumRegFilters);
  81             return E_OUTOFMEMORY;
  82         }
  83         CopyMemory(pRegFilters[i].Name, pInRegFilters[i].Name, (lstrlenW(pInRegFilters[i].Name)+1)*sizeof(WCHAR));
  84     }
  85
  86     pEnumRegFilters->IEnumRegFilters_iface.lpVtbl = &IEnumRegFiltersImpl_Vtbl;
  87     pEnumRegFilters->refCount = 1;
  88     pEnumRegFilters->uIndex = 0;
  89     pEnumRegFilters->RegFilters = pRegFilters;
  90     pEnumRegFilters->size = size;
  91
  92     *ppEnum = &pEnumRegFilters->IEnumRegFilters_iface;
  93
  94     return S_OK;
  95 }
  96
  97 static HRESULT WINAPI IEnumRegFiltersImpl_QueryInterface(IEnumRegFilters * iface, REFIID riid, LPVOID * ppv)
  98 {
  99     TRACE("(%p)->(%s, %p)\n", iface, qzdebugstr_guid(riid), ppv);
 100
 101     *ppv = NULL;
 102
 103     if (IsEqualIID(riid, &IID_IUnknown))
 104         *ppv = iface;
 105     else if (IsEqualIID(riid, &IID_IEnumRegFilters))
 106         *ppv = iface;
 107
 108     if (*ppv)
 109     {
 110         IUnknown_AddRef((IUnknown *)(*ppv));
 111         return S_OK;
 112     }
 113
 114     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 115
 116     return E_NOINTERFACE;
 117 }
 118
 119 static ULONG WINAPI IEnumRegFiltersImpl_AddRef(IEnumRegFilters * iface)
 120 {
 121     IEnumRegFiltersImpl *This = impl_from_IEnumRegFilters(iface);
 122     ULONG refCount = InterlockedIncrement(&This->refCount);
 123
 124     TRACE("(%p)\n", iface);
 125
 126     return refCount;
 127 }
 128
 129 static ULONG WINAPI IEnumRegFiltersImpl_Release(IEnumRegFilters * iface)
 130 {
 131     IEnumRegFiltersImpl *This = impl_from_IEnumRegFilters(iface);
 132     ULONG refCount = InterlockedDecrement(&This->refCount);
 133
 134     TRACE("(%p)\n", iface);
 135
 136     if (!refCount)
 137     {
 138         ULONG i;
 139
 140         for(i = 0; i < This->size; i++)
 141         {
 142             CoTaskMemFree(This->RegFilters[i].Name);
 143         }
 144         CoTaskMemFree(This->RegFilters);
 145         CoTaskMemFree(This);
 146         return 0;
 147     } else
 148         return refCount;
 149 }
 150
 151 static HRESULT WINAPI IEnumRegFiltersImpl_Next(IEnumRegFilters * iface, ULONG cFilters, REGFILTER ** ppRegFilter, ULONG * pcFetched)
 152 {
 153     ULONG cFetched;
 154     IEnumRegFiltersImpl *This = impl_from_IEnumRegFilters(iface);
 155     unsigned int i;
 156
 157     cFetched = min(This->size, This->uIndex + cFilters) - This->uIndex;
 158
 159     TRACE("(%p)->(%u, %p, %p)\n", iface, cFilters, ppRegFilter, pcFetched);
 160
 161     if (cFetched > 0)
 162     {
 163         for(i = 0; i < cFetched; i++)
 164         {
 165             /* The string in the REGFILTER structure must be allocated in the same block as the REGFILTER structure itself */
 166             ppRegFilter[i] = CoTaskMemAlloc(sizeof(REGFILTER)+(lstrlenW(This->RegFilters[This->uIndex + i].Name)+1)*sizeof(WCHAR));
 167             if (!ppRegFilter[i])
 168             {
 169                 while(i)
 170                 {
 171                     CoTaskMemFree(ppRegFilter[--i]);
 172                     ppRegFilter[i] = NULL;
 173                 }
 174                 return E_OUTOFMEMORY;
 175         }
 176             ppRegFilter[i]->Clsid = This->RegFilters[This->uIndex + i].Clsid;
 177             ppRegFilter[i]->Name = (WCHAR*)((char*)ppRegFilter[i]+sizeof(REGFILTER));
 178             CopyMemory(ppRegFilter[i]->Name, This->RegFilters[This->uIndex + i].Name,
 179                             (lstrlenW(This->RegFilters[This->uIndex + i].Name)+1)*sizeof(WCHAR));
 180         }
 181
 182         This->uIndex += cFetched;
 183         if (pcFetched)
 184             *pcFetched = cFetched;
 185         return S_OK;
 186     }
 187
 188     return S_FALSE;
 189 }
 190
 191 static HRESULT WINAPI IEnumRegFiltersImpl_Skip(IEnumRegFilters * iface, ULONG n)
 192 {
 193     TRACE("(%p)->(%u)\n", iface, n);
 194
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI IEnumRegFiltersImpl_Reset(IEnumRegFilters * iface)
 199 {
 200     IEnumRegFiltersImpl *This = impl_from_IEnumRegFilters(iface);
 201
 202     TRACE("(%p)\n", iface);
 203
 204     This->uIndex = 0;
 205     return S_OK;
 206 }
 207
 208 static HRESULT WINAPI IEnumRegFiltersImpl_Clone(IEnumRegFilters * iface, IEnumRegFilters ** ppEnum)
 209 {
 210     TRACE("(%p)->(%p)\n", iface, ppEnum);
 211
 212     return E_NOTIMPL;
 213 }
 214
 215 static const IEnumRegFiltersVtbl IEnumRegFiltersImpl_Vtbl =
 216 {
 217     IEnumRegFiltersImpl_QueryInterface,
 218     IEnumRegFiltersImpl_AddRef,
 219     IEnumRegFiltersImpl_Release,
 220     IEnumRegFiltersImpl_Next,
 221     IEnumRegFiltersImpl_Skip,
 222     IEnumRegFiltersImpl_Reset,
 223     IEnumRegFiltersImpl_Clone
 224 };