avifil32: Don't leak the buffer on HeapReAlloc() failure in AVIFILE_AddFrame().
[wine] / dlls / comctl32 / dsa.c
1 /*
2  * Dynamic structure array (DSA) implementation
3  *
4  * Copyright 1998 Eric Kohl
5  *           1998 Juergen Schmied <j.schmied@metronet.de>
6  *           2000 Eric Kohl for CodeWeavers
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  *
22  * NOTES
23  *     These functions were involuntarily documented by Microsoft in 2002 as
24  *     the outcome of an anti-trust suit brought by various U.S. governments.
25  *     As a result the specifications on MSDN are inaccurate, incomplete 
26  *     and misleading. A much more complete (unofficial) documentation is
27  *     available at:
28  *
29  *     http://members.ozemail.com.au/~geoffch/samples/win32/shell/comctl32  
30  */
31
32 #include <stdarg.h>
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winuser.h"
37 #include "commctrl.h"
38
39 #include "comctl32.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(dsa);
43
44 struct _DSA
45 {
46     INT  nItemCount;
47     LPVOID pData;
48     INT  nMaxCount;
49     INT  nItemSize;
50     INT  nGrow;
51 };
52
53 /**************************************************************************
54  * DSA_Create [COMCTL32.320]
55  *
56  * Creates a dynamic storage array
57  *
58  * PARAMS
59  *     nSize [I] size of the array elements
60  *     nGrow [I] number of elements by which the array grows when it is filled
61  *
62  * RETURNS
63  *     Success: pointer to an array control structure. Use this like a handle.
64  *     Failure: NULL
65  *
66  * NOTES
67  *     The DSA_ functions can be used to create and manipulate arrays of
68  *     fixed-size memory blocks. These arrays can store any kind of data
69  *     (e.g. strings and icons).
70  */
71 HDSA WINAPI DSA_Create (INT nSize, INT nGrow)
72 {
73     HDSA hdsa;
74
75     TRACE("(size=%d grow=%d)\n", nSize, nGrow);
76
77     hdsa = Alloc (sizeof(*hdsa));
78     if (hdsa)
79     {
80         hdsa->nItemCount = 0;
81         hdsa->pData = NULL;
82         hdsa->nMaxCount = 0;
83         hdsa->nItemSize = nSize;
84         hdsa->nGrow = max(1, nGrow);
85     }
86
87     return hdsa;
88 }
89
90
91 /**************************************************************************
92  * DSA_Destroy [COMCTL32.321]
93  * 
94  * Destroys a dynamic storage array
95  *
96  * PARAMS
97  *     hdsa [I] pointer to the array control structure
98  *
99  * RETURNS
100  *     Success: TRUE
101  *     Failure: FALSE
102  */
103 BOOL WINAPI DSA_Destroy (const HDSA hdsa)
104 {
105     TRACE("(%p)\n", hdsa);
106
107     if (!hdsa)
108         return FALSE;
109
110     if (hdsa->pData && (!Free (hdsa->pData)))
111         return FALSE;
112
113     return Free (hdsa);
114 }
115
116
117 /**************************************************************************
118  * DSA_GetItem [COMCTL32.322]
119  *
120  * Copies the specified item into a caller-supplied buffer.
121  *
122  * PARAMS
123  *     hdsa   [I] pointer to the array control structure
124  *     nIndex [I] number of the Item to get
125  *     pDest  [O] destination buffer. Has to be >= dwElementSize.
126  *
127  * RETURNS
128  *     Success: TRUE
129  *     Failure: FALSE
130  */
131 BOOL WINAPI DSA_GetItem (const HDSA hdsa, INT nIndex, LPVOID pDest)
132 {
133     LPVOID pSrc;
134
135     TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
136
137     if (!hdsa)
138         return FALSE;
139     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
140         return FALSE;
141
142     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
143     memmove (pDest, pSrc, hdsa->nItemSize);
144
145     return TRUE;
146 }
147
148
149 /**************************************************************************
150  * DSA_GetItemPtr [COMCTL32.323]
151  *
152  * Retrieves a pointer to the specified item.
153  *
154  * PARAMS
155  *     hdsa   [I] pointer to the array control structure
156  *     nIndex [I] index of the desired item
157  *
158  * RETURNS
159  *     Success: pointer to an item
160  *     Failure: NULL
161  */
162 LPVOID WINAPI DSA_GetItemPtr (const HDSA hdsa, INT nIndex)
163 {
164     LPVOID pSrc;
165
166     TRACE("(%p %d)\n", hdsa, nIndex);
167
168     if (!hdsa)
169         return NULL;
170     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
171         return NULL;
172
173     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
174
175     TRACE("-- ret=%p\n", pSrc);
176
177     return pSrc;
178 }
179
180
181 /**************************************************************************
182  * DSA_SetItem [COMCTL32.325]
183  *
184  * Sets the contents of an item in the array.
185  *
186  * PARAMS
187  *     hdsa   [I] pointer to the array control structure
188  *     nIndex [I] index for the item
189  *     pSrc   [I] pointer to the new item data
190  *
191  * RETURNS
192  *     Success: TRUE
193  *     Failure: FALSE
194  */
195 BOOL WINAPI DSA_SetItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
196 {
197     INT  nSize, nNewItems;
198     LPVOID pDest, lpTemp;
199
200     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
201
202     if ((!hdsa) || nIndex < 0)
203         return FALSE;
204
205     if (hdsa->nItemCount <= nIndex) {
206         /* within the old array */
207         if (hdsa->nMaxCount > nIndex) {
208             /* within the allocated space, set a new boundary */
209             hdsa->nItemCount = nIndex + 1;
210         }
211         else {
212             /* resize the block of memory */
213             nNewItems =
214                 hdsa->nGrow * ((((nIndex + 1) - 1) / hdsa->nGrow) + 1);
215             nSize = hdsa->nItemSize * nNewItems;
216
217             lpTemp = ReAlloc (hdsa->pData, nSize);
218             if (!lpTemp)
219                 return FALSE;
220
221             hdsa->nMaxCount = nNewItems;
222             hdsa->nItemCount = nIndex + 1;
223             hdsa->pData = lpTemp;
224         }
225     }
226
227     /* put the new entry in */
228     pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
229     TRACE("-- move dest=%p src=%p size=%d\n",
230            pDest, pSrc, hdsa->nItemSize);
231     memmove (pDest, pSrc, hdsa->nItemSize);
232
233     return TRUE;
234 }
235
236
237 /**************************************************************************
238  * DSA_InsertItem [COMCTL32.324]
239  *
240  * Inserts an item into the array at the specified index.
241  *
242  * PARAMS
243  *     hdsa   [I] pointer to the array control structure
244  *     nIndex [I] index for the new item
245  *     pSrc   [I] pointer to the element
246  *
247  * RETURNS
248  *     Success: position of the new item
249  *     Failure: -1
250  */
251 INT WINAPI DSA_InsertItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
252 {
253     INT   nNewItems, nSize;
254     LPVOID  lpTemp, lpDest;
255
256     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
257
258     if ((!hdsa) || nIndex < 0)
259         return -1;
260
261     /* when nIndex >= nItemCount then append */
262     if (nIndex >= hdsa->nItemCount)
263          nIndex = hdsa->nItemCount;
264
265     /* do we need to resize ? */
266     if (hdsa->nItemCount >= hdsa->nMaxCount) {
267         nNewItems = hdsa->nMaxCount + hdsa->nGrow;
268         nSize = hdsa->nItemSize * nNewItems;
269
270         lpTemp = ReAlloc (hdsa->pData, nSize);
271         if (!lpTemp)
272             return -1;
273
274         hdsa->nMaxCount = nNewItems;
275         hdsa->pData = lpTemp;
276     }
277
278     /* do we need to move elements ? */
279     if (nIndex < hdsa->nItemCount) {
280         lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
281         lpDest = (char *) lpTemp + hdsa->nItemSize;
282         nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
283         TRACE("-- move dest=%p src=%p size=%d\n",
284                lpDest, lpTemp, nSize);
285         memmove (lpDest, lpTemp, nSize);
286     }
287
288     /* ok, we can put the new Item in */
289     hdsa->nItemCount++;
290     lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
291     TRACE("-- move dest=%p src=%p size=%d\n",
292            lpDest, pSrc, hdsa->nItemSize);
293     memmove (lpDest, pSrc, hdsa->nItemSize);
294
295     return nIndex;
296 }
297
298
299 /**************************************************************************
300  * DSA_DeleteItem [COMCTL32.326]
301  *
302  * Deletes the specified item from the array.
303  *
304  * PARAMS
305  *     hdsa   [I] pointer to the array control structure
306  *     nIndex [I] index for the element to delete
307  *
308  * RETURNS
309  *     Success: number of the deleted element
310  *     Failure: -1
311  */
312 INT WINAPI DSA_DeleteItem (const HDSA hdsa, INT nIndex)
313 {
314     LPVOID lpDest,lpSrc;
315     INT  nSize;
316
317     TRACE("(%p %d)\n", hdsa, nIndex);
318
319     if (!hdsa)
320         return -1;
321     if (nIndex < 0 || nIndex >= hdsa->nItemCount)
322         return -1;
323
324     /* do we need to move ? */
325     if (nIndex < hdsa->nItemCount - 1) {
326         lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
327         lpSrc = (char *) lpDest + hdsa->nItemSize;
328         nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
329         TRACE("-- move dest=%p src=%p size=%d\n",
330                lpDest, lpSrc, nSize);
331         memmove (lpDest, lpSrc, nSize);
332     }
333
334     hdsa->nItemCount--;
335
336     /* free memory ? */
337     if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
338         nSize = hdsa->nItemSize * hdsa->nItemCount;
339
340         lpDest = ReAlloc (hdsa->pData, nSize);
341         if (!lpDest)
342             return -1;
343
344         hdsa->nMaxCount = hdsa->nItemCount;
345         hdsa->pData = lpDest;
346     }
347
348     return nIndex;
349 }
350
351
352 /**************************************************************************
353  * DSA_DeleteAllItems [COMCTL32.327]
354  *
355  * Removes all items and reinitializes the array.
356  *
357  * PARAMS
358  *     hdsa [I] pointer to the array control structure
359  *
360  * RETURNS
361  *     Success: TRUE
362  *     Failure: FALSE
363  */
364 BOOL WINAPI DSA_DeleteAllItems (const HDSA hdsa)
365 {
366     TRACE("(%p)\n", hdsa);
367
368     if (!hdsa)
369         return FALSE;
370     if (hdsa->pData && (!Free (hdsa->pData)))
371         return FALSE;
372
373     hdsa->nItemCount = 0;
374     hdsa->pData = NULL;
375     hdsa->nMaxCount = 0;
376
377     return TRUE;
378 }
379
380
381 /**************************************************************************
382  * DSA_EnumCallback [COMCTL32.387]
383  *
384  * Enumerates all items in a dynamic storage array.
385  *
386  * PARAMS
387  *     hdsa     [I] handle to the dynamic storage array
388  *     enumProc [I]
389  *     lParam   [I]
390  *
391  * RETURNS
392  *     none
393  */
394 VOID WINAPI DSA_EnumCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
395                               LPVOID lParam)
396 {
397     INT i;
398
399     TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
400
401     if (!hdsa)
402         return;
403     if (hdsa->nItemCount <= 0)
404         return;
405
406     for (i = 0; i < hdsa->nItemCount; i++) {
407         LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
408         if ((enumProc)(lpItem, lParam) == 0)
409             return;
410     }
411
412     return;
413 }
414
415
416 /**************************************************************************
417  * DSA_DestroyCallback [COMCTL32.388]
418  *
419  * Enumerates all items in a dynamic storage array and destroys it.
420  *
421  * PARAMS
422  *     hdsa     [I] handle to the dynamic storage array
423  *     enumProc [I]
424  *     lParam   [I]
425  *
426  * RETURNS
427  *     none
428  */
429 void WINAPI DSA_DestroyCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
430                                  LPVOID lParam)
431 {
432     TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
433
434     DSA_EnumCallback (hdsa, enumProc, lParam);
435     DSA_Destroy (hdsa);
436 }