/* * Undocumented functions from COMCTL32.DLL * * Copyright 1998 Eric Kohl * 1998 Juergen Schmied * 2000 Eric Kohl for CodeWeavers * * 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 #include /* atoi */ #include #include #include "commctrl.h" #include "objbase.h" #include "winbase.h" #include "winerror.h" #include "winreg.h" #include "wine/unicode.h" #include "comctl32.h" #include "debugtools.h" DEFAULT_DEBUG_CHANNEL(commctrl); extern HANDLE COMCTL32_hHeap; /* handle to the private heap */ 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); INT __cdecl _wtoi(LPWSTR string); /************************************************************************** * 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 * * 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.s.LowPart = 0; position.s.HighPart = 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\n", hDpa); 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 * * 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] * * 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 * * 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; INT nIndex; TRACE("%p %p %08lx %p %p %08lx)\n", hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam); if (IsBadWritePtr (hdpa1, sizeof(DPA))) return FALSE; if (IsBadWritePtr (hdpa2, sizeof(DPA))) return FALSE; if (IsBadCodePtr ((FARPROC)pfnCompare)) return FALSE; if (IsBadCodePtr ((FARPROC)pfnMerge)) return FALSE; if (dwFlags & DPAM_SORT) { 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) 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) { if (!(dwFlags & 8)) { PVOID ptr; ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1); (pfnMerge)(2, ptr, NULL, lParam); } nIndex--; pWork1--; } else { if (!(dwFlags & 4)) { PVOID ptr; ptr = (pfnMerge)(3, *pWork2, NULL, lParam); if (!ptr) return FALSE; DPA_InsertPtr (hdpa1, nIndex, ptr); } nCount--; pWork2--; } } while (nCount >= 0); return TRUE; } /************************************************************************** * Alloc [COMCTL32.71] * * Allocates memory block from the dll's private 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("(0x%lx)\n", dwSize); lpPtr = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize); TRACE("-- 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 private 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("(%p 0x%08lx)\n", lpSrc, dwSize); if (lpSrc) lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize); else lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize); TRACE("-- ret=%p\n", lpDest); return lpDest; } /************************************************************************** * Free [COMCTL32.73] * * Frees an allocated memory block from the dll's private heap. * * PARAMS * lpMem [I] pointer to memory block which will be freed * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI COMCTL32_Free (LPVOID lpMem) { TRACE("(%p)\n", lpMem); return HeapFree (COMCTL32_hHeap, 0, lpMem); } /************************************************************************** * GetSize [COMCTL32.74] * * Retrieves the size of the specified memory block from the dll's * private 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("(%p)\n", lpMem); return HeapSize (COMCTL32_hHeap, 0, lpMem); } /************************************************************************** * The MRU-API is a set of functions to manipulate MRU(Most Recently Used) * lists. * * Stored in the reg. as a set of values under a single key. Each item in the * list has a value name that is a single char. 'a' - 'z', '{', '|' or '}'. * The order of the list is stored with value name 'MRUList' which is a string * containing the value names (i.e. 'a', 'b', etc.) in the relevant order. */ typedef struct tagCREATEMRULISTA { DWORD cbSize; /* size of struct */ DWORD nMaxItems; /* max no. of items in list */ DWORD dwFlags; /* see below */ HKEY hKey; /* root reg. key under which list is saved */ LPCSTR lpszSubKey; /* reg. subkey */ PROC lpfnCompare; /* item compare proc */ } CREATEMRULISTA, *LPCREATEMRULISTA; typedef struct tagCREATEMRULISTW { DWORD cbSize; /* size of struct */ DWORD nMaxItems; /* max no. of items in list */ DWORD dwFlags; /* see below */ HKEY hKey; /* root reg. key under which list is saved */ LPCWSTR lpszSubKey; /* reg. subkey */ PROC lpfnCompare; /* item compare proc */ } CREATEMRULISTW, *LPCREATEMRULISTW; /* dwFlags */ #define MRUF_STRING_LIST 0 /* list will contain strings */ #define MRUF_BINARY_LIST 1 /* list will contain binary data */ #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */ /* If list is a string list lpfnCompare has the following prototype * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2) * for binary lists the prototype is * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData) * where cbData is the no. of bytes to compare. * Need to check what return value means identical - 0? */ typedef struct tagWINEMRUITEM { DWORD size; /* size of data stored */ DWORD itemFlag; /* flags */ BYTE datastart; } WINEMRUITEM, *LPWINEMRUITEM; /* itemFlag */ #define WMRUIF_CHANGED 0x0001 /* this dataitem changed */ typedef struct tagWINEMRULIST { CREATEMRULISTW extview; /* original create information */ BOOL isUnicode; /* is compare fn Unicode */ DWORD wineFlags; /* internal flags */ DWORD cursize; /* current size of realMRU */ LPSTR realMRU; /* pointer to string of index names */ LPWINEMRUITEM *array; /* array of pointers to data */ /* in 'a' to 'z' order */ } WINEMRULIST, *LPWINEMRULIST; /* wineFlags */ #define WMRUF_CHANGED 0x0001 /* MRU list has changed */ /************************************************************************** * MRU_SaveChanged - Localize MRU saving code * */ VOID MRU_SaveChanged( LPWINEMRULIST mp ) { INT i, err; HKEY newkey; WCHAR realname[2]; LPWINEMRUITEM witem; WCHAR emptyW[] = {'\0'}; /* or should we do the following instead of RegOpenKeyEx: */ /* open the sub key */ if ((err = RegOpenKeyExW( mp->extview.hKey, mp->extview.lpszSubKey, 0, KEY_WRITE, &newkey))) { /* not present - what to do ??? */ ERR("Can not open key, error=%d, attempting to create\n", err); if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey, 0, emptyW, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, 0, &newkey, 0))) { ERR("failed to create key /%s/, err=%d\n", debugstr_w(mp->extview.lpszSubKey), err); return; } } if (mp->wineFlags & WMRUF_CHANGED) { mp->wineFlags &= ~WMRUF_CHANGED; err = RegSetValueExA(newkey, "MRUList", 0, REG_SZ, mp->realMRU, strlen(mp->realMRU) + 1); if (err) { ERR("error saving MRUList, err=%d\n", err); } TRACE("saving MRUList=/%s/\n", mp->realMRU); } realname[1] = 0; for(i=0; icursize; i++) { witem = mp->array[i]; if (witem->itemFlag & WMRUIF_CHANGED) { witem->itemFlag &= ~WMRUIF_CHANGED; realname[0] = 'a' + i; err = RegSetValueExW(newkey, realname, 0, (mp->extview.dwFlags & MRUF_BINARY_LIST) ? REG_BINARY : REG_SZ, &witem->datastart, witem->size); if (err) { ERR("error saving /%s/, err=%d\n", debugstr_w(realname), err); } TRACE("saving value for name /%s/ size=%ld\n", debugstr_w(realname), witem->size); } } RegCloseKey( newkey ); } /************************************************************************** * FreeMRUList [COMCTL32.152] * * PARAMS * hMRUList [I] Handle to list. * */ DWORD WINAPI FreeMRUList (HANDLE hMRUList) { LPWINEMRULIST mp = (LPWINEMRULIST)hMRUList; INT i; TRACE("\n"); if (mp->wineFlags & WMRUF_CHANGED) { /* need to open key and then save the info */ MRU_SaveChanged( mp ); } for(i=0; iextview.nMaxItems; i++) { if (mp->array[i]) COMCTL32_Free(mp->array[i]); } COMCTL32_Free(mp->realMRU); COMCTL32_Free(mp->array); COMCTL32_Free((LPWSTR)mp->extview.lpszSubKey); return COMCTL32_Free(mp); } /************************************************************************** * FindMRUData [COMCTL32.169] * * Searches binary list for item that matches lpData of length cbData. * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value * corresponding to item's reg. name will be stored in it ('a' -> 0). * * PARAMS * hList [I] list handle * lpData [I] data to find * cbData [I] length of data * lpRegNum [O] position in registry (maybe NULL) * * RETURNS * Position in list 0 -> MRU. -1 if item not found. */ INT WINAPI FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum) { LPWINEMRULIST mp = (LPWINEMRULIST)hList; INT i, ret; LPSTR dataA = NULL; if (!mp->extview.lpfnCompare) { ERR("MRU list not properly created. No compare procedure.\n"); return -1; } if(!(mp->extview.dwFlags & MRUF_BINARY_LIST) && !mp->isUnicode) { DWORD len = WideCharToMultiByte(CP_ACP, 0, lpData, -1, NULL, 0, NULL, NULL); dataA = COMCTL32_Alloc(len); WideCharToMultiByte(CP_ACP, 0, lpData, -1, dataA, len, NULL, NULL); } for(i=0; icursize; i++) { if (mp->extview.dwFlags & MRUF_BINARY_LIST) { if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart, cbData)) break; } else { if(mp->isUnicode) { if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart)) break; } else { DWORD len = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&mp->array[i]->datastart, -1, NULL, 0, NULL, NULL); LPSTR itemA = COMCTL32_Alloc(len); INT cmp; WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&mp->array[i]->datastart, -1, itemA, len, NULL, NULL); cmp = mp->extview.lpfnCompare(dataA, itemA); COMCTL32_Free(itemA); if(!cmp) break; } } } if(dataA) COMCTL32_Free(dataA); if (i < mp->cursize) ret = i; else ret = -1; if (lpRegNum && (ret != -1)) *lpRegNum = 'a' + i; TRACE("(%08x, %p, %ld, %p) returning %d\n", hList, lpData, cbData, lpRegNum, ret); return ret; } /************************************************************************** * AddMRUData [COMCTL32.167] * * Add item to MRU binary list. If item already exists in list then it is * simply moved up to the top of the list and not added again. If list is * full then the least recently used item is removed to make room. * * PARAMS * hList [I] Handle to list. * lpData [I] ptr to data to add. * cbData [I] no. of bytes of data. * * RETURNS * No. corresponding to registry name where value is stored 'a' -> 0 etc. * -1 on error. */ INT WINAPI AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData) { LPWINEMRULIST mp = (LPWINEMRULIST)hList; LPWINEMRUITEM witem; INT i, replace, ret; if ((replace = FindMRUData (hList, lpData, cbData, NULL)) < 0) { /* either add a new entry or replace oldest */ if (mp->cursize < mp->extview.nMaxItems) { /* Add in a new item */ replace = mp->cursize; mp->cursize++; } else { /* get the oldest entry and replace data */ replace = mp->realMRU[mp->cursize - 1] - 'a'; COMCTL32_Free(mp->array[replace]); } } else { /* free up the old data */ COMCTL32_Free(mp->array[replace]); } /* Allocate space for new item and move in the data */ mp->array[replace] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(cbData + sizeof(WINEMRUITEM)); witem->itemFlag |= WMRUIF_CHANGED; witem->size = cbData; memcpy( &witem->datastart, lpData, cbData); /* now rotate MRU list */ mp->wineFlags |= WMRUF_CHANGED; for(i=mp->cursize-1; i>=1; i--) { mp->realMRU[i] = mp->realMRU[i-1]; } mp->realMRU[0] = replace + 'a'; TRACE("(%08x, %p, %ld) adding data, /%c/ now most current\n", hList, lpData, cbData, replace+'a'); ret = replace; if (!(mp->extview.dwFlags & MRUF_DELAYED_SAVE)) { /* save changed stuff right now */ MRU_SaveChanged( mp ); } return ret; } /************************************************************************** * AddMRUStringW [COMCTL32.401] * * Add item to MRU string list. If item already exists in list them it is * simply moved up to the top of the list and not added again. If list is * full then the least recently used item is removed to make room. * * PARAMS * hList [I] Handle to list. * lpszString [I] ptr to string to add. * * RETURNS * No. corresponding to registry name where value is stored 'a' -> 0 etc. * -1 on error. */ INT WINAPI AddMRUStringW(HANDLE hList, LPCWSTR lpszString) { FIXME("(%08x, %s) empty stub!\n", hList, debugstr_w(lpszString)); return 0; } /************************************************************************** * AddMRUStringA [COMCTL32.153] */ INT WINAPI AddMRUStringA(HANDLE hList, LPCSTR lpszString) { FIXME("(%08x, %s) empty stub!\n", hList, debugstr_a(lpszString)); return 0; } /************************************************************************** * DelMRUString [COMCTL32.156] * * Removes item from either string or binary list (despite its name) * * PARAMS * hList [I] list handle * nItemPos [I] item position to remove 0 -> MRU * * RETURNS * TRUE if successful, FALSE if nItemPos is out of range. */ BOOL WINAPI DelMRUString(HANDLE hList, INT nItemPos) { FIXME("(%08x, %d): stub\n", hList, nItemPos); return TRUE; } /************************************************************************** * FindMRUStringW [COMCTL32.402] */ INT WINAPI FindMRUStringW (HANDLE hList, LPCWSTR lpszString, LPINT lpRegNum) { FIXME("stub\n"); return -1; } /************************************************************************** * FindMRUStringA [COMCTL32.155] * * Searches string list for item that matches lpszString. * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value * corresponding to item's reg. name will be stored in it ('a' -> 0). * * PARAMS * hList [I] list handle * lpszString [I] string to find * lpRegNum [O] position in registry (maybe NULL) * * RETURNS * Position in list 0 -> MRU. -1 if item not found. */ INT WINAPI FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum) { DWORD len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0); LPWSTR stringW = COMCTL32_Alloc(len * sizeof(WCHAR)); INT ret; MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len); ret = FindMRUData(hList, stringW, len * sizeof(WCHAR), lpRegNum); COMCTL32_Free(stringW); return ret; } /************************************************************************* * CreateMRUListLazy_common */ HANDLE CreateMRUListLazy_common(LPWINEMRULIST mp) { INT i, err; HKEY newkey; DWORD datasize, dwdisp; WCHAR realname[2]; LPWINEMRUITEM witem; DWORD type; WCHAR emptyW[] = {'\0'}; /* get space to save indices that will turn into names * but in order of most to least recently used */ mp->realMRU = (LPSTR) COMCTL32_Alloc(mp->extview.nMaxItems + 2); /* get space to save pointers to actual data in order of * 'a' to 'z' (0 to n). */ mp->array = (LPVOID) COMCTL32_Alloc(mp->extview.nMaxItems * sizeof(LPVOID)); /* open the sub key */ if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey, 0, emptyW, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, 0, &newkey, &dwdisp))) { /* error - what to do ??? */ ERR("(%lu %lu %lx %lx \"%s\" %p): Can not open key, error=%d\n", mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags, (DWORD)mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey), mp->extview.lpfnCompare, err); return 0; } /* get values from key 'MRUList' */ if (newkey) { datasize = mp->extview.nMaxItems + 1; if((err=RegQueryValueExA( newkey, "MRUList", 0, &type, mp->realMRU, &datasize))) { /* not present - set size to 1 (will become 0 later) */ datasize = 1; *mp->realMRU = 0; } TRACE("MRU list = %s\n", mp->realMRU); mp->cursize = datasize - 1; /* datasize now has number of items in the MRUList */ /* get actual values for each entry */ realname[1] = 0; for(i=0; icursize; i++) { realname[0] = 'a' + i; if(RegQueryValueExW( newkey, realname, 0, &type, 0, &datasize)) { /* not present - what to do ??? */ ERR("Key %s not found 1\n", debugstr_w(realname)); } mp->array[i] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(datasize + sizeof(WINEMRUITEM)); witem->size = datasize; if(RegQueryValueExW( newkey, realname, 0, &type, &witem->datastart, &datasize)) { /* not present - what to do ??? */ ERR("Key %s not found 2\n", debugstr_w(realname)); } } RegCloseKey( newkey ); } else mp->cursize = 0; TRACE("(%lu %lu %lx %lx \"%s\" %p): Current Size = %ld\n", mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags, (DWORD)mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey), mp->extview.lpfnCompare, mp->cursize); return (HANDLE)mp; } /************************************************************************** * CreateMRUListLazyW [COMCTL32.404] */ HANDLE WINAPI CreateMRUListLazyW (LPCREATEMRULISTW lpcml, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4) { LPWINEMRULIST mp; if (lpcml == NULL) return 0; if (lpcml->cbSize < sizeof(CREATEMRULISTW)) return 0; mp = (LPWINEMRULIST) COMCTL32_Alloc(sizeof(WINEMRULIST)); memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW)); mp->extview.lpszSubKey = COMCTL32_Alloc((strlenW(lpcml->lpszSubKey) + 1) * sizeof(WCHAR)); strcpyW((LPWSTR)mp->extview.lpszSubKey, lpcml->lpszSubKey); mp->isUnicode = TRUE; return CreateMRUListLazy_common(mp); } /************************************************************************** * CreateMRUListLazyA [COMCTL32.157] */ HANDLE WINAPI CreateMRUListLazyA (LPCREATEMRULISTA lpcml, DWORD dwParam2, DWORD dwParam3, DWORD dwParam4) { LPWINEMRULIST mp; DWORD len; if (lpcml == NULL) return 0; if (lpcml->cbSize < sizeof(CREATEMRULISTA)) return 0; mp = (LPWINEMRULIST) COMCTL32_Alloc(sizeof(WINEMRULIST)); memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW)); len = MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1, NULL, 0); mp->extview.lpszSubKey = COMCTL32_Alloc(len * sizeof(WCHAR)); MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1, (LPWSTR)mp->extview.lpszSubKey, len); mp->isUnicode = FALSE; return CreateMRUListLazy_common(mp); } /************************************************************************** * CreateMRUListW [COMCTL32.400] * * PARAMS * lpcml [I] ptr to CREATEMRULIST structure. * * RETURNS * Handle to MRU list. */ HANDLE WINAPI CreateMRUListW (LPCREATEMRULISTW lpcml) { return CreateMRUListLazyW(lpcml, 0, 0, 0); } /************************************************************************** * CreateMRUListA [COMCTL32.151] */ HANDLE WINAPI CreateMRUListA (LPCREATEMRULISTA lpcml) { return CreateMRUListLazyA (lpcml, 0, 0, 0); } /************************************************************************** * EnumMRUListW [COMCTL32.403] * * Enumerate item in a list * * PARAMS * hList [I] list handle * nItemPos [I] item position to enumerate * lpBuffer [O] buffer to receive item * nBufferSize [I] size of buffer * * RETURNS * For binary lists specifies how many bytes were copied to buffer, for * string lists specifies full length of string. Enumerating past the end * of list returns -1. * If lpBuffer == NULL or nItemPos is -ve return value is no. of items in * the list. */ INT WINAPI EnumMRUListW(HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize) { LPWINEMRULIST mp = (LPWINEMRULIST) hList; LPWINEMRUITEM witem; INT desired, datasize; if (nItemPos >= mp->cursize) return -1; if ((nItemPos < 0) || !lpBuffer) return mp->cursize; desired = mp->realMRU[nItemPos]; desired -= 'a'; TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired); witem = mp->array[desired]; datasize = min( witem->size, nBufferSize ); memcpy( lpBuffer, &witem->datastart, datasize); TRACE("(%08x, %d, %p, %ld): returning len=%d\n", hList, nItemPos, lpBuffer, nBufferSize, datasize); return datasize; } /************************************************************************** * EnumMRUListA [COMCTL32.154] * */ INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize) { LPWINEMRULIST mp = (LPWINEMRULIST) hList; LPWINEMRUITEM witem; INT desired, datasize; DWORD lenA; if (nItemPos >= mp->cursize) return -1; if ((nItemPos < 0) || !lpBuffer) return mp->cursize; desired = mp->realMRU[nItemPos]; desired -= 'a'; TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired); witem = mp->array[desired]; if(mp->extview.dwFlags & MRUF_BINARY_LIST) { datasize = min( witem->size, nBufferSize ); memcpy( lpBuffer, &witem->datastart, datasize); } else { lenA = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1, NULL, 0, NULL, NULL); datasize = min( witem->size, nBufferSize ); WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1, lpBuffer, datasize, NULL, NULL); } TRACE("(%08x, %d, %p, %ld): returning len=%d\n", hList, nItemPos, lpBuffer, nBufferSize, datasize); return datasize; } /************************************************************************** * Str_GetPtrA [COMCTL32.233] * * PARAMS * lpSrc [I] * lpDest [O] * nMaxLen [I] * * RETURNS */ INT WINAPI Str_GetPtrA (LPCSTR lpSrc, LPSTR lpDest, INT nMaxLen) { INT len; TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen); if (!lpDest && lpSrc) return strlen (lpSrc); if (nMaxLen == 0) return 0; if (lpSrc == NULL) { lpDest[0] = '\0'; return 0; } len = strlen (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 */ BOOL WINAPI Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc) { TRACE("(%p %p)\n", lppDest, lpSrc); if (lpSrc) { LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1); if (!ptr) return FALSE; strcpy (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 */ INT WINAPI Str_GetPtrW (LPCWSTR lpSrc, LPWSTR lpDest, INT nMaxLen) { INT len; TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen); if (!lpDest && lpSrc) return strlenW (lpSrc); if (nMaxLen == 0) return 0; if (lpSrc == NULL) { lpDest[0] = L'\0'; return 0; } len = strlenW (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 */ BOOL WINAPI Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc) { TRACE("(%p %p)\n", lppDest, lpSrc); if (lpSrc) { INT len = strlenW (lpSrc) + 1; LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR)); if (!ptr) return FALSE; strcpyW (ptr, lpSrc); *lppDest = ptr; } else { if (*lppDest) { COMCTL32_Free (*lppDest); *lppDest = NULL; } } return TRUE; } /************************************************************************** * Str_GetPtrWtoA [internal] * * Converts a unicode string into a multi byte string * * PARAMS * lpSrc [I] Pointer to the unicode source string * lpDest [O] Pointer to caller supplied storage for the multi byte string * nMaxLen [I] Size, in bytes, of the destination buffer * * RETURNS * Length, in bytes, of the converted string. */ INT Str_GetPtrWtoA (LPCWSTR lpSrc, LPSTR lpDest, INT nMaxLen) { INT len; TRACE("(%s %p %d)\n", debugstr_w(lpSrc), lpDest, nMaxLen); if (!lpDest && lpSrc) return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL); if (nMaxLen == 0) return 0; if (lpSrc == NULL) { lpDest[0] = '\0'; return 0; } len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL); if (len >= nMaxLen) len = nMaxLen - 1; WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL); lpDest[len] = '\0'; return len; } /************************************************************************** * Str_SetPtrAtoW [internal] * * Converts a multi byte string to a unicode string. * If the pointer to the destination buffer is NULL a buffer is allocated. * If the destination buffer is too small to keep the converted multi byte * string the destination buffer is reallocated. If the source pointer is * NULL, the destination buffer is freed. * * PARAMS * lppDest [I/O] pointer to a pointer to the destination buffer * lpSrc [I] pointer to a multi byte string * * RETURNS * TRUE: conversion successful * FALSE: error */ BOOL Str_SetPtrAtoW (LPWSTR *lppDest, LPCSTR lpSrc) { TRACE("(%p %s)\n", lppDest, lpSrc); if (lpSrc) { INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0); LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len*sizeof(WCHAR)); if (!ptr) return FALSE; MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len); *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 * fixed-size 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 an array control structure. Use this like a handle. * Failure: NULL */ HDSA WINAPI DSA_Create (INT nSize, INT nGrow) { HDSA hdsa; TRACE("(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 = 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 && (!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 */ 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 = (LPVOID)COMCTL32_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] * * 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 = (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 = (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] * * 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 = (LPVOID)COMCTL32_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 && (!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 (INT nGrow) { HDPA hdpa; TRACE("(%d)\n", nGrow); hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA)); if (hdpa) { hdpa->nGrow = max(8, nGrow); hdpa->hHeap = COMCTL32_hHeap; hdpa->nMaxCount = hdpa->nGrow * 2; hdpa->ptrs = (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID)); } TRACE("-- %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 */ 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 = (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 * ((INT)((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, INT i) { TRACE("(%p %d)\n", hdpa, i); if (!hdpa) return NULL; if (!hdpa->ptrs) { WARN("no pointer array.\n"); return NULL; } if ((i < 0) || (i >= hdpa->nItemCount)) { WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount); return NULL; } TRACE("-- %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 */ INT WINAPI DPA_GetPtrIndex (const HDPA hdpa, LPVOID p) { INT 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 */ INT WINAPI DPA_InsertPtr (const HDPA hdpa, INT i, LPVOID p) { INT nNewItems, nSize, nIndex = 0; LPVOID *lpTemp, *lpDest; TRACE("(%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, 2 * hdpa->nGrow * sizeof(LPVOID)); if (!hdpa->ptrs) return -1; hdpa->nMaxCount = hdpa->nGrow * 2; nIndex = 0; } else { if (hdpa->nItemCount >= hdpa->nMaxCount) { TRACE("-- 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) { nIndex = hdpa->nItemCount; TRACE("-- appending at %d\n", nIndex); } else { TRACE("-- inserting at %d\n", i); lpTemp = hdpa->ptrs + i; lpDest = lpTemp + 1; nSize = (hdpa->nItemCount - i) * sizeof(LPVOID); TRACE("-- 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 */ 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) 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+1; } else { /* resize the block of memory */ INT nNewItems = hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1); INT 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, 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 = (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 */ BOOL WINAPI DPA_DeleteAllPtrs (const HDPA hdpa) { TRACE("(%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] * * Ordinary 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 */ static VOID DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r, PFNDPACOMPARE pfnCompare, LPARAM lParam) { INT m; LPVOID t; TRACE("l=%i r=%i\n", l, r); if (l==r) /* one element is always sorted */ return; if (r0) { t = lpPtrs[m+1]; memmove(&lpPtrs[l+1],&lpPtrs[l],(m-l+1)*sizeof lpPtrs[l]); lpPtrs[l] = t; m++; } l++; } } /************************************************************************** * 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 */ BOOL WINAPI DPA_Sort (const HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam) { if (!hdpa || !pfnCompare) return FALSE; TRACE("(%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"! * Function is NOT tested! * If something goes wrong, blame HIM not ME! (Eric Kohl) */ INT WINAPI DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart, PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions) { if (!hdpa || !pfnCompare || !pFind) return -1; TRACE("(%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 */ INT l, r, x, n; LPVOID *lpPtr; TRACE("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("-- ret=%d\n", n); return n; } } if (uOptions & DPAS_INSERTBEFORE) { TRACE("-- ret=%d\n", r); return r; } if (uOptions & DPAS_INSERTAFTER) { TRACE("-- ret=%d\n", l); return l; } } else { /* array is not sorted --> use linear search */ LPVOID *lpPtr; INT nIndex; TRACE("linear search\n"); nIndex = (nStart == -1)? 0 : nStart; lpPtr = hdpa->ptrs; for (; nIndex < hdpa->nItemCount; nIndex++) { if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) { TRACE("-- ret=%d\n", nIndex); return nIndex; } } } TRACE("-- 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 (INT nGrow, HANDLE hHeap) { HDPA hdpa; TRACE("(%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 : COMCTL32_hHeap; hdpa->nMaxCount = hdpa->nGrow * 2; hdpa->ptrs = (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, hdpa->nMaxCount * sizeof(LPVOID)); } TRACE("-- %p\n", hdpa); return hdpa; } /************************************************************************** * Notification functions */ typedef struct tagNOTIFYDATA { HWND hwndFrom; HWND hwndTo; DWORD dwParam3; DWORD dwParam4; DWORD dwParam5; DWORD dwParam6; } NOTIFYDATA, *LPNOTIFYDATA; /************************************************************************** * DoNotify [Internal] */ static LRESULT DoNotify (LPNOTIFYDATA lpNotify, UINT uCode, LPNMHDR lpHdr) { NMHDR nmhdr; LPNMHDR lpNmh = NULL; UINT idFrom = 0; TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n", lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr, lpNotify->dwParam5); if (!lpNotify->hwndTo) return 0; if (lpNotify->hwndFrom == -1) { lpNmh = lpHdr; idFrom = lpHdr->idFrom; } else { if (lpNotify->hwndFrom) { HWND hwndParent = GetParent (lpNotify->hwndFrom); if (hwndParent) { hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER); /* the following is done even if the return from above * is zero. GLA 12/2001 */ idFrom = GetDlgCtrlID (lpNotify->hwndFrom); } } lpNmh = (lpHdr) ? lpHdr : &nmhdr; lpNmh->hwndFrom = lpNotify->hwndFrom; lpNmh->idFrom = idFrom; lpNmh->code = uCode; } return SendMessageA (lpNotify->hwndTo, WM_NOTIFY, idFrom, (LPARAM)lpNmh); } /************************************************************************** * SendNotify [COMCTL32.341] * * PARAMS * hwndTo [I] * hwndFrom [I] * uCode [I] * lpHdr [I] * * RETURNS * Success: return value from notification * Failure: 0 */ LRESULT WINAPI COMCTL32_SendNotify (HWND hwndTo, HWND hwndFrom, UINT uCode, LPNMHDR lpHdr) { NOTIFYDATA notify; TRACE("(0x%04x 0x%04x %d %p)\n", hwndTo, hwndFrom, uCode, lpHdr); notify.hwndFrom = hwndFrom; notify.hwndTo = hwndTo; notify.dwParam5 = 0; notify.dwParam6 = 0; return DoNotify (¬ify, uCode, lpHdr); } /************************************************************************** * SendNotifyEx [COMCTL32.342] * * PARAMS * hwndFrom [I] * hwndTo [I] * uCode [I] * lpHdr [I] * dwParam5 [I] * * RETURNS * Success: return value from notification * Failure: 0 */ LRESULT WINAPI COMCTL32_SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode, LPNMHDR lpHdr, DWORD dwParam5) { NOTIFYDATA notify; HWND hwndNotify; TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n", hwndFrom, hwndTo, uCode, lpHdr, dwParam5); hwndNotify = hwndTo; if (!hwndTo) { if (IsWindow (hwndFrom)) { hwndNotify = GetParent (hwndFrom); if (!hwndNotify) return 0; } } notify.hwndFrom = hwndFrom; notify.hwndTo = hwndNotify; notify.dwParam5 = dwParam5; notify.dwParam6 = 0; return DoNotify (¬ify, uCode, lpHdr); } /************************************************************************** * 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) { INT 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. */ INT WINAPI COMCTL32_StrToIntA (LPSTR lpString) { return atoi(lpString); } /************************************************************************** * StrToIntW [COMCTL32.365] Converts a wide char string to a signed integer. */ INT WINAPI COMCTL32_StrToIntW (LPWSTR lpString) { return _wtoi(lpString); } /************************************************************************** * DPA_EnumCallback [COMCTL32.385] * * Enumerates all items in a dynamic pointer array. * * PARAMS * hdpa [I] handle to the dynamic pointer array * enumProc [I] * lParam [I] * * RETURNS * none */ VOID WINAPI DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam) { INT i; TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam); if (!hdpa) return; if (hdpa->nItemCount <= 0) return; for (i = 0; i < hdpa->nItemCount; i++) { if ((enumProc)(hdpa->ptrs[i], lParam) == 0) return; } return; } /************************************************************************** * DPA_DestroyCallback [COMCTL32.386] * * Enumerates all items in a dynamic pointer array and destroys it. * * PARAMS * hdpa [I] handle to the dynamic pointer array * enumProc [I] * lParam [I] * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI DPA_DestroyCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam) { TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam); DPA_EnumCallback (hdpa, enumProc, lParam); return DPA_Destroy (hdpa); } /************************************************************************** * DSA_EnumCallback [COMCTL32.387] * * Enumerates all items in a dynamic storage array. * * PARAMS * hdsa [I] handle to the dynamic storage array * enumProc [I] * lParam [I] * * RETURNS * none */ VOID WINAPI DSA_EnumCallback (const HDSA hdsa, DSAENUMPROC enumProc, LPARAM lParam) { INT i; TRACE("(%p %p %08lx)\n", hdsa, enumProc, lParam); if (!hdsa) return; if (hdsa->nItemCount <= 0) return; for (i = 0; i < hdsa->nItemCount; i++) { LPVOID lpItem = DSA_GetItemPtr (hdsa, i); if ((enumProc)(lpItem, lParam) == 0) return; } return; } /************************************************************************** * DSA_DestroyCallback [COMCTL32.388] * * Enumerates all items in a dynamic storage array and destroys it. * * PARAMS * hdsa [I] handle to the dynamic storage array * enumProc [I] * lParam [I] * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI DSA_DestroyCallback (const HDSA hdsa, DSAENUMPROC enumProc, LPARAM lParam) { TRACE("(%p %p %08lx)\n", hdsa, enumProc, lParam); DSA_EnumCallback (hdsa, enumProc, lParam); return DSA_Destroy (hdsa); } /************************************************************************** * StrCSpnA [COMCTL32.356] * */ INT WINAPI COMCTL32_StrCSpnA( LPCSTR lpStr, LPCSTR lpSet) { return strcspn(lpStr, lpSet); } /************************************************************************** * StrChrW [COMCTL32.358] * */ LPWSTR WINAPI COMCTL32_StrChrW( LPCWSTR lpStart, WORD wMatch) { return strchrW(lpStart, wMatch); } /************************************************************************** * StrCmpNA [COMCTL32.352] * */ INT WINAPI COMCTL32_StrCmpNA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar) { return strncmp(lpStr1, lpStr2, nChar); } /************************************************************************** * StrCmpNIA [COMCTL32.353] * */ INT WINAPI COMCTL32_StrCmpNIA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar) { return strncasecmp(lpStr1, lpStr2, nChar); } /************************************************************************** * StrCmpNW [COMCTL32.360] * */ INT WINAPI COMCTL32_StrCmpNW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) { return strncmpW(lpStr1, lpStr2, nChar); } /************************************************************************** * StrCmpNIW [COMCTL32.361] * */ INT WINAPI COMCTL32_StrCmpNIW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) { FIXME("(%s, %s, %i): stub\n", debugstr_w(lpStr1), debugstr_w(lpStr2), nChar); return 0; } /************************************************************************** * StrRChrA [COMCTL32.351] * */ LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch ) { LPCSTR lpGotIt = NULL; BOOL dbcs = IsDBCSLeadByte( LOBYTE(wMatch) ); TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch); if (!lpEnd) lpEnd = lpStart + strlen(lpStart); for(; lpStart < lpEnd; lpStart = CharNextA(lpStart)) { if (*lpStart != LOBYTE(wMatch)) continue; if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue; lpGotIt = lpStart; } return (LPSTR)lpGotIt; } /************************************************************************** * StrRChrW [COMCTL32.359] * */ LPWSTR WINAPI COMCTL32_StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch) { LPCWSTR lpGotIt = NULL; TRACE("(%p, %p, %x)\n", lpStart, lpEnd, wMatch); if (!lpEnd) lpEnd = lpStart + strlenW(lpStart); for(; lpStart < lpEnd; lpStart = CharNextW(lpStart)) if (*lpStart == wMatch) lpGotIt = lpStart; return (LPWSTR)lpGotIt; } /************************************************************************** * StrStrA [COMCTL32.354] * */ LPSTR WINAPI COMCTL32_StrStrA( LPCSTR lpFirst, LPCSTR lpSrch) { return strstr(lpFirst, lpSrch); } /************************************************************************** * StrStrW [COMCTL32.362] * */ LPWSTR WINAPI COMCTL32_StrStrW( LPCWSTR lpFirst, LPCWSTR lpSrch) { return strstrW(lpFirst, lpSrch); } /************************************************************************** * StrSpnW [COMCTL32.364] * */ INT WINAPI COMCTL32_StrSpnW( LPWSTR lpStr, LPWSTR lpSet) { LPWSTR lpLoop = lpStr; /* validate ptr */ if ((lpStr == 0) || (lpSet == 0)) return 0; /* while(*lpLoop) { if lpLoop++; } */ for(; (*lpLoop != 0); lpLoop++) if( strchrW(lpSet, *(WORD*)lpLoop)) return (INT)(lpLoop-lpStr); return (INT)(lpLoop-lpStr); } /************************************************************************** * @ [COMCTL32.410] * * FIXME: What's this supposed to do? * Parameter 1 is an HWND, you're on your own for the rest. */ BOOL WINAPI COMCTL32_410( HWND hw, DWORD b, DWORD c, DWORD d) { FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d); return TRUE; } /************************************************************************** * @ [COMCTL32.411] * * FIXME: What's this supposed to do? * Parameter 1 is an HWND, you're on your own for the rest. */ BOOL WINAPI COMCTL32_411( HWND hw, DWORD b, DWORD c) { FIXME("(%x, %lx, %lx): stub!\n", hw, b, c); return TRUE; } /************************************************************************** * @ [COMCTL32.412] * * FIXME: What's this supposed to do? * Parameter 1 is an HWND, you're on your own for the rest. */ BOOL WINAPI COMCTL32_412( HWND hwnd, DWORD b, DWORD c) { FIXME("(%x, %lx, %lx): stub!\n", hwnd, b, c); if (IsWindow (hwnd) == FALSE) return FALSE; if (b == 0) return FALSE; return TRUE; } /************************************************************************** * @ [COMCTL32.413] * * FIXME: What's this supposed to do? * Parameter 1 is an HWND, you're on your own for the rest. */ BOOL WINAPI COMCTL32_413( HWND hw, DWORD b, DWORD c, DWORD d) { FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d); return TRUE; } /************************************************************************** * @ [COMCTL32.415] * * FIXME: What's this supposed to do? * Parameter 1 is an HWND, you're on your own for the rest. */ BOOL WINAPI COMCTL32_415( HWND hwnd, DWORD b, DWORD c, DWORD d, DWORD e) { FIXME("(%x, %lx, %lx, %lx, %lx): stub!\n", hwnd, b, c, d, e); return TRUE; } /************************************************************************** * @ [COMCTL32.419] * * FIXME: What's this supposed to do? */ BOOL WINAPI COMCTL32_419( DWORD a, DWORD b, DWORD c, DWORD d) { FIXME("(%lx, %lx, %lx, %lx): stub!\n", a, b, c, d); return TRUE; }