--- trunk/reactos/lib/comctl32/comctl32undoc.c 2005-08-12 13:46:36 UTC (rev 17325)
+++ trunk/reactos/lib/comctl32/comctl32undoc.c 2005-08-12 16:31:56 UTC (rev 17326)
@@ -55,314 +55,9 @@
WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
-struct _DSA
-{
- INT nItemCount;
- LPVOID pData;
- INT nMaxCount;
- INT nItemSize;
- INT nGrow;
-};
-
-struct _DPA
-{
- INT nItemCount;
- LPVOID *ptrs;
- HANDLE hHeap;
- INT nGrow;
- INT nMaxCount;
-};
-
-typedef struct _STREAMDATA
-{
- DWORD dwSize;
- DWORD dwData2;
- DWORD dwItems;
-} STREAMDATA, *PSTREAMDATA;
-
-typedef struct _LOADDATA
-{
- INT nCount;
- PVOID ptr;
-} LOADDATA, *LPLOADDATA;
-
-typedef HRESULT (CALLBACK *DPALOADPROC)(LPLOADDATA,IStream*,LPARAM);
-
static const WCHAR strMRUList[] = { 'M','R','U','L','i','s','t',0 };
/**************************************************************************
- * DPA_LoadStream [COMCTL32.9]
- *
- * Loads a dynamic pointer array from a stream
- *
- * PARAMS
- * phDpa [O] pointer to a handle to a dynamic pointer array
- * loadProc [I] pointer to a callback function
- * pStream [I] pointer to a stream
- * lParam [I] application specific value
- *
- * RETURNS
- * Success: TRUE
- * Failure: FALSE
- *
- * NOTES
- * No more information available yet!
- */
-HRESULT WINAPI DPA_LoadStream (HDPA *phDpa, DPALOADPROC loadProc,
- IStream *pStream, LPARAM lParam)
-{
- HRESULT errCode;
- LARGE_INTEGER position;
- ULARGE_INTEGER newPosition;
- STREAMDATA streamData;
- LOADDATA loadData;
- ULONG ulRead;
- HDPA hDpa;
- PVOID *ptr;
-
- FIXME ("phDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
- phDpa, loadProc, pStream, lParam);
-
- if (!phDpa || !loadProc || !pStream)
- return E_INVALIDARG;
-
- *phDpa = (HDPA)NULL;
-
- position.QuadPart = 0;
-
- /*
- * Zero out our streamData
- */
- memset(&streamData,0,sizeof(STREAMDATA));
-
- errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &newPosition);
- if (errCode != S_OK)
- return errCode;
-
- errCode = IStream_Read (pStream, &streamData, sizeof(STREAMDATA), &ulRead);
- if (errCode != S_OK)
- return errCode;
-
- FIXME ("dwSize=%lu dwData2=%lu dwItems=%lu\n",
- streamData.dwSize, streamData.dwData2, streamData.dwItems);
-
- if ( ulRead < sizeof(STREAMDATA) ||
- lParam < sizeof(STREAMDATA) ||
- streamData.dwSize < sizeof(STREAMDATA) ||
- streamData.dwData2 < 1) {
- errCode = E_FAIL;
- }
-
- if (streamData.dwItems > (UINT_MAX / 2 / sizeof(VOID*))) /* 536870911 */
- return E_OUTOFMEMORY;
-
- /* create the dpa */
- hDpa = DPA_Create (streamData.dwItems);
- if (!hDpa)
- return E_OUTOFMEMORY;
-
- if (!DPA_Grow (hDpa, streamData.dwItems))
- return E_OUTOFMEMORY;
-
- /* load data from the stream into the dpa */
- ptr = hDpa->ptrs;
- for (loadData.nCount = 0; loadData.nCount < streamData.dwItems; loadData.nCount++) {
- errCode = (loadProc)(&loadData, pStream, lParam);
- if (errCode != S_OK) {
- errCode = S_FALSE;
- break;
- }
-
- *ptr = loadData.ptr;
- ptr++;
- }
-
- /* set the number of items */
- hDpa->nItemCount = loadData.nCount;
-
- /* store the handle to the dpa */
- *phDpa = hDpa;
- FIXME ("new hDpa=%p, errorcode=%lx\n", hDpa, errCode);
-
- return errCode;
-}
-
-
-/**************************************************************************
- * DPA_SaveStream [COMCTL32.10]
- *
- * Saves a dynamic pointer array to a stream
- *
- * PARAMS
- * hDpa [I] handle to a dynamic pointer array
- * loadProc [I] pointer to a callback function
- * pStream [I] pointer to a stream
- * lParam [I] application specific value
- *
- * RETURNS
- * Success: TRUE
- * Failure: FALSE
- *
- * NOTES
- * No more information available yet!
- */
-HRESULT WINAPI DPA_SaveStream (const HDPA hDpa, DPALOADPROC loadProc,
- IStream *pStream, LPARAM lParam)
-{
-
- FIXME ("hDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
- hDpa, loadProc, pStream, lParam);
-
- return E_FAIL;
-}
-
-
-/**************************************************************************
- * DPA_Merge [COMCTL32.11]
- *
- * Merge two dynamic pointers arrays.
- *
- * PARAMS
- * hdpa1 [I] handle to a dynamic pointer array
- * hdpa2 [I] handle to a dynamic pointer array
- * dwFlags [I] flags
- * pfnCompare [I] pointer to sort function
- * pfnMerge [I] pointer to merge function
- * lParam [I] application specific value
- *
- * RETURNS
- * Success: TRUE
- * Failure: FALSE
- *
- * NOTES
- * No more information available yet!
- */
-BOOL WINAPI DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
- PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge,
- LPARAM lParam)
-{
- INT nCount;
- LPVOID *pWork1, *pWork2;
- INT nResult, i;
- INT nIndex;
-
- TRACE("%p %p %08lx %p %p %08lx)\n",
- hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
-
- if (IsBadWritePtr (hdpa1, sizeof(*hdpa1)))
- return FALSE;
-
- if (IsBadWritePtr (hdpa2, sizeof(*hdpa2)))
- return FALSE;
-
- if (IsBadCodePtr ((FARPROC)pfnCompare))
- return FALSE;
-
- if (IsBadCodePtr ((FARPROC)pfnMerge))
- return FALSE;
-
- if (!(dwFlags & DPAM_NOSORT)) {
- TRACE("sorting dpa's!\n");
- if (hdpa1->nItemCount > 0)
- DPA_Sort (hdpa1, pfnCompare, lParam);
- TRACE ("dpa 1 sorted!\n");
- if (hdpa2->nItemCount > 0)
- DPA_Sort (hdpa2, pfnCompare, lParam);
- TRACE ("dpa 2 sorted!\n");
- }
-
- if (hdpa2->nItemCount < 1)
- return TRUE;
-
- TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
- hdpa1->nItemCount, hdpa2->nItemCount);
-
-
- /* working but untrusted implementation */
-
- pWork1 = &(hdpa1->ptrs[hdpa1->nItemCount - 1]);
- pWork2 = &(hdpa2->ptrs[hdpa2->nItemCount - 1]);
-
- nIndex = hdpa1->nItemCount - 1;
- nCount = hdpa2->nItemCount - 1;
-
- do
- {
- if (nIndex < 0) {
- if ((nCount >= 0) && (dwFlags & DPAM_INSERT)) {
- /* Now insert the remaining new items into DPA 1 */
- TRACE("%d items to be inserted at start of DPA 1\n",
- nCount+1);
- for (i=nCount; i>=0; i--) {
- PVOID ptr;
-
- ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
- if (!ptr)
- return FALSE;
- DPA_InsertPtr (hdpa1, 0, ptr);
- pWork2--;
- }
- }
- break;
- }
- nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
- TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
- nResult, nIndex, nCount);
-
- if (nResult == 0)
- {
- PVOID ptr;
-
- ptr = (pfnMerge)(1, *pWork1, *pWork2, lParam);
- if (!ptr)
- return FALSE;
-
- nCount--;
- pWork2--;
- *pWork1 = ptr;
- nIndex--;
- pWork1--;
- }
- else if (nResult > 0)
- {
- /* item in DPA 1 missing from DPA 2 */
- if (dwFlags & DPAM_DELETE)
- {
- /* Now delete the extra item in DPA1 */
- PVOID ptr;
-
- ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
-
- (pfnMerge)(2, ptr, NULL, lParam);
- }
- nIndex--;
- pWork1--;
- }
- else
- {
- /* new item in DPA 2 */
- if (dwFlags & DPAM_INSERT)
- {
- /* Now insert the new item in DPA 1 */
- PVOID ptr;
-
- ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
- if (!ptr)
- return FALSE;
- DPA_InsertPtr (hdpa1, nIndex+1, ptr);
- }
- nCount--;
- pWork2--;
- }
-
- }
- while (nCount >= 0);
-
- return TRUE;
-}
-
-
-/**************************************************************************
* Alloc [COMCTL32.71]
*
* Allocates memory block from the dll's private heap
@@ -1416,912 +1111,6 @@
/**************************************************************************
- * 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 an array control structure. Use this like a handle.
- * Failure: NULL
- *
- * NOTES
- * The DSA_ functions can be used to create and manipulate arrays of
- * fixed-size memory blocks. These arrays can store any kind of data
- * (e.g. strings and icons).
- */
-HDSA WINAPI DSA_Create (INT nSize, INT nGrow)
-{
- HDSA hdsa;
-
- TRACE("(size=%d grow=%d)\n", nSize, nGrow);
-
- hdsa = Alloc (sizeof(*hdsa));
- if (hdsa)
- {
- hdsa->nItemCount = 0;
- hdsa->pData = NULL;
- hdsa->nMaxCount = 0;
- hdsa->nItemSize = nSize;
- hdsa->nGrow = max(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
- */
-BOOL WINAPI DSA_Destroy (const HDSA hdsa)
-{
- TRACE("(%p)\n", hdsa);
-
- if (!hdsa)
- return FALSE;
-
- if (hdsa->pData && (!Free (hdsa->pData)))
- return FALSE;
-
- return Free (hdsa);
-}
-
-
-/**************************************************************************
- * DSA_GetItem [COMCTL32.322]
- *
- * Copies the specified item into a caller-supplied buffer.
- *
- * 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
- */
-BOOL WINAPI DSA_GetItem (const HDSA hdsa, INT nIndex, LPVOID pDest)
-{
- LPVOID pSrc;
-
- TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
-
- if (!hdsa)
- return FALSE;
- if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
- return FALSE;
-
- pSrc = (char *) 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, INT nIndex)
-{
- LPVOID pSrc;
-
- TRACE("(%p %d)\n", hdsa, nIndex);
-
- if (!hdsa)
- return NULL;
- if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
- return NULL;
-
- pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
-
- TRACE("-- 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
- */
-BOOL WINAPI DSA_SetItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
-{
- INT nSize, nNewItems;
- LPVOID pDest, lpTemp;
-
- TRACE("(%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 + 1;
- }
- else {
- /* resize the block of memory */
- nNewItems =
- hdsa->nGrow * ((INT)(((nIndex + 1) - 1) / hdsa->nGrow) + 1);
- nSize = hdsa->nItemSize * nNewItems;
-
- lpTemp = ReAlloc (hdsa->pData, nSize);
- if (!lpTemp)
- return FALSE;
-
- hdsa->nMaxCount = nNewItems;
- hdsa->nItemCount = nIndex + 1;
- hdsa->pData = lpTemp;
- }
- }
-
- /* put the new entry in */
- pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
- TRACE("-- move dest=%p src=%p size=%d\n",
- pDest, pSrc, hdsa->nItemSize);
- memmove (pDest, pSrc, hdsa->nItemSize);
-
- return TRUE;
-}
-
-
-/**************************************************************************
- * DSA_InsertItem [COMCTL32.324]
- *
- * Inserts an item into the array at the specified index.
- *
- * 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
- */
-INT WINAPI DSA_InsertItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
-{
- INT nNewItems, nSize;
- LPVOID lpTemp, lpDest;
-
- TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
-
- if ((!hdsa) || nIndex < 0)
- return -1;
-
- /* 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 = 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 = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
- lpDest = (char *) lpTemp + hdsa->nItemSize;
- nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
- TRACE("-- 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 = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
- TRACE("-- move dest=%p src=%p size=%d\n",
- lpDest, pSrc, hdsa->nItemSize);
- memmove (lpDest, pSrc, hdsa->nItemSize);
-
- return nIndex;
-}
-
-
-/**************************************************************************
- * DSA_DeleteItem [COMCTL32.326]
- *
- * Deletes the specified item from the array.
- *
- * 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
- */
-INT WINAPI DSA_DeleteItem (const HDSA hdsa, INT nIndex)
-{
- LPVOID lpDest,lpSrc;
- INT nSize;
-
- TRACE("(%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 = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
- lpSrc = (char *) lpDest + hdsa->nItemSize;
- nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
- TRACE("-- 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 = ReAlloc (hdsa->pData, nSize);
- if (!lpDest)
- return -1;
-
- hdsa->nMaxCount = hdsa->nItemCount;
- hdsa->pData = lpDest;
- }
-
- return nIndex;
-}
-
-
-/**************************************************************************
- * DSA_DeleteAllItems [COMCTL32.327]
- *
- * Removes all items and reinitializes the array.
- *
- * PARAMS
- * hdsa [I] pointer to the array control structure
- *
- * RETURNS
- * Success: TRUE
- * Failure: FALSE
- */
-BOOL WINAPI DSA_DeleteAllItems (const HDSA hdsa)
-{
- TRACE("(%p)\n", hdsa);
-
- if (!hdsa)
- return FALSE;
- if (hdsa->pData && (!Free (hdsa->pData)))
- return FALSE;
-
- hdsa->nItemCount = 0;
- hdsa->pData = NULL;
- hdsa->nMaxCount = 0;
-
- return TRUE;
-}
-
-
-/**************************************************************************
- * DPA_Destroy [COMCTL32.329]
- *
- * Destroys a dynamic pointer array
- *
- * PARAMS
- * hdpa [I] handle (pointer) to the pointer array
- *
- * RETURNS
- * Success: TRUE
- * Failure: FALSE
- */
-BOOL WINAPI DPA_Destroy (const HDPA hdpa)
-{
- TRACE("(%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 by which the array grows when it's too small
- *
- * RETURNS
- * Success: TRUE
- * Failure: FALSE
- */
-BOOL WINAPI DPA_Grow (const HDPA hdpa, INT nGrow)
-{
- TRACE("(%p %d)\n", hdpa, nGrow);
-
- if (!hdpa)
- return FALSE;
-
- hdpa->nGrow = max(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)
-{
- INT nNewItems, nSize;
- HDPA hdpaTemp;
-
- if (!hdpa)
- return NULL;
-
- TRACE("(%p %p)\n", hdpa, hdpaNew);
-
- if (!hdpaNew) {
- /* create a new DPA */
- hdpaTemp = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
- sizeof(*hdpaTemp));
- 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 *
- ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
- nSize = nNewItems * sizeof(LPVOID);
- hdpaTemp->ptrs = 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, INT nIndex)
-{
- TRACE("(%p %d)\n", hdpa, nIndex);
-
- if (!hdpa)
- return NULL;
- if (!hdpa->ptrs) {
- WARN("no pointer array.\n");
- return NULL;
- }
- if ((nIndex < 0) || (nIndex >= hdpa->nItemCount)) {
- WARN("not enough pointers in array (%d vs %d).\n",nIndex,hdpa->nItemCount);
- return NULL;
- }
-
- TRACE("-- %p\n", hdpa->ptrs[nIndex]);
-
- return hdpa->ptrs[nIndex];
-}
-
-
-/**************************************************************************
- * 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
- */
-INT WINAPI DPA_GetPtrIndex (const HDPA hdpa, LPVOID p)
-{
- INT i;
-
- if (!hdpa || !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
- */
-INT WINAPI DPA_InsertPtr (const HDPA hdpa, INT i, LPVOID p)
-{
- TRACE("(%p %d %p)\n", hdpa, i, p);
-
- if (!hdpa || i < 0) return -1;
-
- if (i >= 0x7fff)
- i = hdpa->nItemCount;
-
- if (i >= hdpa->nItemCount)
- return DPA_SetPtr(hdpa, i, p) ? i : -1;
-
- /* create empty spot at the end */
- if (!DPA_SetPtr(hdpa, hdpa->nItemCount, 0)) return -1;
- memmove (hdpa->ptrs + i + 1, hdpa->ptrs + i, (hdpa->nItemCount - i - 1) * sizeof(LPVOID));
- hdpa->ptrs[i] = p;
- return i;
-}
-
-/**************************************************************************
- * 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
- */
-BOOL WINAPI DPA_SetPtr (const HDPA hdpa, INT i, LPVOID p)
-{
- LPVOID *lpTemp;
-
- TRACE("(%p %d %p)\n", hdpa, i, p);
-
- if (!hdpa || i < 0 || i > 0x7fff)
- return FALSE;
-
- if (hdpa->nItemCount <= i) {
- /* within the old array */
- if (hdpa->nMaxCount <= i) {
- /* resize the block of memory */
- INT nNewItems =
- hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1);
- INT nSize = nNewItems * sizeof(LPVOID);
-
- if (hdpa->ptrs)
- lpTemp = HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, hdpa->ptrs, nSize);
- else
- lpTemp = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, nSize);
-
- if (!lpTemp)
- return FALSE;
-
- hdpa->nMaxCount = nNewItems;
- hdpa->ptrs = lpTemp;
- }
- hdpa->nItemCount = i+1;
- }
-
- /* 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, INT i)
-{
- LPVOID *lpDest, *lpSrc, lpTemp = NULL;
- INT nSize;
-
- TRACE("(%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;
- lpSrc = lpDest + 1;
- nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
- TRACE("-- 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) {
- INT nNewItems = max(hdpa->nGrow * 2, hdpa->nItemCount);
- nSize = nNewItems * sizeof(LPVOID);
- lpDest = 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
- */
[truncated at 1000 lines; 2397 more skipped]