dpa.c File Reference

#include <stdarg.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "commctrl.h"
#include "objbase.h"
#include "comctl32.h"
#include "wine/debug.h"

Include dependency graph for dpa.c:

Go to the source code of this file.

Classes
struct	_DPA
struct	_STREAMDATA

Macros
#define	COBJMACROS

Typedefs
typedef struct _DPA	DPA
typedef struct _STREAMDATA	STREAMDATA
typedef struct _STREAMDATA *	PSTREAMDATA

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dpa)
HRESULT WINAPI	DPA_LoadStream (HDPA *phDpa, PFNDPASTREAM loadProc, IStream *pStream, LPVOID pData)
HRESULT WINAPI	DPA_SaveStream (HDPA hDpa, PFNDPASTREAM saveProc, IStream *pStream, LPVOID pData)
BOOL WINAPI	DPA_Merge (HDPA hdpa1, HDPA hdpa2, DWORD dwFlags, PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
BOOL WINAPI	DPA_Destroy (HDPA hdpa)
BOOL WINAPI	DPA_Grow (HDPA hdpa, INT nGrow)
HDPA WINAPI	DPA_Clone (const HDPA hdpa, HDPA hdpaNew)
LPVOID WINAPI	DPA_GetPtr (HDPA hdpa, INT nIndex)
INT WINAPI	DPA_GetPtrIndex (HDPA hdpa, LPCVOID p)
INT WINAPI	DPA_InsertPtr (HDPA hdpa, INT i, LPVOID p)
BOOL WINAPI	DPA_SetPtr (HDPA hdpa, INT i, LPVOID p)
LPVOID WINAPI	DPA_DeletePtr (HDPA hdpa, INT i)
BOOL WINAPI	DPA_DeleteAllPtrs (HDPA hdpa)
static VOID	DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r, PFNDPACOMPARE pfnCompare, LPARAM lParam)
BOOL WINAPI	DPA_Sort (HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam)
INT WINAPI	DPA_Search (HDPA hdpa, LPVOID pFind, INT nStart, PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
HDPA WINAPI	DPA_CreateEx (INT nGrow, HANDLE hHeap)
HDPA WINAPI	DPA_Create (INT nGrow)
VOID WINAPI	DPA_EnumCallback (HDPA hdpa, PFNDPAENUMCALLBACK enumProc, LPVOID lParam)
void WINAPI	DPA_DestroyCallback (HDPA hdpa, PFNDPAENUMCALLBACK enumProc, LPVOID lParam)
ULONGLONG WINAPI	DPA_GetSize (HDPA hdpa)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 32 of file dpa.c.

Typedef Documentation

DPA

typedef struct _DPA DPA

PSTREAMDATA

typedef struct _STREAMDATA * PSTREAMDATA

STREAMDATA

typedef struct _STREAMDATA STREAMDATA

Function Documentation

DPA_Clone()

HDPA WINAPI DPA_Clone	(	const HDPA	hdpa,
		HDPA	hdpaNew
	)

Definition at line 470 of file dpa.c.

{
    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 *
                (((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;
}

Referenced by init_functions().

DPA_Create()

HDPA WINAPI DPA_Create

(

INT

nGrow

)

Definition at line 950 of file dpa.c.

{
    return DPA_CreateEx( nGrow, 0 );
}

Referenced by CPointerArray< T, GrowthRate >::CPointerArray(), DPA_LoadStream(), CDefView::FillList(), CMenuSFToolbar::FillToolbar(), init_functions(), InitShellServices(), LISTVIEW_InsertItemT(), LISTVIEW_NCCreate(), ranges_create(), REBAR_NCCreate(), SIC_Initialize(), TAB_Create(), TREEVIEW_BuildChildDPA(), and TREEVIEW_Create().

DPA_CreateEx()

HDPA WINAPI DPA_CreateEx	(	INT	nGrow,
		HANDLE	hHeap
	)

Definition at line 909 of file dpa.c.

{
    HDPA hdpa;
 
    TRACE("(%d %p)\n", nGrow, hHeap);
 
    if (hHeap)
        hdpa = HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(*hdpa));
    else
        hdpa = Alloc (sizeof(*hdpa));
 
    if (hdpa) {
        hdpa->nGrow = max(8, nGrow);
        hdpa->hHeap = hHeap ? hHeap : GetProcessHeap();
        hdpa->nMaxCount = hdpa->nGrow * 2;
        hdpa->ptrs = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
                                hdpa->nMaxCount * sizeof(LPVOID));
    }
 
    TRACE("-- %p\n", hdpa);
 
    return hdpa;
}

Referenced by DPA_Create(), and init_functions().

DPA_DeleteAllPtrs()

BOOL WINAPI DPA_DeleteAllPtrs

(

HDPA

hdpa

)

Definition at line 730 of file dpa.c.

{
    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 = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
                                     hdpa->nMaxCount * sizeof(LPVOID));
 
    return TRUE;
}

Referenced by CPointerArray< T, GrowthRate >::Clear(), init_functions(), and ranges_clear().

DPA_DeletePtr()

LPVOID WINAPI DPA_DeletePtr	(	HDPA	hdpa,
		INT	i
	)

Definition at line 677 of file dpa.c.

{
    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 = lpDest;
    }
 
    return lpTemp;
}

