Ignore:
Timestamp:
Sep 5, 2001, 2:05:03 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/comctl32undoc.c

    r6380 r6644  
     1/* $Id: comctl32undoc.c,v 1.22 2001-09-05 12:04:57 bird Exp $ */
    12/*
    23 * Undocumented functions from COMCTL32.DLL
    … …  
    9899
    99100    FIXME ("phDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
    100            phDpa, loadProc, pStream, lParam);
     101       phDpa, loadProc, pStream, lParam);
    101102
    102103    if (!phDpa || !loadProc || !pStream)
    103         return E_INVALIDARG;
     104    return E_INVALIDARG;
    104105
    105106    *phDpa = (HDPA)NULL;
    … …  
    110111    errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &newPosition);
    111112    if (errCode != S_OK)
    112         return errCode;
     113    return errCode;
    113114
    114115    errCode = IStream_Read (pStream, &streamData, sizeof(STREAMDATA), &ulRead);
    115116    if (errCode != S_OK)
    116         return errCode;
     117    return errCode;
    117118
    118119    FIXME ("dwSize=%lu dwData2=%lu dwItems=%lu\n",
    119            streamData.dwSize, streamData.dwData2, streamData.dwItems);
     120       streamData.dwSize, streamData.dwData2, streamData.dwItems);
    120121
    121122    if (lParam < sizeof(STREAMDATA) ||
    122         streamData.dwSize < sizeof(STREAMDATA) ||
    123         streamData.dwData2 < 1) {
    124         errCode = E_FAIL;
     123    streamData.dwSize < sizeof(STREAMDATA) ||
     124    streamData.dwData2 < 1) {
     125    errCode = E_FAIL;
    125126    }
    126127
    … …  
    128129    hDpa = DPA_Create (streamData.dwItems);
    129130    if (!hDpa)
    130         return E_OUTOFMEMORY;
     131    return E_OUTOFMEMORY;
    131132
    132133    if (!DPA_Grow (hDpa, streamData.dwItems))
    133         return E_OUTOFMEMORY;
     134    return E_OUTOFMEMORY;
    134135
    135136    /* load data from the stream into the dpa */
    … …  
    137138    for (loadData.nCount = 0; loadData.nCount < streamData.dwItems; loadData.nCount++) {
    138139        errCode = (loadProc)(&loadData, pStream, lParam);
    139         if (errCode != S_OK) {
    140             errCode = S_FALSE;
    141             break;
    142         }
    143 
    144         *ptr = loadData.ptr;
    145         ptr++;
     140    if (errCode != S_OK) {
     141        errCode = S_FALSE;
     142        break;
     143    }
     144
     145    *ptr = loadData.ptr;
     146    ptr++;
    146147    }
    147148
    … …  
    177178
    178179    FIXME ("hDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
    179            hDpa, loadProc, pStream, lParam);
     180       hDpa, loadProc, pStream, lParam);
    180181
    181182    return E_FAIL;
    … …  
    200201BOOL WINAPI
    201202DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
    202            PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
     203       PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
    203204{
    204205    INT nCount;
    … …  
    208209
    209210    TRACE("%p %p %08lx %p %p %08lx)\n",
    210            hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
     211       hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
    211212
    212213    if (IsBadWritePtr (hdpa1, sizeof(DPA)))
    213         return FALSE;
     214    return FALSE;
    214215
    215216    if (IsBadWritePtr (hdpa2, sizeof(DPA)))
    216         return FALSE;
     217    return FALSE;
    217218
    218219    if (IsBadCodePtr ((FARPROC)pfnCompare))
    219         return FALSE;
     220    return FALSE;
    220221
    221222    if (IsBadCodePtr ((FARPROC)pfnMerge))
    222         return FALSE;
     223    return FALSE;
    223224
    224225    if (dwFlags & DPAM_SORT) {
    225         TRACE("sorting dpa's!\n");
    226         if (hdpa1->nItemCount > 0)
    227         DPA_Sort (hdpa1, pfnCompare, lParam);
    228         TRACE ("dpa 1 sorted!\n");
    229         if (hdpa2->nItemCount > 0)
    230         DPA_Sort (hdpa2, pfnCompare, lParam);
    231         TRACE ("dpa 2 sorted!\n");
     226    TRACE("sorting dpa's!\n");
     227    if (hdpa1->nItemCount > 0)
     228    DPA_Sort (hdpa1, pfnCompare, lParam);
     229    TRACE ("dpa 1 sorted!\n");
     230    if (hdpa2->nItemCount > 0)
     231    DPA_Sort (hdpa2, pfnCompare, lParam);
     232    TRACE ("dpa 2 sorted!\n");
    232233    }
    233234
    234235    if (hdpa2->nItemCount < 1)
    235         return TRUE;
     236    return TRUE;
    236237
    237238    TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
    238            hdpa1->nItemCount, hdpa2->nItemCount);
     239       hdpa1->nItemCount, hdpa2->nItemCount);
    239240
    240241
    … …  
    250251    {
    251252        if (nIndex < 0) break;
    252         nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
    253         TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
    254               nResult, nIndex, nCount);
    255 
    256         if (nResult == 0)
    257         {
    258             PVOID ptr;
    259 
    260             ptr = (pfnMerge)(1, *pWork1, *pWork2, lParam);
    261             if (!ptr)
    262                 return FALSE;
    263 
    264             nCount--;
    265             pWork2--;
    266             *pWork1 = ptr;
    267             nIndex--;
    268             pWork1--;
    269         }
    270         else if (nResult < 0)
    271         {
    272             if (!dwFlags & 8)
    273             {
    274                 PVOID ptr;
    275 
    276                 ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
    277 
    278                 (pfnMerge)(2, ptr, NULL, lParam);
    279             }
    280             nIndex--;
    281             pWork1--;
    282         }
    283         else
    284         {
    285             if (!dwFlags & 4)
    286             {
    287                 PVOID ptr;
    288 
    289                 ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
    290                 if (!ptr)
    291                     return FALSE;
    292                 DPA_InsertPtr (hdpa1, nIndex, ptr);
    293             }
    294             nCount--;
    295             pWork2--;
    296         }
     253    nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
     254    TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
     255          nResult, nIndex, nCount);
     256
     257    if (nResult == 0)
     258    {
     259        PVOID ptr;
     260
     261        ptr = (pfnMerge)(1, *pWork1, *pWork2, lParam);
     262        if (!ptr)
     263        return FALSE;
     264
     265        nCount--;
     266        pWork2--;
     267        *pWork1 = ptr;
     268        nIndex--;
     269        pWork1--;
     270    }
     271    else if (nResult < 0)
     272    {
     273        if (!dwFlags & 8)
     274        {
     275        PVOID ptr;
     276
     277        ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
     278
     279        (pfnMerge)(2, ptr, NULL, lParam);
     280        }
     281        nIndex--;
     282        pWork1--;
     283    }
     284    else
     285    {
     286        if (!dwFlags & 4)
     287        {
     288        PVOID ptr;
     289
     290        ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
     291        if (!ptr)
     292            return FALSE;
     293        DPA_InsertPtr (hdpa1, nIndex, ptr);
     294        }
     295        nCount--;
     296        pWork2--;
     297    }
    297298
    298299    }
    … …  
    358359
    359360    if (lpSrc)
    360         lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
     361    lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
    361362    else
    362         lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
     363    lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
    363364
    364365    TRACE("-- ret=%p\n", lpDest);
    … …  
    458459HANDLE WINAPI
    459460CreateMRUListLazyA (LPCREATEMRULIST lpcml, DWORD dwParam2,
    460                     DWORD dwParam3, DWORD dwParam4);
     461            DWORD dwParam3, DWORD dwParam4);
    461462
    462463
    … …  
    490491#if 0
    491492    if (!(hmru->dwParam1 & 1001)) {
    492         RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
    493                           hmru->lpszMRUString,
    494                           strlen (hmru->lpszMRUString));
     493    RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
     494              hmru->lpszMRUString,
     495              strlen (hmru->lpszMRUString));
    495496    }
    496497
    … …  
    506507/**************************************************************************
    507508 *              AddMRUData [COMCTL32.167]
    508  * 
     509 *
    509510 * Add item to MRU binary list.  If item already exists in list then it is
    510511 * simply moved up to the top of the list and not added again.  If list is
    … …  
    530531/**************************************************************************
    531532 *              AddMRUStringA [COMCTL32.153]
    532  * 
     533 *
    533534 * Add item to MRU string list.  If item already exists in list them it is
    534535 * simply moved up to the top of the list and not added again.  If list is
    … …  
    572573/**************************************************************************
    573574 *                  FindMRUData [COMCTL32.169]
    574  * 
     575 *
    575576 * Searches binary list for item that matches lpData of length cbData.
    576577 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
    … …  
    590591{
    591592    FIXME("(%08x, %p, %ld, %p) empty stub!\n",
    592            hList, lpData, cbData, lpRegNum);
     593       hList, lpData, cbData, lpRegNum);
    593594
    594595    return 0;
    … …  
    597598/**************************************************************************
    598599 *                  FindMRUStringA [COMCTL32.155]
    599  * 
     600 *
    600601 * Searches string list for item that matches lpszString.
    601602 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
    … …  
    614615{
    615616    FIXME("(%08x, %s, %p) empty stub!\n", hList, debugstr_a(lpszString),
    616           lpRegNum);
     617      lpRegNum);
    617618
    618619    return 0;
    … …  
    640641
    641642    if (lpcml == NULL)
    642         return 0;
     643    return 0;
    643644
    644645    if (lpcml->cbSize < sizeof(CREATEMRULIST))
    645         return 0;
     646    return 0;
    646647
    647648    FIXME("(%lu %lu %lx %lx \"%s\" %p)\n",
    648           lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
    649           (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare);
     649      lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
     650      (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare);
    650651
    651652    /* dummy pointer creation */
    … …  
    659660/**************************************************************************
    660661 *                EnumMRUListA [COMCTL32.154]
    661  * 
     662 *
    662663 * Enumerate item in a list
    663664 *
    … …  
    673674 *    of list returns -1.
    674675 *    If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
    675  *    the list. 
     676 *    the list.
    676677 */
    677678INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer,
    … …  
    679680{
    680681    FIXME("(%08x, %d, %p, %ld): stub\n", hList, nItemPos, lpBuffer,
    681           nBufferSize);
     682      nBufferSize);
    682683    return 0;
    683684}
    … …  
    702703
    703704    if (!lpDest && lpSrc)
    704         return strlen (lpSrc);
     705    return strlen (lpSrc);
    705706
    706707    if (nMaxLen == 0)
    707         return 0;
     708    return 0;
    708709
    709710    if (lpSrc == NULL) {
    710         lpDest[0] = '\0';
    711         return 0;
     711    lpDest[0] = '\0';
     712    return 0;
    712713    }
    713714
    714715    len = strlen (lpSrc);
    715716    if (len >= nMaxLen)
    716         len = nMaxLen - 1;
     717    len = nMaxLen - 1;
    717718
    718719    RtlMoveMemory (lpDest, lpSrc, len);
    … …  
    737738{
    738739    TRACE("(%p %p)\n", lppDest, lpSrc);
    739  
     740
    740741    if (lpSrc) {
    741         LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
    742         if (!ptr)
    743             return FALSE;
    744         strcpy (ptr, lpSrc);
    745         *lppDest = ptr;
     742    LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
     743    if (!ptr)
     744        return FALSE;
     745    strcpy (ptr, lpSrc);
     746    *lppDest = ptr;
    746747    }
    747748    else {
    748         if (*lppDest) {
    749             COMCTL32_Free (*lppDest);
    750             *lppDest = NULL;
    751         }
     749    if (*lppDest) {
     750        COMCTL32_Free (*lppDest);
     751        *lppDest = NULL;
     752    }
    752753    }
    753754
    … …  
    775776
    776777    if (!lpDest && lpSrc)
    777         return strlenW (lpSrc);
     778    return strlenW (lpSrc);
    778779
    779780    if (nMaxLen == 0)
    780         return 0;
     781    return 0;
    781782
    782783    if (lpSrc == NULL) {
    783         lpDest[0] = L'\0';
    784         return 0;
     784    lpDest[0] = L'\0';
     785    return 0;
    785786    }
    786787
    787788    len = strlenW (lpSrc);
    788789    if (len >= nMaxLen)
    789         len = nMaxLen - 1;
     790    len = nMaxLen - 1;
    790791
    791792    RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
    … …  
    810811{
    811812    TRACE("(%p %p)\n", lppDest, lpSrc);
    812  
     813
    813814    if (lpSrc) {
    814         INT len = strlenW (lpSrc) + 1;
    815         LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
    816         if (!ptr)
    817             return FALSE;
    818         strcpyW (ptr, lpSrc);
    819         *lppDest = ptr;
     815    INT len = strlenW (lpSrc) + 1;
     816    LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
     817    if (!ptr)
     818        return FALSE;
     819    strcpyW (ptr, lpSrc);
     820    *lppDest = ptr;
    820821    }
    821822    else {
    822         if (*lppDest) {
    823             COMCTL32_Free (*lppDest);
    824             *lppDest = NULL;
    825         }
     823    if (*lppDest) {
     824        COMCTL32_Free (*lppDest);
     825        *lppDest = NULL;
     826    }
    826827    }
    827828
    … …  
    852853
    853854    if (!lpDest && lpSrc)
    854         return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
     855    return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
    855856
    856857    if (nMaxLen == 0)
    857         return 0;
     858    return 0;
    858859
    859860    if (lpSrc == NULL) {
    860         lpDest[0] = '\0';
    861         return 0;
     861    lpDest[0] = '\0';
     862    return 0;
    862863    }
    863864
    864865    len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
    865866    if (len >= nMaxLen)
    866         len = nMaxLen - 1;
     867    len = nMaxLen - 1;
    867868
    868869    WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
    … …  
    897898
    898899    if (lpSrc) {
    899         INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
    900         LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len*sizeof(WCHAR));
    901 
    902         if (!ptr)
    903             return FALSE;
    904         MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
    905         *lppDest = ptr;
     900    INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
     901    LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len*sizeof(WCHAR));
     902
     903    if (!ptr)
     904        return FALSE;
     905    MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
     906    *lppDest = ptr;
    906907    }
    907908    else {
    908         if (*lppDest) {
    909             COMCTL32_Free (*lppDest);
    910             *lppDest = NULL;
    911         }
     909    if (*lppDest) {
     910        COMCTL32_Free (*lppDest);
     911        *lppDest = NULL;
     912    }
    912913    }
    913914
    … …  
    944945    if (hdsa)
    945946    {
    946         hdsa->nItemCount = 0;
     947    hdsa->nItemCount = 0;
    947948        hdsa->pData = NULL;
    948         hdsa->nMaxCount = 0;
    949         hdsa->nItemSize = nSize;
    950         hdsa->nGrow = max(1, nGrow);
     949    hdsa->nMaxCount = 0;
     950    hdsa->nItemSize = nSize;
     951    hdsa->nGrow = max(1, nGrow);
    951952    }
    952953
    … …  
    972973
    973974    if (!hdsa)
    974         return FALSE;
     975    return FALSE;
    975976
    976977    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
    977         return FALSE;
     978    return FALSE;
    978979
    979980    return COMCTL32_Free (hdsa);
    … …  
    982983
    983984/**************************************************************************
    984  * DSA_GetItem [COMCTL32.322] 
     985 * DSA_GetItem [COMCTL32.322]
    985986 *
    986987 * PARAMS
    … …  
    10001001
    10011002    TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
    1002    
     1003
    10031004    if (!hdsa)
    1004         return FALSE;
     1005    return FALSE;
    10051006    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
    1006         return FALSE;
     1007    return FALSE;
    10071008
    10081009    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    … …  
    10141015
    10151016/**************************************************************************
    1016  * DSA_GetItemPtr [COMCTL32.323] 
     1017 * DSA_GetItemPtr [COMCTL32.323]
    10171018 *
    10181019 * Retrieves a pointer to the specified item.
    … …  
    10351036
    10361037    if (!hdsa)
    1037         return NULL;
     1038    return NULL;
    10381039    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
    1039         return NULL;
     1040    return NULL;
    10401041
    10411042    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    1042    
     1043
    10431044    TRACE("-- ret=%p\n", pSrc);
    10441045
    … …  
    10481049
    10491050/**************************************************************************
    1050  * DSA_SetItem [COMCTL32.325] 
     1051 * DSA_SetItem [COMCTL32.325]
    10511052 *
    10521053 * Sets the contents of an item in the array.
    … …  
    10671068    INT  nSize, nNewItems;
    10681069    LPVOID pDest, lpTemp;
    1069    
     1070
    10701071    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    10711072
    10721073    if ((!hdsa) || nIndex < 0)
    1073         return FALSE;
    1074      
     1074    return FALSE;
     1075
    10751076    if (hdsa->nItemCount <= nIndex) {
    1076         /* within the old array */
    1077         if (hdsa->nMaxCount > nIndex) {
    1078             /* within the allocated space, set a new boundary */
    1079             hdsa->nItemCount = nIndex + 1;
    1080         }
    1081         else {
    1082             /* resize the block of memory */
    1083             nNewItems =
    1084                 hdsa->nGrow * ((INT)(((nIndex + 1) - 1) / hdsa->nGrow) + 1);
    1085             nSize = hdsa->nItemSize * nNewItems;
    1086 
    1087             lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
    1088             if (!lpTemp)
    1089                 return FALSE;
    1090 
    1091             hdsa->nMaxCount = nNewItems;
    1092             hdsa->nItemCount = nIndex + 1;
    1093             hdsa->pData = lpTemp;
    1094         }   
     1077    /* within the old array */
     1078    if (hdsa->nMaxCount > nIndex) {
     1079        /* within the allocated space, set a new boundary */
     1080        hdsa->nItemCount = nIndex + 1;
     1081    }
     1082    else {
     1083        /* resize the block of memory */
     1084        nNewItems =
     1085        hdsa->nGrow * ((INT)(((nIndex + 1) - 1) / hdsa->nGrow) + 1);
     1086        nSize = hdsa->nItemSize * nNewItems;
     1087
     1088        lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
     1089        if (!lpTemp)
     1090        return FALSE;
     1091
     1092        hdsa->nMaxCount = nNewItems;
     1093        hdsa->nItemCount = nIndex + 1;
     1094        hdsa->pData = lpTemp;
     1095    }
    10951096    }
    10961097
    … …  
    10981099    pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    10991100    TRACE("-- move dest=%p src=%p size=%d\n",
    1100            pDest, pSrc, hdsa->nItemSize);
     1101       pDest, pSrc, hdsa->nItemSize);
    11011102    memmove (pDest, pSrc, hdsa->nItemSize);
    11021103
    … …  
    11061107
    11071108/**************************************************************************
    1108  * DSA_InsertItem [COMCTL32.324] 
     1109 * DSA_InsertItem [COMCTL32.324]
    11091110 *
    11101111 * PARAMS
    … …  
    11241125    LPVOID  lpTemp, lpDest;
    11251126    LPDWORD p;
    1126    
     1127
    11271128    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    11281129
    11291130    if ((!hdsa) || nIndex < 0)
    1130         return -1;
     1131    return -1;
    11311132
    11321133    for (i = 0; i < hdsa->nItemSize; i += 4) {
    1133         p = *(DWORD**)((char *) pSrc + i);
    1134         if (IsBadStringPtrA ((char*)p, 256))
    1135             TRACE("-- %d=%p\n", i, (DWORD*)p);
    1136         else
    1137             TRACE("-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
    1138     }
    1139    
     1134    p = *(DWORD**)((char *) pSrc + i);
     1135    if (IsBadStringPtrA ((char*)p, 256))
     1136        TRACE("-- %d=%p\n", i, (DWORD*)p);
     1137    else
     1138        TRACE("-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
     1139    }
     1140
    11401141    /* when nIndex >= nItemCount then append */
    11411142    if (nIndex >= hdsa->nItemCount)
    1142         nIndex = hdsa->nItemCount;
     1143    nIndex = hdsa->nItemCount;
    11431144
    11441145    /* do we need to resize ? */
    11451146    if (hdsa->nItemCount >= hdsa->nMaxCount) {
    1146         nNewItems = hdsa->nMaxCount + hdsa->nGrow;
    1147         nSize = hdsa->nItemSize * nNewItems;
    1148 
    1149         lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
    1150         if (!lpTemp)
    1151             return -1;
    1152 
    1153         hdsa->nMaxCount = nNewItems;
    1154         hdsa->pData = lpTemp;         
     1147    nNewItems = hdsa->nMaxCount + hdsa->nGrow;
     1148    nSize = hdsa->nItemSize * nNewItems;
     1149
     1150    lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
     1151    if (!lpTemp)
     1152        return -1;
     1153
     1154    hdsa->nMaxCount = nNewItems;
     1155    hdsa->pData = lpTemp;
    11551156    }
    11561157
    11571158    /* do we need to move elements ? */
    11581159    if (nIndex < hdsa->nItemCount) {
    1159         lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    1160         lpDest = (char *) lpTemp + hdsa->nItemSize;
    1161         nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
    1162         TRACE("-- move dest=%p src=%p size=%d\n",
    1163                lpDest, lpTemp, nSize);
    1164         memmove (lpDest, lpTemp, nSize);
     1160    lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
     1161    lpDest = (char *) lpTemp + hdsa->nItemSize;
     1162    nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
     1163    TRACE("-- move dest=%p src=%p size=%d\n",
     1164           lpDest, lpTemp, nSize);
     1165    memmove (lpDest, lpTemp, nSize);
    11651166    }
    11661167
    … …  
    11691170    lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    11701171    TRACE("-- move dest=%p src=%p size=%d\n",
    1171            lpDest, pSrc, hdsa->nItemSize);
     1172       lpDest, pSrc, hdsa->nItemSize);
    11721173    memmove (lpDest, pSrc, hdsa->nItemSize);
    11731174
    … …  
    11771178
    11781179/**************************************************************************
    1179  * DSA_DeleteItem [COMCTL32.326] 
     1180 * DSA_DeleteItem [COMCTL32.326]
    11801181 *
    11811182 * PARAMS
    … …  
    11931194    LPVOID lpDest,lpSrc;
    11941195    INT  nSize;
    1195    
     1196
    11961197    TRACE("(%p %d)\n", hdsa, nIndex);
    11971198
    11981199    if (!hdsa)
    1199         return -1;
     1200    return -1;
    12001201    if (nIndex < 0 || nIndex >= hdsa->nItemCount)
    1201         return -1;
     1202    return -1;
    12021203
    12031204    /* do we need to move ? */
    12041205    if (nIndex < hdsa->nItemCount - 1) {
    1205         lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    1206         lpSrc = (char *) lpDest + hdsa->nItemSize;
    1207         nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
    1208         TRACE("-- move dest=%p src=%p size=%d\n",
    1209                lpDest, lpSrc, nSize);
    1210         memmove (lpDest, lpSrc, nSize);
    1211     }
    1212    
     1206    lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
     1207    lpSrc = (char *) lpDest + hdsa->nItemSize;
     1208    nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
     1209    TRACE("-- move dest=%p src=%p size=%d\n",
     1210           lpDest, lpSrc, nSize);
     1211    memmove (lpDest, lpSrc, nSize);
     1212    }
     1213
    12131214    hdsa->nItemCount--;
    1214    
     1215
    12151216    /* free memory ? */
    12161217    if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
    1217         nSize = hdsa->nItemSize * hdsa->nItemCount;
    1218 
    1219         lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
    1220         if (!lpDest)
    1221             return -1;
    1222 
    1223         hdsa->nMaxCount = hdsa->nItemCount;
    1224         hdsa->pData = lpDest;
     1218    nSize = hdsa->nItemSize * hdsa->nItemCount;
     1219
     1220    lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
     1221    if (!lpDest)
     1222        return -1;
     1223
     1224    hdsa->nMaxCount = hdsa->nItemCount;
     1225    hdsa->pData = lpDest;
    12251226    }
    12261227
    … …  
    12471248    TRACE("(%p)\n", hdsa);
    12481249
    1249     if (!hdsa) 
    1250         return FALSE;
     1250    if (!hdsa)
     1251    return FALSE;
    12511252    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
    1252         return FALSE;
     1253    return FALSE;
    12531254
    12541255    hdsa->nItemCount = 0;
    … …  
    12851286    hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
    12861287    if (hdpa) {
    1287         hdpa->nGrow = max(8, nGrow);
    1288         hdpa->hHeap = COMCTL32_hHeap;
    1289         hdpa->nMaxCount = hdpa->nGrow * 2;
    1290         hdpa->ptrs =
    1291             (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
     1288    hdpa->nGrow = max(8, nGrow);
     1289    hdpa->hHeap = COMCTL32_hHeap;
     1290    hdpa->nMaxCount = hdpa->nGrow * 2;
     1291    hdpa->ptrs =
     1292        (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
    12921293    }
    12931294
    … …  
    13151316
    13161317    if (!hdpa)
    1317         return FALSE;
     1318    return FALSE;
    13181319
    13191320    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
    1320         return FALSE;
     1321    return FALSE;
    13211322
    13221323    return HeapFree (hdpa->hHeap, 0, hdpa);
    … …  
    13441345
    13451346    if (!hdpa)
    1346         return FALSE;
     1347    return FALSE;
    13471348
    13481349    hdpa->nGrow = max(8, nGrow);
    … …  
    13791380
    13801381    if (!hdpa)
    1381         return NULL;
     1382    return NULL;
    13821383
    13831384    TRACE("(%p %p)\n", hdpa, hdpaNew);
    13841385
    13851386    if (!hdpaNew) {
    1386         /* create a new DPA */
    1387         hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1388                                     sizeof(DPA));
    1389         hdpaTemp->hHeap = hdpa->hHeap;
    1390         hdpaTemp->nGrow = hdpa->nGrow;
     1387    /* create a new DPA */
     1388    hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1389                    sizeof(DPA));
     1390    hdpaTemp->hHeap = hdpa->hHeap;
     1391    hdpaTemp->nGrow = hdpa->nGrow;
    13911392    }
    13921393    else
    1393         hdpaTemp = hdpaNew;
     1394    hdpaTemp = hdpaNew;
    13941395
    13951396    if (hdpaTemp->ptrs) {
    1396         /* remove old pointer array */
    1397         HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
    1398         hdpaTemp->ptrs = NULL;
    1399         hdpaTemp->nItemCount = 0;
    1400         hdpaTemp->nMaxCount = 0;
     1397    /* remove old pointer array */
     1398    HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
     1399    hdpaTemp->ptrs = NULL;
     1400    hdpaTemp->nItemCount = 0;
     1401    hdpaTemp->nMaxCount = 0;
    14011402    }
    14021403
    14031404    /* create a new pointer array */
    14041405    nNewItems = hdpaTemp->nGrow *
    1405                 ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
     1406        ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
    14061407    nSize = nNewItems * sizeof(LPVOID);
    14071408    hdpaTemp->ptrs =
    1408         (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
     1409    (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
    14091410    hdpaTemp->nMaxCount = nNewItems;
    14101411
    … …  
    14121413    hdpaTemp->nItemCount = hdpa->nItemCount;
    14131414    memmove (hdpaTemp->ptrs, hdpa->ptrs,
    1414              hdpaTemp->nItemCount * sizeof(LPVOID));
     1415         hdpaTemp->nItemCount * sizeof(LPVOID));
    14151416
    14161417    return hdpaTemp;
    … …  
    14381439
    14391440    if (!hdpa)
    1440         return NULL;
     1441    return NULL;
    14411442    if (!hdpa->ptrs) {
    1442         WARN("no pointer array.\n");
    1443         return NULL;
     1443    WARN("no pointer array.\n");
     1444    return NULL;
    14441445    }
    14451446    if ((i < 0) || (i >= hdpa->nItemCount)) {
    1446         WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
    1447         return NULL;
     1447    WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
     1448    return NULL;
    14481449    }
    14491450
    … …  
    14741475
    14751476    if (!hdpa->ptrs)
    1476         return -1;
     1477    return -1;
    14771478
    14781479    for (i = 0; i < hdpa->nItemCount; i++) {
    1479         if (hdpa->ptrs[i] == p)
    1480             return i;
     1480    if (hdpa->ptrs[i] == p)
     1481        return i;
    14811482    }
    14821483
    … …  
    15091510
    15101511    if ((!hdpa) || (i < 0))
    1511         return -1;
     1512    return -1;
    15121513
    15131514    if (!hdpa->ptrs) {
    1514         hdpa->ptrs =
    1515             (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1516                                 2 * hdpa->nGrow * sizeof(LPVOID));
    1517         if (!hdpa->ptrs)
    1518             return -1;
    1519         hdpa->nMaxCount = hdpa->nGrow * 2;
     1515    hdpa->ptrs =
     1516        (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1517                2 * hdpa->nGrow * sizeof(LPVOID));
     1518    if (!hdpa->ptrs)
     1519        return -1;
     1520    hdpa->nMaxCount = hdpa->nGrow * 2;
    15201521        nIndex = 0;
    15211522    }
    15221523    else {
    1523         if (hdpa->nItemCount >= hdpa->nMaxCount) {
    1524             TRACE("-- resizing\n");
    1525             nNewItems = hdpa->nMaxCount + hdpa->nGrow;
    1526             nSize = nNewItems * sizeof(LPVOID);
    1527 
    1528             lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1529                                            hdpa->ptrs, nSize);
    1530             if (!lpTemp)
    1531                 return -1;
    1532             hdpa->nMaxCount = nNewItems;
    1533             hdpa->ptrs = lpTemp;
    1534         }
    1535 
    1536         if (i >= hdpa->nItemCount) {
    1537             nIndex = hdpa->nItemCount;
    1538             TRACE("-- appending at %d\n", nIndex);
    1539         }
    1540         else {
    1541             TRACE("-- inserting at %d\n", i);
    1542             lpTemp = hdpa->ptrs + i;
    1543             lpDest = lpTemp + 1;
    1544             nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
    1545             TRACE("-- move dest=%p src=%p size=%x\n",
    1546                    lpDest, lpTemp, nSize);
    1547             memmove (lpDest, lpTemp, nSize);
    1548             nIndex = i;
    1549         }
     1524    if (hdpa->nItemCount >= hdpa->nMaxCount) {
     1525        TRACE("-- resizing\n");
     1526        nNewItems = hdpa->nMaxCount + hdpa->nGrow;
     1527        nSize = nNewItems * sizeof(LPVOID);
     1528
     1529        lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1530                       hdpa->ptrs, nSize);
     1531        if (!lpTemp)
     1532        return -1;
     1533        hdpa->nMaxCount = nNewItems;
     1534        hdpa->ptrs = lpTemp;
     1535    }
     1536
     1537    if (i >= hdpa->nItemCount) {
     1538        nIndex = hdpa->nItemCount;
     1539        TRACE("-- appending at %d\n", nIndex);
     1540    }
     1541    else {
     1542        TRACE("-- inserting at %d\n", i);
     1543        lpTemp = hdpa->ptrs + i;
     1544        lpDest = lpTemp + 1;
     1545        nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
     1546        TRACE("-- move dest=%p src=%p size=%x\n",
     1547           lpDest, lpTemp, nSize);
     1548        memmove (lpDest, lpTemp, nSize);
     1549        nIndex = i;
     1550    }
    15501551    }
    15511552
    … …  
    15771578{
    15781579    LPVOID *lpTemp;
    1579    
     1580
    15801581    TRACE("(%p %d %p)\n", hdpa, i, p);
    15811582
    15821583    if ((!hdpa) || i < 0)
    1583         return FALSE;
    1584      
     1584    return FALSE;
     1585
    15851586    if (hdpa->nItemCount <= i) {
    1586         /* within the old array */
    1587         if (hdpa->nMaxCount > i) {
    1588             /* within the allocated space, set a new boundary */
    1589             hdpa->nItemCount = i+1;
    1590         }
    1591         else {
    1592             /* resize the block of memory */
    1593             INT nNewItems =
    1594                 hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1);
    1595             INT nSize = nNewItems * sizeof(LPVOID);
    1596 
    1597             lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1598                                            hdpa->ptrs, nSize);
    1599             if (!lpTemp)
    1600                 return FALSE;
    1601 
    1602             hdpa->nItemCount = nNewItems;
    1603             hdpa->ptrs = lpTemp;       
    1604         }   
     1587    /* within the old array */
     1588    if (hdpa->nMaxCount > i) {
     1589        /* within the allocated space, set a new boundary */
     1590        hdpa->nItemCount = i+1;
     1591    }
     1592    else {
     1593        /* resize the block of memory */
     1594        INT nNewItems =
     1595        hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1);
     1596        INT nSize = nNewItems * sizeof(LPVOID);
     1597
     1598        lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1599                       hdpa->ptrs, nSize);
     1600        if (!lpTemp)
     1601        return FALSE;
     1602
     1603        hdpa->nItemCount = nNewItems;
     1604        hdpa->ptrs = lpTemp;
     1605    }
    16051606    }
    16061607
    … …  
    16311632    LPVOID *lpDest, *lpSrc, lpTemp = NULL;
    16321633    INT  nSize;
    1633    
     1634
    16341635    TRACE("(%p %d)\n", hdpa, i);
    16351636
    16361637    if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
    1637         return NULL;
     1638    return NULL;
    16381639
    16391640    lpTemp = hdpa->ptrs[i];
    … …  
    16411642    /* do we need to move ?*/
    16421643    if (i < hdpa->nItemCount - 1) {
    1643         lpDest = hdpa->ptrs + i;
    1644         lpSrc = lpDest + 1;
    1645         nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
    1646         TRACE("-- move dest=%p src=%p size=%x\n",
    1647                lpDest, lpSrc, nSize);
    1648         memmove (lpDest, lpSrc, nSize);
    1649     }
    1650    
     1644    lpDest = hdpa->ptrs + i;
     1645    lpSrc = lpDest + 1;
     1646    nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
     1647    TRACE("-- move dest=%p src=%p size=%x\n",
     1648           lpDest, lpSrc, nSize);
     1649    memmove (lpDest, lpSrc, nSize);
     1650    }
     1651
    16511652    hdpa->nItemCount --;
    1652    
     1653
    16531654    /* free memory ?*/
    16541655    if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
    1655         INT nNewItems = max(hdpa->nGrow * 2, hdpa->nItemCount);
    1656         nSize = nNewItems * sizeof(LPVOID);
    1657         lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1658                                       hdpa->ptrs, nSize);
    1659         if (!lpDest)
    1660             return NULL;
    1661 
    1662         hdpa->nMaxCount = nNewItems;
    1663         hdpa->ptrs = (LPVOID*)lpDest;         
     1656    INT nNewItems = max(hdpa->nGrow * 2, hdpa->nItemCount);
     1657    nSize = nNewItems * sizeof(LPVOID);
     1658    lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1659                      hdpa->ptrs, nSize);
     1660    if (!lpDest)
     1661        return NULL;
     1662
     1663    hdpa->nMaxCount = nNewItems;
     1664    hdpa->ptrs = (LPVOID*)lpDest;
    16641665    }
    16651666
    … …  
    16861687    TRACE("(%p)\n", hdpa);
    16871688
    1688     if (!hdpa) 
    1689         return FALSE;
     1689    if (!hdpa)
     1690    return FALSE;
    16901691
    16911692    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
    1692         return FALSE;
     1693    return FALSE;
    16931694
    16941695    hdpa->nItemCount = 0;
    16951696    hdpa->nMaxCount = hdpa->nGrow * 2;
    16961697    hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1697                                      hdpa->nMaxCount * sizeof(LPVOID));
     1698                     hdpa->nMaxCount * sizeof(LPVOID));
    16981699
    16991700    return TRUE;
    … …  
    17191720static VOID
    17201721DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r,
    1721                PFNDPACOMPARE pfnCompare, LPARAM lParam)
     1722           PFNDPACOMPARE pfnCompare, LPARAM lParam)
    17221723{
    17231724    INT m;
    … …  
    17251726
    17261727    TRACE("l=%i r=%i\n", l, r);
    1727  
     1728
    17281729    if (l==r)    /* one element is always sorted */
    17291730        return;
    17301731    if (r<l)     /* oops, got it in the wrong order */
    1731         {
     1732    {
    17321733        DPA_QuickSort(lpPtrs, r, l, pfnCompare, lParam);
    17331734        return;
    1734         }
     1735    }
    17351736    m = (l+r)/2; /* divide by two */
    17361737    DPA_QuickSort(lpPtrs, l, m, pfnCompare, lParam);
    … …  
    17381739
    17391740    /* join the two sides */
    1740     while( (l<=m) && (m<r) ) 
     1741    while( (l<=m) && (m<r) )
    17411742    {
    17421743        if(pfnCompare(lpPtrs[l],lpPtrs[m+1],lParam)>0)
    … …  
    17721773{
    17731774    if (!hdpa || !pfnCompare)
    1774         return FALSE;
     1775    return FALSE;
    17751776
    17761777    TRACE("(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
    17771778
    17781779    if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
    1779         DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
    1780                        pfnCompare, lParam);
     1780    DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
     1781               pfnCompare, lParam);
    17811782
    17821783    return TRUE;
    … …  
    18091810INT WINAPI
    18101811DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart,
    1811             PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
     1812        PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
    18121813{
    18131814    if (!hdpa || !pfnCompare || !pFind)
    1814         return -1;
     1815    return -1;
    18151816
    18161817    TRACE("(%p %p %d %p 0x%08lx 0x%08x)\n",
    1817            hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
     1818       hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
    18181819
    18191820    if (uOptions & DPAS_SORTED) {
    1820         /* array is sorted --> use binary search */
    1821         INT l, r, x, n;
    1822         LPVOID *lpPtr;
    1823 
    1824         TRACE("binary search\n");
    1825 
    1826         l = (nStart == -1) ? 0 : nStart;
    1827         r = hdpa->nItemCount - 1;
    1828         lpPtr = hdpa->ptrs;
    1829         while (r >= l) {
    1830             x = (l + r) / 2;
    1831             n = (pfnCompare)(pFind, lpPtr[x], lParam);
    1832             if (n < 0)
    1833                 r = x - 1;
    1834             else
    1835                 l = x + 1;
    1836             if (n == 0) {
    1837                 TRACE("-- ret=%d\n", n);
    1838                 return n;
    1839             }
    1840         }
    1841 
    1842         if (uOptions & DPAS_INSERTBEFORE) {
    1843             TRACE("-- ret=%d\n", r);
    1844             return r;
    1845         }
    1846 
    1847         if (uOptions & DPAS_INSERTAFTER) {
    1848             TRACE("-- ret=%d\n", l);
    1849             return l;
    1850         }
     1821    /* array is sorted --> use binary search */
     1822    INT l, r, x, n;
     1823    LPVOID *lpPtr;
     1824
     1825    TRACE("binary search\n");
     1826
     1827    l = (nStart == -1) ? 0 : nStart;
     1828    r = hdpa->nItemCount - 1;
     1829    lpPtr = hdpa->ptrs;
     1830    while (r >= l) {
     1831        x = (l + r) / 2;
     1832        n = (pfnCompare)(pFind, lpPtr[x], lParam);
     1833        if (n < 0)
     1834        r = x - 1;
     1835        else
     1836        l = x + 1;
     1837        if (n == 0) {
     1838        TRACE("-- ret=%d\n", n);
     1839        return n;
     1840        }
     1841    }
     1842
     1843    if (uOptions & DPAS_INSERTBEFORE) {
     1844        TRACE("-- ret=%d\n", r);
     1845        return r;
     1846    }
     1847
     1848    if (uOptions & DPAS_INSERTAFTER) {
     1849        TRACE("-- ret=%d\n", l);
     1850        return l;
     1851    }
    18511852    }
    18521853    else {
    1853         /* array is not sorted --> use linear search */
    1854         LPVOID *lpPtr;
    1855         INT  nIndex;
    1856 
    1857         TRACE("linear search\n");
    1858        
    1859         nIndex = (nStart == -1)? 0 : nStart;
    1860         lpPtr = hdpa->ptrs;
    1861         for (; nIndex < hdpa->nItemCount; nIndex++) {
    1862             if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
    1863                 TRACE("-- ret=%d\n", nIndex);
    1864                 return nIndex;
    1865             }
    1866         }
     1854    /* array is not sorted --> use linear search */
     1855    LPVOID *lpPtr;
     1856    INT  nIndex;
     1857
     1858    TRACE("linear search\n");
     1859
     1860    nIndex = (nStart == -1)? 0 : nStart;
     1861    lpPtr = hdpa->ptrs;
     1862    for (; nIndex < hdpa->nItemCount; nIndex++) {
     1863        if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
     1864        TRACE("-- ret=%d\n", nIndex);
     1865        return nIndex;
     1866        }
     1867    }
    18671868    }
    18681869
    … …  
    18941895
    18951896    if (hHeap)
    1896         hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
     1897    hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
    18971898    else
    1898         hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
     1899    hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
    18991900
    19001901    if (hdpa) {
    1901         hdpa->nGrow = min(8, nGrow);
    1902         hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
    1903         hdpa->nMaxCount = hdpa->nGrow * 2;
    1904         hdpa->ptrs =
    1905             (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
    1906                                 hdpa->nMaxCount * sizeof(LPVOID));
     1902    hdpa->nGrow = min(8, nGrow);
     1903    hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
     1904    hdpa->nMaxCount = hdpa->nGrow * 2;
     1905    hdpa->ptrs =
     1906        (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
     1907                hdpa->nMaxCount * sizeof(LPVOID));
    19071908    }
    19081909
    … …  
    19401941
    19411942    TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
    1942            lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
    1943            lpNotify->dwParam5);
     1943       lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
     1944       lpNotify->dwParam5);
    19441945
    19451946    if (!lpNotify->hwndTo)
    1946         return 0;
     1947    return 0;
    19471948
    19481949    if (lpNotify->hwndFrom == -1) {
    1949         lpNmh = lpHdr;
    1950         idFrom = lpHdr->idFrom;
     1950    lpNmh = lpHdr;
     1951    idFrom = lpHdr->idFrom;
    19511952    }
    19521953    else {
    1953         if (lpNotify->hwndFrom) {
    1954             HWND hwndParent = GetParent (lpNotify->hwndFrom);
    1955             if (hwndParent) {
    1956                 hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER);
    1957                 if (hwndParent)
    1958                     idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
    1959             }
    1960         }
    1961 
    1962         lpNmh = (lpHdr) ? lpHdr : &nmhdr;
    1963 
    1964         lpNmh->hwndFrom = lpNotify->hwndFrom;
    1965         lpNmh->idFrom = idFrom;
    1966         lpNmh->code = uCode;
     1954    if (lpNotify->hwndFrom) {
     1955        HWND hwndParent = GetParent (lpNotify->hwndFrom);
     1956        if (hwndParent) {
     1957        hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER);
     1958        if (hwndParent)
     1959            idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
     1960        }
     1961    }
     1962
     1963    lpNmh = (lpHdr) ? lpHdr : &nmhdr;
     1964
     1965    lpNmh->hwndFrom = lpNotify->hwndFrom;
     1966    lpNmh->idFrom = idFrom;
     1967    lpNmh->code = uCode;
    19671968    }
    19681969
    … …  
    19871988LRESULT WINAPI
    19881989COMCTL32_SendNotify (HWND hwndFrom, HWND hwndTo,
    1989                      UINT uCode, LPNMHDR lpHdr)
     1990             UINT uCode, LPNMHDR lpHdr)
    19901991{
    19911992    NOTIFYDATA notify;
    19921993
    19931994    TRACE("(0x%04x 0x%04x %d %p)\n",
    1994            hwndFrom, hwndTo, uCode, lpHdr);
     1995       hwndFrom, hwndTo, uCode, lpHdr);
    19951996
    19961997    notify.hwndFrom = hwndFrom;
    … …  
    20202021LRESULT WINAPI
    20212022COMCTL32_SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
    2022                        LPNMHDR lpHdr, DWORD dwParam5)
     2023               LPNMHDR lpHdr, DWORD dwParam5)
    20232024{
    20242025    NOTIFYDATA notify;
    … …  
    20262027
    20272028    TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
    2028            hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
     2029       hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
    20292030
    20302031    hwndNotify = hwndTo;
    20312032    if (!hwndTo) {
    2032         if (IsWindow (hwndFrom)) {
    2033             hwndNotify = GetParent (hwndFrom);
    2034             if (!hwndNotify)
    2035                 return 0;
    2036         }
     2033    if (IsWindow (hwndFrom)) {
     2034        hwndNotify = GetParent (hwndFrom);
     2035        if (!hwndNotify)
     2036        return 0;
     2037    }
    20372038    }
    20382039
    … …  
    20692070
    20702071    if (*lpStr2 == 0)
    2071         return ((LPSTR)lpStr1);
     2072    return ((LPSTR)lpStr1);
    20722073    len1 = 0;
    20732074    while (lpStr1[len1] != 0) ++len1;
    … …  
    20752076    while (lpStr2[len2] != 0) ++len2;
    20762077    if (len2 == 0)
    2077         return ((LPSTR)(lpStr1 + len1));
     2078    return ((LPSTR)(lpStr1 + len1));
    20782079    first = tolower (*lpStr2);
    20792080    while (len1 >= len2) {
    2080         if (tolower(*lpStr1) == first) {
    2081             for (i = 1; i < len2; ++i)
    2082                 if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
    2083                     break;
    2084             if (i >= len2)
    2085                 return ((LPSTR)lpStr1);
     2081    if (tolower(*lpStr1) == first) {
     2082        for (i = 1; i < len2; ++i)
     2083        if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
     2084            break;
     2085        if (i >= len2)
     2086        return ((LPSTR)lpStr1);
    20862087        }
    2087         ++lpStr1; --len1;
     2088    ++lpStr1; --len1;
    20882089    }
    20892090    return (NULL);
    … …  
    21162117 *
    21172118 * Enumerates all items in a dynamic pointer array.
    2118  *
    2119  * PARAMS
    2120  *     hdpa     [I] handle to the dynamic pointer array
    2121  *     enumProc [I]
    2122  *     lParam   [I]
    2123  *
    2124  * RETURNS
    2125  *     none
    2126  */
    2127 
    2128 VOID WINAPI
    2129 DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
    2130 {
    2131     INT i;
    2132 
    2133     TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam);
    2134 
    2135     if (!hdpa)
    2136         return;
    2137     if (hdpa->nItemCount <= 0)
    2138         return;
    2139 
    2140     for (i = 0; i < hdpa->nItemCount; i++) {
    2141         if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
    2142             return;
    2143     }
    2144 
    2145     return;
    2146 }
    2147 
    2148 
    2149 /**************************************************************************
    2150  * DPA_DestroyCallback [COMCTL32.386]
    2151  *
    2152  * Enumerates all items in a dynamic pointer array and destroys it.
    21532119 *
    21542120 * PARAMS
    … …  
    21582124 *
    21592125 * RETURNS
     2126 *     none
     2127 */
     2128
     2129VOID WINAPI
     2130DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
     2131{
     2132    INT i;
     2133
     2134    TRACE("(%p %p %08lx)\n", hdpa, enumProc, lParam);
     2135
     2136    if (!hdpa)
     2137    return;
     2138    if (hdpa->nItemCount <= 0)
     2139    return;
     2140
     2141    for (i = 0; i < hdpa->nItemCount; i++) {
     2142    if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
     2143        return;
     2144    }
     2145
     2146    return;
     2147}
     2148
     2149
     2150/**************************************************************************
     2151 * DPA_DestroyCallback [COMCTL32.386]
     2152 *
     2153 * Enumerates all items in a dynamic pointer array and destroys it.
     2154 *
     2155 * PARAMS
     2156 *     hdpa     [I] handle to the dynamic pointer array
     2157 *     enumProc [I]
     2158 *     lParam   [I]
     2159 *
     2160 * RETURNS
    21602161 *     Success: TRUE
    21612162 *     Failure: FALSE
    … …  
    21952196
    21962197    if (!hdsa)
    2197         return;
     2198    return;
    21982199    if (hdsa->nItemCount <= 0)
    2199         return;
     2200    return;
    22002201
    22012202    for (i = 0; i < hdsa->nItemCount; i++) {
    2202         LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
    2203         if ((enumProc)(lpItem, lParam) == 0)
    2204             return;
     2203    LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
     2204    if ((enumProc)(lpItem, lParam) == 0)
     2205        return;
    22052206    }
    22062207
    … …  
    23012302        if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
    23022303        lpGotIt = lpStart;
    2303     }   
     2304    }
    23042305    return (LPSTR)lpGotIt;
    23052306}
    … …  
    23552356    if( strchrW(lpSet, *(WORD*)lpLoop))
    23562357      return (INT)(lpLoop-lpStr);
    2357  
     2358
    23582359  return (INT)(lpLoop-lpStr);
    23592360}
    … …  
    23992400
    24002401    if (IsWindow (hwnd) == FALSE)
    2401         return FALSE;
     2402    return FALSE;
    24022403
    24032404    if (b == 0)
    2404         return FALSE;
     2405    return FALSE;
    24052406
    24062407
Note: See TracChangeset for help on using the changeset viewer.