| /* |
| * Undocumented functions from COMCTL32.DLL |
| * |
| * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de> |
| * 1998 Juergen Schmied <j.schmied@metronet.de> |
| * NOTES |
| * All of these functions are UNDOCUMENTED!! And I mean UNDOCUMENTED!!!! |
| * Do NOT rely on names or contents of undocumented structures and types!!! |
| * These functions are used by EXPLORER.EXE, IEXPLORE.EXE and |
| * COMCTL32.DLL (internally). |
| * |
| * TODO |
| * - Add more functions. |
| * - Write some documentation. |
| */ |
| |
| #include <string.h> |
| #include <stdlib.h> |
| #include <ctype.h> |
| #include "windows.h" |
| #include "commctrl.h" |
| #include "heap.h" |
| #include "debug.h" |
| |
| |
| CRITICAL_SECTION cs_comctl_alloc; |
| HANDLE32 hComctl32Heap = 0; |
| |
| |
| /************************************************************************** |
| * COMCTL32_11 [COMCTL32.11] |
| */ |
| |
| DWORD WINAPI |
| COMCTL32_11 (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3, |
| DWORD dwParam4, DWORD dwParam5, DWORD dwParam6) |
| { |
| |
| FIXME (commctrl, "(%08lx, %08lx, %08lx, %08lx, %08lx, %08lx): empty stub\n", |
| dwParam1, dwParam2, dwParam3, dwParam4, dwParam5, dwParam6); |
| |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * Alloc [COMCTL32.71] |
| * |
| * Allocates memory block from the dll's local heap |
| * |
| * PARAMS |
| * dwSize [I] size of the allocated memory block |
| * |
| * RETURNS |
| * Success: pointer to allocated memory block |
| * Failure: NULL |
| */ |
| |
| LPVOID WINAPI |
| COMCTL32_Alloc (DWORD dwSize) |
| { |
| LPVOID lpPtr; |
| |
| TRACE (commctrl, "(0x%lx)\n", dwSize); |
| |
| if (hComctl32Heap == 0) { |
| EnterCriticalSection ((void*)&cs_comctl_alloc); |
| hComctl32Heap = HeapCreate (0, 1, 0x4000000); |
| LeaveCriticalSection ((void*)&cs_comctl_alloc); |
| TRACE (commctrl, "Heap created: 0x%x\n", hComctl32Heap); |
| if (!hComctl32Heap) |
| return NULL; |
| } |
| |
| lpPtr = HeapAlloc (hComctl32Heap, HEAP_ZERO_MEMORY, dwSize); |
| TRACE (commctrl, "-- ret=%p\n", lpPtr); |
| return lpPtr; |
| } |
| |
| |
| /************************************************************************** |
| * ReAlloc [COMCTL32.72] |
| * |
| * Changes the size of an allocated memory block or allocates a memory |
| * block using the dll's local heap. |
| * |
| * PARAMS |
| * lpSrc [I] pointer to memory block which will be resized |
| * dwSize [I] new size of the memory block. |
| * |
| * RETURNS |
| * Success: pointer to the resized memory block |
| * Failure: NULL |
| * |
| * NOTES |
| * If lpSrc is a NULL-pointer, then COMCTL32_ReAlloc allocates a memory |
| * block like COMCTL32_Alloc. |
| */ |
| |
| LPVOID WINAPI |
| COMCTL32_ReAlloc (LPVOID lpSrc, DWORD dwSize) |
| { |
| LPVOID lpDest; |
| |
| TRACE (commctrl, "(%p 0x%08lx)\n", lpSrc, dwSize); |
| |
| if (hComctl32Heap == 0) { |
| EnterCriticalSection ((void*)&cs_comctl_alloc); |
| hComctl32Heap = HeapCreate (0, 1, 0x4000000); |
| LeaveCriticalSection ((void*)&cs_comctl_alloc); |
| TRACE (commctrl, "Heap created: 0x%x\n", hComctl32Heap); |
| if (!hComctl32Heap) |
| return NULL; |
| } |
| |
| if (lpSrc) |
| lpDest = HeapReAlloc (hComctl32Heap, HEAP_ZERO_MEMORY, lpSrc, dwSize); |
| else |
| lpDest = HeapAlloc (hComctl32Heap, HEAP_ZERO_MEMORY, dwSize); |
| |
| TRACE (commctrl, "-- ret=%p\n", lpDest); |
| |
| return lpDest; |
| } |
| |
| |
| /************************************************************************** |
| * Free [COMCTL32.73] |
| .* |
| * Frees an allocated memory block from the dll's local heap. |
| * |
| * PARAMS |
| * lpMem [I] pointer to memory block which will be freed |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| COMCTL32_Free (LPVOID lpMem) |
| { |
| TRACE (commctrl, "(%p)\n", lpMem); |
| |
| return HeapFree (hComctl32Heap, 0, lpMem); |
| } |
| |
| |
| /************************************************************************** |
| * GetSize [COMCTL32.74] |
| * |
| * Retrieves the size of the specified memory block from the dll's |
| * local heap. |
| * |
| * PARAMS |
| * lpMem [I] pointer to an allocated memory block |
| * |
| * RETURNS |
| * Success: size of the specified memory block |
| * Failure: 0 |
| */ |
| |
| DWORD WINAPI |
| COMCTL32_GetSize (LPVOID lpMem) |
| { |
| TRACE (commctrl, "(%p)\n", lpMem); |
| |
| return HeapSize (hComctl32Heap, 0, lpMem); |
| } |
| |
| |
| /************************************************************************** |
| * The MRU-API is a set of functions to manipulate MRU(Most Recently Used) |
| * lists. |
| * |
| * |
| */ |
| |
| typedef struct tagMRUINFO |
| { |
| DWORD dwParam1; |
| DWORD dwParam2; |
| DWORD dwParam3; |
| HKEY hkeyMain; |
| LPCSTR lpszSubKey; |
| DWORD dwParam6; |
| } MRUINFO, *LPMRUINFO; |
| |
| |
| |
| /************************************************************************** |
| * CreateMRUListA [COMCTL32.151] |
| * |
| * PARAMS |
| * dwParam |
| * |
| * RETURNS |
| */ |
| |
| LPVOID WINAPI |
| CreateMRUListEx32A (LPMRUINFO lpmi, DWORD dwParam2, |
| DWORD dwParam3, DWORD dwParam4); |
| |
| LPVOID WINAPI |
| CreateMRUList32A (LPMRUINFO lpmi) |
| { |
| return CreateMRUListEx32A (lpmi, 0, 0, 0); |
| } |
| |
| |
| |
| DWORD WINAPI |
| FreeMRUList32A (LPVOID ptr) |
| { |
| FIXME (commctrl, "(%p) empty stub!\n", ptr); |
| |
| COMCTL32_Free (ptr); |
| |
| return TRUE; |
| } |
| |
| |
| |
| |
| |
| |
| LPVOID WINAPI |
| CreateMRUListEx32A (LPMRUINFO lpmi, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4) |
| { |
| DWORD dwLocal1; |
| HKEY hkeyResult; |
| DWORD dwLocal3; |
| LPVOID lMRU; |
| DWORD dwLocal5; |
| DWORD dwLocal6; |
| DWORD dwLocal7; |
| DWORD dwDisposition; |
| |
| /* internal variables */ |
| LPVOID ptr; |
| |
| FIXME (commctrl, "(%p) empty stub!\n", lpmi); |
| |
| if (lpmi) { |
| FIXME (commctrl, "(%lx %lx %lx %lx \"%s\" %lx)\n", |
| lpmi->dwParam1, lpmi->dwParam2, lpmi->dwParam3, |
| lpmi->hkeyMain, lpmi->lpszSubKey, lpmi->dwParam6); |
| } |
| |
| /* dummy pointer creation */ |
| ptr = COMCTL32_Alloc (32); |
| |
| FIXME (commctrl, "-- ret = %p\n", ptr); |
| |
| return ptr; |
| } |
| |
| |
| |
| DWORD WINAPI |
| AddMRUData (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) |
| { |
| |
| FIXME (commctrl, "(%lx %lx %lx) empty stub!\n", |
| dwParam1, dwParam2, dwParam3); |
| |
| return 0; |
| } |
| |
| |
| DWORD WINAPI |
| FindMRUData (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4) |
| { |
| |
| FIXME (commctrl, "(%lx %lx %lx %lx) empty stub!\n", |
| dwParam1, dwParam2, dwParam3, dwParam4); |
| |
| return -1; |
| } |
| |
| |
| |
| /************************************************************************** |
| * Str_GetPtrA [COMCTL32.233] |
| * |
| * PARAMS |
| * lpSrc [I] |
| * lpDest [O] |
| * nMaxLen [I] |
| * |
| * RETURNS |
| */ |
| |
| INT32 WINAPI |
| Str_GetPtr32A (LPCSTR lpSrc, LPSTR lpDest, INT32 nMaxLen) |
| { |
| INT32 len; |
| |
| TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen); |
| |
| if (!lpDest && lpSrc) |
| return lstrlen32A (lpSrc); |
| |
| if (nMaxLen == 0) |
| return 0; |
| |
| if (lpSrc == NULL) { |
| lpDest[0] = '\0'; |
| return 0; |
| } |
| |
| len = lstrlen32A (lpSrc); |
| if (len >= nMaxLen) |
| len = nMaxLen - 1; |
| |
| RtlMoveMemory (lpDest, lpSrc, len); |
| lpDest[len] = '\0'; |
| |
| return len; |
| } |
| |
| |
| /************************************************************************** |
| * Str_SetPtrA [COMCTL32.234] |
| * |
| * PARAMS |
| * lppDest [O] |
| * lpSrc [I] |
| * |
| * RETURNS |
| */ |
| |
| BOOL32 WINAPI |
| Str_SetPtr32A (LPSTR *lppDest, LPCSTR lpSrc) |
| { |
| TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc); |
| |
| if (lpSrc) { |
| LPSTR ptr = COMCTL32_ReAlloc (lppDest, lstrlen32A (lpSrc) + 1); |
| if (!ptr) |
| return FALSE; |
| lstrcpy32A (ptr, lpSrc); |
| *lppDest = ptr; |
| } |
| else { |
| if (*lppDest) { |
| COMCTL32_Free (*lppDest); |
| *lppDest = NULL; |
| } |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * Str_GetPtrW [COMCTL32.235] |
| * |
| * PARAMS |
| * lpSrc [I] |
| * lpDest [O] |
| * nMaxLen [I] |
| * |
| * RETURNS |
| */ |
| |
| INT32 WINAPI |
| Str_GetPtr32W (LPCWSTR lpSrc, LPWSTR lpDest, INT32 nMaxLen) |
| { |
| INT32 len; |
| |
| TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen); |
| |
| if (!lpDest && lpSrc) |
| return lstrlen32W (lpSrc); |
| |
| if (nMaxLen == 0) |
| return 0; |
| |
| if (lpSrc == NULL) { |
| lpDest[0] = L'\0'; |
| return 0; |
| } |
| |
| len = lstrlen32W (lpSrc); |
| if (len >= nMaxLen) |
| len = nMaxLen - 1; |
| |
| RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR)); |
| lpDest[len] = L'\0'; |
| |
| return len; |
| } |
| |
| |
| /************************************************************************** |
| * Str_SetPtrW [COMCTL32.236] |
| * |
| * PARAMS |
| * lpDest [O] |
| * lpSrc [I] |
| * |
| * RETURNS |
| */ |
| |
| BOOL32 WINAPI |
| Str_SetPtr32W (LPWSTR *lppDest, LPCWSTR lpSrc) |
| { |
| TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc); |
| |
| if (lpSrc) { |
| INT32 len = lstrlen32W (lpSrc) + 1; |
| LPWSTR ptr = COMCTL32_ReAlloc (lppDest, len * sizeof(WCHAR)); |
| if (!ptr) |
| return FALSE; |
| lstrcpy32W (ptr, lpSrc); |
| *lppDest = ptr; |
| } |
| else { |
| if (*lppDest) { |
| COMCTL32_Free (*lppDest); |
| *lppDest = NULL; |
| } |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * The DSA-API is a set of functions to create and manipulate arrays of |
| * fix sized memory blocks. These arrays can store any kind of data |
| * (strings, icons...). |
| */ |
| |
| /************************************************************************** |
| * DSA_Create [COMCTL32.320] Creates a dynamic storage array |
| * |
| * PARAMS |
| * nSize [I] size of the array elements |
| * nGrow [I] number of elements by which the array grows when it is filled |
| * |
| * RETURNS |
| * Success: pointer to a array control structure. use this like a handle. |
| * Failure: NULL |
| */ |
| |
| HDSA WINAPI |
| DSA_Create (INT32 nSize, INT32 nGrow) |
| { |
| HDSA hdsa; |
| |
| TRACE (commctrl, "(size=%d grow=%d)\n", nSize, nGrow); |
| |
| hdsa = (HDSA)COMCTL32_Alloc (sizeof(DSA)); |
| if (hdsa) |
| { |
| hdsa->nItemCount = 0; |
| hdsa->pData = NULL; |
| hdsa->nMaxCount = 0; |
| hdsa->nItemSize = nSize; |
| hdsa->nGrow = MIN(1, nGrow); |
| } |
| |
| return hdsa; |
| } |
| |
| |
| /************************************************************************** |
| * DSA_Destroy [COMCTL32.321] Destroys a dynamic storage array |
| * |
| * PARAMS |
| * hdsa [I] pointer to the array control structure |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DSA_Destroy (const HDSA hdsa) |
| { |
| TRACE (commctrl, "(%p)\n", hdsa); |
| |
| if (!hdsa) |
| return FALSE; |
| |
| if (hdsa->pData && (!COMCTL32_Free (hdsa->pData))) |
| return FALSE; |
| |
| return COMCTL32_Free (hdsa); |
| } |
| |
| |
| /************************************************************************** |
| * DSA_GetItem [COMCTL32.322] |
| * |
| * PARAMS |
| * hdsa [I] pointer to the array control structure |
| * nIndex [I] number of the Item to get |
| * pDest [O] destination buffer. Has to be >= dwElementSize. |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DSA_GetItem (const HDSA hdsa, INT32 nIndex, LPVOID pDest) |
| { |
| LPVOID pSrc; |
| |
| TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pDest); |
| |
| if (!hdsa) |
| return FALSE; |
| if ((nIndex < 0) || (nIndex >= hdsa->nItemCount)) |
| return FALSE; |
| |
| pSrc = hdsa->pData + (hdsa->nItemSize * nIndex); |
| memmove (pDest, pSrc, hdsa->nItemSize); |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * DSA_GetItemPtr [COMCTL32.323] |
| * |
| * Retrieves a pointer to the specified item. |
| * |
| * PARAMS |
| * hdsa [I] pointer to the array control structure |
| * nIndex [I] index of the desired item |
| * |
| * RETURNS |
| * Success: pointer to an item |
| * Failure: NULL |
| */ |
| |
| LPVOID WINAPI |
| DSA_GetItemPtr (const HDSA hdsa, INT32 nIndex) |
| { |
| LPVOID pSrc; |
| |
| TRACE (commctrl, "(%p %d)\n", hdsa, nIndex); |
| |
| if (!hdsa) |
| return NULL; |
| if ((nIndex < 0) || (nIndex >= hdsa->nItemCount)) |
| return NULL; |
| |
| pSrc = hdsa->pData + (hdsa->nItemSize * nIndex); |
| |
| TRACE (commctrl, "-- ret=%p\n", pSrc); |
| |
| return pSrc; |
| } |
| |
| |
| /************************************************************************** |
| * DSA_SetItem [COMCTL32.325] |
| * |
| * Sets the contents of an item in the array. |
| * |
| * PARAMS |
| * hdsa [I] pointer to the array control structure |
| * nIndex [I] index for the item |
| * pSrc [I] pointer to the new item data |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DSA_SetItem (const HDSA hdsa, INT32 nIndex, LPVOID pSrc) |
| { |
| INT32 nSize, nNewItems; |
| LPVOID pDest, lpTemp; |
| |
| TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pSrc); |
| |
| if ((!hdsa) || nIndex < 0) |
| return FALSE; |
| |
| if (hdsa->nItemCount <= nIndex) { |
| /* within the old array */ |
| if (hdsa->nMaxCount > nIndex) { |
| /* within the allocated space, set a new boundary */ |
| hdsa->nItemCount = nIndex; |
| } |
| else { |
| /* resize the block of memory */ |
| nNewItems = |
| hdsa->nGrow * ((INT32)((nIndex - 1) / hdsa->nGrow) + 1); |
| nSize = hdsa->nItemSize * nNewItems; |
| |
| lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize); |
| if (!lpTemp) |
| return FALSE; |
| |
| hdsa->nMaxCount = nNewItems; |
| hdsa->pData = lpTemp; |
| } |
| } |
| |
| /* put the new entry in */ |
| pDest = hdsa->pData + (hdsa->nItemSize * nIndex); |
| TRACE (commctrl, "-- move dest=%p src=%p size=%d\n", |
| pDest, pSrc, hdsa->nItemSize); |
| memmove (pDest, pSrc, hdsa->nItemSize); |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * DSA_InsertItem [COMCTL32.325] |
| * |
| * PARAMS |
| * hdsa [I] pointer to the array control structure |
| * nIndex [I] index for the new item |
| * pSrc [I] pointer to the element |
| * |
| * RETURNS |
| * Success: position of the new item |
| * Failure: -1 |
| */ |
| |
| INT32 WINAPI |
| DSA_InsertItem (const HDSA hdsa, INT32 nIndex, LPVOID pSrc) |
| { |
| INT32 nNewItems, nSize, i; |
| LPVOID lpTemp, lpDest; |
| LPDWORD p; |
| |
| TRACE(commctrl, "(%p %d %p)\n", hdsa, nIndex, pSrc); |
| |
| if ((!hdsa) || nIndex < 0) |
| return -1; |
| |
| for (i = 0; i < hdsa->nItemSize; i += 4) { |
| p = *(DWORD**)(pSrc + i); |
| if (IsBadStringPtr32A ((char*)p, 256)) |
| TRACE (commctrl, "-- %d=%p\n", i, (DWORD*)p); |
| else |
| TRACE (commctrl, "-- %d=%p [%s]\n", i, p, debugstr_a((char*)p)); |
| } |
| |
| /* when nIndex > nItemCount then append */ |
| if (nIndex >= hdsa->nItemCount) |
| nIndex = hdsa->nItemCount; |
| |
| /* do we need to resize ? */ |
| if (hdsa->nItemCount >= hdsa->nMaxCount) { |
| nNewItems = hdsa->nMaxCount + hdsa->nGrow; |
| nSize = hdsa->nItemSize * nNewItems; |
| |
| lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize); |
| if (!lpTemp) |
| return -1; |
| |
| hdsa->nMaxCount = nNewItems; |
| hdsa->pData = lpTemp; |
| } |
| |
| /* do we need to move elements ? */ |
| if (nIndex < hdsa->nItemCount) { |
| lpTemp = hdsa->pData + (hdsa->nItemSize * nIndex); |
| lpDest = lpTemp + hdsa->nItemSize; |
| nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize; |
| TRACE (commctrl, "-- move dest=%p src=%p size=%d\n", |
| lpDest, lpTemp, nSize); |
| memmove (lpDest, lpTemp, nSize); |
| } |
| |
| /* ok, we can put the new Item in */ |
| hdsa->nItemCount++; |
| lpDest = hdsa->pData + (hdsa->nItemSize * nIndex); |
| TRACE (commctrl, "-- move dest=%p src=%p size=%d\n", |
| lpDest, pSrc, hdsa->nItemSize); |
| memmove (lpDest, pSrc, hdsa->nItemSize); |
| |
| return hdsa->nItemCount; |
| } |
| |
| |
| /************************************************************************** |
| * DSA_DeleteItem [COMCTL32.326] |
| * |
| * PARAMS |
| * hdsa [I] pointer to the array control structure |
| * nIndex [I] index for the element to delete |
| * |
| * RETURNS |
| * Success: number of the deleted element |
| * Failure: -1 |
| */ |
| |
| INT32 WINAPI |
| DSA_DeleteItem (const HDSA hdsa, INT32 nIndex) |
| { |
| LPVOID lpDest,lpSrc; |
| INT32 nSize; |
| |
| TRACE (commctrl, "(%p %d)\n", hdsa, nIndex); |
| |
| if (!hdsa) |
| return -1; |
| if (nIndex < 0 || nIndex >= hdsa->nItemCount) |
| return -1; |
| |
| /* do we need to move ? */ |
| if (nIndex < hdsa->nItemCount - 1) { |
| lpDest = hdsa->pData + (hdsa->nItemSize * nIndex); |
| lpSrc = lpDest + hdsa->nItemSize; |
| nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1); |
| TRACE (commctrl, "-- move dest=%p src=%p size=%d\n", |
| lpDest, lpSrc, nSize); |
| memmove (lpDest, lpSrc, nSize); |
| } |
| |
| hdsa->nItemCount--; |
| |
| /* free memory ? */ |
| if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) { |
| nSize = hdsa->nItemSize * hdsa->nItemCount; |
| |
| lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize); |
| if (!lpDest) |
| return -1; |
| |
| hdsa->nMaxCount = hdsa->nItemCount; |
| hdsa->pData = lpDest; |
| } |
| |
| return nIndex; |
| } |
| |
| |
| /************************************************************************** |
| * DSA_DeleteAllItems [COMCTL32.326] |
| * |
| * Removes all items and reinitializes the array. |
| * |
| * PARAMS |
| * hdsa [I] pointer to the array control structure |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DSA_DeleteAllItems (const HDSA hdsa) |
| { |
| TRACE (commctrl, "(%p)\n", hdsa); |
| |
| if (!hdsa) |
| return FALSE; |
| if (hdsa->pData && (!COMCTL32_Free (hdsa->pData))) |
| return FALSE; |
| |
| hdsa->nItemCount = 0; |
| hdsa->pData = NULL; |
| hdsa->nMaxCount = 0; |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * The DPA-API is a set of functions to create and manipulate arrays of |
| * pointers. |
| */ |
| |
| /************************************************************************** |
| * DPA_Create [COMCTL32.328] Creates a dynamic pointer array |
| * |
| * PARAMS |
| * nGrow [I] number of items by which the array grows when it is filled |
| * |
| * RETURNS |
| * Success: handle (pointer) to the pointer array. |
| * Failure: NULL |
| */ |
| |
| HDPA WINAPI |
| DPA_Create (INT32 nGrow) |
| { |
| HDPA hdpa; |
| |
| TRACE (commctrl, "(%d)\n", nGrow); |
| |
| hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA)); |
| if (hdpa) { |
| hdpa->nGrow = MIN(8, nGrow); |
| hdpa->hHeap = hComctl32Heap; |
| hdpa->nMaxCount = hdpa->nGrow * 2; |
| hdpa->ptrs = |
| (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID)); |
| } |
| |
| TRACE (commctrl, "-- %p\n", hdpa); |
| |
| return hdpa; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_Destroy [COMCTL32.329] Destroys a dynamic pointer array |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DPA_Destroy (const HDPA hdpa) |
| { |
| TRACE (commctrl, "(%p)\n", hdpa); |
| |
| if (!hdpa) |
| return FALSE; |
| |
| if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs))) |
| return FALSE; |
| |
| return HeapFree (hdpa->hHeap, 0, hdpa); |
| } |
| |
| |
| /************************************************************************** |
| * DPA_Grow [COMCTL32.330] |
| * |
| * Sets the growth amount. |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the existing (source) pointer array |
| * nGrow [I] number of items, the array grows, when it's too small |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DPA_Grow (const HDPA hdpa, INT32 nGrow) |
| { |
| TRACE (commctrl, "(%p %d)\n", hdpa, nGrow); |
| |
| if (!hdpa) |
| return FALSE; |
| |
| hdpa->nGrow = MIN(8, nGrow); |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_Clone [COMCTL32.331] |
| * |
| * Copies a pointer array to an other one or creates a copy |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the existing (source) pointer array |
| * hdpaNew [O] handle (pointer) to the destination pointer array |
| * |
| * RETURNS |
| * Success: pointer to the destination pointer array. |
| * Failure: NULL |
| * |
| * NOTES |
| * - If the 'hdpaNew' is a NULL-Pointer, a copy of the source pointer |
| * array will be created and it's handle (pointer) is returned. |
| * - If 'hdpa' is a NULL-Pointer, the original implementation crashes, |
| * this implementation just returns NULL. |
| */ |
| |
| HDPA WINAPI |
| DPA_Clone (const HDPA hdpa, const HDPA hdpaNew) |
| { |
| INT32 nNewItems, nSize; |
| HDPA hdpaTemp; |
| |
| if (!hdpa) |
| return NULL; |
| |
| TRACE (commctrl, "(%p %p)\n", hdpa, hdpaNew); |
| |
| if (!hdpaNew) { |
| /* create a new DPA */ |
| hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, |
| sizeof(DPA)); |
| hdpaTemp->hHeap = hdpa->hHeap; |
| hdpaTemp->nGrow = hdpa->nGrow; |
| } |
| else |
| hdpaTemp = hdpaNew; |
| |
| if (hdpaTemp->ptrs) { |
| /* remove old pointer array */ |
| HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs); |
| hdpaTemp->ptrs = NULL; |
| hdpaTemp->nItemCount = 0; |
| hdpaTemp->nMaxCount = 0; |
| } |
| |
| /* create a new pointer array */ |
| nNewItems = hdpaTemp->nGrow * |
| ((INT32)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1); |
| nSize = nNewItems * sizeof(LPVOID); |
| hdpaTemp->ptrs = |
| (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize); |
| hdpaTemp->nMaxCount = nNewItems; |
| |
| /* clone the pointer array */ |
| hdpaTemp->nItemCount = hdpa->nItemCount; |
| memmove (hdpaTemp->ptrs, hdpa->ptrs, |
| hdpaTemp->nItemCount * sizeof(LPVOID)); |
| |
| return hdpaTemp; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_GetPtr [COMCTL32.332] |
| * |
| * Retrieves a pointer from a dynamic pointer array |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * nIndex [I] array index of the desired pointer |
| * |
| * RETURNS |
| * Success: pointer |
| * Failure: NULL |
| */ |
| |
| LPVOID WINAPI |
| DPA_GetPtr (const HDPA hdpa, INT32 i) |
| { |
| TRACE (commctrl, "(%p %d)\n", hdpa, i); |
| |
| if (!hdpa) |
| return NULL; |
| if (!hdpa->ptrs) |
| return NULL; |
| if ((i < 0) || (i >= hdpa->nItemCount)) |
| return NULL; |
| |
| TRACE (commctrl, "-- %p\n", hdpa->ptrs[i]); |
| |
| return hdpa->ptrs[i]; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_GetPtrIndex [COMCTL32.333] |
| * |
| * Retrieves the index of the specified pointer |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * p [I] pointer |
| * |
| * RETURNS |
| * Success: index of the specified pointer |
| * Failure: -1 |
| */ |
| |
| INT32 WINAPI |
| DPA_GetPtrIndex (const HDPA hdpa, LPVOID p) |
| { |
| INT32 i; |
| |
| if (!hdpa->ptrs) |
| return -1; |
| |
| for (i = 0; i < hdpa->nItemCount; i++) { |
| if (hdpa->ptrs[i] == p) |
| return i; |
| } |
| |
| return -1; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_InsertPtr [COMCTL32.334] |
| * |
| * Inserts a pointer into a dynamic pointer array |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the array |
| * i [I] array index |
| * p [I] pointer to insert |
| * |
| * RETURNS |
| * Success: index of the inserted pointer |
| * Failure: -1 |
| */ |
| |
| INT32 WINAPI |
| DPA_InsertPtr (const HDPA hdpa, INT32 i, LPVOID p) |
| { |
| INT32 nNewItems, nSize, nIndex = 0; |
| LPVOID *lpTemp, *lpDest; |
| |
| TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p); |
| |
| if ((!hdpa) || (i < 0)) |
| return -1; |
| |
| if (!hdpa->ptrs) { |
| hdpa->ptrs = |
| (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, |
| hdpa->nGrow * sizeof(LPVOID)); |
| if (!hdpa->ptrs) |
| return -1; |
| hdpa->nMaxCount = hdpa->nGrow; |
| nIndex = 0; |
| } |
| else { |
| if (hdpa->nItemCount > hdpa->nMaxCount) { |
| TRACE (commctrl, "-- resizing\n"); |
| nNewItems = hdpa->nMaxCount + hdpa->nGrow; |
| nSize = nNewItems * sizeof(LPVOID); |
| |
| lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, |
| hdpa->ptrs, nSize); |
| if (!lpTemp) |
| return -1; |
| hdpa->nMaxCount = nNewItems; |
| hdpa->ptrs = lpTemp; |
| } |
| |
| if (i >= hdpa->nItemCount) { |
| TRACE (commctrl, "-- appending at %d\n", nIndex); |
| nIndex = hdpa->nItemCount; |
| } |
| else { |
| TRACE (commctrl, "-- inserting at %d\n", i); |
| lpTemp = hdpa->ptrs + (sizeof(LPVOID) * i); |
| lpDest = lpTemp + sizeof(LPVOID); |
| nSize = (hdpa->nItemCount - i) * sizeof(LPVOID); |
| TRACE (commctrl, "-- move dest=%p src=%p size=%x\n", |
| lpDest, lpTemp, nSize); |
| memmove (lpDest, lpTemp, nSize); |
| nIndex = i; |
| } |
| } |
| |
| /* insert item */ |
| hdpa->nItemCount++; |
| hdpa->ptrs[nIndex] = p; |
| |
| return nIndex; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_SetPtr [COMCTL32.335] |
| * |
| * Sets a pointer in the pointer array |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * i [I] index of the pointer that will be set |
| * p [I] pointer to be set |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DPA_SetPtr (const HDPA hdpa, INT32 i, LPVOID p) |
| { |
| LPVOID *lpTemp; |
| |
| TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p); |
| |
| if ((!hdpa) || i < 0) |
| return FALSE; |
| |
| if (hdpa->nItemCount <= i) { |
| /* within the old array */ |
| if (hdpa->nMaxCount > i) { |
| /* within the allocated space, set a new boundary */ |
| hdpa->nItemCount = i; |
| } |
| else { |
| /* resize the block of memory */ |
| INT32 nNewItems = |
| hdpa->nGrow * ((INT32)((i - 1) / hdpa->nGrow) + 1); |
| INT32 nSize = nNewItems * sizeof(LPVOID); |
| |
| lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, |
| hdpa->ptrs, nSize); |
| if (!lpTemp) |
| return FALSE; |
| |
| hdpa->nItemCount = nNewItems; |
| hdpa->ptrs = lpTemp; |
| } |
| } |
| |
| /* put the new entry in */ |
| hdpa->ptrs[i] = p; |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_DeletePtr [COMCTL32.336] |
| * |
| * Removes a pointer from the pointer array. |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * i [I] index of the pointer that will be deleted |
| * |
| * RETURNS |
| * Success: deleted pointer |
| * Failure: NULL |
| */ |
| |
| LPVOID WINAPI |
| DPA_DeletePtr (const HDPA hdpa, INT32 i) |
| { |
| LPVOID lpDest, lpSrc, lpTemp = NULL; |
| INT32 nSize; |
| |
| TRACE (commctrl, "(%p %d)\n", hdpa, i); |
| |
| if ((!hdpa) || i < 0 || i >= hdpa->nItemCount) |
| return NULL; |
| |
| lpTemp = hdpa->ptrs[i]; |
| |
| /* do we need to move ?*/ |
| if (i < hdpa->nItemCount - 1) { |
| lpDest = hdpa->ptrs + (i * sizeof (LPVOID)); |
| lpSrc = lpDest + sizeof(LPVOID); |
| nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID); |
| TRACE (commctrl,"-- move dest=%p src=%p size=%x\n", |
| lpDest, lpSrc, nSize); |
| memmove (lpDest, lpSrc, nSize); |
| } |
| |
| hdpa->nItemCount --; |
| |
| /* free memory ?*/ |
| if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) { |
| INT32 nNewItems = MIN(hdpa->nGrow * 2, hdpa->nItemCount); |
| nSize = nNewItems * sizeof(LPVOID); |
| lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, |
| hdpa->ptrs, nSize); |
| if (!lpDest) |
| return NULL; |
| |
| hdpa->nMaxCount = nNewItems; |
| hdpa->ptrs = (LPVOID*)lpDest; |
| } |
| |
| return lpTemp; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_DeleteAllPtrs [COMCTL32.337] |
| * |
| * Removes all pointers and reinitializes the array. |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DPA_DeleteAllPtrs (const HDPA hdpa) |
| { |
| TRACE (commctrl, "(%p)\n", hdpa); |
| |
| if (!hdpa) |
| return FALSE; |
| |
| if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs))) |
| return FALSE; |
| |
| hdpa->nItemCount = 0; |
| hdpa->nMaxCount = hdpa->nGrow * 2; |
| hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, |
| hdpa->nMaxCount * sizeof(LPVOID)); |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_QuickSort [Internal] |
| * |
| * Modified version of quicksort (used by DPA_Sort). |
| * |
| * PARAMS |
| * lpPtrs [I] pointer to the pointer array |
| * l [I] index of the "left border" of the partition |
| * r [I] index of the "right border" of the partition |
| * pfnCompare [I] pointer to the compare function |
| * lParam [I] user defined value (3rd parameter in compare function) |
| * |
| * RETURNS |
| * NONE |
| * |
| * NOTES |
| * Taken from R.Sedgewick "Algorithms in C"! |
| * If something goes wrong, blame HIM not ME! (Eric Kohl) |
| */ |
| |
| static VOID |
| DPA_QuickSort (LPVOID *lpPtrs , INT32 l, INT32 r, |
| PFNDPACOMPARE pfnCompare, LPARAM lParam) |
| { |
| LPVOID t, v; |
| INT32 i, j; |
| |
| if (r > l) { |
| v = lpPtrs[r]; |
| i = l - 1; |
| j = r; |
| for (;;) { |
| while ((pfnCompare)(lpPtrs[++i], v, lParam) < 0); |
| while ((pfnCompare)(lpPtrs[--j], v, lParam) > 0); |
| if (i >= j) |
| break; |
| t = lpPtrs[i]; |
| lpPtrs[i] = lpPtrs[j]; |
| lpPtrs[j] = t; |
| } |
| t = lpPtrs[i]; |
| lpPtrs[i] = lpPtrs[r]; |
| lpPtrs[r] = t; |
| DPA_QuickSort (lpPtrs, l, i - 1, pfnCompare, lParam); |
| DPA_QuickSort (lpPtrs, i + 1, r, pfnCompare, lParam); |
| } |
| } |
| |
| |
| /************************************************************************** |
| * DPA_Sort [COMCTL32.338] |
| * |
| * Sorts a pointer array using a user defined compare function |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * pfnCompare [I] pointer to the compare function |
| * lParam [I] user defined value (3rd parameter of compare function) |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL32 WINAPI |
| DPA_Sort (const HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam) |
| { |
| if (!hdpa || !pfnCompare) |
| return FALSE; |
| |
| TRACE (commctrl, "(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam); |
| |
| if ((hdpa->nItemCount > 1) && (hdpa->ptrs)) |
| DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1, |
| pfnCompare, lParam); |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_Search [COMCTL32.339] |
| * |
| * Searches a pointer array for a specified pointer |
| * |
| * PARAMS |
| * hdpa [I] handle (pointer) to the pointer array |
| * pFind [I] pointer to search for |
| * nStart [I] start index |
| * pfnCompare [I] pointer to the compare function |
| * lParam [I] user defined value (3rd parameter of compare function) |
| * uOptions [I] search options |
| * |
| * RETURNS |
| * Success: index of the pointer in the array. |
| * Failure: -1 |
| * |
| * NOTES |
| * Binary search taken from R.Sedgewick "Algorithms in C"! |
| * If something goes wrong, blame HIM not ME! (Eric Kohl) |
| */ |
| |
| INT32 WINAPI |
| DPA_Search (const HDPA hdpa, LPVOID pFind, INT32 nStart, |
| PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT32 uOptions) |
| { |
| if (!hdpa || !pfnCompare || !pFind) |
| return -1; |
| |
| TRACE (commctrl, "(%p %p %d %p 0x%08lx 0x%08x)\n", |
| hdpa, pFind, nStart, pfnCompare, lParam, uOptions); |
| |
| if (uOptions & DPAS_SORTED) { |
| /* array is sorted --> use binary search */ |
| INT32 l, r, x, n; |
| LPVOID *lpPtr; |
| |
| TRACE (commctrl, "binary search\n"); |
| |
| l = (nStart == -1) ? 0 : nStart; |
| r = hdpa->nItemCount - 1; |
| lpPtr = hdpa->ptrs; |
| while (r >= l) { |
| x = (l + r) / 2; |
| n = (pfnCompare)(pFind, lpPtr[x], lParam); |
| if (n < 0) |
| r = x - 1; |
| else |
| l = x + 1; |
| if (n == 0) { |
| TRACE (commctrl, "-- ret=%d\n", n); |
| return n; |
| } |
| } |
| |
| if (uOptions & DPAS_INSERTBEFORE) { |
| TRACE (commctrl, "-- ret=%d\n", r); |
| return r; |
| } |
| |
| if (uOptions & DPAS_INSERTAFTER) { |
| TRACE (commctrl, "-- ret=%d\n", r); |
| return l; |
| } |
| } |
| else { |
| /* array is not sorted --> use linear search */ |
| LPVOID *lpPtr; |
| INT32 nIndex; |
| |
| TRACE (commctrl, "linear search\n"); |
| |
| nIndex = (nStart == -1)? 0 : nStart; |
| lpPtr = hdpa->ptrs; |
| for (; nIndex < hdpa->nItemCount; nIndex++) { |
| if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) { |
| TRACE (commctrl, "-- ret=%d\n", nIndex); |
| return nIndex; |
| } |
| } |
| } |
| |
| TRACE (commctrl, "-- not found: ret=-1\n"); |
| return -1; |
| } |
| |
| |
| /************************************************************************** |
| * DPA_CreateEx [COMCTL32.340] |
| * |
| * Creates a dynamic pointer array using the specified size and heap. |
| * |
| * PARAMS |
| * nGrow [I] number of items by which the array grows when it is filled |
| * hHeap [I] handle to the heap where the array is stored |
| * |
| * RETURNS |
| * Success: handle (pointer) to the pointer array. |
| * Failure: NULL |
| */ |
| |
| HDPA WINAPI |
| DPA_CreateEx (INT32 nGrow, HANDLE32 hHeap) |
| { |
| HDPA hdpa; |
| |
| TRACE (commctrl, "(%d 0x%x)\n", nGrow, hHeap); |
| |
| if (hHeap) |
| hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA)); |
| else |
| hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA)); |
| |
| if (hdpa) { |
| hdpa->nGrow = MIN(8, nGrow); |
| hdpa->hHeap = hHeap ? hHeap : hComctl32Heap; |
| hdpa->nMaxCount = hdpa->nGrow * 2; |
| hdpa->ptrs = |
| (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, |
| hdpa->nMaxCount * sizeof(LPVOID)); |
| } |
| |
| TRACE (commctrl, "-- %p\n", hdpa); |
| |
| return hdpa; |
| } |
| |
| |
| /************************************************************************** |
| * SendNotify [COMCTL32.341] |
| * |
| */ |
| |
| DWORD WINAPI |
| COMCTL32_SendNotify (DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4) |
| { |
| FIXME (commctrl, "(0x%08lx 0x%08lx 0x%08lx 0x%08lx)\n", |
| dw1, dw2, dw3, dw4); |
| |
| return 0; |
| } |
| |
| |
| |
| /************************************************************************** |
| * StrChrA [COMCTL32.350] |
| * |
| */ |
| |
| LPSTR WINAPI |
| COMCTL32_StrChrA (LPCSTR lpString, CHAR cChar) |
| { |
| return strchr (lpString, cChar); |
| } |
| |
| |
| /************************************************************************** |
| * StrStrIA [COMCTL32.355] |
| */ |
| |
| LPSTR WINAPI |
| COMCTL32_StrStrIA (LPCSTR lpStr1, LPCSTR lpStr2) |
| { |
| INT32 len1, len2, i; |
| CHAR first; |
| |
| if (*lpStr2 == 0) |
| return ((LPSTR)lpStr1); |
| len1 = 0; |
| while (lpStr1[len1] != 0) ++len1; |
| len2 = 0; |
| while (lpStr2[len2] != 0) ++len2; |
| if (len2 == 0) |
| return ((LPSTR)(lpStr1 + len1)); |
| first = tolower (*lpStr2); |
| while (len1 >= len2) { |
| if (tolower(*lpStr1) == first) { |
| for (i = 1; i < len2; ++i) |
| if (tolower (lpStr1[i]) != tolower(lpStr2[i])) |
| break; |
| if (i >= len2) |
| return ((LPSTR)lpStr1); |
| } |
| ++lpStr1; --len1; |
| } |
| return (NULL); |
| } |
| |
| |
| /************************************************************************** |
| * StrToIntA [COMCTL32.357] Converts a string to a signed integer. |
| */ |
| |
| INT32 WINAPI |
| COMCTL32_StrToIntA (LPSTR lpString) |
| { |
| return atoi(lpString); |
| } |
| |
| |
| /************************************************************************** |
| * COMCTL32_385 [COMCTL32.385] |
| */ |
| |
| DWORD WINAPI |
| COMCTL32_385 (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) |
| { |
| |
| FIXME (commctrl, "(%08lx, %08lx, %08lx): empty stub\n", |
| dwParam1, dwParam2, dwParam3); |
| |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * COMCTL32_386 [COMCTL32.386] |
| */ |
| |
| DWORD WINAPI |
| COMCTL32_386 (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) |
| { |
| |
| FIXME (commctrl, "(%08lx, %08lx, %08lx): empty stub\n", |
| dwParam1, dwParam2, dwParam3); |
| |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * COMCTL32_387 [COMCTL32.387] |
| */ |
| |
| DWORD WINAPI |
| COMCTL32_387 (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) |
| { |
| |
| FIXME (commctrl, "(%08lx, %08lx, %08lx): empty stub\n", |
| dwParam1, dwParam2, dwParam3); |
| |
| return 0; |
| } |
| |
| |
| /************************************************************************** |
| * COMCTL32_388 [COMCTL32.388] |
| */ |
| |
| DWORD WINAPI |
| COMCTL32_388 (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3) |
| { |
| |
| FIXME (commctrl, "(%08lx, %08lx, %08lx): empty stub\n", |
| dwParam1, dwParam2, dwParam3); |
| |
| return 0; |
| } |
| |