Referenced by DPA_Merge(), init_functions(), LISTVIEW_DeleteAllItems(), LISTVIEW_DeleteColumn(), LISTVIEW_DeleteItem(), LISTVIEW_InsertColumnT(), LISTVIEW_InsertItemT(), ranges_add(), ranges_del(), REBAR_DeleteBand(), REBAR_HandleUDDrag(), REBAR_MoveBand(), REBAR_MoveBandToRowOffset(), CPointerArray< T, GrowthRate >::RemoveAt(), SIC_IconAppend(), TAB_DeleteItem(), TAB_Destroy(), and TREEVIEW_FreeItem().

DPA_Destroy()

BOOL WINAPI DPA_Destroy

(

HDPA

hdpa

)

Definition at line 396 of file dpa.c.

{
    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);
}

Referenced by DPA_DestroyCallback(), DPA_LoadStream(), CMenuSFToolbar::FillToolbar(), init_functions(), LISTVIEW_DeleteAllItems(), LISTVIEW_DeleteItem(), LISTVIEW_InsertItemT(), LISTVIEW_NCCreate(), LISTVIEW_NCDestroy(), ranges_destroy(), REBAR_Destroy(), ShutdownShellServices(), SIC_Initialize(), TAB_Destroy(), TREEVIEW_BuildChildDPA(), TREEVIEW_Destroy(), and TREEVIEW_Sort().

DPA_DestroyCallback()

void WINAPI DPA_DestroyCallback	(	HDPA	hdpa,
		PFNDPAENUMCALLBACK	enumProc,
		LPVOID	lParam
	)

Definition at line 1003 of file dpa.c.

{
    TRACE("(%p %p %p)\n", hdpa, enumProc, lParam);
 
    DPA_EnumCallback (hdpa, enumProc, lParam);
    DPA_Destroy (hdpa);
}

Referenced by CDefView::FillList(), init_functions(), SIC_Destroy(), and CPointerArray< T, GrowthRate >::~CPointerArray().

DPA_EnumCallback()

VOID WINAPI DPA_EnumCallback	(	HDPA	hdpa,
		PFNDPAENUMCALLBACK	enumProc,
		LPVOID	lParam
	)

Definition at line 969 of file dpa.c.

