Sweden-Number/controls/comctl32undoc.c

/*
 * Undocumented functions from COMCTL32.DLL
 *
 * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
 *
 * NOTES
 *     All of these functions are UNDOCUMENTED!! And I mean UNDOCUMENTED!!!!
 *     Do NOT rely on names of undocumented structures and types!!!
 *     These functions are used by EXPLORER.EXE, IEXPLORE.EXE and
 *     COMCTL32.DLL (internally).
 *
 * TODO
 *     - Fix DSA_InsertItem.
 *     - Write documentation.
 */

#include <string.h>
#include "windows.h"
#include "heap.h"
#include "debug.h"


typedef struct _DSA_DATA
{
    DWORD   dwEntryCount;
    DWORD   dwMaxCount;
    DWORD   dwInitial;
    DWORD   dwGrow;
    LPSTR   *ptrs;
} DSA_DATA, *LPDSA_DATA;


typedef struct _DPA_DATA
{
    DWORD   dwEntryCount;
    DWORD   dwMaxCount;
    DWORD   dwGrow;
    LPDWORD ptrs; 
} DPA_DATA, *LPDPA_DATA;


DWORD WINAPI Alloc (DWORD);
DWORD WINAPI ReAlloc (DWORD, DWORD);
DWORD WINAPI Free (DWORD);

DWORD WINAPI DSA_Create (DWORD, DWORD);


DWORD WINAPI DPA_Create (DWORD);
DWORD WINAPI DPA_GetPtr (DWORD, DWORD);
DWORD WINAPI DPA_InsertPtr (DWORD, DWORD, DWORD);


LPSTR WINAPI COMCTL32_StrChrA (LPSTR lpString, CHAR cChar);


DWORD WINAPI
Alloc (DWORD dwParam1)
{
    DWORD dwPtr;

    dwPtr = (DWORD)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY, dwParam1);

    TRACE (commctrl, "(0x%08lx) ret=0x%08lx\n", dwParam1, dwPtr);

    return dwPtr;
}


DWORD WINAPI
ReAlloc (DWORD dwParam1, DWORD dwParam2)
{
    DWORD dwPtr;

    if (dwParam1 == 0)
	dwPtr = (DWORD)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY, dwParam2);
    else
	dwPtr = (DWORD)HeapReAlloc (SystemHeap, HEAP_ZERO_MEMORY, 
				    (LPVOID)dwParam1, dwParam2);

    TRACE (commctrl, "(0x%08lx 0x%08lx) ret=0x%08lx\n",
	   dwParam1, dwParam2, dwPtr);

    return dwPtr;
}


DWORD WINAPI
Free (DWORD dwParam1)
{
    TRACE (commctrl, "(0x%08lx)\n", dwParam1);
    HeapFree (SystemHeap, 0, (LPVOID)dwParam1);

    return 0;
}





DWORD WINAPI
DSA_Create (DWORD dwParam1, DWORD dwParam2)
{
    LPDSA_DATA dsaPtr;

    dsaPtr = (LPDSA_DATA)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY, sizeof(DSA_DATA));
    dsaPtr->dwInitial = dwParam1;
    dsaPtr->dwGrow = dwParam2;

    TRACE (commctrl, "(0x%08lx 0x%08lx) ret=0x%08lx\n",
	   dwParam1, dwParam2, (DWORD)dsaPtr);

    return (DWORD)dsaPtr;
}


DWORD WINAPI
DSA_Destroy (DWORD dwParam1)
{
    LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;
    DWORD i;

    TRACE (commctrl, "(0x%08lx):semi-stub!\n", dwParam1);

    if (dsaPtr->ptrs) {
	for (i = 0; i < dsaPtr->dwEntryCount; i++) {
	    if (dsaPtr->ptrs[i])
		HeapFree (SystemHeap, 0, (LPSTR)dsaPtr->ptrs[i]);
	}
    }

    HeapFree (SystemHeap, 0, dsaPtr);

    return 0;
}


DWORD WINAPI
DSA_InsertItem (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
    LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;
    DWORD dwIndex;
    INT32 len;

    TRACE (commctrl, "(0x%08lx 0x%08lx \"%s\"):semi-stub!\n",
	   dwParam1, dwParam2, (LPSTR)dwParam3);

    if (dsaPtr->ptrs == NULL) {
	dsaPtr->ptrs = (LPSTR*)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY,
					  dsaPtr->dwInitial * sizeof(LPVOID));
	dsaPtr->dwMaxCount = dsaPtr->dwInitial;
        dwIndex = 0;
	len = lstrlen32A ((LPSTR)dwParam3);
	dsaPtr->ptrs[dwIndex] =
	    (LPSTR)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY, len+1);
	lstrcpy32A (dsaPtr->ptrs[dwIndex], (LPSTR)dwParam3);
    }
    else {
	TRACE (commctrl, "(0x%08lx 0x%08lx)\n",
	       dsaPtr->dwEntryCount, dsaPtr->dwMaxCount);
	if (dwParam2 >= dsaPtr->dwEntryCount) {
	    if (dsaPtr->dwEntryCount < dsaPtr->dwMaxCount) {
		dwIndex = dsaPtr->dwEntryCount;
		len = lstrlen32A ((LPSTR)dwParam3);
		dsaPtr->ptrs[dwIndex] =
		    (LPSTR)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY, len+1);
		lstrcpy32A (dsaPtr->ptrs[dwIndex], (LPSTR)dwParam3);
	    }
	    else {
		FIXME (commctrl, "resizing array! stub!\n");

		dwIndex = dwParam2;

	    }
	}
	else {
	    FIXME (commctrl, "inserting! stub!\n");

	    dwIndex = dwParam2;
	}
    }

    dsaPtr->dwEntryCount++;

    TRACE (commctrl, "ret=0x%08lx\n", dwIndex);

    return (dwIndex);
}


