msi: Free the column info data when updating the table column info.
[wine] / 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 };