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 #include "wine/unicode.h"
  24
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  28
  29 typedef struct IEnumRegFiltersImpl
  30 {
  31     const IEnumRegFiltersVtbl * lpVtbl;
  32     LONG refCount;
  33     ULONG size;
  34     REGFILTER* RegFilters;
  35     ULONG uIndex;
  36 } IEnumRegFiltersImpl;
  37
  38 static const struct IEnumRegFiltersVtbl IEnumRegFiltersImpl_Vtbl;
  39
  40 HRESULT IEnumRegFiltersImpl_Construct(REGFILTER* pInRegFilters, const ULONG size, IEnumRegFilters ** ppEnum)
  41 {
  42     IEnumRegFiltersImpl* pEnumRegFilters;
  43     REGFILTER* pRegFilters = NULL;
  44     unsigned int i;
  45
  46     TRACE("(%p, %d, %p)\n", pInRegFilters, size, ppEnum);
  47
  48     pEnumRegFilters = CoTaskMemAlloc(sizeof(IEnumRegFiltersImpl));
  49     if (!pEnumRegFilters)
  50     {
  51         *ppEnum = NULL;
  52         return E_OUTOFMEMORY;
  53     }
  54
  55     /* Accept size of 0 */
  56     if (size)
  57     {
  58         pRegFilters = CoTaskMemAlloc(sizeof(REGFILTER)*size);
  59         if (!pRegFilters)
  60         {
  61             CoTaskMemFree(pEnumRegFilters);
  62             *ppEnum = NULL;
  63            return E_OUTOFMEMORY;
  64         }
  65     }
  66
  67     for(i = 0; i < size; i++)
  68     {
  69         pRegFilters[i].Clsid = pInRegFilters[i].Clsid;
  70         pRegFilters[i].Name = CoTaskMemAlloc((strlenW(pInRegFilters[i].Name)+1)*sizeof(WCHAR));
  71         if (!pRegFilters[i].Name)
  72         {
  73             while(i)
  74                 CoTaskMemFree(pRegFilters[--i].Name);
  75             CoTaskMemFree(pRegFilters);
  76             CoTaskMemFree(pEnumRegFilters);
  77             return E_OUTOFMEMORY;
  78         }
  79         CopyMemory(pRegFilters[i].Name, pInRegFilters[i].Name, (strlenW(pInRegFilters[i].Name)+1)*sizeof(WCHAR));
  80     }
  81
  82     pEnumRegFilters->lpVtbl = &IEnumRegFiltersImpl_Vtbl;
  83     pEnumRegFilters->refCount = 1;
  84     pEnumRegFilters->uIndex = 0;
  85     pEnumRegFilters->RegFilters = pRegFilters;
  86     pEnumRegFilters->size = size;
  87
  88     *ppEnum = (IEnumRegFilters *)(&pEnumRegFilters->lpVtbl);
  89
  90     return S_OK;
  91 }
  92
  93 static HRESULT WINAPI IEnumRegFiltersImpl_QueryInterface(IEnumRegFilters * iface, REFIID riid, LPVOID * ppv)
  94 {
  95     TRACE("(%p)->(%s, %p)\n", iface, qzdebugstr_guid(riid), ppv);
  96
  97     *ppv = NULL;
  98
  99     if (IsEqualIID(riid, &IID_IUnknown))
 100         *ppv = iface;
 101     else if (IsEqualIID(riid, &IID_IEnumRegFilters))
 102         *ppv = iface;
 103
 104     if (*ppv)
 105     {
 106         IUnknown_AddRef((IUnknown *)(*ppv));
 107         return S_OK;
 108     }
 109
 110     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 111
 112     return E_NOINTERFACE;
 113 }
 114
 115 static ULONG WINAPI IEnumRegFiltersImpl_AddRef(IEnumRegFilters * iface)
 116 {
 117     IEnumRegFiltersImpl *This = (IEnumRegFiltersImpl *)iface;
 118     ULONG refCount = InterlockedIncrement(&This->refCount);
 119
 120     TRACE("(%p)\n", iface);
 121
 122     return refCount;
 123 }
 124
 125 static ULONG WINAPI IEnumRegFiltersImpl_Release(IEnumRegFilters * iface)
 126 {
 127     IEnumRegFiltersImpl *This = (IEnumRegFiltersImpl *)iface;
 128     ULONG refCount = InterlockedDecrement(&This->refCount);
 129
 130     TRACE("(%p)\n", iface);
 131
 132     if (!refCount)
 133     {
 134         ULONG i;
 135
 136         for(i = 0; i < This->size; i++)
 137         {
 138             CoTaskMemFree(This->RegFilters[i].Name);
 139         }
 140         CoTaskMemFree(This->RegFilters);
 141         CoTaskMemFree(This);
 142         return 0;
 143     } else
 144         return refCount;
 145 }
 146
 147 static HRESULT WINAPI IEnumRegFiltersImpl_Next(IEnumRegFilters * iface, ULONG cFilters, REGFILTER ** ppRegFilter, ULONG * pcFetched)
 148 {
 149     ULONG cFetched;
 150     IEnumRegFiltersImpl *This = (IEnumRegFiltersImpl *)iface;
 151     unsigned int i;
 152
 153     cFetched = min(This->size, This->uIndex + cFilters) - This->uIndex;
 154
 155     TRACE("(%p)->(%u, %p, %p)\n", iface, cFilters, ppRegFilter, pcFetched);
 156
 157     if (cFetched > 0)
 158     {
 159         for(i = 0; i < cFetched; i++)
 160         {
 161             /* The string in the REGFILTER structure must be allocated in the same block as the REGFILTER structure itself */
 162             ppRegFilter[i] = CoTaskMemAlloc(sizeof(REGFILTER)+(strlenW(This->RegFilters[This->uIndex + i].Name)+1)*sizeof(WCHAR));
 163             if (!ppRegFilter[i])
 164             {
 165                 while(i)
 166                 {
 167                     CoTaskMemFree(ppRegFilter[--i]);
 168                     ppRegFilter[i] = NULL;
 169                 }
 170                 return E_OUTOFMEMORY;
 171         }
 172             ppRegFilter[i]->Clsid = This->RegFilters[This->uIndex + i].Clsid;
 173             ppRegFilter[i]->Name = (WCHAR*)((char*)ppRegFilter[i]+sizeof(REGFILTER));
 174             CopyMemory(ppRegFilter[i]->Name, This->RegFilters[This->uIndex + i].Name,
 175                             (strlenW(This->RegFilters[This->uIndex + i].Name)+1)*sizeof(WCHAR));
 176         }
 177
 178         This->uIndex += cFetched;
 179         if (pcFetched)
 180             *pcFetched = cFetched;
 181         return S_OK;
 182     }
 183
 184     return S_FALSE;
 185 }
 186
 187 static HRESULT WINAPI IEnumRegFiltersImpl_Skip(IEnumRegFilters * iface, ULONG n)
 188 {
 189     TRACE("(%p)->(%u)\n", iface, n);
 190
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI IEnumRegFiltersImpl_Reset(IEnumRegFilters * iface)
 195 {
 196     IEnumRegFiltersImpl *This = (IEnumRegFiltersImpl *)iface;
 197
 198     TRACE("(%p)\n", iface);
 199
 200     This->uIndex = 0;
 201     return S_OK;
 202 }
 203
 204 static HRESULT WINAPI IEnumRegFiltersImpl_Clone(IEnumRegFilters * iface, IEnumRegFilters ** ppEnum)
 205 {
 206     TRACE("(%p)->(%p)\n", iface, ppEnum);
 207
 208     return E_NOTIMPL;
 209 }
 210
 211 static const IEnumRegFiltersVtbl IEnumRegFiltersImpl_Vtbl =
 212 {
 213     IEnumRegFiltersImpl_QueryInterface,
 214     IEnumRegFiltersImpl_AddRef,
 215     IEnumRegFiltersImpl_Release,
 216     IEnumRegFiltersImpl_Next,
 217     IEnumRegFiltersImpl_Skip,
 218     IEnumRegFiltersImpl_Reset,
 219     IEnumRegFiltersImpl_Clone
 220 };