DWORD WINAPI
DSA_GetItemPtr (DWORD dwParam1, DWORD dwParam2)
{
    LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;

    TRACE (commctrl, "(0x%08lx 0x%08lx)\n", dwParam1, dwParam2);

    if (dsaPtr == NULL)
	return 0;
    if (dsaPtr->ptrs == NULL)
	return 0;
    if ((dwParam2 < 0) || (dwParam2 >= dsaPtr->dwEntryCount))
	return 0;

    TRACE (commctrl, "ret=0x%08lx\n", (DWORD)dsaPtr->ptrs[dwParam2]);

    return (DWORD)dsaPtr->ptrs[dwParam2];
}


DWORD WINAPI
DSA_DeleteItem (DWORD dwParam1, DWORD dwParam2)
{
    LPDSA_DATA dsaPtr = (LPDSA_DATA)dwParam1;

    TRACE (commctrl, "(0x%08lx 0x%08lx):semi-stub!\n",
	   dwParam1, dwParam2);

    if (dsaPtr->ptrs) {
	if (dsaPtr->dwEntryCount == 1) {
	    if (dsaPtr->ptrs[dwParam2])
		HeapFree (SystemHeap, 0, dsaPtr->ptrs[dwParam2]);
	    dsaPtr->dwEntryCount--;
	}
	else {
	    LPSTR *oldPtrs = dsaPtr->ptrs;
	    TRACE (commctrl, "complex delete!\n");

	    if (dsaPtr->ptrs[dwParam2])
		HeapFree (SystemHeap, 0, dsaPtr->ptrs[dwParam2]);

	    dsaPtr->dwEntryCount--;
	    dsaPtr->ptrs = 
		(LPSTR*)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY,
				   dsaPtr->dwEntryCount * sizeof(LPVOID));
	    if (dwParam2 > 0) {
		memcpy (&dsaPtr->ptrs[0], &oldPtrs[0],
			dwParam2 * sizeof(LPSTR));
	    }

	    if (dwParam2 < dsaPtr->dwEntryCount) {
		memcpy (&dsaPtr->ptrs[dwParam2], &oldPtrs[dwParam2+1],
			(dsaPtr->dwEntryCount - dwParam2) * sizeof(LPSTR));
	    }
	    HeapFree (SystemHeap, 0, oldPtrs);
	}

	if (dsaPtr->dwEntryCount == 0) {
	    HeapFree (SystemHeap, 0, dsaPtr->ptrs);
	    dsaPtr->ptrs = NULL;
	}
    }

    return 0;
}





DWORD WINAPI
DPA_Create (DWORD dwParam1)
{
    LPDPA_DATA dpaPtr;

    TRACE (commctrl, "(0x%08lx)\n", dwParam1);

    dpaPtr = (LPDPA_DATA)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY, sizeof(DPA_DATA));
    dpaPtr->dwGrow = dwParam1;

    TRACE (commctrl, "ret=0x%08lx\n", (DWORD)dpaPtr);

    return (DWORD)dpaPtr;
}



DWORD WINAPI
DPA_GetPtr (DWORD dwParam1, DWORD dwParam2)
{
    LPDPA_DATA dpaPtr = (LPDPA_DATA)dwParam1;

    TRACE (commctrl, "(0x%08lx 0x%08lx)\n", dwParam1, dwParam2);

    if (dpaPtr == NULL)
	return 0;
    if (dpaPtr->ptrs == NULL)
	return 0;
    if ((dwParam2 < 0) || (dwParam2 >= dpaPtr->dwEntryCount))
	return 0;

    TRACE (commctrl, "ret=0x%08lx\n", (DWORD)dpaPtr->ptrs[dwParam2]);

    return (DWORD)dpaPtr->ptrs[dwParam2];
}



DWORD WINAPI
DPA_InsertPtr (DWORD dwParam1, DWORD dwParam2, DWORD dwParam3)
{
    LPDPA_DATA dpaPtr = (LPDPA_DATA)dwParam1;
    DWORD dwIndex;

    TRACE (commctrl, "(0x%08lx 0x%08lx 0x%lx)\n",
	   dwParam1, dwParam2, dwParam3);

    if (dpaPtr->ptrs == NULL) {
	dpaPtr->ptrs = (LPDWORD)HeapAlloc (SystemHeap, HEAP_ZERO_MEMORY,
					   dpaPtr->dwGrow * sizeof(LPVOID));
	dpaPtr->dwMaxCount = dpaPtr->dwGrow;
        dwIndex = 0;
        dpaPtr->ptrs[dwIndex] = dwParam3;
    }
    else {
	FIXME (commctrl, "adding to existing array! stub!\n");


	dwIndex = dwParam2;
    }

    dpaPtr->dwEntryCount++;

    return (dwIndex);
}


LPSTR WINAPI
COMCTL32_StrChrA (LPSTR lpString, CHAR cChar)
{
    return strchr (lpString, cChar);
}