{
    INT i;
 
    TRACE("(%p %p %p)\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;
}

Referenced by CPointerArray< T, GrowthRate >::Clear(), DPA_DestroyCallback(), init_functions(), InitShellServices(), ShutdownShellServices(), and TREEVIEW_SetFont().

DPA_GetPtr()

LPVOID WINAPI DPA_GetPtr	(	HDPA	hdpa,
		INT	nIndex
	)

Definition at line 527 of file dpa.c.

{
    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()

INT WINAPI DPA_GetPtrIndex	(	HDPA	hdpa,
		LPCVOID	p
	)

Definition at line 561 of file dpa.c.

{
    INT i;
 
    if (!hdpa || !hdpa->ptrs)
        return -1;
 
    for (i = 0; i < hdpa->nItemCount; i++) {
        if (hdpa->ptrs[i] == p)
            return i;
    }
 
    return -1;
}

Referenced by CPointerArray< T, GrowthRate >::IndexOf(), init_functions(), LISTVIEW_CallBackCompareEx(), LISTVIEW_DeleteAllItems(), LISTVIEW_DeleteItem(), LISTVIEW_MapIdToIndex(), LISTVIEW_SortItems(), TREEVIEW_FreeItem(), TREEVIEW_GetItemIndex(), and TREEVIEW_VerifyItem().

DPA_GetSize()

ULONGLONG WINAPI DPA_GetSize

(

HDPA

hdpa

)

Definition at line 1023 of file dpa.c.

{
    TRACE("(%p)\n", hdpa);
 
    if (!hdpa) return 0;
 
    return sizeof(DPA) + hdpa->nMaxCount*sizeof(PVOID);
}

DPA_Grow()

BOOL WINAPI DPA_Grow	(	HDPA	hdpa,
		INT	nGrow
	)

Definition at line 423 of file dpa.c.

{
    INT items;
    TRACE("(%p %d)\n", hdpa, nGrow);
 
    if (!hdpa)
        return FALSE;
 
    nGrow = max( 8, nGrow );
    items = nGrow * (((hdpa->nMaxCount - 1) / nGrow) + 1);
    if (items > hdpa->nMaxCount)
    {
        void *ptr;
 
        if (hdpa->ptrs)
            ptr = HeapReAlloc( hdpa->hHeap, HEAP_ZERO_MEMORY, hdpa->ptrs, items * sizeof(LPVOID) );
        else
            ptr = HeapAlloc( hdpa->hHeap, HEAP_ZERO_MEMORY, items * sizeof(LPVOID) );
        if (!ptr) return FALSE;
        hdpa->nMaxCount = items;
        hdpa->ptrs = ptr;
    }
    hdpa->nGrow = nGrow;
 
    return TRUE;
}

Referenced by DPA_LoadStream(), and init_functions().

DPA_InsertPtr()

INT WINAPI DPA_InsertPtr	(	HDPA	hdpa,
		INT	i,
		LPVOID	p
	)

Definition at line 591 of file dpa.c.

{
    TRACE("(%p %d %p)\n", hdpa, i, p);
 
    if (!hdpa || i < 0) return -1;
 
    /* append item if index is out of bounds */
    i = min(hdpa->nItemCount, i);
 
    /* create empty spot at the end */
    if (!DPA_SetPtr(hdpa, hdpa->nItemCount, 0)) return -1;
    
    if (i != hdpa->nItemCount - 1)
        memmove (hdpa->ptrs + i + 1, hdpa->ptrs + i, 
                 (hdpa->nItemCount - i - 1) * sizeof(LPVOID));
    
    hdpa->ptrs[i] = p;
    return i;
}

Referenced by CPointerArray< T, GrowthRate >::Append(), DPA_Merge(), CDefView::FillList(), init_functions(), CPointerArray< T, GrowthRate >::Insert(), LISTVIEW_InsertColumnT(), LISTVIEW_InsertItemT(), ranges_add(), ranges_del(), REBAR_HandleUDDrag(), REBAR_InsertBandT(), REBAR_MoveBand(), REBAR_MoveBandToRowOffset(), set_sub_item(), SIC_IconAppend(), TAB_InsertItemT(), TREEVIEW_AllocateItem(), and TREEVIEW_BuildChildDPA().

DPA_LoadStream()

HRESULT WINAPI DPA_LoadStream	(	HDPA *	phDpa,
		PFNDPASTREAM	loadProc,
		IStream *	pStream,
		LPVOID	pData
	)

Definition at line 82 of file dpa.c.

{
    HRESULT errCode;
    LARGE_INTEGER position;
    ULARGE_INTEGER initial_pos;
    STREAMDATA  streamData;
    DPASTREAMINFO streamInfo;
    ULONG ulRead;
    HDPA hDpa;
    PVOID *ptr;
 
    TRACE ("phDpa=%p loadProc=%p pStream=%p pData=%p\n",
           phDpa, loadProc, pStream, pData);
 
    if (!phDpa || !loadProc || !pStream)
        return E_INVALIDARG;
 
    *phDpa = NULL;
 
    position.QuadPart = 0;
 
    errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &initial_pos);
    if (errCode != S_OK)
        return errCode;
 
    memset(&streamData, 0, sizeof(STREAMDATA));
    errCode = IStream_Read (pStream, &streamData, sizeof(STREAMDATA), &ulRead);
    if (errCode != S_OK)
        return errCode;
 
    TRACE ("dwSize=%u dwData2=%u dwItems=%u\n",
           streamData.dwSize, streamData.dwData2, streamData.dwItems);
 
    if (ulRead < sizeof(STREAMDATA) ||
        streamData.dwSize < sizeof(STREAMDATA) || streamData.dwData2 != 1) {
        /* back to initial position */
        position.QuadPart = initial_pos.QuadPart;
        IStream_Seek (pStream, position, STREAM_SEEK_SET, NULL);
        return 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)) {
        DPA_Destroy (hDpa);
        return E_OUTOFMEMORY;
    }
 
    /* load data from the stream into the dpa */
    ptr = hDpa->ptrs;
    for (streamInfo.iPos = 0; streamInfo.iPos < streamData.dwItems; streamInfo.iPos++) {
        errCode = (loadProc)(&streamInfo, pStream, pData);
        if (errCode != S_OK) {
            errCode = S_FALSE;
            break;
        }
 
        *ptr = streamInfo.pvItem;
        ptr++;
    }
 
    /* set the number of items */
    hDpa->nItemCount = streamInfo.iPos;
 
    /* store the handle to the dpa */
    *phDpa = hDpa;
    TRACE ("new hDpa=%p, errorcode=%x\n", hDpa, errCode);
 
    return errCode;
}

