configure: Changes from running autconf after previous patch.
[wine/hacks.git] / dlls / comctl32 / dsa.c
blob13f63e23de4d156266d64cdffe47a1d7b8bda379
1 /*
2 * Dynamic structure array (DSA) implementation
4 * Copyright 1998 Eric Kohl
5 * 1998 Juergen Schmied <j.schmied@metronet.de>
6 * 2000 Eric Kohl for CodeWeavers
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.
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.
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
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:
29 * http://members.ozemail.com.au/~geoffch/samples/win32/shell/comctl32
32 #include <stdarg.h>
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winuser.h"
37 #include "commctrl.h"
39 #include "comctl32.h"
40 #include "wine/debug.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(dsa);
44 struct _DSA
46 INT nItemCount;
47 LPVOID pData;
48 INT nMaxCount;
49 INT nItemSize;
50 INT nGrow;
53 /**************************************************************************
54 * DSA_Create [COMCTL32.320]
56 * Creates a dynamic storage array
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
62 * RETURNS
63 * Success: pointer to an array control structure. Use this like a handle.
64 * Failure: NULL
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).
71 HDSA WINAPI DSA_Create (INT nSize, INT nGrow)
73 HDSA hdsa;
75 TRACE("(size=%d grow=%d)\n", nSize, nGrow);
77 hdsa = Alloc (sizeof(*hdsa));
78 if (hdsa)
80 hdsa->nItemCount = 0;
81 hdsa->pData = NULL;
82 hdsa->nMaxCount = 0;
83 hdsa->nItemSize = nSize;
84 hdsa->nGrow = max(1, nGrow);
87 return hdsa;
91 /**************************************************************************
92 * DSA_Destroy [COMCTL32.321]
94 * Destroys a dynamic storage array
96 * PARAMS
97 * hdsa [I] pointer to the array control structure
99 * RETURNS
100 * Success: TRUE
101 * Failure: FALSE
103 BOOL WINAPI DSA_Destroy (const HDSA hdsa)
105 TRACE("(%p)\n", hdsa);
107 if (!hdsa)
108 return FALSE;
110 if (hdsa->pData && (!Free (hdsa->pData)))
111 return FALSE;
113 return Free (hdsa);
117 /**************************************************************************
118 * DSA_GetItem [COMCTL32.322]
120 * Copies the specified item into a caller-supplied buffer.
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.
127 * RETURNS
128 * Success: TRUE
129 * Failure: FALSE
131 BOOL WINAPI DSA_GetItem (const HDSA hdsa, INT nIndex, LPVOID pDest)
133 LPVOID pSrc;
135 TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
137 if (!hdsa)
138 return FALSE;
139 if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
140 return FALSE;
142 pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
143 memmove (pDest, pSrc, hdsa->nItemSize);
145 return TRUE;
149 /**************************************************************************
150 * DSA_GetItemPtr [COMCTL32.323]
152 * Retrieves a pointer to the specified item.
154 * PARAMS
155 * hdsa [I] pointer to the array control structure
156 * nIndex [I] index of the desired item
158 * RETURNS
159 * Success: pointer to an item
160 * Failure: NULL
162 LPVOID WINAPI DSA_GetItemPtr (const HDSA hdsa, INT nIndex)
164 LPVOID pSrc;
166 TRACE("(%p %d)\n", hdsa, nIndex);
168 if (!hdsa)
169 return NULL;
170 if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
171 return NULL;
173 pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
175 TRACE("-- ret=%p\n", pSrc);
177 return pSrc;
181 /**************************************************************************
182 * DSA_SetItem [COMCTL32.325]
184 * Sets the contents of an item in the array.
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
191 * RETURNS
192 * Success: TRUE
193 * Failure: FALSE
195 BOOL WINAPI DSA_SetItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
197 INT nSize, nNewItems;
198 LPVOID pDest, lpTemp;
200 TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
202 if ((!hdsa) || nIndex < 0)
203 return FALSE;
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;
211 else {
212 /* resize the block of memory */
213 nNewItems =
214 hdsa->nGrow * ((((nIndex + 1) - 1) / hdsa->nGrow) + 1);
215 nSize = hdsa->nItemSize * nNewItems;
217 lpTemp = ReAlloc (hdsa->pData, nSize);
218 if (!lpTemp)
219 return FALSE;
221 hdsa->nMaxCount = nNewItems;
222 hdsa->nItemCount = nIndex + 1;
223 hdsa->pData = lpTemp;
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);
233 return TRUE;
237 /**************************************************************************
238 * DSA_InsertItem [COMCTL32.324]
240 * Inserts an item into the array at the specified index.
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
247 * RETURNS
248 * Success: position of the new item
249 * Failure: -1
251 INT WINAPI DSA_InsertItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
253 INT nNewItems, nSize;
254 LPVOID lpTemp, lpDest;
256 TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
258 if ((!hdsa) || nIndex < 0)
259 return -1;
261 /* when nIndex >= nItemCount then append */
262 if (nIndex >= hdsa->nItemCount)
263 nIndex = hdsa->nItemCount;
265 /* do we need to resize ? */
266 if (hdsa->nItemCount >= hdsa->nMaxCount) {
267 nNewItems = hdsa->nMaxCount + hdsa->nGrow;
268 nSize = hdsa->nItemSize * nNewItems;
270 lpTemp = ReAlloc (hdsa->pData, nSize);
271 if (!lpTemp)
272 return -1;
274 hdsa->nMaxCount = nNewItems;
275 hdsa->pData = lpTemp;
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);
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);
295 return nIndex;
299 /**************************************************************************
300 * DSA_DeleteItem [COMCTL32.326]
302 * Deletes the specified item from the array.
304 * PARAMS
305 * hdsa [I] pointer to the array control structure
306 * nIndex [I] index for the element to delete
308 * RETURNS
309 * Success: number of the deleted element
310 * Failure: -1
312 INT WINAPI DSA_DeleteItem (const HDSA hdsa, INT nIndex)
314 LPVOID lpDest,lpSrc;
315 INT nSize;
317 TRACE("(%p %d)\n", hdsa, nIndex);
319 if (!hdsa)
320 return -1;
321 if (nIndex < 0 || nIndex >= hdsa->nItemCount)
322 return -1;
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);
334 hdsa->nItemCount--;
336 /* free memory ? */
337 if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
338 nSize = hdsa->nItemSize * hdsa->nItemCount;
340 lpDest = ReAlloc (hdsa->pData, nSize);
341 if (!lpDest)
342 return -1;
344 hdsa->nMaxCount = hdsa->nItemCount;
345 hdsa->pData = lpDest;
348 return nIndex;
352 /**************************************************************************
353 * DSA_DeleteAllItems [COMCTL32.327]
355 * Removes all items and reinitializes the array.
357 * PARAMS
358 * hdsa [I] pointer to the array control structure
360 * RETURNS
361 * Success: TRUE
362 * Failure: FALSE
364 BOOL WINAPI DSA_DeleteAllItems (const HDSA hdsa)
366 TRACE("(%p)\n", hdsa);
368 if (!hdsa)
369 return FALSE;
370 if (hdsa->pData && (!Free (hdsa->pData)))
371 return FALSE;
373 hdsa->nItemCount = 0;
374 hdsa->pData = NULL;
375 hdsa->nMaxCount = 0;
377 return TRUE;
381 /**************************************************************************
382 * DSA_EnumCallback [COMCTL32.387]
384 * Enumerates all items in a dynamic storage array.
386 * PARAMS
387 * hdsa [I] handle to the dynamic storage array
388 * enumProc [I]
389 * lParam [I]
391 * RETURNS
392 * none
394 VOID WINAPI DSA_EnumCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
395 LPVOID lParam)
397 INT i;
399 TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
401 if (!hdsa)
402 return;
403 if (hdsa->nItemCount <= 0)
404 return;
406 for (i = 0; i < hdsa->nItemCount; i++) {
407 LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
408 if ((enumProc)(lpItem, lParam) == 0)
409 return;
412 return;
416 /**************************************************************************
417 * DSA_DestroyCallback [COMCTL32.388]
419 * Enumerates all items in a dynamic storage array and destroys it.
421 * PARAMS
422 * hdsa [I] handle to the dynamic storage array
423 * enumProc [I]
424 * lParam [I]
426 * RETURNS
427 * none
429 void WINAPI DSA_DestroyCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
430 LPVOID lParam)
432 TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
434 DSA_EnumCallback (hdsa, enumProc, lParam);
435 DSA_Destroy (hdsa);