?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add config.h/port.h to allow compilation/linking in MSVC.
[wine/multimedia.git] / dlls / comctl32 / comctl32undoc.c
blobe882aaec8cdd668df182ab7c9b84f0944a22654b
1 /*
2 * Undocumented functions from COMCTL32.DLL
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * NOTES
23 * All of these functions are UNDOCUMENTED!! And I mean UNDOCUMENTED!!!!
24 * Do NOT rely on names or contents of undocumented structures and types!!!
25 * These functions are used by EXPLORER.EXE, IEXPLORE.EXE and
26 * COMCTL32.DLL (internally).
27 *
28 * TODO
29 * - Add more functions.
30 * - Write some documentation.
31 */
32 #include "config.h"
33 #include "wine/port.h"
34
35 #include <string.h>
36 #include <stdlib.h> /* atoi */
37 #include <ctype.h>
38 #include <limits.h>
39
40 #include "commctrl.h"
41 #include "objbase.h"
42 #include "winbase.h"
43 #include "winerror.h"
44 #include "winreg.h"
45
46 #include "wine/unicode.h"
47 #include "comctl32.h"
48
49 #include "wine/debug.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
52
53
54 extern HANDLE COMCTL32_hHeap; /* handle to the private heap */
55
56
57 typedef struct _STREAMDATA
58 {
59 DWORD dwSize;
60 DWORD dwData2;
61 DWORD dwItems;
62 } STREAMDATA, *PSTREAMDATA;
63
64 typedef struct _LOADDATA
65 {
66 INT nCount;
67 PVOID ptr;
68 } LOADDATA, *LPLOADDATA;
69
70 typedef HRESULT (CALLBACK *DPALOADPROC)(LPLOADDATA,IStream*,LPARAM);
71
72 /**************************************************************************
73 * DPA_LoadStream [COMCTL32.9]
74 *
75 * Loads a dynamic pointer array from a stream
76 *
77 * PARAMS
78 * phDpa [O] pointer to a handle to a dynamic pointer array
79 * loadProc [I] pointer to a callback function
80 * pStream [I] pointer to a stream
81 * lParam [I] application specific value
82 *
83 * NOTES
84 * No more information available yet!
85 */
86
87 HRESULT WINAPI
88 DPA_LoadStream (HDPA *phDpa, DPALOADPROC loadProc, IStream *pStream, LPARAM lParam)
89 {
90 HRESULT errCode;
91 LARGE_INTEGER position;
92 ULARGE_INTEGER newPosition;
93 STREAMDATA streamData;
94 LOADDATA loadData;
95 ULONG ulRead;
96 HDPA hDpa;
97 PVOID *ptr;
98
99 FIXME ("phDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
100 phDpa, loadProc, pStream, lParam);
101
102 if (!phDpa || !loadProc || !pStream)
103 return E_INVALIDARG;
104
105 *phDpa = (HDPA)NULL;
106
107 position.s.LowPart = 0;
108 position.s.HighPart = 0;
109
110 /*
111 * Zero out our streamData
112 */
113 memset(&streamData,0,sizeof(STREAMDATA));
114
115 errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &newPosition);
116 if (errCode != S_OK)
117 return errCode;
118
119 errCode = IStream_Read (pStream, &streamData, sizeof(STREAMDATA), &ulRead);
120 if (errCode != S_OK)
121 return errCode;
122
123 FIXME ("dwSize=%lu dwData2=%lu dwItems=%lu\n",
124 streamData.dwSize, streamData.dwData2, streamData.dwItems);
125
126 if ( ulRead < sizeof(STREAMDATA) ||
127 lParam < sizeof(STREAMDATA) ||
128 streamData.dwSize < sizeof(STREAMDATA) ||
129 streamData.dwData2 < 1) {
130 errCode = E_FAIL;
131 }
132
133 if (streamData.dwItems > (UINT_MAX / 2 / sizeof(VOID*))) /* 536870911 */
134 return E_OUTOFMEMORY;
135
136 /* create the dpa */
137 hDpa = DPA_Create (streamData.dwItems);
138 if (!hDpa)
139 return E_OUTOFMEMORY;
140
141 if (!DPA_Grow (hDpa, streamData.dwItems))
142 return E_OUTOFMEMORY;
143
144 /* load data from the stream into the dpa */
145 ptr = hDpa->ptrs;
146 for (loadData.nCount = 0; loadData.nCount < streamData.dwItems; loadData.nCount++) {
147 errCode = (loadProc)(&loadData, pStream, lParam);
148 if (errCode != S_OK) {
149 errCode = S_FALSE;
150 break;
151 }
152
153 *ptr = loadData.ptr;
154 ptr++;
155 }
156
157 /* set the number of items */
158 hDpa->nItemCount = loadData.nCount;
159
160 /* store the handle to the dpa */
161 *phDpa = hDpa;
162 FIXME ("new hDpa=%p\n", hDpa);
163
164 return errCode;
165 }
166
167
168 /**************************************************************************
169 * DPA_SaveStream [COMCTL32.10]
170 *
171 * Saves a dynamic pointer array to a stream
172 *
173 * PARAMS
174 * hDpa [I] handle to a dynamic pointer array
175 * loadProc [I] pointer to a callback function
176 * pStream [I] pointer to a stream
177 * lParam [I] application specific value
178 *
179 * NOTES
180 * No more information available yet!
181 */
182
183 HRESULT WINAPI
184 DPA_SaveStream (const HDPA hDpa, DPALOADPROC loadProc, IStream *pStream, LPARAM lParam)
185 {
186
187 FIXME ("hDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
188 hDpa, loadProc, pStream, lParam);
189
190 return E_FAIL;
191 }
192
193
194 /**************************************************************************
195 * DPA_Merge [COMCTL32.11]
196 *
197 * PARAMS
198 * hdpa1 [I] handle to a dynamic pointer array
199 * hdpa2 [I] handle to a dynamic pointer array
200 * dwFlags [I] flags
201 * pfnCompare [I] pointer to sort function
202 * pfnMerge [I] pointer to merge function
203 * lParam [I] application specific value
204 *
205 * NOTES
206 * No more information available yet!
207 */
208
209 BOOL WINAPI
210 DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
211 PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
212 {
213 INT nCount;
214 LPVOID *pWork1, *pWork2;
215 INT nResult, i;
216 INT nIndex;
217
218 TRACE("%p %p %08lx %p %p %08lx)\n",
219 hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
220
221 if (IsBadWritePtr (hdpa1, sizeof(DPA)))
222 return FALSE;
223
224 if (IsBadWritePtr (hdpa2, sizeof(DPA)))
225 return FALSE;
226
227 if (IsBadCodePtr ((FARPROC)pfnCompare))
228 return FALSE;
229
230 if (IsBadCodePtr ((FARPROC)pfnMerge))
231 return FALSE;
232
233 if (!(dwFlags & DPAM_NOSORT)) {
234 TRACE("sorting dpa's!\n");
235 if (hdpa1->nItemCount > 0)
236 DPA_Sort (hdpa1, pfnCompare, lParam);
237 TRACE ("dpa 1 sorted!\n");
238 if (hdpa2->nItemCount > 0)
239 DPA_Sort (hdpa2, pfnCompare, lParam);
240 TRACE ("dpa 2 sorted!\n");
241 }
242
243 if (hdpa2->nItemCount < 1)
244 return TRUE;
245
246 TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
247 hdpa1->nItemCount, hdpa2->nItemCount);
248
249
250 /* working but untrusted implementation */
251
252 pWork1 = &(hdpa1->ptrs[hdpa1->nItemCount - 1]);
253 pWork2 = &(hdpa2->ptrs[hdpa2->nItemCount - 1]);
254
255 nIndex = hdpa1->nItemCount - 1;
256 nCount = hdpa2->nItemCount - 1;
257
258 do
259 {
260 if (nIndex < 0) {
261 if ((nCount >= 0) && (dwFlags & DPAM_INSERT)) {
262 /* Now insert the remaining new items into DPA 1 */
263 TRACE("%d items to be inserted at start of DPA 1\n",
264 nCount+1);
265 for (i=nCount; i>=0; i--) {
266 PVOID ptr;
267
268 ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
269 if (!ptr)
270 return FALSE;
271 DPA_InsertPtr (hdpa1, 0, ptr);
272 pWork2--;
273 }
274 }
275 break;
276 }
277 nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
278 TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
279 nResult, nIndex, nCount);
280
281 if (nResult == 0)
282 {
283 PVOID ptr;
284
285 ptr = (pfnMerge)(1, *pWork1, *pWork2, lParam);
286 if (!ptr)
287 return FALSE;
288
289 nCount--;
290 pWork2--;
291 *pWork1 = ptr;
292 nIndex--;
293 pWork1--;
294 }
295 else if (nResult > 0)
296 {
297 /* item in DPA 1 missing from DPA 2 */
298 if (dwFlags & DPAM_DELETE)
299 {
300 /* Now delete the extra item in DPA1 */
301 PVOID ptr;
302
303 ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
304
305 (pfnMerge)(2, ptr, NULL, lParam);
306 }
307 nIndex--;
308 pWork1--;
309 }
310 else
311 {
312 /* new item in DPA 2 */
313 if (dwFlags & DPAM_INSERT)
314 {
315 /* Now insert the new item in DPA 1 */
316 PVOID ptr;
317
318 ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
319 if (!ptr)
320 return FALSE;
321 DPA_InsertPtr (hdpa1, nIndex+1, ptr);
322 }
323 nCount--;
324 pWork2--;
325 }
326
327 }
328 while (nCount >= 0);
329
330 return TRUE;
331 }
332
333
334 /**************************************************************************
335 * Alloc [COMCTL32.71]
336 *
337 * Allocates memory block from the dll's private heap
338 *
339 * PARAMS
340 * dwSize [I] size of the allocated memory block
341 *
342 * RETURNS
343 * Success: pointer to allocated memory block
344 * Failure: NULL
345 */
346
347 LPVOID WINAPI
348 COMCTL32_Alloc (DWORD dwSize)
349 {
350 LPVOID lpPtr;
351
352 TRACE("(0x%lx)\n", dwSize);
353
354 lpPtr = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
355
356 TRACE("-- ret=%p\n", lpPtr);
357
358 return lpPtr;
359 }
360
361
362 /**************************************************************************
363 * ReAlloc [COMCTL32.72]
364 *
365 * Changes the size of an allocated memory block or allocates a memory
366 * block using the dll's private heap.
367 *
368 * PARAMS
369 * lpSrc [I] pointer to memory block which will be resized
370 * dwSize [I] new size of the memory block.
371 *
372 * RETURNS
373 * Success: pointer to the resized memory block
374 * Failure: NULL
375 *
376 * NOTES
377 * If lpSrc is a NULL-pointer, then COMCTL32_ReAlloc allocates a memory
378 * block like COMCTL32_Alloc.
379 */
380
381 LPVOID WINAPI
382 COMCTL32_ReAlloc (LPVOID lpSrc, DWORD dwSize)
383 {
384 LPVOID lpDest;
385
386 TRACE("(%p 0x%08lx)\n", lpSrc, dwSize);
387
388 if (lpSrc)
389 lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
390 else
391 lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
392
393 TRACE("-- ret=%p\n", lpDest);
394
395 return lpDest;
396 }
397
398
399 /**************************************************************************
400 * Free [COMCTL32.73]
401 *
402 * Frees an allocated memory block from the dll's private heap.
403 *
404 * PARAMS
405 * lpMem [I] pointer to memory block which will be freed
406 *
407 * RETURNS
408 * Success: TRUE
409 * Failure: FALSE
410 */
411
412 BOOL WINAPI
413 COMCTL32_Free (LPVOID lpMem)
414 {
415 TRACE("(%p)\n", lpMem);
416
417 return HeapFree (COMCTL32_hHeap, 0, lpMem);
418 }
419
420
421 /**************************************************************************
422 * GetSize [COMCTL32.74]
423 *
424 * Retrieves the size of the specified memory block from the dll's
425 * private heap.
426 *
427 * PARAMS
428 * lpMem [I] pointer to an allocated memory block
429 *
430 * RETURNS
431 * Success: size of the specified memory block
432 * Failure: 0
433 */
434
435 DWORD WINAPI
436 COMCTL32_GetSize (LPVOID lpMem)
437 {
438 TRACE("(%p)\n", lpMem);
439
440 return HeapSize (COMCTL32_hHeap, 0, lpMem);
441 }
442
443
444 /**************************************************************************
445 * The MRU-API is a set of functions to manipulate MRU(Most Recently Used)
446 * lists.
447 *
448 * Stored in the reg. as a set of values under a single key. Each item in the
449 * list has a value name that is a single char. 'a' - 'z', '{', '|' or '}'.
450 * The order of the list is stored with value name 'MRUList' which is a string
451 * containing the value names (i.e. 'a', 'b', etc.) in the relevant order.
452 */
453
454 typedef struct tagCREATEMRULISTA
455 {
456 DWORD cbSize; /* size of struct */
457 DWORD nMaxItems; /* max no. of items in list */
458 DWORD dwFlags; /* see below */
459 HKEY hKey; /* root reg. key under which list is saved */
460 LPCSTR lpszSubKey; /* reg. subkey */
461 PROC lpfnCompare; /* item compare proc */
462 } CREATEMRULISTA, *LPCREATEMRULISTA;
463
464 typedef struct tagCREATEMRULISTW
465 {
466 DWORD cbSize; /* size of struct */
467 DWORD nMaxItems; /* max no. of items in list */
468 DWORD dwFlags; /* see below */
469 HKEY hKey; /* root reg. key under which list is saved */
470 LPCWSTR lpszSubKey; /* reg. subkey */
471 PROC lpfnCompare; /* item compare proc */
472 } CREATEMRULISTW, *LPCREATEMRULISTW;
473
474 /* dwFlags */
475 #define MRUF_STRING_LIST 0 /* list will contain strings */
476 #define MRUF_BINARY_LIST 1 /* list will contain binary data */
477 #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
478
479 /* If list is a string list lpfnCompare has the following prototype
480 * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
481 * for binary lists the prototype is
482 * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
483 * where cbData is the no. of bytes to compare.
484 * Need to check what return value means identical - 0?
485 */
486
487 typedef struct tagWINEMRUITEM
488 {
489 DWORD size; /* size of data stored */
490 DWORD itemFlag; /* flags */
491 BYTE datastart;
492 } WINEMRUITEM, *LPWINEMRUITEM;
493
494 /* itemFlag */
495 #define WMRUIF_CHANGED 0x0001 /* this dataitem changed */
496
497 typedef struct tagWINEMRULIST
498 {
499 CREATEMRULISTW extview; /* original create information */
500 BOOL isUnicode; /* is compare fn Unicode */
501 DWORD wineFlags; /* internal flags */
502 DWORD cursize; /* current size of realMRU */
503 LPSTR realMRU; /* pointer to string of index names */
504 LPWINEMRUITEM *array; /* array of pointers to data */
505 /* in 'a' to 'z' order */
506 } WINEMRULIST, *LPWINEMRULIST;
507
508 /* wineFlags */
509 #define WMRUF_CHANGED 0x0001 /* MRU list has changed */
510
511 /**************************************************************************
512 * MRU_SaveChanged - Localize MRU saving code
513 *
514 */
515 VOID MRU_SaveChanged( LPWINEMRULIST mp )
516 {
517 UINT i, err;
518 HKEY newkey;
519 WCHAR realname[2];
520 LPWINEMRUITEM witem;
521 WCHAR emptyW[] = {'\0'};
522
523 /* or should we do the following instead of RegOpenKeyEx:
524 */
525
526 /* open the sub key */
527 if ((err = RegOpenKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
528 0, KEY_WRITE, &newkey))) {
529 /* not present - what to do ??? */
530 ERR("Can not open key, error=%d, attempting to create\n",
531 err);
532 if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
533 0,
534 emptyW,
535 REG_OPTION_NON_VOLATILE,
536 KEY_READ | KEY_WRITE,
537 0,
538 &newkey,
539 0))) {
540 ERR("failed to create key /%s/, err=%d\n",
541 debugstr_w(mp->extview.lpszSubKey), err);
542 return;
543 }
544 }
545 if (mp->wineFlags & WMRUF_CHANGED) {
546 mp->wineFlags &= ~WMRUF_CHANGED;
547 err = RegSetValueExA(newkey, "MRUList", 0, REG_SZ,
548 mp->realMRU, strlen(mp->realMRU) + 1);
549 if (err) {
550 ERR("error saving MRUList, err=%d\n", err);
551 }
552 TRACE("saving MRUList=/%s/\n", mp->realMRU);
553 }
554 realname[1] = 0;
555 for(i=0; i<mp->cursize; i++) {
556 witem = mp->array[i];
557 if (witem->itemFlag & WMRUIF_CHANGED) {
558 witem->itemFlag &= ~WMRUIF_CHANGED;
559 realname[0] = 'a' + i;
560 err = RegSetValueExW(newkey, realname, 0,
561 (mp->extview.dwFlags & MRUF_BINARY_LIST) ?
562 REG_BINARY : REG_SZ,
563 &witem->datastart, witem->size);
564 if (err) {
565 ERR("error saving /%s/, err=%d\n", debugstr_w(realname), err);
566 }
567 TRACE("saving value for name /%s/ size=%ld\n",
568 debugstr_w(realname), witem->size);
569 }
570 }
571 RegCloseKey( newkey );
572 }
573
574 /**************************************************************************
575 * FreeMRUList [COMCTL32.152]
576 *
577 * PARAMS
578 * hMRUList [I] Handle to list.
579 *
580 */
581 DWORD WINAPI
582 FreeMRUList (HANDLE hMRUList)
583 {
584 LPWINEMRULIST mp = (LPWINEMRULIST)hMRUList;
585 UINT i;
586
587 TRACE("\n");
588 if (mp->wineFlags & WMRUF_CHANGED) {
589 /* need to open key and then save the info */
590 MRU_SaveChanged( mp );
591 }
592
593 for(i=0; i<mp->extview.nMaxItems; i++) {
594 if (mp->array[i])
595 COMCTL32_Free(mp->array[i]);
596 }
597 COMCTL32_Free(mp->realMRU);
598 COMCTL32_Free(mp->array);
599 COMCTL32_Free((LPWSTR)mp->extview.lpszSubKey);
600 return COMCTL32_Free(mp);
601 }
602
603
604 /**************************************************************************
605 * FindMRUData [COMCTL32.169]
606 *
607 * Searches binary list for item that matches lpData of length cbData.
608 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
609 * corresponding to item's reg. name will be stored in it ('a' -> 0).
610 *
611 * PARAMS
612 * hList [I] list handle
613 * lpData [I] data to find
614 * cbData [I] length of data
615 * lpRegNum [O] position in registry (maybe NULL)
616 *
617 * RETURNS
618 * Position in list 0 -> MRU. -1 if item not found.
619 */
620 INT WINAPI
621 FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum)
622 {
623 LPWINEMRULIST mp = (LPWINEMRULIST)hList;
624 UINT i, ret;
625 LPSTR dataA = NULL;
626
627 if (!mp->extview.lpfnCompare) {
628 ERR("MRU list not properly created. No compare procedure.\n");
629 return -1;
630 }
631
632 if(!(mp->extview.dwFlags & MRUF_BINARY_LIST) && !mp->isUnicode) {
633 DWORD len = WideCharToMultiByte(CP_ACP, 0, lpData, -1,
634 NULL, 0, NULL, NULL);
635 dataA = COMCTL32_Alloc(len);
636 WideCharToMultiByte(CP_ACP, 0, lpData, -1, dataA, len, NULL, NULL);
637 }
638
639 for(i=0; i<mp->cursize; i++) {
640 if (mp->extview.dwFlags & MRUF_BINARY_LIST) {
641 if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart,
642 cbData))
643 break;
644 }
645 else {
646 if(mp->isUnicode) {
647 if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart))
648 break;
649 } else {
650 DWORD len = WideCharToMultiByte(CP_ACP, 0,
651 (LPWSTR)&mp->array[i]->datastart, -1,
652 NULL, 0, NULL, NULL);
653 LPSTR itemA = COMCTL32_Alloc(len);
654 INT cmp;
655 WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&mp->array[i]->datastart, -1,
656 itemA, len, NULL, NULL);
657
658 cmp = mp->extview.lpfnCompare(dataA, itemA);
659 COMCTL32_Free(itemA);
660 if(!cmp)
661 break;
662 }
663 }
664 }
665 if(dataA)
666 COMCTL32_Free(dataA);
667 if (i < mp->cursize)
668 ret = i;
669 else
670 ret = -1;
671 if (lpRegNum && (ret != -1))
672 *lpRegNum = 'a' + i;
673
674 TRACE("(%p, %p, %ld, %p) returning %d\n",
675 hList, lpData, cbData, lpRegNum, ret);
676
677 return ret;
678 }
679
680
681 /**************************************************************************
682 * AddMRUData [COMCTL32.167]
683 *
684 * Add item to MRU binary list. If item already exists in list then it is
685 * simply moved up to the top of the list and not added again. If list is
686 * full then the least recently used item is removed to make room.
687 *
688 * PARAMS
689 * hList [I] Handle to list.
690 * lpData [I] ptr to data to add.
691 * cbData [I] no. of bytes of data.
692 *
693 * RETURNS
694 * No. corresponding to registry name where value is stored 'a' -> 0 etc.
695 * -1 on error.
696 */
697 INT WINAPI
698 AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData)
699 {
700 LPWINEMRULIST mp = (LPWINEMRULIST)hList;
701 LPWINEMRUITEM witem;
702 INT i, replace, ret;
703
704 if ((replace = FindMRUData (hList, lpData, cbData, NULL)) < 0) {
705 /* either add a new entry or replace oldest */
706 if (mp->cursize < mp->extview.nMaxItems) {
707 /* Add in a new item */
708 replace = mp->cursize;
709 mp->cursize++;
710 }
711 else {
712 /* get the oldest entry and replace data */
713 replace = mp->realMRU[mp->cursize - 1] - 'a';
714 COMCTL32_Free(mp->array[replace]);
715 }
716 }
717 else {
718 /* free up the old data */
719 COMCTL32_Free(mp->array[replace]);
720 }
721
722 /* Allocate space for new item and move in the data */
723 mp->array[replace] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(cbData +
724 sizeof(WINEMRUITEM));
725 witem->itemFlag |= WMRUIF_CHANGED;
726 witem->size = cbData;
727 memcpy( &witem->datastart, lpData, cbData);
728
729 /* now rotate MRU list */
730 mp->wineFlags |= WMRUF_CHANGED;
731 for(i=mp->cursize-1; i>=1; i--) {
732 mp->realMRU[i] = mp->realMRU[i-1];
733 }
734 mp->realMRU[0] = replace + 'a';
735 TRACE("(%p, %p, %ld) adding data, /%c/ now most current\n",
736 hList, lpData, cbData, replace+'a');
737 ret = replace;
738
739 if (!(mp->extview.dwFlags & MRUF_DELAYED_SAVE)) {
740 /* save changed stuff right now */
741 MRU_SaveChanged( mp );
742 }
743
744 return ret;
745 }
746
747 /**************************************************************************
748 * AddMRUStringW [COMCTL32.401]
749 *
750 * Add item to MRU string list. If item already exists in list them it is
751 * simply moved up to the top of the list and not added again. If list is
752 * full then the least recently used item is removed to make room.
753 *
754 * PARAMS
755 * hList [I] Handle to list.
756 * lpszString [I] ptr to string to add.
757 *
758 * RETURNS
759 * No. corresponding to registry name where value is stored 'a' -> 0 etc.
760 * -1 on error.
761 */
762 INT WINAPI
763 AddMRUStringW(HANDLE hList, LPCWSTR lpszString)
764 {
765 FIXME("(%p, %s) empty stub!\n", hList, debugstr_w(lpszString));
766
767 return 0;
768 }
769
770 /**************************************************************************
771 * AddMRUStringA [COMCTL32.153]
772 */
773 INT WINAPI
774 AddMRUStringA(HANDLE hList, LPCSTR lpszString)
775 {
776 FIXME("(%p, %s) empty stub!\n", hList, debugstr_a(lpszString));
777
778 return 0;
779 }
780
781 /**************************************************************************
782 * DelMRUString [COMCTL32.156]
783 *
784 * Removes item from either string or binary list (despite its name)
785 *
786 * PARAMS
787 * hList [I] list handle
788 * nItemPos [I] item position to remove 0 -> MRU
789 *
790 * RETURNS
791 * TRUE if successful, FALSE if nItemPos is out of range.
792 */
793 BOOL WINAPI
794 DelMRUString(HANDLE hList, INT nItemPos)
795 {
796 FIXME("(%p, %d): stub\n", hList, nItemPos);
797 return TRUE;
798 }
799
800 /**************************************************************************
801 * FindMRUStringW [COMCTL32.402]
802 */
803 INT WINAPI
804 FindMRUStringW (HANDLE hList, LPCWSTR lpszString, LPINT lpRegNum)
805 {
806 FIXME("stub\n");
807 return -1;
808 }
809
810 /**************************************************************************
811 * FindMRUStringA [COMCTL32.155]
812 *
813 * Searches string list for item that matches lpszString.
814 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
815 * corresponding to item's reg. name will be stored in it ('a' -> 0).
816 *
817 * PARAMS
818 * hList [I] list handle
819 * lpszString [I] string to find
820 * lpRegNum [O] position in registry (maybe NULL)
821 *
822 * RETURNS
823 * Position in list 0 -> MRU. -1 if item not found.
824 */
825 INT WINAPI
826 FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum)
827 {
828 DWORD len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0);
829 LPWSTR stringW = COMCTL32_Alloc(len * sizeof(WCHAR));
830 INT ret;
831
832 MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len);
833 ret = FindMRUData(hList, stringW, len * sizeof(WCHAR), lpRegNum);
834 COMCTL32_Free(stringW);
835 return ret;
836 }
837
838 /*************************************************************************
839 * CreateMRUListLazy_common
840 */
841 HANDLE CreateMRUListLazy_common(LPWINEMRULIST mp)
842 {
843 UINT i, err;
844 HKEY newkey;
845 DWORD datasize, dwdisp;
846 WCHAR realname[2];
847 LPWINEMRUITEM witem;
848 DWORD type;
849 WCHAR emptyW[] = {'\0'};
850
851 /* get space to save indices that will turn into names
852 * but in order of most to least recently used
853 */
854 mp->realMRU = (LPSTR) COMCTL32_Alloc(mp->extview.nMaxItems + 2);
855
856 /* get space to save pointers to actual data in order of
857 * 'a' to 'z' (0 to n).
858 */
859 mp->array = (LPVOID) COMCTL32_Alloc(mp->extview.nMaxItems *
860 sizeof(LPVOID));
861
862 /* open the sub key */
863 if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
864 0,
865 emptyW,
866 REG_OPTION_NON_VOLATILE,
867 KEY_READ | KEY_WRITE,
868 0,
869 &newkey,
870 &dwdisp))) {
871 /* error - what to do ??? */
872 ERR("(%lu %lu %lx %lx \"%s\" %p): Can not open key, error=%d\n",
873 mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
874 (DWORD)mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
875 mp->extview.lpfnCompare, err);
876 return 0;
877 }
878
879 /* get values from key 'MRUList' */
880 if (newkey) {
881 datasize = mp->extview.nMaxItems + 1;
882 if((err=RegQueryValueExA( newkey, "MRUList", 0, &type, mp->realMRU,
883 &datasize))) {
884 /* not present - set size to 1 (will become 0 later) */
885 datasize = 1;
886 *mp->realMRU = 0;
887 }
888
889 TRACE("MRU list = %s\n", mp->realMRU);
890
891 mp->cursize = datasize - 1;
892 /* datasize now has number of items in the MRUList */
893
894 /* get actual values for each entry */
895 realname[1] = 0;
896 for(i=0; i<mp->cursize; i++) {
897 realname[0] = 'a' + i;
898 if(RegQueryValueExW( newkey, realname, 0, &type, 0, &datasize)) {
899 /* not present - what to do ??? */
900 ERR("Key %s not found 1\n", debugstr_w(realname));
901 }
902 mp->array[i] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(datasize +
903 sizeof(WINEMRUITEM));
904 witem->size = datasize;
905 if(RegQueryValueExW( newkey, realname, 0, &type,
906 &witem->datastart, &datasize)) {
907 /* not present - what to do ??? */
908 ERR("Key %s not found 2\n", debugstr_w(realname));
909 }
910 }
911 RegCloseKey( newkey );
912 }
913 else
914 mp->cursize = 0;
915
916 TRACE("(%lu %lu %lx %lx \"%s\" %p): Current Size = %ld\n",
917 mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
918 (DWORD)mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
919 mp->extview.lpfnCompare, mp->cursize);
920 return (HANDLE)mp;
921 }
922
923 /**************************************************************************
924 * CreateMRUListLazyW [COMCTL32.404]
925 */
926 HANDLE WINAPI
927 CreateMRUListLazyW (LPCREATEMRULISTW lpcml, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4)
928 {
929 LPWINEMRULIST mp;
930
931 if (lpcml == NULL)
932 return 0;
933
934 if (lpcml->cbSize < sizeof(CREATEMRULISTW))
935 return 0;
936
937 mp = (LPWINEMRULIST) COMCTL32_Alloc(sizeof(WINEMRULIST));
938 memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
939 mp->extview.lpszSubKey = COMCTL32_Alloc((strlenW(lpcml->lpszSubKey) + 1) *
940 sizeof(WCHAR));
941 strcpyW((LPWSTR)mp->extview.lpszSubKey, lpcml->lpszSubKey);
942 mp->isUnicode = TRUE;
943
944 return CreateMRUListLazy_common(mp);
945 }
946
947 /**************************************************************************
948 * CreateMRUListLazyA [COMCTL32.157]
949 */
950 HANDLE WINAPI
951 CreateMRUListLazyA (LPCREATEMRULISTA lpcml, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4)
952 {
953 LPWINEMRULIST mp;
954 DWORD len;
955
956 if (lpcml == NULL)
957 return 0;
958
959 if (lpcml->cbSize < sizeof(CREATEMRULISTA))
960 return 0;
961
962 mp = (LPWINEMRULIST) COMCTL32_Alloc(sizeof(WINEMRULIST));
963 memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
964 len = MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1, NULL, 0);
965 mp->extview.lpszSubKey = COMCTL32_Alloc(len * sizeof(WCHAR));
966 MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1,
967 (LPWSTR)mp->extview.lpszSubKey, len);
968 mp->isUnicode = FALSE;
969 return CreateMRUListLazy_common(mp);
970 }
971
972 /**************************************************************************
973 * CreateMRUListW [COMCTL32.400]
974 *
975 * PARAMS
976 * lpcml [I] ptr to CREATEMRULIST structure.
977 *
978 * RETURNS
979 * Handle to MRU list.
980 */
981 HANDLE WINAPI
982 CreateMRUListW (LPCREATEMRULISTW lpcml)
983 {
984 return CreateMRUListLazyW(lpcml, 0, 0, 0);
985 }
986
987 /**************************************************************************
988 * CreateMRUListA [COMCTL32.151]
989 */
990 HANDLE WINAPI
991 CreateMRUListA (LPCREATEMRULISTA lpcml)
992 {
993 return CreateMRUListLazyA (lpcml, 0, 0, 0);
994 }
995
996
997 /**************************************************************************
998 * EnumMRUListW [COMCTL32.403]
999 *
1000 * Enumerate item in a list
1001 *
1002 * PARAMS
1003 * hList [I] list handle
1004 * nItemPos [I] item position to enumerate
1005 * lpBuffer [O] buffer to receive item
1006 * nBufferSize [I] size of buffer
1007 *
1008 * RETURNS
1009 * For binary lists specifies how many bytes were copied to buffer, for
1010 * string lists specifies full length of string. Enumerating past the end
1011 * of list returns -1.
1012 * If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
1013 * the list.
1014 */
1015 INT WINAPI EnumMRUListW(HANDLE hList, INT nItemPos, LPVOID lpBuffer,
1016 DWORD nBufferSize)
1017 {
1018 LPWINEMRULIST mp = (LPWINEMRULIST) hList;
1019 LPWINEMRUITEM witem;
1020 INT desired, datasize;
1021
1022 if (nItemPos >= mp->cursize) return -1;
1023 if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
1024 desired = mp->realMRU[nItemPos];
1025 desired -= 'a';
1026 TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
1027 witem = mp->array[desired];
1028 datasize = min( witem->size, nBufferSize );
1029 memcpy( lpBuffer, &witem->datastart, datasize);
1030 TRACE("(%p, %d, %p, %ld): returning len=%d\n",
1031 hList, nItemPos, lpBuffer, nBufferSize, datasize);
1032 return datasize;
1033 }
1034
1035 /**************************************************************************
1036 * EnumMRUListA [COMCTL32.154]
1037 *
1038 */
1039 INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer,
1040 DWORD nBufferSize)
1041 {
1042 LPWINEMRULIST mp = (LPWINEMRULIST) hList;
1043 LPWINEMRUITEM witem;
1044 INT desired, datasize;
1045 DWORD lenA;
1046
1047 if (nItemPos >= mp->cursize) return -1;
1048 if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
1049 desired = mp->realMRU[nItemPos];
1050 desired -= 'a';
1051 TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
1052 witem = mp->array[desired];
1053 if(mp->extview.dwFlags & MRUF_BINARY_LIST) {
1054 datasize = min( witem->size, nBufferSize );
1055 memcpy( lpBuffer, &witem->datastart, datasize);
1056 } else {
1057 lenA = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
1058 NULL, 0, NULL, NULL);
1059 datasize = min( witem->size, nBufferSize );
1060 WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
1061 lpBuffer, datasize, NULL, NULL);
1062 }
1063 TRACE("(%p, %d, %p, %ld): returning len=%d\n",
1064 hList, nItemPos, lpBuffer, nBufferSize, datasize);
1065 return datasize;
1066 }
1067
1068
1069 /**************************************************************************
1070 * Str_GetPtrA [COMCTL32.233]
1071 *
1072 * PARAMS
1073 * lpSrc [I]
1074 * lpDest [O]
1075 * nMaxLen [I]
1076 *
1077 * RETURNS
1078 */
1079
1080 INT WINAPI
1081 Str_GetPtrA (LPCSTR lpSrc, LPSTR lpDest, INT nMaxLen)
1082 {
1083 INT len;
1084
1085 TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
1086
1087 if (!lpDest && lpSrc)
1088 return strlen (lpSrc);
1089
1090 if (nMaxLen == 0)
1091 return 0;
1092
1093 if (lpSrc == NULL) {
1094 lpDest[0] = '\0';
1095 return 0;
1096 }
1097
1098 len = strlen (lpSrc);
1099 if (len >= nMaxLen)
1100 len = nMaxLen - 1;
1101
1102 RtlMoveMemory (lpDest, lpSrc, len);
1103 lpDest[len] = '\0';
1104
1105 return len;
1106 }
1107
1108
1109 /**************************************************************************
1110 * Str_SetPtrA [COMCTL32.234]
1111 *
1112 * PARAMS
1113 * lppDest [O]
1114 * lpSrc [I]
1115 *
1116 * RETURNS
1117 */
1118
1119 BOOL WINAPI
1120 Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc)
1121 {
1122 TRACE("(%p %p)\n", lppDest, lpSrc);
1123
1124 if (lpSrc) {
1125 LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
1126 if (!ptr)
1127 return FALSE;
1128 strcpy (ptr, lpSrc);
1129 *lppDest = ptr;
1130 }
1131 else {
1132 if (*lppDest) {
1133 COMCTL32_Free (*lppDest);
1134 *lppDest = NULL;
1135 }
1136 }
1137
1138 return TRUE;
1139 }
1140
1141
1142 /**************************************************************************
1143 * Str_GetPtrW [COMCTL32.235]
1144 *
1145 * PARAMS
1146 * lpSrc [I]
1147 * lpDest [O]
1148 * nMaxLen [I]
1149 *
1150 * RETURNS
1151 */
1152
1153 INT WINAPI
1154 Str_GetPtrW (LPCWSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
1155 {
1156 INT len;
1157
1158 TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
1159
1160 if (!lpDest && lpSrc)
1161 return strlenW (lpSrc);
1162
1163 if (nMaxLen == 0)
1164 return 0;
1165
1166 if (lpSrc == NULL) {
1167 lpDest[0] = L'\0';
1168 return 0;
1169 }
1170
1171 len = strlenW (lpSrc);
1172 if (len >= nMaxLen)
1173 len = nMaxLen - 1;
1174
1175 RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
1176 lpDest[len] = L'\0';
1177
1178 return len;
1179 }
1180
1181
1182 /**************************************************************************
1183 * Str_SetPtrW [COMCTL32.236]
1184 *
1185 * PARAMS
1186 * lpDest [O]
1187 * lpSrc [I]
1188 *
1189 * RETURNS
1190 */
1191
1192 BOOL WINAPI
1193 Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc)
1194 {
1195 TRACE("(%p %p)\n", lppDest, lpSrc);
1196
1197 if (lpSrc) {
1198 INT len = strlenW (lpSrc) + 1;
1199 LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
1200 if (!ptr)
1201 return FALSE;
1202 strcpyW (ptr, lpSrc);
1203 *lppDest = ptr;
1204 }
1205 else {
1206 if (*lppDest) {
1207 COMCTL32_Free (*lppDest);
1208 *lppDest = NULL;
1209 }
1210 }
1211
1212 return TRUE;
1213 }
1214
1215
1216 /**************************************************************************
1217 * Str_GetPtrWtoA [internal]
1218 *
1219 * Converts a unicode string into a multi byte string
1220 *
1221 * PARAMS
1222 * lpSrc [I] Pointer to the unicode source string
1223 * lpDest [O] Pointer to caller supplied storage for the multi byte string
1224 * nMaxLen [I] Size, in bytes, of the destination buffer
1225 *
1226 * RETURNS
1227 * Length, in bytes, of the converted string.
1228 */
1229
1230 INT
1231 Str_GetPtrWtoA (LPCWSTR lpSrc, LPSTR lpDest, INT nMaxLen)
1232 {
1233 INT len;
1234
1235 TRACE("(%s %p %d)\n", debugstr_w(lpSrc), lpDest, nMaxLen);
1236
1237 if (!lpDest && lpSrc)
1238 return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
1239
1240 if (nMaxLen == 0)
1241 return 0;
1242
1243 if (lpSrc == NULL) {
1244 lpDest[0] = '\0';
1245 return 0;
1246 }
1247
1248 len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
1249 if (len >= nMaxLen)
1250 len = nMaxLen - 1;
1251
1252 WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
1253 lpDest[len] = '\0';
1254
1255 return len;
1256 }
1257
1258
1259 /**************************************************************************
1260 * Str_SetPtrAtoW [internal]
1261 *
1262 * Converts a multi byte string to a unicode string.
1263 * If the pointer to the destination buffer is NULL a buffer is allocated.
1264 * If the destination buffer is too small to keep the converted multi byte
1265 * string the destination buffer is reallocated. If the source pointer is
1266 * NULL, the destination buffer is freed.
1267 *
1268 * PARAMS
1269 * lppDest [I/O] pointer to a pointer to the destination buffer
1270 * lpSrc [I] pointer to a multi byte string
1271 *
1272 * RETURNS
1273 * TRUE: conversion successful
1274 * FALSE: error
1275 */
1276
1277 BOOL
1278 Str_SetPtrAtoW (LPWSTR *lppDest, LPCSTR lpSrc)
1279 {
1280 TRACE("(%p %s)\n", lppDest, lpSrc);
1281
1282 if (lpSrc) {
1283 INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
1284 LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len*sizeof(WCHAR));
1285
1286 if (!ptr)
1287 return FALSE;
1288 MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
1289 *lppDest = ptr;
1290 }
1291 else {
1292 if (*lppDest) {
1293 COMCTL32_Free (*lppDest);
1294 *lppDest = NULL;
1295 }
1296 }
1297
1298 return TRUE;
1299 }
1300
1301
1302 /**************************************************************************
1303 * The DSA-API is a set of functions to create and manipulate arrays of
1304 * fixed-size memory blocks. These arrays can store any kind of data
1305 * (strings, icons...).
1306 */
1307
1308 /**************************************************************************
1309 * DSA_Create [COMCTL32.320] Creates a dynamic storage array
1310 *
1311 * PARAMS
1312 * nSize [I] size of the array elements
1313 * nGrow [I] number of elements by which the array grows when it is filled
1314 *
1315 * RETURNS
1316 * Success: pointer to an array control structure. Use this like a handle.
1317 * Failure: NULL
1318 */
1319
1320 HDSA WINAPI
1321 DSA_Create (INT nSize, INT nGrow)
1322 {
1323 HDSA hdsa;
1324
1325 TRACE("(size=%d grow=%d)\n", nSize, nGrow);
1326
1327 hdsa = (HDSA)COMCTL32_Alloc (sizeof(DSA));
1328 if (hdsa)
1329 {
1330 hdsa->nItemCount = 0;
1331 hdsa->pData = NULL;
1332 hdsa->nMaxCount = 0;
1333 hdsa->nItemSize = nSize;
1334 hdsa->nGrow = max(1, nGrow);
1335 }
1336
1337 return hdsa;
1338 }
1339
1340
1341 /**************************************************************************
1342 * DSA_Destroy [COMCTL32.321] Destroys a dynamic storage array
1343 *
1344 * PARAMS
1345 * hdsa [I] pointer to the array control structure
1346 *
1347 * RETURNS
1348 * Success: TRUE
1349 * Failure: FALSE
1350 */
1351
1352 BOOL WINAPI
1353 DSA_Destroy (const HDSA hdsa)
1354 {
1355 TRACE("(%p)\n", hdsa);
1356
1357 if (!hdsa)
1358 return FALSE;
1359
1360 if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
1361 return FALSE;
1362
1363 return COMCTL32_Free (hdsa);
1364 }
1365
1366
1367 /**************************************************************************
1368 * DSA_GetItem [COMCTL32.322]
1369 *
1370 * PARAMS
1371 * hdsa [I] pointer to the array control structure
1372 * nIndex [I] number of the Item to get
1373 * pDest [O] destination buffer. Has to be >= dwElementSize.
1374 *
1375 * RETURNS
1376 * Success: TRUE
1377 * Failure: FALSE
1378 */
1379
1380 BOOL WINAPI
1381 DSA_GetItem (const HDSA hdsa, INT nIndex, LPVOID pDest)
1382 {
1383 LPVOID pSrc;
1384
1385 TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
1386
1387 if (!hdsa)
1388 return FALSE;
1389 if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
1390 return FALSE;
1391
1392 pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1393 memmove (pDest, pSrc, hdsa->nItemSize);
1394
1395 return TRUE;
1396 }
1397
1398
1399 /**************************************************************************
1400 * DSA_GetItemPtr [COMCTL32.323]
1401 *
1402 * Retrieves a pointer to the specified item.
1403 *
1404 * PARAMS
1405 * hdsa [I] pointer to the array control structure
1406 * nIndex [I] index of the desired item
1407 *
1408 * RETURNS
1409 * Success: pointer to an item
1410 * Failure: NULL
1411 */
1412
1413 LPVOID WINAPI
1414 DSA_GetItemPtr (const HDSA hdsa, INT nIndex)
1415 {
1416 LPVOID pSrc;
1417
1418 TRACE("(%p %d)\n", hdsa, nIndex);
1419
1420 if (!hdsa)
1421 return NULL;
1422 if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
1423 return NULL;
1424
1425 pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1426
1427 TRACE("-- ret=%p\n", pSrc);
1428
1429 return pSrc;
1430 }
1431
1432
1433 /**************************************************************************
1434 * DSA_SetItem [COMCTL32.325]
1435 *
1436 * Sets the contents of an item in the array.
1437 *
1438 * PARAMS
1439 * hdsa [I] pointer to the array control structure
1440 * nIndex [I] index for the item
1441 * pSrc [I] pointer to the new item data
1442 *
1443 * RETURNS
1444 * Success: TRUE
1445 * Failure: FALSE
1446 */
1447
1448 BOOL WINAPI
1449 DSA_SetItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
1450 {
1451 INT nSize, nNewItems;
1452 LPVOID pDest, lpTemp;
1453
1454 TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
1455
1456 if ((!hdsa) || nIndex < 0)
1457 return FALSE;
1458
1459 if (hdsa->nItemCount <= nIndex) {
1460 /* within the old array */
1461 if (hdsa->nMaxCount > nIndex) {
1462 /* within the allocated space, set a new boundary */
1463 hdsa->nItemCount = nIndex + 1;
1464 }
1465 else {
1466 /* resize the block of memory */
1467 nNewItems =
1468 hdsa->nGrow * ((INT)(((nIndex + 1) - 1) / hdsa->nGrow) + 1);
1469 nSize = hdsa->nItemSize * nNewItems;
1470
1471 lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
1472 if (!lpTemp)
1473 return FALSE;
1474
1475 hdsa->nMaxCount = nNewItems;
1476 hdsa->nItemCount = nIndex + 1;
1477 hdsa->pData = lpTemp;
1478 }
1479 }
1480
1481 /* put the new entry in */
1482 pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1483 TRACE("-- move dest=%p src=%p size=%d\n",
1484 pDest, pSrc, hdsa->nItemSize);
1485 memmove (pDest, pSrc, hdsa->nItemSize);
1486
1487 return TRUE;
1488 }
1489
1490
1491 /**************************************************************************
1492 * DSA_InsertItem [COMCTL32.324]
1493 *
1494 * PARAMS
1495 * hdsa [I] pointer to the array control structure
1496 * nIndex [I] index for the new item
1497 * pSrc [I] pointer to the element
1498 *
1499 * RETURNS
1500 * Success: position of the new item
1501 * Failure: -1
1502 */
1503
1504 INT WINAPI
1505 DSA_InsertItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
1506 {
1507 INT nNewItems, nSize;
1508 LPVOID lpTemp, lpDest;
1509
1510 TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
1511
1512 if ((!hdsa) || nIndex < 0)
1513 return -1;
1514
1515 /* when nIndex >= nItemCount then append */
1516 if (nIndex >= hdsa->nItemCount)
1517 nIndex = hdsa->nItemCount;
1518
1519 /* do we need to resize ? */
1520 if (hdsa->nItemCount >= hdsa->nMaxCount) {
1521 nNewItems = hdsa->nMaxCount + hdsa->nGrow;
1522 nSize = hdsa->nItemSize * nNewItems;
1523
1524 lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
1525 if (!lpTemp)
1526 return -1;
1527
1528 hdsa->nMaxCount = nNewItems;
1529 hdsa->pData = lpTemp;
1530 }
1531
1532 /* do we need to move elements ? */
1533 if (nIndex < hdsa->nItemCount) {
1534 lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1535 lpDest = (char *) lpTemp + hdsa->nItemSize;
1536 nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
1537 TRACE("-- move dest=%p src=%p size=%d\n",
1538 lpDest, lpTemp, nSize);
1539 memmove (lpDest, lpTemp, nSize);
1540 }
1541
1542 /* ok, we can put the new Item in */
1543 hdsa->nItemCount++;
1544 lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1545 TRACE("-- move dest=%p src=%p size=%d\n",
1546 lpDest, pSrc, hdsa->nItemSize);
1547 memmove (lpDest, pSrc, hdsa->nItemSize);
1548
1549 return nIndex;
1550 }
1551
1552
1553 /**************************************************************************
1554 * DSA_DeleteItem [COMCTL32.326]
1555 *
1556 * PARAMS
1557 * hdsa [I] pointer to the array control structure
1558 * nIndex [I] index for the element to delete
1559 *
1560 * RETURNS
1561 * Success: number of the deleted element
1562 * Failure: -1
1563 */
1564
1565 INT WINAPI
1566 DSA_DeleteItem (const HDSA hdsa, INT nIndex)
1567 {
1568 LPVOID lpDest,lpSrc;
1569 INT nSize;
1570
1571 TRACE("(%p %d)\n", hdsa, nIndex);
1572
1573 if (!hdsa)
1574 return -1;
1575 if (nIndex < 0 || nIndex >= hdsa->nItemCount)
1576 return -1;
1577
1578 /* do we need to move ? */
1579 if (nIndex < hdsa->nItemCount - 1) {
1580 lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1581 lpSrc = (char *) lpDest + hdsa->nItemSize;
1582 nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
1583 TRACE("-- move dest=%p src=%p size=%d\n",
1584 lpDest, lpSrc, nSize);
1585 memmove (lpDest, lpSrc, nSize);
1586 }
1587
1588 hdsa->nItemCount--;
1589
1590 /* free memory ? */
1591 if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
1592 nSize = hdsa->nItemSize * hdsa->nItemCount;
1593
1594 lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
1595 if (!lpDest)
1596 return -1;
1597
1598 hdsa->nMaxCount = hdsa->nItemCount;
1599 hdsa->pData = lpDest;
1600 }
1601
1602 return nIndex;
1603 }
1604
1605
1606 /**************************************************************************
1607 * DSA_DeleteAllItems [COMCTL32.327]
1608 *
1609 * Removes all items and reinitializes the array.
1610 *
1611 * PARAMS
1612 * hdsa [I] pointer to the array control structure
1613 *
1614 * RETURNS
1615 * Success: TRUE
1616 * Failure: FALSE
1617 */
1618
1619 BOOL WINAPI
1620 DSA_DeleteAllItems (const HDSA hdsa)
1621 {
1622 TRACE("(%p)\n", hdsa);
1623
1624 if (!hdsa)
1625 return FALSE;
1626 if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
1627 return FALSE;
1628
1629 hdsa->nItemCount = 0;
1630 hdsa->pData = NULL;
1631 hdsa->nMaxCount = 0;
1632
1633 return TRUE;
1634 }
1635
1636
1637 /**************************************************************************
1638 * The DPA-API is a set of functions to create and manipulate arrays of
1639 * pointers.
1640 */
1641
1642 /**************************************************************************
1643 * DPA_Create [COMCTL32.328] Creates a dynamic pointer array
1644 *
1645 * PARAMS
1646 * nGrow [I] number of items by which the array grows when it is filled
1647 *
1648 * RETURNS
1649 * Success: handle (pointer) to the pointer array.
1650 * Failure: NULL
1651 */
1652
1653 HDPA WINAPI
1654 DPA_Create (INT nGrow)
1655 {
1656 HDPA hdpa;
1657
1658 TRACE("(%d)\n", nGrow);
1659
1660 hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
1661 if (hdpa) {
1662 hdpa->nGrow = max(8, nGrow);
1663 hdpa->hHeap = COMCTL32_hHeap;
1664 hdpa->nMaxCount = hdpa->nGrow * 2;
1665 hdpa->ptrs =
1666 (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
1667 }
1668
1669 TRACE("-- %p\n", hdpa);
1670
1671 return hdpa;
1672 }
1673
1674
1675 /**************************************************************************
1676 * DPA_Destroy [COMCTL32.329] Destroys a dynamic pointer array
1677 *
1678 * PARAMS
1679 * hdpa [I] handle (pointer) to the pointer array
1680 *
1681 * RETURNS
1682 * Success: TRUE
1683 * Failure: FALSE
1684 */
1685
1686 BOOL WINAPI
1687 DPA_Destroy (const HDPA hdpa)
1688 {
1689 TRACE("(%p)\n", hdpa);
1690
1691 if (!hdpa)
1692 return FALSE;
1693
1694 if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
1695 return FALSE;
1696
1697 return HeapFree (hdpa->hHeap, 0, hdpa);
1698 }
1699
1700
1701 /**************************************************************************
1702 * DPA_Grow [COMCTL32.330]
1703 *
1704 * Sets the growth amount.
1705 *
1706 * PARAMS
1707 * hdpa [I] handle (pointer) to the existing (source) pointer array
1708 * nGrow [I] number of items by which the array grows when it's too small
1709 *
1710 * RETURNS
1711 * Success: TRUE
1712 * Failure: FALSE
1713 */
1714
1715 BOOL WINAPI
1716 DPA_Grow (const HDPA hdpa, INT nGrow)
1717 {
1718 TRACE("(%p %d)\n", hdpa, nGrow);
1719
1720 if (!hdpa)
1721 return FALSE;
1722
1723 hdpa->nGrow = max(8, nGrow);
1724
1725 return TRUE;
1726 }
1727
1728
1729 /**************************************************************************
1730 * DPA_Clone [COMCTL32.331]
1731 *
1732 * Copies a pointer array to an other one or creates a copy
1733 *
1734 * PARAMS
1735 * hdpa [I] handle (pointer) to the existing (source) pointer array
1736 * hdpaNew [O] handle (pointer) to the destination pointer array
1737 *
1738 * RETURNS
1739 * Success: pointer to the destination pointer array.
1740 * Failure: NULL
1741 *
1742 * NOTES
1743 * - If the 'hdpaNew' is a NULL-Pointer, a copy of the source pointer
1744 * array will be created and it's handle (pointer) is returned.
1745 * - If 'hdpa' is a NULL-Pointer, the original implementation crashes,
1746 * this implementation just returns NULL.
1747 */
1748
1749 HDPA WINAPI
1750 DPA_Clone (const HDPA hdpa, const HDPA hdpaNew)
1751 {
1752 INT nNewItems, nSize;
1753 HDPA hdpaTemp;
1754
1755 if (!hdpa)
1756 return NULL;
1757
1758 TRACE("(%p %p)\n", hdpa, hdpaNew);
1759
1760 if (!hdpaNew) {
1761 /* create a new DPA */
1762 hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1763 sizeof(DPA));
1764 hdpaTemp->hHeap = hdpa->hHeap;
1765 hdpaTemp->nGrow = hdpa->nGrow;
1766 }
1767 else
1768 hdpaTemp = hdpaNew;
1769
1770 if (hdpaTemp->ptrs) {
1771 /* remove old pointer array */
1772 HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
1773 hdpaTemp->ptrs = NULL;
1774 hdpaTemp->nItemCount = 0;
1775 hdpaTemp->nMaxCount = 0;
1776 }
1777
1778 /* create a new pointer array */
1779 nNewItems = hdpaTemp->nGrow *
1780 ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
1781 nSize = nNewItems * sizeof(LPVOID);
1782 hdpaTemp->ptrs =
1783 (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
1784 hdpaTemp->nMaxCount = nNewItems;
1785
1786 /* clone the pointer array */
1787 hdpaTemp->nItemCount = hdpa->nItemCount;
1788 memmove (hdpaTemp->ptrs, hdpa->ptrs,
1789 hdpaTemp->nItemCount * sizeof(LPVOID));
1790
1791 return hdpaTemp;
1792 }
1793
1794
1795 /**************************************************************************
1796 * DPA_GetPtr [COMCTL32.332]
1797 *
1798 * Retrieves a pointer from a dynamic pointer array
1799 *
1800 * PARAMS
1801 * hdpa [I] handle (pointer) to the pointer array
1802 * nIndex [I] array index of the desired pointer
1803 *
1804 * RETURNS
1805 * Success: pointer
1806 * Failure: NULL
1807 */
1808
1809 LPVOID WINAPI
1810 DPA_GetPtr (const HDPA hdpa, INT i)
1811 {
1812 TRACE("(%p %d)\n", hdpa, i);
1813
1814 if (!hdpa)
1815 return NULL;
1816 if (!hdpa->ptrs) {
1817 WARN("no pointer array.\n");
1818 return NULL;
1819 }
1820 if ((i < 0) || (i >= hdpa->nItemCount)) {
1821 WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
1822 return NULL;
1823 }
1824
1825 TRACE("-- %p\n", hdpa->ptrs[i]);
1826
1827 return hdpa->ptrs[i];
1828 }
1829
1830
1831 /**************************************************************************
1832 * DPA_GetPtrIndex [COMCTL32.333]
1833 *
1834 * Retrieves the index of the specified pointer
1835 *
1836 * PARAMS
1837 * hdpa [I] handle (pointer) to the pointer array
1838 * p [I] pointer
1839 *
1840 * RETURNS
1841 * Success: index of the specified pointer
1842 * Failure: -1
1843 */
1844
1845 INT WINAPI
1846 DPA_GetPtrIndex (const HDPA hdpa, LPVOID p)
1847 {
1848 INT i;
1849
1850 if (!hdpa || !hdpa->ptrs)
1851 return -1;
1852
1853 for (i = 0; i < hdpa->nItemCount; i++) {
1854 if (hdpa->ptrs[i] == p)
1855 return i;
1856 }
1857
1858 return -1;
1859 }
1860
1861
1862 /**************************************************************************
1863 * DPA_InsertPtr [COMCTL32.334]
1864 *
1865 * Inserts a pointer into a dynamic pointer array
1866 *
1867 * PARAMS
1868 * hdpa [I] handle (pointer) to the array
1869 * i [I] array index
1870 * p [I] pointer to insert
1871 *
1872 * RETURNS
1873 * Success: index of the inserted pointer
1874 * Failure: -1
1875 */
1876
1877 INT WINAPI
1878 DPA_InsertPtr (const HDPA hdpa, INT i, LPVOID p)
1879 {
1880 TRACE("(%p %d %p)\n", hdpa, i, p);
1881
1882 if (!hdpa || i < 0) return -1;
1883
1884 if (i >= 0x7fff)
1885 i = hdpa->nItemCount;
1886
1887 if (i >= hdpa->nItemCount)
1888 return DPA_SetPtr(hdpa, i, p) ? i : -1;
1889
1890 /* create empty spot at the end */
1891 if (!DPA_SetPtr(hdpa, hdpa->nItemCount, 0)) return -1;
1892 memmove (hdpa->ptrs + i + 1, hdpa->ptrs + i, (hdpa->nItemCount - i - 1) * sizeof(LPVOID));
1893 hdpa->ptrs[i] = p;
1894 return i;
1895 }
1896
1897 /**************************************************************************
1898 * DPA_SetPtr [COMCTL32.335]
1899 *
1900 * Sets a pointer in the pointer array
1901 *
1902 * PARAMS
1903 * hdpa [I] handle (pointer) to the pointer array
1904 * i [I] index of the pointer that will be set
1905 * p [I] pointer to be set
1906 *
1907 * RETURNS
1908 * Success: TRUE
1909 * Failure: FALSE
1910 */
1911
1912 BOOL WINAPI
1913 DPA_SetPtr (const HDPA hdpa, INT i, LPVOID p)
1914 {
1915 LPVOID *lpTemp;
1916
1917 TRACE("(%p %d %p)\n", hdpa, i, p);
1918
1919 if (!hdpa || i < 0 || i > 0x7fff)
1920 return FALSE;
1921
1922 if (hdpa->nItemCount <= i) {
1923 /* within the old array */
1924 if (hdpa->nMaxCount <= i) {
1925 /* resize the block of memory */
1926 INT nNewItems =
1927 hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1);
1928 INT nSize = nNewItems * sizeof(LPVOID);
1929
1930 if (hdpa->ptrs)
1931 lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, hdpa->ptrs, nSize);
1932 else
1933 lpTemp = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, nSize);
1934
1935 if (!lpTemp)
1936 return FALSE;
1937
1938 hdpa->nMaxCount = nNewItems;
1939 hdpa->ptrs = lpTemp;
1940 }
1941 hdpa->nItemCount = i+1;
1942 }
1943
1944 /* put the new entry in */
1945 hdpa->ptrs[i] = p;
1946
1947 return TRUE;
1948 }
1949
1950
1951 /**************************************************************************
1952 * DPA_DeletePtr [COMCTL32.336]
1953 *
1954 * Removes a pointer from the pointer array.
1955 *
1956 * PARAMS
1957 * hdpa [I] handle (pointer) to the pointer array
1958 * i [I] index of the pointer that will be deleted
1959 *
1960 * RETURNS
1961 * Success: deleted pointer
1962 * Failure: NULL
1963 */
1964
1965 LPVOID WINAPI
1966 DPA_DeletePtr (const HDPA hdpa, INT i)
1967 {
1968 LPVOID *lpDest, *lpSrc, lpTemp = NULL;
1969 INT nSize;
1970
1971 TRACE("(%p %d)\n", hdpa, i);
1972
1973 if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
1974 return NULL;
1975
1976 lpTemp = hdpa->ptrs[i];
1977
1978 /* do we need to move ?*/
1979 if (i < hdpa->nItemCount - 1) {
1980 lpDest = hdpa->ptrs + i;
1981 lpSrc = lpDest + 1;
1982 nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
1983 TRACE("-- move dest=%p src=%p size=%x\n",
1984 lpDest, lpSrc, nSize);
1985 memmove (lpDest, lpSrc, nSize);
1986 }
1987
1988 hdpa->nItemCount --;
1989
1990 /* free memory ?*/
1991 if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
1992 INT nNewItems = max(hdpa->nGrow * 2, hdpa->nItemCount);
1993 nSize = nNewItems * sizeof(LPVOID);
1994 lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1995 hdpa->ptrs, nSize);
1996 if (!lpDest)
1997 return NULL;
1998
1999 hdpa->nMaxCount = nNewItems;
2000 hdpa->ptrs = (LPVOID*)lpDest;
2001 }
2002
2003 return lpTemp;
2004 }
2005
2006
2007 /**************************************************************************
2008 * DPA_DeleteAllPtrs [COMCTL32.337]
2009 *
2010 * Removes all pointers and reinitializes the array.
2011 *
2012 * PARAMS
2013 * hdpa [I] handle (pointer) to the pointer array
2014 *
2015 * RETURNS
2016 * Success: TRUE
2017 * Failure: FALSE
2018 */
2019
2020 BOOL WINAPI
2021 DPA_DeleteAllPtrs (const HDPA hdpa)
2022 {
2023 TRACE("(%p)\n", hdpa);
2024
2025 if (!hdpa)
2026 return FALSE;
2027
2028 if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
2029 return FALSE;
2030
2031 hdpa->nItemCount = 0;
2032 hdpa->nMaxCount = hdpa->nGrow * 2;
2033 hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
2034 hdpa->nMaxCount * sizeof(LPVOID));
2035
2036 return TRUE;
2037 }
2038
2039
2040 /**************************************************************************
2041 * DPA_QuickSort [Internal]
2042 *
2043 * Ordinary quicksort (used by DPA_Sort).
2044 *
2045 * PARAMS
2046 * lpPtrs [I] pointer to the pointer array
2047 * l [I] index of the "left border" of the partition
2048 * r [I] index of the "right border" of the partition
2049 * pfnCompare [I] pointer to the compare function
2050 * lParam [I] user defined value (3rd parameter in compare function)
2051 *
2052 * RETURNS
2053 * NONE
2054 */
2055
2056 static VOID
2057 DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r,
2058 PFNDPACOMPARE pfnCompare, LPARAM lParam)
2059 {
2060 INT m;
2061 LPVOID t;
2062
2063 TRACE("l=%i r=%i\n", l, r);
2064
2065 if (l==r) /* one element is always sorted */
2066 return;
2067 if (r<l) /* oops, got it in the wrong order */
2068 {
2069 DPA_QuickSort(lpPtrs, r, l, pfnCompare, lParam);
2070 return;
2071 }
2072 m = (l+r)/2; /* divide by two */
2073 DPA_QuickSort(lpPtrs, l, m, pfnCompare, lParam);
2074 DPA_QuickSort(lpPtrs, m+1, r, pfnCompare, lParam);
2075
2076 /* join the two sides */
2077 while( (l<=m) && (m<r) )
2078 {
2079 if(pfnCompare(lpPtrs[l],lpPtrs[m+1],lParam)>0)
2080 {
2081 t = lpPtrs[m+1];
2082 memmove(&lpPtrs[l+1],&lpPtrs[l],(m-l+1)*sizeof lpPtrs[l]);
2083 lpPtrs[l] = t;
2084
2085 m++;
2086 }
2087 l++;
2088 }
2089 }
2090
2091
2092 /**************************************************************************
2093 * DPA_Sort [COMCTL32.338]
2094 *
2095 * Sorts a pointer array using a user defined compare function
2096 *
2097 * PARAMS
2098 * hdpa [I] handle (pointer) to the pointer array
2099 * pfnCompare [I] pointer to the compare function
2100 * lParam [I] user defined value (3rd parameter of compare function)
2101 *
2102 * RETURNS
2103 * Success: TRUE
2104 * Failure: FALSE
2105 */
2106
2107 BOOL WINAPI
2108 DPA_Sort (const HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam)
2109 {
2110 if (!hdpa || !pfnCompare)
2111 return FALSE;
2112
2113 TRACE("(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
2114
2115 if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
2116 DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
2117 pfnCompare, lParam);
2118
2119 return TRUE;
2120 }
2121
2122
2123 /**************************************************************************
2124 * DPA_Search [COMCTL32.339]
2125 *
2126 * Searches a pointer array for a specified pointer
2127 *
2128 * PARAMS
2129 * hdpa [I] handle (pointer) to the pointer array
2130 * pFind [I] pointer to search for
2131 * nStart [I] start index
2132 * pfnCompare [I] pointer to the compare function
2133 * lParam [I] user defined value (3rd parameter of compare function)
2134 * uOptions [I] search options
2135 *
2136 * RETURNS
2137 * Success: index of the pointer in the array.
2138 * Failure: -1
2139 *
2140 * NOTES
2141 * Binary search taken from R.Sedgewick "Algorithms in C"!
2142 * Function is NOT tested!
2143 * If something goes wrong, blame HIM not ME! (Eric Kohl)
2144 */
2145
2146 INT WINAPI
2147 DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart,
2148 PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
2149 {
2150 if (!hdpa || !pfnCompare || !pFind)
2151 return -1;
2152
2153 TRACE("(%p %p %d %p 0x%08lx 0x%08x)\n",
2154 hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
2155
2156 if (uOptions & DPAS_SORTED) {
2157 /* array is sorted --> use binary search */
2158 INT l, r, x, n;
2159 LPVOID *lpPtr;
2160
2161 TRACE("binary search\n");
2162
2163 l = (nStart == -1) ? 0 : nStart;
2164 r = hdpa->nItemCount - 1;
2165 lpPtr = hdpa->ptrs;
2166 while (r >= l) {
2167 x = (l + r) / 2;
2168 n = (pfnCompare)(pFind, lpPtr[x], lParam);
2169 if (n < 0)
2170 r = x - 1;
2171 else
2172 l = x + 1;
2173 if (n == 0) {
2174 TRACE("-- ret=%d\n", n);
2175 return n;
2176 }
2177 }
2178
2179 if (uOptions & DPAS_INSERTBEFORE) {
2180 TRACE("-- ret=%d\n", r);
2181 return r;
2182 }
2183
2184 if (uOptions & DPAS_INSERTAFTER) {
2185 TRACE("-- ret=%d\n", l);
2186 return l;
2187 }
2188 }
2189 else {
2190 /* array is not sorted --> use linear search */
2191 LPVOID *lpPtr;
2192 INT nIndex;
2193
2194 TRACE("linear search\n");
2195
2196 nIndex = (nStart == -1)? 0 : nStart;
2197 lpPtr = hdpa->ptrs;
2198 for (; nIndex < hdpa->nItemCount; nIndex++) {
2199 if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
2200 TRACE("-- ret=%d\n", nIndex);
2201 return nIndex;
2202 }
2203 }
2204 }
2205
2206 TRACE("-- not found: ret=-1\n");
2207 return -1;
2208 }
2209
2210
2211 /**************************************************************************
2212 * DPA_CreateEx [COMCTL32.340]
2213 *
2214 * Creates a dynamic pointer array using the specified size and heap.
2215 *
2216 * PARAMS
2217 * nGrow [I] number of items by which the array grows when it is filled
2218 * hHeap [I] handle to the heap where the array is stored
2219 *
2220 * RETURNS
2221 * Success: handle (pointer) to the pointer array.
2222 * Failure: NULL
2223 */
2224
2225 HDPA WINAPI
2226 DPA_CreateEx (INT nGrow, HANDLE hHeap)
2227 {
2228 HDPA hdpa;
2229
2230 TRACE("(%d %p)\n", nGrow, hHeap);
2231
2232 if (hHeap)
2233 hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
2234 else
2235 hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
2236
2237 if (hdpa) {
2238 hdpa->nGrow = min(8, nGrow);
2239 hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
2240 hdpa->nMaxCount = hdpa->nGrow * 2;
2241 hdpa->ptrs =
2242 (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
2243 hdpa->nMaxCount * sizeof(LPVOID));
2244 }
2245
2246 TRACE("-- %p\n", hdpa);
2247
2248 return hdpa;
2249 }
2250
2251
2252 /**************************************************************************
2253 * Notification functions
2254 */
2255
2256 typedef struct tagNOTIFYDATA
2257 {
2258 HWND hwndFrom;
2259 HWND hwndTo;
2260 DWORD dwParam3;
2261 DWORD dwParam4;
2262 DWORD dwParam5;
2263 DWORD dwParam6;
2264 } NOTIFYDATA, *LPNOTIFYDATA;
2265
2266
2267 /**************************************************************************
2268 * DoNotify [Internal]
2269 */
2270
2271 static LRESULT
2272 DoNotify (LPNOTIFYDATA lpNotify, UINT uCode, LPNMHDR lpHdr)
2273 {
2274 NMHDR nmhdr;
2275 LPNMHDR lpNmh = NULL;
2276 UINT idFrom = 0;
2277
2278 TRACE("(%p %p %d %p 0x%08lx)\n",
2279 lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
2280 lpNotify->dwParam5);
2281
2282 if (!lpNotify->hwndTo)
2283 return 0;
2284
2285 if (lpNotify->hwndFrom == (HWND)-1) {
2286 lpNmh = lpHdr;
2287 idFrom = lpHdr->idFrom;
2288 }
2289 else {
2290 if (lpNotify->hwndFrom) {
2291 HWND hwndParent = GetParent (lpNotify->hwndFrom);
2292 if (hwndParent) {
2293 hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER);
2294 /* the following is done even if the return from above
2295 * is zero. GLA 12/2001 */
2296 idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
2297 }
2298 }
2299
2300 lpNmh = (lpHdr) ? lpHdr : &nmhdr;
2301
2302 lpNmh->hwndFrom = lpNotify->hwndFrom;
2303 lpNmh->idFrom = idFrom;
2304 lpNmh->code = uCode;
2305 }
2306
2307 return SendMessageA (lpNotify->hwndTo, WM_NOTIFY, idFrom, (LPARAM)lpNmh);
2308 }
2309
2310
2311 /**************************************************************************
2312 * SendNotify [COMCTL32.341]
2313 *
2314 * PARAMS
2315 * hwndTo [I]
2316 * hwndFrom [I]
2317 * uCode [I]
2318 * lpHdr [I]
2319 *
2320 * RETURNS
2321 * Success: return value from notification
2322 * Failure: 0
2323 */
2324
2325 LRESULT WINAPI
2326 COMCTL32_SendNotify (HWND hwndTo, HWND hwndFrom,
2327 UINT uCode, LPNMHDR lpHdr)
2328 {
2329 NOTIFYDATA notify;
2330
2331 TRACE("(%p %p %d %p)\n",
2332 hwndTo, hwndFrom, uCode, lpHdr);
2333
2334 notify.hwndFrom = hwndFrom;
2335 notify.hwndTo = hwndTo;
2336 notify.dwParam5 = 0;
2337 notify.dwParam6 = 0;
2338
2339 return DoNotify (&notify, uCode, lpHdr);
2340 }
2341
2342
2343 /**************************************************************************
2344 * SendNotifyEx [COMCTL32.342]
2345 *
2346 * PARAMS
2347 * hwndFrom [I]
2348 * hwndTo [I]
2349 * uCode [I]
2350 * lpHdr [I]
2351 * dwParam5 [I]
2352 *
2353 * RETURNS
2354 * Success: return value from notification
2355 * Failure: 0
2356 */
2357
2358 LRESULT WINAPI
2359 COMCTL32_SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
2360 LPNMHDR lpHdr, DWORD dwParam5)
2361 {
2362 NOTIFYDATA notify;
2363 HWND hwndNotify;
2364
2365 TRACE("(%p %p %d %p 0x%08lx)\n",
2366 hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
2367
2368 hwndNotify = hwndTo;
2369 if (!hwndTo) {
2370 if (IsWindow (hwndFrom)) {
2371 hwndNotify = GetParent (hwndFrom);
2372 if (!hwndNotify)
2373 return 0;
2374 }
2375 }
2376
2377 notify.hwndFrom = hwndFrom;
2378 notify.hwndTo = hwndNotify;
2379 notify.dwParam5 = dwParam5;
2380 notify.dwParam6 = 0;
2381
2382 return DoNotify (&notify, uCode, lpHdr);
2383 }
2384
2385
2386 /**************************************************************************
2387 * StrChrA [COMCTL32.350]
2388 *
2389 */
2390
2391 LPSTR WINAPI
2392 COMCTL32_StrChrA (LPCSTR lpString, CHAR cChar)
2393 {
2394 return strchr (lpString, cChar);
2395 }
2396
2397
2398 /**************************************************************************
2399 * StrStrIA [COMCTL32.355]
2400 */
2401
2402 LPSTR WINAPI
2403 COMCTL32_StrStrIA (LPCSTR lpStr1, LPCSTR lpStr2)
2404 {
2405 INT len1, len2, i;
2406 CHAR first;
2407
2408 if (*lpStr2 == 0)
2409 return ((LPSTR)lpStr1);
2410 len1 = 0;
2411 while (lpStr1[len1] != 0) ++len1;
2412 len2 = 0;
2413 while (lpStr2[len2] != 0) ++len2;
2414 if (len2 == 0)
2415 return ((LPSTR)(lpStr1 + len1));
2416 first = tolower (*lpStr2);
2417 while (len1 >= len2) {
2418 if (tolower(*lpStr1) == first) {
2419 for (i = 1; i < len2; ++i)
2420 if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
2421 break;
2422 if (i >= len2)
2423 return ((LPSTR)lpStr1);
2424 }
2425 ++lpStr1; --len1;
2426 }
2427 return (NULL);
2428 }
2429
2430 /**************************************************************************
2431 * StrToIntA [COMCTL32.357] Converts a string to a signed integer.
2432 */
2433
2434 INT WINAPI
2435 COMCTL32_StrToIntA (LPSTR lpString)
2436 {
2437 return atoi(lpString);
2438 }
2439
2440 /**************************************************************************
2441 * StrStrIW [COMCTL32.363]
2442 */
2443
2444 LPWSTR WINAPI
2445 COMCTL32_StrStrIW (LPCWSTR lpStr1, LPCWSTR lpStr2)
2446 {
2447 INT len1, len2, i;
2448 WCHAR first;
2449
2450 if (*lpStr2 == 0)
2451 return ((LPWSTR)lpStr1);
2452 len1 = 0;
2453 while (lpStr1[len1] != 0) ++len1;
2454 len2 = 0;
2455 while (lpStr2[len2] != 0) ++len2;
2456 if (len2 == 0)
2457 return ((LPWSTR)(lpStr1 + len1));
2458 first = tolowerW (*lpStr2);
2459 while (len1 >= len2) {
2460 if (tolowerW (*lpStr1) == first) {
2461 for (i = 1; i < len2; ++i)
2462 if (tolowerW (lpStr1[i]) != tolowerW(lpStr2[i]))
2463 break;
2464 if (i >= len2)
2465 return ((LPWSTR)lpStr1);
2466 }
2467 ++lpStr1; --len1;
2468 }
2469 return (NULL);
2470 }
2471
2472 /**************************************************************************
2473 * StrToIntW [COMCTL32.365] Converts a wide char string to a signed integer.
2474 */
2475
2476 INT WINAPI
2477 COMCTL32_StrToIntW (LPWSTR lpString)
2478 {
2479 return atoiW(lpString);
2480 }
2481
2482
2483 /**************************************************************************
2484 * DPA_EnumCallback [COMCTL32.385]
2485 *
2486 * Enumerates all items in a dynamic pointer array.
2487 *
2488 * PARAMS
2489 * hdpa [I] handle to the dynamic pointer array
2490 * enumProc [I]
2491 * lParam [I]
2492 *
2493 * RETURNS
2494 * none
2495 */
2496
2497 VOID WINAPI
2498 DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
2499 {
2500 INT i;
2501
2502 TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam);
2503
2504 if (!hdpa)
2505 return;
2506 if (hdpa->nItemCount <= 0)
2507 return;
2508
2509 for (i = 0; i < hdpa->nItemCount; i++) {
2510 if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
2511 return;
2512 }
2513
2514 return;
2515 }
2516
2517
2518 /**************************************************************************
2519 * DPA_DestroyCallback [COMCTL32.386]
2520 *
2521 * Enumerates all items in a dynamic pointer array and destroys it.
2522 *
2523 * PARAMS
2524 * hdpa [I] handle to the dynamic pointer array
2525 * enumProc [I]
2526 * lParam [I]
2527 *
2528 * RETURNS
2529 * Success: TRUE
2530 * Failure: FALSE
2531 */
2532
2533 BOOL WINAPI
2534 DPA_DestroyCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
2535 {
2536 TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam);
2537
2538 DPA_EnumCallback (hdpa, enumProc, lParam);
2539
2540 return DPA_Destroy (hdpa);
2541 }
2542
2543
2544 /**************************************************************************
2545 * DSA_EnumCallback [COMCTL32.387]
2546 *
2547 * Enumerates all items in a dynamic storage array.
2548 *
2549 * PARAMS
2550 * hdsa [I] handle to the dynamic storage array
2551 * enumProc [I]
2552 * lParam [I]
2553 *
2554 * RETURNS
2555 * none
2556 */
2557
2558 VOID WINAPI
2559 DSA_EnumCallback (const HDSA hdsa, DSAENUMPROC enumProc, LPARAM lParam)
2560 {
2561 INT i;
2562
2563 TRACE("(%p %p %08lx)\n", hdsa, enumProc, lParam);
2564
2565 if (!hdsa)
2566 return;
2567 if (hdsa->nItemCount <= 0)
2568 return;
2569
2570 for (i = 0; i < hdsa->nItemCount; i++) {
2571 LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
2572 if ((enumProc)(lpItem, lParam) == 0)
2573 return;
2574 }
2575
2576 return;
2577 }
2578
2579
2580 /**************************************************************************
2581 * DSA_DestroyCallback [COMCTL32.388]
2582 *
2583 * Enumerates all items in a dynamic storage array and destroys it.
2584 *
2585 * PARAMS
2586 * hdsa [I] handle to the dynamic storage array
2587 * enumProc [I]
2588 * lParam [I]
2589 *
2590 * RETURNS
2591 * Success: TRUE
2592 * Failure: FALSE
2593 */
2594
2595 BOOL WINAPI
2596 DSA_DestroyCallback (const HDSA hdsa, DSAENUMPROC enumProc, LPARAM lParam)
2597 {
2598 TRACE("(%p %p %08lx)\n", hdsa, enumProc, lParam);
2599
2600 DSA_EnumCallback (hdsa, enumProc, lParam);
2601
2602 return DSA_Destroy (hdsa);
2603 }
2604
2605 /**************************************************************************
2606 * StrCSpnA [COMCTL32.356]
2607 *
2608 */
2609 INT WINAPI COMCTL32_StrCSpnA( LPCSTR lpStr, LPCSTR lpSet) {
2610 return strcspn(lpStr, lpSet);
2611 }
2612
2613 /**************************************************************************
2614 * StrChrW [COMCTL32.358]
2615 *
2616 */
2617 LPWSTR WINAPI COMCTL32_StrChrW( LPCWSTR lpStart, WORD wMatch) {
2618 return strchrW(lpStart, wMatch);
2619 }
2620
2621 /**************************************************************************
2622 * StrCmpNA [COMCTL32.352]
2623 *
2624 */
2625 INT WINAPI COMCTL32_StrCmpNA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar) {
2626 return strncmp(lpStr1, lpStr2, nChar);
2627 }
2628
2629 /**************************************************************************
2630 * StrCmpNIA [COMCTL32.353]
2631 *
2632 */
2633 INT WINAPI COMCTL32_StrCmpNIA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar) {
2634 return strncasecmp(lpStr1, lpStr2, nChar);
2635 }
2636
2637 /**************************************************************************
2638 * StrCmpNW [COMCTL32.360]
2639 *
2640 */
2641 INT WINAPI COMCTL32_StrCmpNW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) {
2642 return strncmpW(lpStr1, lpStr2, nChar);
2643 }
2644
2645 /**************************************************************************
2646 * StrCmpNIW [COMCTL32.361]
2647 *
2648 */
2649 INT WINAPI COMCTL32_StrCmpNIW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) {
2650 FIXME("(%s, %s, %i): stub\n", debugstr_w(lpStr1), debugstr_w(lpStr2), nChar);
2651 return 0;
2652 }
2653
2654 /**************************************************************************
2655 * StrRChrA [COMCTL32.351]
2656 *
2657 */
2658 LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch )
2659 {
2660 LPCSTR lpGotIt = NULL;
2661 BOOL dbcs = IsDBCSLeadByte( LOBYTE(wMatch) );
2662
2663 TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
2664
2665 if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
2666
2667 for(; lpStart < lpEnd; lpStart = CharNextA(lpStart))
2668 {
2669 if (*lpStart != LOBYTE(wMatch)) continue;
2670 if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
2671 lpGotIt = lpStart;
2672 }
2673 return (LPSTR)lpGotIt;
2674 }
2675
2676
2677 /**************************************************************************
2678 * StrRChrW [COMCTL32.359]
2679 *
2680 */
2681 LPWSTR WINAPI COMCTL32_StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch)
2682 {
2683 LPCWSTR lpGotIt = NULL;
2684
2685 TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch);
2686 if (!lpEnd) lpEnd = lpStart + strlenW(lpStart);
2687
2688 for(; lpStart < lpEnd; lpStart = CharNextW(lpStart))
2689 if (*lpStart == wMatch) lpGotIt = lpStart;
2690
2691 return (LPWSTR)lpGotIt;
2692 }
2693
2694
2695 /**************************************************************************
2696 * StrStrA [COMCTL32.354]
2697 *
2698 */
2699 LPSTR WINAPI COMCTL32_StrStrA( LPCSTR lpFirst, LPCSTR lpSrch) {
2700 return strstr(lpFirst, lpSrch);
2701 }
2702
2703 /**************************************************************************
2704 * StrStrW [COMCTL32.362]
2705 *
2706 */
2707 LPWSTR WINAPI COMCTL32_StrStrW( LPCWSTR lpFirst, LPCWSTR lpSrch) {
2708 return strstrW(lpFirst, lpSrch);
2709 }
2710
2711 /**************************************************************************
2712 * StrSpnW [COMCTL32.364]
2713 *
2714 */
2715 INT WINAPI COMCTL32_StrSpnW( LPWSTR lpStr, LPWSTR lpSet) {
2716 LPWSTR lpLoop = lpStr;
2717
2718 /* validate ptr */
2719 if ((lpStr == 0) || (lpSet == 0)) return 0;
2720
2721 /* while(*lpLoop) { if lpLoop++; } */
2722
2723 for(; (*lpLoop != 0); lpLoop++)
2724 if( strchrW(lpSet, *(WORD*)lpLoop))
2725 return (INT)(lpLoop-lpStr);
2726
2727 return (INT)(lpLoop-lpStr);
2728 }
2729
2730 /**************************************************************************
2731 * @ [COMCTL32.410]
2732 *
2733 * FIXME: What's this supposed to do?
2734 * Parameter 1 is an HWND, you're on your own for the rest.
2735 */
2736
2737 BOOL WINAPI COMCTL32_410( HWND hw, DWORD b, DWORD c, DWORD d) {
2738
2739 FIXME("(%p, %lx, %lx, %lx): stub!\n", hw, b, c, d);
2740
2741 return TRUE;
2742 }
2743
2744 /**************************************************************************
2745 * @ [COMCTL32.411]
2746 *
2747 * FIXME: What's this supposed to do?
2748 * Parameter 1 is an HWND, you're on your own for the rest.
2749 */
2750
2751 BOOL WINAPI COMCTL32_411( HWND hw, DWORD b, DWORD c) {
2752
2753 FIXME("(%p, %lx, %lx): stub!\n", hw, b, c);
2754
2755 return TRUE;
2756 }
2757
2758 /**************************************************************************
2759 * @ [COMCTL32.412]
2760 *
2761 * FIXME: What's this supposed to do?
2762 * Parameter 1 is an HWND, you're on your own for the rest.
2763 */
2764
2765 BOOL WINAPI COMCTL32_412( HWND hwnd, DWORD b, DWORD c)
2766 {
2767 FIXME("(%p, %lx, %lx): stub!\n", hwnd, b, c);
2768
2769 if (IsWindow (hwnd) == FALSE)
2770 return FALSE;
2771
2772 if (b == 0)
2773 return FALSE;
2774
2775
2776 return TRUE;
2777 }
2778
2779 /**************************************************************************
2780 * @ [COMCTL32.413]
2781 *
2782 * FIXME: What's this supposed to do?
2783 * Parameter 1 is an HWND, you're on your own for the rest.
2784 */
2785
2786 BOOL WINAPI COMCTL32_413( HWND hw, DWORD b, DWORD c, DWORD d) {
2787
2788 FIXME("(%p, %lx, %lx, %lx): stub!\n", hw, b, c, d);
2789
2790 return TRUE;
2791 }
2792
2793
2794 /**************************************************************************
2795 * @ [COMCTL32.415]
2796 *
2797 * FIXME: What's this supposed to do?
2798 * Parameter 1 is an HWND, you're on your own for the rest.
2799 */
2800
2801 BOOL WINAPI COMCTL32_415( HWND hwnd, DWORD b, DWORD c, DWORD d, DWORD e)
2802 {
2803
2804 FIXME("(%p, %lx, %lx, %lx, %lx): stub!\n", hwnd, b, c, d, e);
2805
2806 return TRUE;
2807 }
2808
2809 /**************************************************************************
2810 * @ [COMCTL32.417]
2811 *
2812 */
2813 BOOL WINAPI COMCTL32_417(HDC hdc, INT x, INT y, UINT flags, const RECT *lprect,
2814 LPCWSTR str, UINT count, const INT *lpDx)
2815 {
2816 return ExtTextOutW(hdc, x, y, flags, lprect, str, count, lpDx);
2817 }
2818
2819 /**************************************************************************
2820 * @ [COMCTL32.419]
2821 *
2822 * FIXME: What's this supposed to do?
2823 */
2824
2825 BOOL WINAPI COMCTL32_419( DWORD a, DWORD b, DWORD c, DWORD d)
2826 {
2827
2828 FIXME("(%lx, %lx, %lx, %lx): stub!\n", a, b, c, d);
2829
2830 return TRUE;
2831 }
Maarten's multimedia branch