Referenced by init_functions().

DPA_Merge()

BOOL WINAPI DPA_Merge	(	HDPA	hdpa1,
		HDPA	hdpa2,
		DWORD	dwFlags,
		PFNDPACOMPARE	pfnCompare,
		PFNDPAMERGE	pfnMerge,
		LPARAM	lParam
	)

Definition at line 265 of file dpa.c.

{
    INT nCount;
    LPVOID *pWork1, *pWork2;
    INT nResult, i;
    INT nIndex;
 
    TRACE("(%p %p %08x %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_SORTED)) {
        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);
 
 
    nIndex = hdpa1->nItemCount - 1;
    nCount = hdpa2->nItemCount - 1;
 
    do
    {
        pWork1 = &hdpa1->ptrs[nIndex];
        pWork2 = &hdpa2->ptrs[nCount];
 
        if (nIndex < 0) {
            if ((nCount >= 0) && (dwFlags & DPAM_UNION)) {
                /* 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)(DPAMM_INSERT, *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)(DPAMM_MERGE, *pWork1, *pWork2, lParam);
            if (!ptr)
                return FALSE;
 
            nCount--;
            *pWork1 = ptr;
            nIndex--;
        }
        else if (nResult > 0)
        {
            /* item in DPA 1 missing from DPA 2 */
            if (dwFlags & DPAM_INTERSECT)
            {
                /* Now delete the extra item in DPA1 */
                PVOID ptr;
 
                ptr = DPA_DeletePtr (hdpa1, nIndex);
 
                (pfnMerge)(DPAMM_DELETE, ptr, NULL, lParam);
            }
            nIndex--;
        }
        else
        {
            /* new item in DPA 2 */
            if (dwFlags & DPAM_UNION)
            {
                /* Now insert the new item in DPA 1 */
                PVOID ptr;
 
                ptr = (pfnMerge)(DPAMM_INSERT, *pWork2, NULL, lParam);
                if (!ptr)
                    return FALSE;
                DPA_InsertPtr (hdpa1, nIndex+1, ptr);
            }
            nCount--;
        }
 
    }
    while (nCount >= 0);
 
    return TRUE;
}

Referenced by init_functions().

DPA_QuickSort()

static VOID DPA_QuickSort ( LPVOID *  lpPtrs, INT  l, INT  r, PFNDPACOMPARE  pfnCompare, LPARAM  lParam  )

static

Definition at line 764 of file dpa.c.

{
    INT m;
    LPVOID t;
 
    TRACE("l=%i r=%i\n", l, r);
 
    if (l==r)    /* one element is always sorted */
        return;
    if (r<l)     /* oops, got it in the wrong order */
        {
        DPA_QuickSort(lpPtrs, r, l, pfnCompare, lParam);
        return;
        }
    m = (l+r)/2; /* divide by two */
    DPA_QuickSort(lpPtrs, l, m, pfnCompare, lParam);
    DPA_QuickSort(lpPtrs, m+1, r, pfnCompare, lParam);
 
    /* join the two sides */
    while( (l<=m) && (m<r) )
    {
        if(pfnCompare(lpPtrs[l],lpPtrs[m+1],lParam)>0)
        {
            t = lpPtrs[m+1];
            memmove(&lpPtrs[l+1],&lpPtrs[l],(m-l+1)*sizeof(lpPtrs[l]));
            lpPtrs[l] = t;
 
            m++;
        }
        l++;
    }
}

Referenced by DPA_QuickSort(), and DPA_Sort().

DPA_SaveStream()

HRESULT WINAPI DPA_SaveStream	(	HDPA	hDpa,
		PFNDPASTREAM	saveProc,
		IStream *	pStream,
		LPVOID	pData
	)

Definition at line 179 of file dpa.c.

{
    LARGE_INTEGER position;
    ULARGE_INTEGER initial_pos, curr_pos;
    STREAMDATA  streamData;
    DPASTREAMINFO streamInfo;
    HRESULT hr;
    PVOID *ptr;
 
    TRACE ("hDpa=%p saveProc=%p pStream=%p pData=%p\n",
            hDpa, saveProc, pStream, pData);
 
    if (!hDpa || !saveProc || !pStream) return E_INVALIDARG;
 
    /* save initial position to write header after completion */
    position.QuadPart = 0;
    hr = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &initial_pos);
    if (hr != S_OK)
        return hr;
 
    /* write empty header */
    streamData.dwSize  = sizeof(streamData);
    streamData.dwData2 = 1;
    streamData.dwItems = 0;
 
    hr = IStream_Write (pStream, &streamData, sizeof(streamData), NULL);
    if (hr != S_OK) {
        position.QuadPart = initial_pos.QuadPart;
        IStream_Seek (pStream, position, STREAM_SEEK_SET, NULL);
        return hr;
    }
 
    /* no items - we're done */
    if (hDpa->nItemCount == 0) return S_OK;
 
    ptr = hDpa->ptrs;
    for (streamInfo.iPos = 0; streamInfo.iPos < hDpa->nItemCount; streamInfo.iPos++) {
        streamInfo.pvItem = *ptr;
        hr = (saveProc)(&streamInfo, pStream, pData);
        if (hr != S_OK) {
            hr = S_FALSE;
            break;
        }
        ptr++;
    }
 
    /* write updated header */
    position.QuadPart = 0;
    IStream_Seek (pStream, position, STREAM_SEEK_CUR, &curr_pos);
 
    streamData.dwSize  = curr_pos.QuadPart - initial_pos.QuadPart;
    streamData.dwData2 = 1;
    streamData.dwItems = streamInfo.iPos;
 
    position.QuadPart = initial_pos.QuadPart;
    IStream_Seek (pStream, position, STREAM_SEEK_SET, NULL);
    IStream_Write (pStream, &streamData, sizeof(streamData), NULL);
 
    position.QuadPart = curr_pos.QuadPart;
    IStream_Seek (pStream, position, STREAM_SEEK_SET, NULL);
 
    return hr;
}

