?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Commented out unused variables to prevent needless compiler warnings.
[wine.git] / dlls / comctl32 / comctl32undoc.c
blobcd1759937d1848aa1cbbbb9f0b59cb56e182701e
1 /*
2 * Undocumented functions from COMCTL32.DLL
3 *
4 * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
5 * 1998 Juergen Schmied <j.schmied@metronet.de>
6 * NOTES
7 * All of these functions are UNDOCUMENTED!! And I mean UNDOCUMENTED!!!!
8 * Do NOT rely on names or contents of undocumented structures and types!!!
9 * These functions are used by EXPLORER.EXE, IEXPLORE.EXE and
10 * COMCTL32.DLL (internally).
11 *
12 * TODO
13 * - Add more functions.
14 * - Write some documentation.
15 */
16
17 #include <string.h>
18 #include <stdlib.h>
19 #include <ctype.h>
20 #include "windows.h"
21 #include "commctrl.h"
22 #include "heap.h"
23 #include "debug.h"
24
25
26 extern HANDLE32 COMCTL32_hHeap; /* handle to the private heap */
27
28 /*
29 * We put some function prototypes here that don't seem to belong in
30 * any header file. When they find their place, we can remove them.
31 */
32 extern LPWSTR __cdecl CRTDLL_wcschr(LPCWSTR, WCHAR);
33 extern LPSTR WINAPI lstrrchr(LPCSTR, LPCSTR, WORD);
34 extern LPWSTR WINAPI lstrrchrw(LPCWSTR, LPCWSTR, WORD);
35 extern LPWSTR WINAPI strstrw(LPCWSTR, LPCWSTR);
36
37
38 /**************************************************************************
39 * DPA_Merge [COMCTL32.11]
40 *
41 * PARAMS
42 * hdpa1 [I] handle to a dynamic pointer array
43 * hdpa2 [I] handle to a dynamic pointer array
44 * dwFlags [I] flags
45 * pfnSort [I] pointer to sort function
46 * dwParam5 [I]
47 * lParam [I] application specific value
48 *
49 * NOTES
50 * No more information available yet!
51 */
52
53 BOOL32 WINAPI
54 DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
55 PFNDPACOMPARE pfnCompare, LPVOID pfnParam5, LPARAM lParam)
56 {
57 /* LPVOID *pWork1, *pWork2; */
58 INT32 nCount1, nCount2;
59
60 TRACE (commctrl, "(%p %p %08lx %p %p %08lx): stub!\n",
61 hdpa1, hdpa2, dwFlags, pfnCompare, pfnParam5, lParam);
62
63 if (IsBadWritePtr32 (hdpa1, sizeof(DPA)))
64 return FALSE;
65
66 if (IsBadWritePtr32 (hdpa2, sizeof(DPA)))
67 return FALSE;
68
69 if (IsBadCodePtr32 ((FARPROC32)pfnCompare))
70 return FALSE;
71
72 if (IsBadCodePtr32 ((FARPROC32)pfnParam5))
73 return FALSE;
74
75 if (dwFlags & DPAM_SORT) {
76 TRACE (commctrl, "sorting dpa's!\n");
77 DPA_Sort (hdpa1, pfnCompare, lParam);
78 DPA_Sort (hdpa2, pfnCompare, lParam);
79 }
80
81 if (hdpa2->nItemCount <= 0)
82 return TRUE;
83
84 nCount1 = hdpa1->nItemCount - 1;
85
86 nCount2 = hdpa2->nItemCount - 1;
87
88 FIXME (commctrl, "nCount1=%d nCount2=%d\n", nCount1, nCount2);
89 FIXME (commctrl, "semi stub!\n");
90 #if 0
91
92 do {
93
94
95 if (nResult == 0) {
96
97 }
98 else if (nResult > 0) {
99
100 }
101 else {
102
103 }
104
105 }
106 while (nCount2 >= 0);
107
108 #endif
109
110
111 return TRUE;
112 }
113
114
115 /**************************************************************************
116 * Alloc [COMCTL32.71]
117 *
118 * Allocates memory block from the dll's private heap
119 *
120 * PARAMS
121 * dwSize [I] size of the allocated memory block
122 *
123 * RETURNS
124 * Success: pointer to allocated memory block
125 * Failure: NULL
126 */
127
128 LPVOID WINAPI
129 COMCTL32_Alloc (DWORD dwSize)
130 {
131 LPVOID lpPtr;
132
133 TRACE (commctrl, "(0x%lx)\n", dwSize);
134
135 lpPtr = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
136
137 TRACE (commctrl, "-- ret=%p\n", lpPtr);
138
139 return lpPtr;
140 }
141
142
143 /**************************************************************************
144 * ReAlloc [COMCTL32.72]
145 *
146 * Changes the size of an allocated memory block or allocates a memory
147 * block using the dll's private heap.
148 *
149 * PARAMS
150 * lpSrc [I] pointer to memory block which will be resized
151 * dwSize [I] new size of the memory block.
152 *
153 * RETURNS
154 * Success: pointer to the resized memory block
155 * Failure: NULL
156 *
157 * NOTES
158 * If lpSrc is a NULL-pointer, then COMCTL32_ReAlloc allocates a memory
159 * block like COMCTL32_Alloc.
160 */
161
162 LPVOID WINAPI
163 COMCTL32_ReAlloc (LPVOID lpSrc, DWORD dwSize)
164 {
165 LPVOID lpDest;
166
167 TRACE (commctrl, "(%p 0x%08lx)\n", lpSrc, dwSize);
168
169 if (lpSrc)
170 lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
171 else
172 lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
173
174 TRACE (commctrl, "-- ret=%p\n", lpDest);
175
176 return lpDest;
177 }
178
179
180 /**************************************************************************
181 * Free [COMCTL32.73]
182 *
183 * Frees an allocated memory block from the dll's private heap.
184 *
185 * PARAMS
186 * lpMem [I] pointer to memory block which will be freed
187 *
188 * RETURNS
189 * Success: TRUE
190 * Failure: FALSE
191 */
192
193 BOOL32 WINAPI
194 COMCTL32_Free (LPVOID lpMem)
195 {
196 TRACE (commctrl, "(%p)\n", lpMem);
197
198 return HeapFree (COMCTL32_hHeap, 0, lpMem);
199 }
200
201
202 /**************************************************************************
203 * GetSize [COMCTL32.74]
204 *
205 * Retrieves the size of the specified memory block from the dll's
206 * private heap.
207 *
208 * PARAMS
209 * lpMem [I] pointer to an allocated memory block
210 *
211 * RETURNS
212 * Success: size of the specified memory block
213 * Failure: 0
214 */
215
216 DWORD WINAPI
217 COMCTL32_GetSize (LPVOID lpMem)
218 {
219 TRACE (commctrl, "(%p)\n", lpMem);
220
221 return HeapSize (COMCTL32_hHeap, 0, lpMem);
222 }
223
224
225 /**************************************************************************
226 * The MRU-API is a set of functions to manipulate MRU(Most Recently Used)
227 * lists.
228 *
229 *
230 */
231
232 typedef struct tagMRUINFO
233 {
234 DWORD dwParam1;
235 DWORD dwParam2;
236 DWORD dwParam3;
237 HKEY hkeyMain;
238 LPCSTR lpszSubKey;
239 DWORD dwParam6;
240 } MRUINFO, *LPMRUINFO;
241
242
243 typedef struct tagMRU
244 {
245 DWORD dwParam1; /* some kind of flag */
246 DWORD dwParam2;
247 DWORD dwParam3;
248 HKEY hkeyMRU;
249 LPCSTR lpszSubKey;
250 DWORD dwParam6;
251 } MRU, *HMRU;
252
253 LPVOID WINAPI
254 CreateMRUListLazy32A (LPMRUINFO lpmi, DWORD dwParam2,
255 DWORD dwParam3, DWORD dwParam4);
256
257
258 /**************************************************************************
259 * CreateMRUListA [COMCTL32.151]
260 *
261 * PARAMS
262 * dwParam
263 *
264 * RETURNS
265 */
266
267 LPVOID WINAPI
268 CreateMRUList32A (LPMRUINFO lpmi)
269 {
270 return CreateMRUListLazy32A (lpmi, 0, 0, 0);
271 }
272
273
274 DWORD WINAPI
275 FreeMRUList32A (HMRU hmru)
276 {
277 FIXME (commctrl, "(%p) empty stub!\n", hmru);
278
279 #if 0
280 if (!(hmru->dwParam1 & 1001)) {
281 RegSetValueEx32A (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
282 hmru->lpszMRUString,
283 lstrlen32A (hmru->lpszMRUString));
284 }
285
286
287 RegClosKey32 (hmru->hkeyMRU
288 COMCTL32_Free32 (hmru->lpszMRUString);
289 #endif
290
291 return COMCTL32_Free (hmru);
292 }
293
294
295
296 DWORD WINAPI
297 AddMRUData (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
298 {
299
300 FIXME (commctrl, "(%lx %lx %lx) empty stub!\n",
301 dwParam1, dwParam2, dwParam3);
302
303 return 0;
304 }
305
306
307 DWORD WINAPI
308 FindMRUData (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4)
309 {
310
311 FIXME (commctrl, "(%lx %lx %lx %lx) empty stub!\n",
312 dwParam1, dwParam2, dwParam3, dwParam4);
313
314 return TRUE;
315 }
316
317
318 LPVOID WINAPI
319 CreateMRUListLazy32A (LPMRUINFO lpmi, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4)
320 {
321 /* DWORD dwLocal1; *
322 * HKEY hkeyResult; *
323 * DWORD dwLocal3; *
324 * LPVOID lMRU; *
325 * DWORD dwLocal5; *
326 * DWORD dwLocal6; *
327 * DWORD dwLocal7; *
328 * DWORD dwDisposition; */
329
330 /* internal variables */
331 LPVOID ptr;
332
333 FIXME (commctrl, "(%p) empty stub!\n", lpmi);
334
335 if (lpmi) {
336 FIXME (commctrl, "(%lx %lx %lx %lx \"%s\" %lx)\n",
337 lpmi->dwParam1, lpmi->dwParam2, lpmi->dwParam3,
338 lpmi->hkeyMain, lpmi->lpszSubKey, lpmi->dwParam6);
339 }
340
341 /* dummy pointer creation */
342 ptr = COMCTL32_Alloc (32);
343
344 FIXME (commctrl, "-- ret = %p\n", ptr);
345
346 return ptr;
347 }
348
349
350
351
352 /**************************************************************************
353 * Str_GetPtrA [COMCTL32.233]
354 *
355 * PARAMS
356 * lpSrc [I]
357 * lpDest [O]
358 * nMaxLen [I]
359 *
360 * RETURNS
361 */
362
363 INT32 WINAPI
364 Str_GetPtr32A (LPCSTR lpSrc, LPSTR lpDest, INT32 nMaxLen)
365 {
366 INT32 len;
367
368 TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
369
370 if (!lpDest && lpSrc)
371 return lstrlen32A (lpSrc);
372
373 if (nMaxLen == 0)
374 return 0;
375
376 if (lpSrc == NULL) {
377 lpDest[0] = '\0';
378 return 0;
379 }
380
381 len = lstrlen32A (lpSrc);
382 if (len >= nMaxLen)
383 len = nMaxLen - 1;
384
385 RtlMoveMemory (lpDest, lpSrc, len);
386 lpDest[len] = '\0';
387
388 return len;
389 }
390
391
392 /**************************************************************************
393 * Str_SetPtrA [COMCTL32.234]
394 *
395 * PARAMS
396 * lppDest [O]
397 * lpSrc [I]
398 *
399 * RETURNS
400 */
401
402 BOOL32 WINAPI
403 Str_SetPtr32A (LPSTR *lppDest, LPCSTR lpSrc)
404 {
405 TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
406
407 if (lpSrc) {
408 LPSTR ptr = COMCTL32_ReAlloc (*lppDest, lstrlen32A (lpSrc) + 1);
409 if (!ptr)
410 return FALSE;
411 lstrcpy32A (ptr, lpSrc);
412 *lppDest = ptr;
413 }
414 else {
415 if (*lppDest) {
416 COMCTL32_Free (*lppDest);
417 *lppDest = NULL;
418 }
419 }
420
421 return TRUE;
422 }
423
424
425 /**************************************************************************
426 * Str_GetPtrW [COMCTL32.235]
427 *
428 * PARAMS
429 * lpSrc [I]
430 * lpDest [O]
431 * nMaxLen [I]
432 *
433 * RETURNS
434 */
435
436 INT32 WINAPI
437 Str_GetPtr32W (LPCWSTR lpSrc, LPWSTR lpDest, INT32 nMaxLen)
438 {
439 INT32 len;
440
441 TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
442
443 if (!lpDest && lpSrc)
444 return lstrlen32W (lpSrc);
445
446 if (nMaxLen == 0)
447 return 0;
448
449 if (lpSrc == NULL) {
450 lpDest[0] = L'\0';
451 return 0;
452 }
453
454 len = lstrlen32W (lpSrc);
455 if (len >= nMaxLen)
456 len = nMaxLen - 1;
457
458 RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
459 lpDest[len] = L'\0';
460
461 return len;
462 }
463
464
465 /**************************************************************************
466 * Str_SetPtrW [COMCTL32.236]
467 *
468 * PARAMS
469 * lpDest [O]
470 * lpSrc [I]
471 *
472 * RETURNS
473 */
474
475 BOOL32 WINAPI
476 Str_SetPtr32W (LPWSTR *lppDest, LPCWSTR lpSrc)
477 {
478 TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
479
480 if (lpSrc) {
481 INT32 len = lstrlen32W (lpSrc) + 1;
482 LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
483 if (!ptr)
484 return FALSE;
485 lstrcpy32W (ptr, lpSrc);
486 *lppDest = ptr;
487 }
488 else {
489 if (*lppDest) {
490 COMCTL32_Free (*lppDest);
491 *lppDest = NULL;
492 }
493 }
494
495 return TRUE;
496 }
497
498
499 /**************************************************************************
500 * The DSA-API is a set of functions to create and manipulate arrays of
501 * fix sized memory blocks. These arrays can store any kind of data
502 * (strings, icons...).
503 */
504
505 /**************************************************************************
506 * DSA_Create [COMCTL32.320] Creates a dynamic storage array
507 *
508 * PARAMS
509 * nSize [I] size of the array elements
510 * nGrow [I] number of elements by which the array grows when it is filled
511 *
512 * RETURNS
513 * Success: pointer to a array control structure. use this like a handle.
514 * Failure: NULL
515 */
516
517 HDSA WINAPI
518 DSA_Create (INT32 nSize, INT32 nGrow)
519 {
520 HDSA hdsa;
521
522 TRACE (commctrl, "(size=%d grow=%d)\n", nSize, nGrow);
523
524 hdsa = (HDSA)COMCTL32_Alloc (sizeof(DSA));
525 if (hdsa)
526 {
527 hdsa->nItemCount = 0;
528 hdsa->pData = NULL;
529 hdsa->nMaxCount = 0;
530 hdsa->nItemSize = nSize;
531 hdsa->nGrow = MAX(1, nGrow);
532 }
533
534 return hdsa;
535 }
536
537
538 /**************************************************************************
539 * DSA_Destroy [COMCTL32.321] Destroys a dynamic storage array
540 *
541 * PARAMS
542 * hdsa [I] pointer to the array control structure
543 *
544 * RETURNS
545 * Success: TRUE
546 * Failure: FALSE
547 */
548
549 BOOL32 WINAPI
550 DSA_Destroy (const HDSA hdsa)
551 {
552 TRACE (commctrl, "(%p)\n", hdsa);
553
554 if (!hdsa)
555 return FALSE;
556
557 if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
558 return FALSE;
559
560 return COMCTL32_Free (hdsa);
561 }
562
563
564 /**************************************************************************
565 * DSA_GetItem [COMCTL32.322]
566 *
567 * PARAMS
568 * hdsa [I] pointer to the array control structure
569 * nIndex [I] number of the Item to get
570 * pDest [O] destination buffer. Has to be >= dwElementSize.
571 *
572 * RETURNS
573 * Success: TRUE
574 * Failure: FALSE
575 */
576
577 BOOL32 WINAPI
578 DSA_GetItem (const HDSA hdsa, INT32 nIndex, LPVOID pDest)
579 {
580 LPVOID pSrc;
581
582 TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pDest);
583
584 if (!hdsa)
585 return FALSE;
586 if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
587 return FALSE;
588
589 pSrc = hdsa->pData + (hdsa->nItemSize * nIndex);
590 memmove (pDest, pSrc, hdsa->nItemSize);
591
592 return TRUE;
593 }
594
595
596 /**************************************************************************
597 * DSA_GetItemPtr [COMCTL32.323]
598 *
599 * Retrieves a pointer to the specified item.
600 *
601 * PARAMS
602 * hdsa [I] pointer to the array control structure
603 * nIndex [I] index of the desired item
604 *
605 * RETURNS
606 * Success: pointer to an item
607 * Failure: NULL
608 */
609
610 LPVOID WINAPI
611 DSA_GetItemPtr (const HDSA hdsa, INT32 nIndex)
612 {
613 LPVOID pSrc;
614
615 TRACE (commctrl, "(%p %d)\n", hdsa, nIndex);
616
617 if (!hdsa)
618 return NULL;
619 if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
620 return NULL;
621
622 pSrc = hdsa->pData + (hdsa->nItemSize * nIndex);
623
624 TRACE (commctrl, "-- ret=%p\n", pSrc);
625
626 return pSrc;
627 }
628
629
630 /**************************************************************************
631 * DSA_SetItem [COMCTL32.325]
632 *
633 * Sets the contents of an item in the array.
634 *
635 * PARAMS
636 * hdsa [I] pointer to the array control structure
637 * nIndex [I] index for the item
638 * pSrc [I] pointer to the new item data
639 *
640 * RETURNS
641 * Success: TRUE
642 * Failure: FALSE
643 */
644
645 BOOL32 WINAPI
646 DSA_SetItem (const HDSA hdsa, INT32 nIndex, LPVOID pSrc)
647 {
648 INT32 nSize, nNewItems;
649 LPVOID pDest, lpTemp;
650
651 TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pSrc);
652
653 if ((!hdsa) || nIndex < 0)
654 return FALSE;
655
656 if (hdsa->nItemCount <= nIndex) {
657 /* within the old array */
658 if (hdsa->nMaxCount > nIndex) {
659 /* within the allocated space, set a new boundary */
660 hdsa->nItemCount = nIndex;
661 }
662 else {
663 /* resize the block of memory */
664 nNewItems =
665 hdsa->nGrow * ((INT32)((nIndex - 1) / hdsa->nGrow) + 1);
666 nSize = hdsa->nItemSize * nNewItems;
667
668 lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
669 if (!lpTemp)
670 return FALSE;
671
672 hdsa->nMaxCount = nNewItems;
673 hdsa->pData = lpTemp;
674 }
675 }
676
677 /* put the new entry in */
678 pDest = hdsa->pData + (hdsa->nItemSize * nIndex);
679 TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
680 pDest, pSrc, hdsa->nItemSize);
681 memmove (pDest, pSrc, hdsa->nItemSize);
682
683 return TRUE;
684 }
685
686
687 /**************************************************************************
688 * DSA_InsertItem [COMCTL32.325]
689 *
690 * PARAMS
691 * hdsa [I] pointer to the array control structure
692 * nIndex [I] index for the new item
693 * pSrc [I] pointer to the element
694 *
695 * RETURNS
696 * Success: position of the new item
697 * Failure: -1
698 */
699
700 INT32 WINAPI
701 DSA_InsertItem (const HDSA hdsa, INT32 nIndex, LPVOID pSrc)
702 {
703 INT32 nNewItems, nSize, i;
704 LPVOID lpTemp, lpDest;
705 LPDWORD p;
706
707 TRACE(commctrl, "(%p %d %p)\n", hdsa, nIndex, pSrc);
708
709 if ((!hdsa) || nIndex < 0)
710 return -1;
711
712 for (i = 0; i < hdsa->nItemSize; i += 4) {
713 p = *(DWORD**)(pSrc + i);
714 if (IsBadStringPtr32A ((char*)p, 256))
715 TRACE (commctrl, "-- %d=%p\n", i, (DWORD*)p);
716 else
717 TRACE (commctrl, "-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
718 }
719
720 /* when nIndex > nItemCount then append */
721 if (nIndex >= hdsa->nItemCount)
722 nIndex = hdsa->nItemCount;
723
724 /* do we need to resize ? */
725 if (hdsa->nItemCount >= hdsa->nMaxCount) {
726 nNewItems = hdsa->nMaxCount + hdsa->nGrow;
727 nSize = hdsa->nItemSize * nNewItems;
728
729 lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
730 if (!lpTemp)
731 return -1;
732
733 hdsa->nMaxCount = nNewItems;
734 hdsa->pData = lpTemp;
735 }
736
737 /* do we need to move elements ? */
738 if (nIndex < hdsa->nItemCount) {
739 lpTemp = hdsa->pData + (hdsa->nItemSize * nIndex);
740 lpDest = lpTemp + hdsa->nItemSize;
741 nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
742 TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
743 lpDest, lpTemp, nSize);
744 memmove (lpDest, lpTemp, nSize);
745 }
746
747 /* ok, we can put the new Item in */
748 hdsa->nItemCount++;
749 lpDest = hdsa->pData + (hdsa->nItemSize * nIndex);
750 TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
751 lpDest, pSrc, hdsa->nItemSize);
752 memmove (lpDest, pSrc, hdsa->nItemSize);
753
754 return hdsa->nItemCount;
755 }
756
757
758 /**************************************************************************
759 * DSA_DeleteItem [COMCTL32.326]
760 *
761 * PARAMS
762 * hdsa [I] pointer to the array control structure
763 * nIndex [I] index for the element to delete
764 *
765 * RETURNS
766 * Success: number of the deleted element
767 * Failure: -1
768 */
769
770 INT32 WINAPI
771 DSA_DeleteItem (const HDSA hdsa, INT32 nIndex)
772 {
773 LPVOID lpDest,lpSrc;
774 INT32 nSize;
775
776 TRACE (commctrl, "(%p %d)\n", hdsa, nIndex);
777
778 if (!hdsa)
779 return -1;
780 if (nIndex < 0 || nIndex >= hdsa->nItemCount)
781 return -1;
782
783 /* do we need to move ? */
784 if (nIndex < hdsa->nItemCount - 1) {
785 lpDest = hdsa->pData + (hdsa->nItemSize * nIndex);
786 lpSrc = lpDest + hdsa->nItemSize;
787 nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
788 TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
789 lpDest, lpSrc, nSize);
790 memmove (lpDest, lpSrc, nSize);
791 }
792
793 hdsa->nItemCount--;
794
795 /* free memory ? */
796 if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
797 nSize = hdsa->nItemSize * hdsa->nItemCount;
798
799 lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
800 if (!lpDest)
801 return -1;
802
803 hdsa->nMaxCount = hdsa->nItemCount;
804 hdsa->pData = lpDest;
805 }
806
807 return nIndex;
808 }
809
810
811 /**************************************************************************
812 * DSA_DeleteAllItems [COMCTL32.326]
813 *
814 * Removes all items and reinitializes the array.
815 *
816 * PARAMS
817 * hdsa [I] pointer to the array control structure
818 *
819 * RETURNS
820 * Success: TRUE
821 * Failure: FALSE
822 */
823
824 BOOL32 WINAPI
825 DSA_DeleteAllItems (const HDSA hdsa)
826 {
827 TRACE (commctrl, "(%p)\n", hdsa);
828
829 if (!hdsa)
830 return FALSE;
831 if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
832 return FALSE;
833
834 hdsa->nItemCount = 0;
835 hdsa->pData = NULL;
836 hdsa->nMaxCount = 0;
837
838 return TRUE;
839 }
840
841
842 /**************************************************************************
843 * The DPA-API is a set of functions to create and manipulate arrays of
844 * pointers.
845 */
846
847 /**************************************************************************
848 * DPA_Create [COMCTL32.328] Creates a dynamic pointer array
849 *
850 * PARAMS
851 * nGrow [I] number of items by which the array grows when it is filled
852 *
853 * RETURNS
854 * Success: handle (pointer) to the pointer array.
855 * Failure: NULL
856 */
857
858 HDPA WINAPI
859 DPA_Create (INT32 nGrow)
860 {
861 HDPA hdpa;
862
863 TRACE (commctrl, "(%d)\n", nGrow);
864
865 hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
866 if (hdpa) {
867 hdpa->nGrow = MAX(8, nGrow);
868 hdpa->hHeap = COMCTL32_hHeap;
869 hdpa->nMaxCount = hdpa->nGrow * 2;
870 hdpa->ptrs =
871 (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
872 }
873
874 TRACE (commctrl, "-- %p\n", hdpa);
875
876 return hdpa;
877 }
878
879
880 /**************************************************************************
881 * DPA_Destroy [COMCTL32.329] Destroys a dynamic pointer array
882 *
883 * PARAMS
884 * hdpa [I] handle (pointer) to the pointer array
885 *
886 * RETURNS
887 * Success: TRUE
888 * Failure: FALSE
889 */
890
891 BOOL32 WINAPI
892 DPA_Destroy (const HDPA hdpa)
893 {
894 TRACE (commctrl, "(%p)\n", hdpa);
895
896 if (!hdpa)
897 return FALSE;
898
899 if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
900 return FALSE;
901
902 return HeapFree (hdpa->hHeap, 0, hdpa);
903 }
904
905
906 /**************************************************************************
907 * DPA_Grow [COMCTL32.330]
908 *
909 * Sets the growth amount.
910 *
911 * PARAMS
912 * hdpa [I] handle (pointer) to the existing (source) pointer array
913 * nGrow [I] number of items, the array grows, when it's too small
914 *
915 * RETURNS
916 * Success: TRUE
917 * Failure: FALSE
918 */
919
920 BOOL32 WINAPI
921 DPA_Grow (const HDPA hdpa, INT32 nGrow)
922 {
923 TRACE (commctrl, "(%p %d)\n", hdpa, nGrow);
924
925 if (!hdpa)
926 return FALSE;
927
928 hdpa->nGrow = MAX(8, nGrow);
929
930 return TRUE;
931 }
932
933
934 /**************************************************************************
935 * DPA_Clone [COMCTL32.331]
936 *
937 * Copies a pointer array to an other one or creates a copy
938 *
939 * PARAMS
940 * hdpa [I] handle (pointer) to the existing (source) pointer array
941 * hdpaNew [O] handle (pointer) to the destination pointer array
942 *
943 * RETURNS
944 * Success: pointer to the destination pointer array.
945 * Failure: NULL
946 *
947 * NOTES
948 * - If the 'hdpaNew' is a NULL-Pointer, a copy of the source pointer
949 * array will be created and it's handle (pointer) is returned.
950 * - If 'hdpa' is a NULL-Pointer, the original implementation crashes,
951 * this implementation just returns NULL.
952 */
953
954 HDPA WINAPI
955 DPA_Clone (const HDPA hdpa, const HDPA hdpaNew)
956 {
957 INT32 nNewItems, nSize;
958 HDPA hdpaTemp;
959
960 if (!hdpa)
961 return NULL;
962
963 TRACE (commctrl, "(%p %p)\n", hdpa, hdpaNew);
964
965 if (!hdpaNew) {
966 /* create a new DPA */
967 hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
968 sizeof(DPA));
969 hdpaTemp->hHeap = hdpa->hHeap;
970 hdpaTemp->nGrow = hdpa->nGrow;
971 }
972 else
973 hdpaTemp = hdpaNew;
974
975 if (hdpaTemp->ptrs) {
976 /* remove old pointer array */
977 HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
978 hdpaTemp->ptrs = NULL;
979 hdpaTemp->nItemCount = 0;
980 hdpaTemp->nMaxCount = 0;
981 }
982
983 /* create a new pointer array */
984 nNewItems = hdpaTemp->nGrow *
985 ((INT32)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
986 nSize = nNewItems * sizeof(LPVOID);
987 hdpaTemp->ptrs =
988 (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
989 hdpaTemp->nMaxCount = nNewItems;
990
991 /* clone the pointer array */
992 hdpaTemp->nItemCount = hdpa->nItemCount;
993 memmove (hdpaTemp->ptrs, hdpa->ptrs,
994 hdpaTemp->nItemCount * sizeof(LPVOID));
995
996 return hdpaTemp;
997 }
998
999
1000 /**************************************************************************
1001 * DPA_GetPtr [COMCTL32.332]
1002 *
1003 * Retrieves a pointer from a dynamic pointer array
1004 *
1005 * PARAMS
1006 * hdpa [I] handle (pointer) to the pointer array
1007 * nIndex [I] array index of the desired pointer
1008 *
1009 * RETURNS
1010 * Success: pointer
1011 * Failure: NULL
1012 */
1013
1014 LPVOID WINAPI
1015 DPA_GetPtr (const HDPA hdpa, INT32 i)
1016 {
1017 TRACE (commctrl, "(%p %d)\n", hdpa, i);
1018
1019 if (!hdpa)
1020 return NULL;
1021 if (!hdpa->ptrs)
1022 return NULL;
1023 if ((i < 0) || (i >= hdpa->nItemCount))
1024 return NULL;
1025
1026 TRACE (commctrl, "-- %p\n", hdpa->ptrs[i]);
1027
1028 return hdpa->ptrs[i];
1029 }
1030
1031
1032 /**************************************************************************
1033 * DPA_GetPtrIndex [COMCTL32.333]
1034 *
1035 * Retrieves the index of the specified pointer
1036 *
1037 * PARAMS
1038 * hdpa [I] handle (pointer) to the pointer array
1039 * p [I] pointer
1040 *
1041 * RETURNS
1042 * Success: index of the specified pointer
1043 * Failure: -1
1044 */
1045
1046 INT32 WINAPI
1047 DPA_GetPtrIndex (const HDPA hdpa, LPVOID p)
1048 {
1049 INT32 i;
1050
1051 if (!hdpa->ptrs)
1052 return -1;
1053
1054 for (i = 0; i < hdpa->nItemCount; i++) {
1055 if (hdpa->ptrs[i] == p)
1056 return i;
1057 }
1058
1059 return -1;
1060 }
1061
1062
1063 /**************************************************************************
1064 * DPA_InsertPtr [COMCTL32.334]
1065 *
1066 * Inserts a pointer into a dynamic pointer array
1067 *
1068 * PARAMS
1069 * hdpa [I] handle (pointer) to the array
1070 * i [I] array index
1071 * p [I] pointer to insert
1072 *
1073 * RETURNS
1074 * Success: index of the inserted pointer
1075 * Failure: -1
1076 */
1077
1078 INT32 WINAPI
1079 DPA_InsertPtr (const HDPA hdpa, INT32 i, LPVOID p)
1080 {
1081 INT32 nNewItems, nSize, nIndex = 0;
1082 LPVOID *lpTemp, *lpDest;
1083
1084 TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p);
1085
1086 if ((!hdpa) || (i < 0))
1087 return -1;
1088
1089 if (!hdpa->ptrs) {
1090 hdpa->ptrs =
1091 (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1092 2 * hdpa->nGrow * sizeof(LPVOID));
1093 if (!hdpa->ptrs)
1094 return -1;
1095 hdpa->nMaxCount = hdpa->nGrow * 2;
1096 nIndex = 0;
1097 }
1098 else {
1099 if (hdpa->nItemCount >= hdpa->nMaxCount) {
1100 TRACE (commctrl, "-- resizing\n");
1101 nNewItems = hdpa->nMaxCount + hdpa->nGrow;
1102 nSize = nNewItems * sizeof(LPVOID);
1103
1104 lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1105 hdpa->ptrs, nSize);
1106 if (!lpTemp)
1107 return -1;
1108 hdpa->nMaxCount = nNewItems;
1109 hdpa->ptrs = lpTemp;
1110 }
1111
1112 if (i >= hdpa->nItemCount) {
1113 nIndex = hdpa->nItemCount;
1114 TRACE (commctrl, "-- appending at %d\n", nIndex);
1115 }
1116 else {
1117 TRACE (commctrl, "-- inserting at %d\n", i);
1118 lpTemp = hdpa->ptrs + i;
1119 lpDest = lpTemp + 1;
1120 nSize = (hdpa->nItemCount - i) * sizeof(LPVOID);
1121 TRACE (commctrl, "-- move dest=%p src=%p size=%x\n",
1122 lpDest, lpTemp, nSize);
1123 memmove (lpDest, lpTemp, nSize);
1124 nIndex = i;
1125 }
1126 }
1127
1128 /* insert item */
1129 hdpa->nItemCount++;
1130 hdpa->ptrs[nIndex] = p;
1131
1132 return nIndex;
1133 }
1134
1135
1136 /**************************************************************************
1137 * DPA_SetPtr [COMCTL32.335]
1138 *
1139 * Sets a pointer in the pointer array
1140 *
1141 * PARAMS
1142 * hdpa [I] handle (pointer) to the pointer array
1143 * i [I] index of the pointer that will be set
1144 * p [I] pointer to be set
1145 *
1146 * RETURNS
1147 * Success: TRUE
1148 * Failure: FALSE
1149 */
1150
1151 BOOL32 WINAPI
1152 DPA_SetPtr (const HDPA hdpa, INT32 i, LPVOID p)
1153 {
1154 LPVOID *lpTemp;
1155
1156 TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p);
1157
1158 if ((!hdpa) || i < 0)
1159 return FALSE;
1160
1161 if (hdpa->nItemCount <= i) {
1162 /* within the old array */
1163 if (hdpa->nMaxCount > i) {
1164 /* within the allocated space, set a new boundary */
1165 hdpa->nItemCount = i;
1166 }
1167 else {
1168 /* resize the block of memory */
1169 INT32 nNewItems =
1170 hdpa->nGrow * ((INT32)((i - 1) / hdpa->nGrow) + 1);
1171 INT32 nSize = nNewItems * sizeof(LPVOID);
1172
1173 lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1174 hdpa->ptrs, nSize);
1175 if (!lpTemp)
1176 return FALSE;
1177
1178 hdpa->nItemCount = nNewItems;
1179 hdpa->ptrs = lpTemp;
1180 }
1181 }
1182
1183 /* put the new entry in */
1184 hdpa->ptrs[i] = p;
1185
1186 return TRUE;
1187 }
1188
1189
1190 /**************************************************************************
1191 * DPA_DeletePtr [COMCTL32.336]
1192 *
1193 * Removes a pointer from the pointer array.
1194 *
1195 * PARAMS
1196 * hdpa [I] handle (pointer) to the pointer array
1197 * i [I] index of the pointer that will be deleted
1198 *
1199 * RETURNS
1200 * Success: deleted pointer
1201 * Failure: NULL
1202 */
1203
1204 LPVOID WINAPI
1205 DPA_DeletePtr (const HDPA hdpa, INT32 i)
1206 {
1207 LPVOID lpDest, lpSrc, lpTemp = NULL;
1208 INT32 nSize;
1209
1210 TRACE (commctrl, "(%p %d)\n", hdpa, i);
1211
1212 if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
1213 return NULL;
1214
1215 lpTemp = hdpa->ptrs[i];
1216
1217 /* do we need to move ?*/
1218 if (i < hdpa->nItemCount - 1) {
1219 lpDest = hdpa->ptrs + i;
1220 lpSrc = lpDest + 1;
1221 nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
1222 TRACE (commctrl,"-- move dest=%p src=%p size=%x\n",
1223 lpDest, lpSrc, nSize);
1224 memmove (lpDest, lpSrc, nSize);
1225 }
1226
1227 hdpa->nItemCount --;
1228
1229 /* free memory ?*/
1230 if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
1231 INT32 nNewItems = MIN(hdpa->nGrow * 2, hdpa->nItemCount);
1232 nSize = nNewItems * sizeof(LPVOID);
1233 lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1234 hdpa->ptrs, nSize);
1235 if (!lpDest)
1236 return NULL;
1237
1238 hdpa->nMaxCount = nNewItems;
1239 hdpa->ptrs = (LPVOID*)lpDest;
1240 }
1241
1242 return lpTemp;
1243 }
1244
1245
1246 /**************************************************************************
1247 * DPA_DeleteAllPtrs [COMCTL32.337]
1248 *
1249 * Removes all pointers and reinitializes the array.
1250 *
1251 * PARAMS
1252 * hdpa [I] handle (pointer) to the pointer array
1253 *
1254 * RETURNS
1255 * Success: TRUE
1256 * Failure: FALSE
1257 */
1258
1259 BOOL32 WINAPI
1260 DPA_DeleteAllPtrs (const HDPA hdpa)
1261 {
1262 TRACE (commctrl, "(%p)\n", hdpa);
1263
1264 if (!hdpa)
1265 return FALSE;
1266
1267 if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
1268 return FALSE;
1269
1270 hdpa->nItemCount = 0;
1271 hdpa->nMaxCount = hdpa->nGrow * 2;
1272 hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1273 hdpa->nMaxCount * sizeof(LPVOID));
1274
1275 return TRUE;
1276 }
1277
1278
1279 /**************************************************************************
1280 * DPA_QuickSort [Internal]
1281 *
1282 * Ordinary quicksort (used by DPA_Sort).
1283 *
1284 * PARAMS
1285 * lpPtrs [I] pointer to the pointer array
1286 * l [I] index of the "left border" of the partition
1287 * r [I] index of the "right border" of the partition
1288 * pfnCompare [I] pointer to the compare function
1289 * lParam [I] user defined value (3rd parameter in compare function)
1290 *
1291 * RETURNS
1292 * NONE
1293 */
1294
1295 static VOID
1296 DPA_QuickSort (LPVOID *lpPtrs, INT32 l, INT32 r,
1297 PFNDPACOMPARE pfnCompare, LPARAM lParam)
1298 {
1299 LPVOID t, v;
1300 INT32 i, j;
1301
1302 TRACE (commctrl, "l=%i r=%i\n", l, r);
1303
1304 i = l;
1305 j = r;
1306 v = lpPtrs[(int)(l+r)/2];
1307 do {
1308 while ((pfnCompare)(lpPtrs[i], v, lParam) < 0) i++;
1309 while ((pfnCompare)(lpPtrs[j], v, lParam) > 0) j--;
1310 if (i <= j)
1311 {
1312 t = lpPtrs[i];
1313 lpPtrs[i++] = lpPtrs[j];
1314 lpPtrs[j--] = t;
1315 }
1316 } while (i <= j);
1317 if (l < j) DPA_QuickSort (lpPtrs, l, j, pfnCompare, lParam);
1318 if (i < r) DPA_QuickSort (lpPtrs, i, r, pfnCompare, lParam);
1319 }
1320
1321
1322 /**************************************************************************
1323 * DPA_Sort [COMCTL32.338]
1324 *
1325 * Sorts a pointer array using a user defined compare function
1326 *
1327 * PARAMS
1328 * hdpa [I] handle (pointer) to the pointer array
1329 * pfnCompare [I] pointer to the compare function
1330 * lParam [I] user defined value (3rd parameter of compare function)
1331 *
1332 * RETURNS
1333 * Success: TRUE
1334 * Failure: FALSE
1335 */
1336
1337 BOOL32 WINAPI
1338 DPA_Sort (const HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam)
1339 {
1340 if (!hdpa || !pfnCompare)
1341 return FALSE;
1342
1343 TRACE (commctrl, "(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
1344
1345 if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
1346 DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
1347 pfnCompare, lParam);
1348
1349 return TRUE;
1350 }
1351
1352
1353 /**************************************************************************
1354 * DPA_Search [COMCTL32.339]
1355 *
1356 * Searches a pointer array for a specified pointer
1357 *
1358 * PARAMS
1359 * hdpa [I] handle (pointer) to the pointer array
1360 * pFind [I] pointer to search for
1361 * nStart [I] start index
1362 * pfnCompare [I] pointer to the compare function
1363 * lParam [I] user defined value (3rd parameter of compare function)
1364 * uOptions [I] search options
1365 *
1366 * RETURNS
1367 * Success: index of the pointer in the array.
1368 * Failure: -1
1369 *
1370 * NOTES
1371 * Binary search taken from R.Sedgewick "Algorithms in C"!
1372 * Function is NOT tested!
1373 * If something goes wrong, blame HIM not ME! (Eric Kohl)
1374 */
1375
1376 INT32 WINAPI
1377 DPA_Search (const HDPA hdpa, LPVOID pFind, INT32 nStart,
1378 PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT32 uOptions)
1379 {
1380 if (!hdpa || !pfnCompare || !pFind)
1381 return -1;
1382
1383 TRACE (commctrl, "(%p %p %d %p 0x%08lx 0x%08x)\n",
1384 hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
1385
1386 if (uOptions & DPAS_SORTED) {
1387 /* array is sorted --> use binary search */
1388 INT32 l, r, x, n;
1389 LPVOID *lpPtr;
1390
1391 TRACE (commctrl, "binary search\n");
1392
1393 l = (nStart == -1) ? 0 : nStart;
1394 r = hdpa->nItemCount - 1;
1395 lpPtr = hdpa->ptrs;
1396 while (r >= l) {
1397 x = (l + r) / 2;
1398 n = (pfnCompare)(pFind, lpPtr[x], lParam);
1399 if (n < 0)
1400 r = x - 1;
1401 else
1402 l = x + 1;
1403 if (n == 0) {
1404 TRACE (commctrl, "-- ret=%d\n", n);
1405 return n;
1406 }
1407 }
1408
1409 if (uOptions & DPAS_INSERTBEFORE) {
1410 TRACE (commctrl, "-- ret=%d\n", r);
1411 return r;
1412 }
1413
1414 if (uOptions & DPAS_INSERTAFTER) {
1415 TRACE (commctrl, "-- ret=%d\n", l);
1416 return l;
1417 }
1418 }
1419 else {
1420 /* array is not sorted --> use linear search */
1421 LPVOID *lpPtr;
1422 INT32 nIndex;
1423
1424 TRACE (commctrl, "linear search\n");
1425
1426 nIndex = (nStart == -1)? 0 : nStart;
1427 lpPtr = hdpa->ptrs;
1428 for (; nIndex < hdpa->nItemCount; nIndex++) {
1429 if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
1430 TRACE (commctrl, "-- ret=%d\n", nIndex);
1431 return nIndex;
1432 }
1433 }
1434 }
1435
1436 TRACE (commctrl, "-- not found: ret=-1\n");
1437 return -1;
1438 }
1439
1440
1441 /**************************************************************************
1442 * DPA_CreateEx [COMCTL32.340]
1443 *
1444 * Creates a dynamic pointer array using the specified size and heap.
1445 *
1446 * PARAMS
1447 * nGrow [I] number of items by which the array grows when it is filled
1448 * hHeap [I] handle to the heap where the array is stored
1449 *
1450 * RETURNS
1451 * Success: handle (pointer) to the pointer array.
1452 * Failure: NULL
1453 */
1454
1455 HDPA WINAPI
1456 DPA_CreateEx (INT32 nGrow, HANDLE32 hHeap)
1457 {
1458 HDPA hdpa;
1459
1460 TRACE (commctrl, "(%d 0x%x)\n", nGrow, hHeap);
1461
1462 if (hHeap)
1463 hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
1464 else
1465 hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
1466
1467 if (hdpa) {
1468 hdpa->nGrow = MIN(8, nGrow);
1469 hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
1470 hdpa->nMaxCount = hdpa->nGrow * 2;
1471 hdpa->ptrs =
1472 (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
1473 hdpa->nMaxCount * sizeof(LPVOID));
1474 }
1475
1476 TRACE (commctrl, "-- %p\n", hdpa);
1477
1478 return hdpa;
1479 }
1480
1481
1482 /**************************************************************************
1483 * Notification functions
1484 */
1485
1486 typedef struct tagNOTIFYDATA
1487 {
1488 HWND32 hwndFrom;
1489 HWND32 hwndTo;
1490 DWORD dwParam3;
1491 DWORD dwParam4;
1492 DWORD dwParam5;
1493 DWORD dwParam6;
1494 } NOTIFYDATA, *LPNOTIFYDATA;
1495
1496
1497 /**************************************************************************
1498 * DoNotify [Internal]
1499 */
1500
1501 static LRESULT
1502 DoNotify (LPNOTIFYDATA lpNotify, UINT32 uCode, LPNMHDR lpHdr)
1503 {
1504 NMHDR nmhdr;
1505 LPNMHDR lpNmh = NULL;
1506 UINT32 idFrom = 0;
1507
1508 TRACE (commctrl, "(0x%04x 0x%04x %d %p 0x%08lx)\n",
1509 lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
1510 lpNotify->dwParam5);
1511
1512 if (!lpNotify->hwndTo)
1513 return 0;
1514
1515 if (lpNotify->hwndFrom == -1) {
1516 lpNmh = lpHdr;
1517 idFrom = lpHdr->idFrom;
1518 }
1519 else {
1520 if (lpNotify->hwndFrom) {
1521 HWND32 hwndParent = GetParent32 (lpNotify->hwndFrom);
1522 if (hwndParent) {
1523 hwndParent = GetWindow32 (lpNotify->hwndFrom, GW_OWNER);
1524 if (hwndParent)
1525 idFrom = GetDlgCtrlID32 (lpNotify->hwndFrom);
1526 }
1527 }
1528
1529 lpNmh = (lpHdr) ? lpHdr : &nmhdr;
1530
1531 lpNmh->hwndFrom = lpNotify->hwndFrom;
1532 lpNmh->idFrom = idFrom;
1533 lpNmh->code = uCode;
1534 }
1535
1536 return SendMessage32A (lpNotify->hwndTo, WM_NOTIFY, idFrom, (LPARAM)lpNmh);
1537 }
1538
1539
1540 /**************************************************************************
1541 * SendNotify [COMCTL32.341]
1542 *
1543 * PARAMS
1544 * hwndFrom [I]
1545 * hwndTo [I]
1546 * uCode [I]
1547 * lpHdr [I]
1548 *
1549 * RETURNS
1550 * Success: return value from notification
1551 * Failure: 0
1552 */
1553
1554 LRESULT WINAPI
1555 COMCTL32_SendNotify (HWND32 hwndFrom, HWND32 hwndTo,
1556 UINT32 uCode, LPNMHDR lpHdr)
1557 {
1558 NOTIFYDATA notify;
1559
1560 TRACE (commctrl, "(0x%04x 0x%04x %d %p)\n",
1561 hwndFrom, hwndTo, uCode, lpHdr);
1562
1563 notify.hwndFrom = hwndFrom;
1564 notify.hwndTo = hwndTo;
1565 notify.dwParam5 = 0;
1566 notify.dwParam6 = 0;
1567
1568 return DoNotify (&notify, uCode, lpHdr);
1569 }
1570
1571
1572 /**************************************************************************
1573 * SendNotifyEx [COMCTL32.342]
1574 *
1575 * PARAMS
1576 * hwndFrom [I]
1577 * hwndTo [I]
1578 * uCode [I]
1579 * lpHdr [I]
1580 * dwParam5 [I]
1581 *
1582 * RETURNS
1583 * Success: return value from notification
1584 * Failure: 0
1585 */
1586
1587 LRESULT WINAPI
1588 COMCTL32_SendNotifyEx (HWND32 hwndTo, HWND32 hwndFrom, UINT32 uCode,
1589 LPNMHDR lpHdr, DWORD dwParam5)
1590 {
1591 NOTIFYDATA notify;
1592 HWND32 hwndNotify;
1593
1594 TRACE (commctrl, "(0x%04x 0x%04x %d %p 0x%08lx)\n",
1595 hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
1596
1597 hwndNotify = hwndTo;
1598 if (!hwndTo) {
1599 if (IsWindow32 (hwndFrom)) {
1600 hwndNotify = GetParent32 (hwndFrom);
1601 if (!hwndNotify)
1602 return 0;
1603 }
1604 }
1605
1606 notify.hwndFrom = hwndFrom;
1607 notify.hwndTo = hwndNotify;
1608 notify.dwParam5 = dwParam5;
1609 notify.dwParam6 = 0;
1610
1611 return DoNotify (&notify, uCode, lpHdr);
1612 }
1613
1614
1615 /**************************************************************************
1616 * StrChrA [COMCTL32.350]
1617 *
1618 */
1619
1620 LPSTR WINAPI
1621 COMCTL32_StrChrA (LPCSTR lpString, CHAR cChar)
1622 {
1623 return strchr (lpString, cChar);
1624 }
1625
1626
1627 /**************************************************************************
1628 * StrStrIA [COMCTL32.355]
1629 */
1630
1631 LPSTR WINAPI
1632 COMCTL32_StrStrIA (LPCSTR lpStr1, LPCSTR lpStr2)
1633 {
1634 INT32 len1, len2, i;
1635 CHAR first;
1636
1637 if (*lpStr2 == 0)
1638 return ((LPSTR)lpStr1);
1639 len1 = 0;
1640 while (lpStr1[len1] != 0) ++len1;
1641 len2 = 0;
1642 while (lpStr2[len2] != 0) ++len2;
1643 if (len2 == 0)
1644 return ((LPSTR)(lpStr1 + len1));
1645 first = tolower (*lpStr2);
1646 while (len1 >= len2) {
1647 if (tolower(*lpStr1) == first) {
1648 for (i = 1; i < len2; ++i)
1649 if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
1650 break;
1651 if (i >= len2)
1652 return ((LPSTR)lpStr1);
1653 }
1654 ++lpStr1; --len1;
1655 }
1656 return (NULL);
1657 }
1658
1659
1660 /**************************************************************************
1661 * StrToIntA [COMCTL32.357] Converts a string to a signed integer.
1662 */
1663
1664 INT32 WINAPI
1665 COMCTL32_StrToIntA (LPSTR lpString)
1666 {
1667 return atoi(lpString);
1668 }
1669
1670
1671 /**************************************************************************
1672 * DPA_EnumCallback [COMCTL32.385]
1673 *
1674 * Enumerates all items in a dynamic pointer array.
1675 *
1676 * PARAMS
1677 * hdpa [I] handle to the dynamic pointer array
1678 * enumProc [I]
1679 * lParam [I]
1680 *
1681 * RETURNS
1682 * none
1683 */
1684
1685 VOID WINAPI
1686 DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
1687 {
1688 INT32 i;
1689
1690 TRACE (commctrl, "(%p %p %08lx)\n", hdpa, enumProc, lParam);
1691
1692 if (!hdpa)
1693 return;
1694 if (hdpa->nItemCount <= 0)
1695 return;
1696
1697 for (i = 0; i < hdpa->nItemCount; i++) {
1698 if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
1699 return;
1700 }
1701
1702 return;
1703 }
1704
1705
1706 /**************************************************************************
1707 * DPA_DestroyCallback [COMCTL32.386]
1708 *
1709 * Enumerates all items in a dynamic pointer array and destroys it.
1710 *
1711 * PARAMS
1712 * hdpa [I] handle to the dynamic pointer array
1713 * enumProc [I]
1714 * lParam [I]
1715 *
1716 * RETURNS
1717 * Success: TRUE
1718 * Failure: FALSE
1719 */
1720
1721 BOOL32 WINAPI
1722 DPA_DestroyCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
1723 {
1724 TRACE (commctrl, "(%p %p %08lx)\n", hdpa, enumProc, lParam);
1725
1726 DPA_EnumCallback (hdpa, enumProc, lParam);
1727
1728 return DPA_Destroy (hdpa);
1729 }
1730
1731
1732 /**************************************************************************
1733 * DSA_EnumCallback [COMCTL32.387]
1734 *
1735 * Enumerates all items in a dynamic storage array.
1736 *
1737 * PARAMS
1738 * hdsa [I] handle to the dynamic storage array
1739 * enumProc [I]
1740 * lParam [I]
1741 *
1742 * RETURNS
1743 * none
1744 */
1745
1746 VOID WINAPI
1747 DSA_EnumCallback (const HDSA hdsa, DSAENUMPROC enumProc, LPARAM lParam)
1748 {
1749 INT32 i;
1750
1751 TRACE (commctrl, "(%p %p %08lx)\n", hdsa, enumProc, lParam);
1752
1753 if (!hdsa)
1754 return;
1755 if (hdsa->nItemCount <= 0)
1756 return;
1757
1758 for (i = 0; i < hdsa->nItemCount; i++) {
1759 LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
1760 if ((enumProc)(lpItem, lParam) == 0)
1761 return;
1762 }
1763
1764 return;
1765 }
1766
1767
1768 /**************************************************************************
1769 * DSA_DestroyCallback [COMCTL32.388]
1770 *
1771 * Enumerates all items in a dynamic storage array and destroys it.
1772 *
1773 * PARAMS
1774 * hdsa [I] handle to the dynamic storage array
1775 * enumProc [I]
1776 * lParam [I]
1777 *
1778 * RETURNS
1779 * Success: TRUE
1780 * Failure: FALSE
1781 */
1782
1783 BOOL32 WINAPI
1784 DSA_DestroyCallback (const HDSA hdsa, DSAENUMPROC enumProc, LPARAM lParam)
1785 {
1786 TRACE (commctrl, "(%p %p %08lx)\n", hdsa, enumProc, lParam);
1787
1788 DSA_EnumCallback (hdsa, enumProc, lParam);
1789
1790 return DSA_Destroy (hdsa);
1791 }
1792
1793 /**************************************************************************
1794 * StrCSpnA [COMCTL32.356]
1795 *
1796 */
1797 INT32 WINAPI COMCTL32_StrCSpnA( LPCSTR lpStr, LPCSTR lpSet) {
1798 return strcspn(lpStr, lpSet);
1799 }
1800
1801 /**************************************************************************
1802 * StrChrW [COMCTL32.358]
1803 *
1804 */
1805 LPWSTR WINAPI COMCTL32_StrChrW( LPCWSTR lpStart, WORD wMatch) {
1806 return CRTDLL_wcschr(lpStart, wMatch);
1807 }
1808
1809 /**************************************************************************
1810 * StrCmpNA [COMCTL32.352]
1811 *
1812 */
1813 INT32 WINAPI COMCTL32_StrCmpNA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar) {
1814 return lstrncmp32A(lpStr1, lpStr2, nChar);
1815 }
1816
1817 /**************************************************************************
1818 * StrCmpNW [COMCTL32.360]
1819 *
1820 */
1821 INT32 WINAPI COMCTL32_StrCmpNW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) {
1822 return lstrncmp32W(lpStr1, lpStr2, nChar);
1823 }
1824
1825 /**************************************************************************
1826 * StrRChrA [COMCTL32.351]
1827 *
1828 */
1829 LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch) {
1830 return lstrrchr(lpStart, lpEnd, wMatch);
1831 }
1832
1833 /**************************************************************************
1834 * StrRChrW [COMCTL32.359]
1835 *
1836 */
1837 LPWSTR WINAPI COMCTL32_StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch) {
1838 return lstrrchrw(lpStart, lpEnd, wMatch);
1839 }
1840
1841 /**************************************************************************
1842 * StrStrA [COMCTL32.354]
1843 *
1844 */
1845 LPSTR WINAPI COMCTL32_StrStrA( LPCSTR lpFirst, LPCSTR lpSrch) {
1846 return strstr(lpFirst, lpSrch);
1847 }
1848
1849 /**************************************************************************
1850 * StrStrW [COMCTL32.362]
1851 *
1852 */
1853 LPWSTR WINAPI COMCTL32_StrStrW( LPCWSTR lpFirst, LPCWSTR lpSrch) {
1854 return strstrw(lpFirst, lpSrch);
1855 }
1856
1857 /**************************************************************************
1858 * StrSpnW [COMCTL32.364]
1859 *
1860 */
1861 INT32 WINAPI COMCTL32_StrSpnW( LPWSTR lpStr, LPWSTR lpSet) {
1862 LPWSTR lpLoop = lpStr;
1863
1864 /* validate ptr */
1865 if ((lpStr == 0) || (lpSet == 0)) return 0;
1866
1867 /* while(*lpLoop) { if lpLoop++; } */
1868
1869 for(; (*lpLoop != 0); lpLoop++)
1870 if( CRTDLL_wcschr(lpSet, *(WORD*)lpLoop))
1871 return (INT32)(lpLoop-lpStr);
1872
1873 return (INT32)(lpLoop-lpStr);
1874 }
1875
1876
Windows API implementation