Referenced by init_functions().

DPA_Search()

INT WINAPI DPA_Search	(	HDPA	hdpa,
		LPVOID	pFind,
		INT	nStart,
		PFNDPACOMPARE	pfnCompare,
		LPARAM	lParam,
		UINT	uOptions
	)

Definition at line 845 of file dpa.c.

{
    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;
 
        /* for binary search ignore start index */
        l = 0;
        r = hdpa->nItemCount - 1;
        lpPtr = hdpa->ptrs;
        while (r >= l) {
            x = (l + r) / 2;
            n = (pfnCompare)(pFind, lpPtr[x], lParam);
            if (n == 0)
                return x;
            else if (n < 0)
                r = x - 1;
            else /* (n > 0) */
                l = x + 1;
        }
        if (uOptions & (DPAS_INSERTBEFORE|DPAS_INSERTAFTER)) return l;
    }
    else {
        /* array is not sorted --> use linear search */
        LPVOID *lpPtr;
        INT  nIndex;
 
        nIndex = (nStart == -1)? 0 : nStart;
        lpPtr = hdpa->ptrs;
        for (; nIndex < hdpa->nItemCount; nIndex++) {
            if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0)
                return nIndex;
        }
    }
 
    return -1;
}

Referenced by init_functions(), LISTVIEW_MapIdToIndex(), ranges_add(), ranges_contain(), ranges_del(), ranges_shift(), CPointerArray< T, GrowthRate >::Search(), SIC_GetIconIndex(), and SIC_IconAppend().

DPA_SetPtr()

BOOL WINAPI DPA_SetPtr	(	HDPA	hdpa,
		INT	i,
		LPVOID	p
	)

Definition at line 626 of file dpa.c.

{
    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) {
            /* resize the block of memory */
            INT nNewItems =
                hdpa->nGrow * ((((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;
}

Referenced by DPA_InsertPtr(), init_functions(), LISTVIEW_InsertItemT(), LISTVIEW_MoveIconTo(), ranges_clone(), and CPointerArray< T, GrowthRate >::Set().

DPA_Sort()

BOOL WINAPI DPA_Sort	(	HDPA	hdpa,
		PFNDPACOMPARE	pfnCompare,
		LPARAM	lParam
	)

Definition at line 813 of file dpa.c.

{
    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;
}

Referenced by DPA_Merge(), CMenuSFToolbar::FillToolbar(), init_functions(), LISTVIEW_SortItems(), CPointerArray< T, GrowthRate >::Sort(), and TREEVIEW_Sort().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dpa

)