Ignore:
Timestamp:
Sep 15, 2001, 11:26:26 AM (24 years ago)
Author:
sandervl
Message:

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/comctl32undoc.c

    r6705 r6709  
    9898
    9999    FIXME ("phDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
    100        phDpa, loadProc, pStream, lParam);
     100           phDpa, loadProc, pStream, lParam);
    101101
    102102    if (!phDpa || !loadProc || !pStream)
    103     return E_INVALIDARG;
     103        return E_INVALIDARG;
    104104
    105105    *phDpa = (HDPA)NULL;
    … …  
    110110    errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &newPosition);
    111111    if (errCode != S_OK)
    112     return errCode;
     112        return errCode;
    113113
    114114    errCode = IStream_Read (pStream, &streamData, sizeof(STREAMDATA), &ulRead);
    115115    if (errCode != S_OK)
    116     return errCode;
     116        return errCode;
    117117
    118118    FIXME ("dwSize=%lu dwData2=%lu dwItems=%lu\n",
    119        streamData.dwSize, streamData.dwData2, streamData.dwItems);
     119           streamData.dwSize, streamData.dwData2, streamData.dwItems);
    120120
    121121    if (lParam < sizeof(STREAMDATA) ||
    122     streamData.dwSize < sizeof(STREAMDATA) ||
    123     streamData.dwData2 < 1) {
    124     errCode = E_FAIL;
     122        streamData.dwSize < sizeof(STREAMDATA) ||
     123        streamData.dwData2 < 1) {
     124        errCode = E_FAIL;
    125125    }
    126126
    … …  
    128128    hDpa = DPA_Create (streamData.dwItems);
    129129    if (!hDpa)
    130     return E_OUTOFMEMORY;
     130        return E_OUTOFMEMORY;
    131131
    132132    if (!DPA_Grow (hDpa, streamData.dwItems))
    133     return E_OUTOFMEMORY;
     133        return E_OUTOFMEMORY;
    134134
    135135    /* load data from the stream into the dpa */
    … …  
    137137    for (loadData.nCount = 0; loadData.nCount < streamData.dwItems; loadData.nCount++) {
    138138        errCode = (loadProc)(&loadData, pStream, lParam);
    139     if (errCode != S_OK) {
    140         errCode = S_FALSE;
    141         break;
    142     }
    143 
    144     *ptr = loadData.ptr;
    145     ptr++;
     139        if (errCode != S_OK) {
     140            errCode = S_FALSE;
     141            break;
     142        }
     143
     144        *ptr = loadData.ptr;
     145        ptr++;
    146146    }
    147147
    … …  
    177177
    178178    FIXME ("hDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
    179        hDpa, loadProc, pStream, lParam);
     179           hDpa, loadProc, pStream, lParam);
    180180
    181181    return E_FAIL;
    … …  
    200200BOOL WINAPI
    201201DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
    202        PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
     202           PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
    203203{
    204204    INT nCount;
    … …  
    208208
    209209    TRACE("%p %p %08lx %p %p %08lx)\n",
    210        hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
     210           hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
    211211
    212212    if (IsBadWritePtr (hdpa1, sizeof(DPA)))
    213     return FALSE;
     213        return FALSE;
    214214
    215215    if (IsBadWritePtr (hdpa2, sizeof(DPA)))
    216     return FALSE;
     216        return FALSE;
    217217
    218218    if (IsBadCodePtr ((FARPROC)pfnCompare))
    219     return FALSE;
     219        return FALSE;
    220220
    221221    if (IsBadCodePtr ((FARPROC)pfnMerge))
    222     return FALSE;
     222        return FALSE;
    223223
    224224    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");
     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");
    232232    }
    233233
    234234    if (hdpa2->nItemCount < 1)
    235     return TRUE;
     235        return TRUE;
    236236
    237237    TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
    238        hdpa1->nItemCount, hdpa2->nItemCount);
     238           hdpa1->nItemCount, hdpa2->nItemCount);
    239239
    240240
    … …  
    250250    {
    251251        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     }
     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        }
    297297
    298298    }
    … …  
    358358
    359359    if (lpSrc)
    360     lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
     360        lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
    361361    else
    362     lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
     362        lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
    363363
    364364    TRACE("-- ret=%p\n", lpDest);
    … …  
    458458HANDLE WINAPI
    459459CreateMRUListLazyA (LPCREATEMRULIST lpcml, DWORD dwParam2,
    460             DWORD dwParam3, DWORD dwParam4);
     460                    DWORD dwParam3, DWORD dwParam4);
    461461
    462462
    … …  
    490490#if 0
    491491    if (!(hmru->dwParam1 & 1001)) {
    492     RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
    493               hmru->lpszMRUString,
    494               strlen (hmru->lpszMRUString));
     492        RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
     493                          hmru->lpszMRUString,
     494                          strlen (hmru->lpszMRUString));
    495495    }
    496496
    … …  
    506506/**************************************************************************
    507507 *              AddMRUData [COMCTL32.167]
    508  *
     508 * 
    509509 * Add item to MRU binary list.  If item already exists in list then it is
    510510 * simply moved up to the top of the list and not added again.  If list is
    … …  
    530530/**************************************************************************
    531531 *              AddMRUStringA [COMCTL32.153]
    532  *
     532 * 
    533533 * Add item to MRU string list.  If item already exists in list them it is
    534534 * simply moved up to the top of the list and not added again.  If list is
    … …  
    572572/**************************************************************************
    573573 *                  FindMRUData [COMCTL32.169]
    574  *
     574 * 
    575575 * Searches binary list for item that matches lpData of length cbData.
    576576 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
    … …  
    590590{
    591591    FIXME("(%08x, %p, %ld, %p) empty stub!\n",
    592        hList, lpData, cbData, lpRegNum);
     592           hList, lpData, cbData, lpRegNum);
    593593
    594594    return 0;
    … …  
    597597/**************************************************************************
    598598 *                  FindMRUStringA [COMCTL32.155]
    599  *
     599 * 
    600600 * Searches string list for item that matches lpszString.
    601601 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
    … …  
    614614{
    615615    FIXME("(%08x, %s, %p) empty stub!\n", hList, debugstr_a(lpszString),
    616       lpRegNum);
     616          lpRegNum);
    617617
    618618    return 0;
    … …  
    640640
    641641    if (lpcml == NULL)
    642     return 0;
     642        return 0;
    643643
    644644    if (lpcml->cbSize < sizeof(CREATEMRULIST))
    645     return 0;
     645        return 0;
    646646
    647647    FIXME("(%lu %lu %lx %lx \"%s\" %p)\n",
    648       lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
    649       (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare);
     648          lpcml->cbSize, lpcml->nMaxItems, lpcml->dwFlags,
     649          (DWORD)lpcml->hKey, lpcml->lpszSubKey, lpcml->lpfnCompare);
    650650
    651651    /* dummy pointer creation */
    … …  
    659659/**************************************************************************
    660660 *                EnumMRUListA [COMCTL32.154]
    661  *
     661 * 
    662662 * Enumerate item in a list
    663663 *
    … …  
    673673 *    of list returns -1.
    674674 *    If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
    675  *    the list.
     675 *    the list. 
    676676 */
    677677INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer,
    … …  
    679679{
    680680    FIXME("(%08x, %d, %p, %ld): stub\n", hList, nItemPos, lpBuffer,
    681       nBufferSize);
     681          nBufferSize);
    682682    return 0;
    683683}
    … …  
    702702
    703703    if (!lpDest && lpSrc)
    704     return strlen (lpSrc);
     704        return strlen (lpSrc);
    705705
    706706    if (nMaxLen == 0)
    707     return 0;
     707        return 0;
    708708
    709709    if (lpSrc == NULL) {
    710     lpDest[0] = '\0';
    711     return 0;
     710        lpDest[0] = '\0';
     711        return 0;
    712712    }
    713713
    714714    len = strlen (lpSrc);
    715715    if (len >= nMaxLen)
    716     len = nMaxLen - 1;
     716        len = nMaxLen - 1;
    717717
    718718    RtlMoveMemory (lpDest, lpSrc, len);
    … …  
    737737{
    738738    TRACE("(%p %p)\n", lppDest, lpSrc);
    739 
     739 
    740740    if (lpSrc) {
    741     LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
    742     if (!ptr)
    743         return FALSE;
    744     strcpy (ptr, lpSrc);
    745     *lppDest = ptr;
     741        LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
     742        if (!ptr)
     743            return FALSE;
     744        strcpy (ptr, lpSrc);
     745        *lppDest = ptr;
    746746    }
    747747    else {
    748     if (*lppDest) {
    749         COMCTL32_Free (*lppDest);
    750         *lppDest = NULL;
    751     }
     748        if (*lppDest) {
     749            COMCTL32_Free (*lppDest);
     750            *lppDest = NULL;
     751        }
    752752    }
    753753
    … …  
    775775
    776776    if (!lpDest && lpSrc)
    777     return strlenW (lpSrc);
     777        return strlenW (lpSrc);
    778778
    779779    if (nMaxLen == 0)
    780     return 0;
     780        return 0;
    781781
    782782    if (lpSrc == NULL) {
    783     lpDest[0] = L'\0';
    784     return 0;
     783        lpDest[0] = L'\0';
     784        return 0;
    785785    }
    786786
    787787    len = strlenW (lpSrc);
    788788    if (len >= nMaxLen)
    789     len = nMaxLen - 1;
     789        len = nMaxLen - 1;
    790790
    791791    RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
    … …  
    810810{
    811811    TRACE("(%p %p)\n", lppDest, lpSrc);
    812 
     812 
    813813    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;
     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;
    820820    }
    821821    else {
    822     if (*lppDest) {
    823         COMCTL32_Free (*lppDest);
    824         *lppDest = NULL;
    825     }
     822        if (*lppDest) {
     823            COMCTL32_Free (*lppDest);
     824            *lppDest = NULL;
     825        }
    826826    }
    827827
    … …  
    852852
    853853    if (!lpDest && lpSrc)
    854     return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
     854        return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
    855855
    856856    if (nMaxLen == 0)
    857     return 0;
     857        return 0;
    858858
    859859    if (lpSrc == NULL) {
    860     lpDest[0] = '\0';
    861     return 0;
     860        lpDest[0] = '\0';
     861        return 0;
    862862    }
    863863
    864864    len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
    865865    if (len >= nMaxLen)
    866     len = nMaxLen - 1;
     866        len = nMaxLen - 1;
    867867
    868868    WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
    … …  
    897897
    898898    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;
     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;
    906906    }
    907907    else {
    908     if (*lppDest) {
    909         COMCTL32_Free (*lppDest);
    910         *lppDest = NULL;
    911     }
     908        if (*lppDest) {
     909            COMCTL32_Free (*lppDest);
     910            *lppDest = NULL;
     911        }
    912912    }
    913913
    … …  
    944944    if (hdsa)
    945945    {
    946     hdsa->nItemCount = 0;
     946        hdsa->nItemCount = 0;
    947947        hdsa->pData = NULL;
    948     hdsa->nMaxCount = 0;
    949     hdsa->nItemSize = nSize;
    950     hdsa->nGrow = max(1, nGrow);
     948        hdsa->nMaxCount = 0;
     949        hdsa->nItemSize = nSize;
     950        hdsa->nGrow = max(1, nGrow);
    951951    }
    952952
    … …  
    972972
    973973    if (!hdsa)
    974     return FALSE;
     974        return FALSE;
    975975
    976976    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
    977     return FALSE;
     977        return FALSE;
    978978
    979979    return COMCTL32_Free (hdsa);
    … …  
    982982
    983983/**************************************************************************
    984  * DSA_GetItem [COMCTL32.322]
     984 * DSA_GetItem [COMCTL32.322] 
    985985 *
    986986 * PARAMS
    … …  
    10001000
    10011001    TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
    1002 
     1002   
    10031003    if (!hdsa)
    1004     return FALSE;
     1004        return FALSE;
    10051005    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
    1006     return FALSE;
     1006        return FALSE;
    10071007
    10081008    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    … …  
    10141014
    10151015/**************************************************************************
    1016  * DSA_GetItemPtr [COMCTL32.323]
     1016 * DSA_GetItemPtr [COMCTL32.323] 
    10171017 *
    10181018 * Retrieves a pointer to the specified item.
    … …  
    10351035
    10361036    if (!hdsa)
    1037     return NULL;
     1037        return NULL;
    10381038    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
    1039     return NULL;
     1039        return NULL;
    10401040
    10411041    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    1042 
     1042   
    10431043    TRACE("-- ret=%p\n", pSrc);
    10441044
    … …  
    10481048
    10491049/**************************************************************************
    1050  * DSA_SetItem [COMCTL32.325]
     1050 * DSA_SetItem [COMCTL32.325] 
    10511051 *
    10521052 * Sets the contents of an item in the array.
    … …  
    10671067    INT  nSize, nNewItems;
    10681068    LPVOID pDest, lpTemp;
    1069 
     1069   
    10701070    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    10711071
    10721072    if ((!hdsa) || nIndex < 0)
    1073     return FALSE;
    1074 
     1073        return FALSE;
     1074     
    10751075    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     }
     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        }   
    10951095    }
    10961096
    … …  
    10981098    pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    10991099    TRACE("-- move dest=%p src=%p size=%d\n",
    1100        pDest, pSrc, hdsa->nItemSize);
     1100           pDest, pSrc, hdsa->nItemSize);
    11011101    memmove (pDest, pSrc, hdsa->nItemSize);
    11021102
    … …  
    11061106
    11071107/**************************************************************************
    1108  * DSA_InsertItem [COMCTL32.324]
     1108 * DSA_InsertItem [COMCTL32.324] 
    11091109 *
    11101110 * PARAMS
    … …  
    11241124    LPVOID  lpTemp, lpDest;
    11251125    LPDWORD p;
    1126 
     1126   
    11271127    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    11281128
    11291129    if ((!hdsa) || nIndex < 0)
    1130     return -1;
     1130        return -1;
    11311131
    11321132    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 
     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   
    11401140    /* when nIndex >= nItemCount then append */
    11411141    if (nIndex >= hdsa->nItemCount)
    1142     nIndex = hdsa->nItemCount;
     1142        nIndex = hdsa->nItemCount;
    11431143
    11441144    /* do we need to resize ? */
    11451145    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;
     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;         
    11551155    }
    11561156
    11571157    /* do we need to move elements ? */
    11581158    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);
     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);
    11651165    }
    11661166
    … …  
    11691169    lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    11701170    TRACE("-- move dest=%p src=%p size=%d\n",
    1171        lpDest, pSrc, hdsa->nItemSize);
     1171           lpDest, pSrc, hdsa->nItemSize);
    11721172    memmove (lpDest, pSrc, hdsa->nItemSize);
    11731173
    … …  
    11771177
    11781178/**************************************************************************
    1179  * DSA_DeleteItem [COMCTL32.326]
     1179 * DSA_DeleteItem [COMCTL32.326] 
    11801180 *
    11811181 * PARAMS
    … …  
    11931193    LPVOID lpDest,lpSrc;
    11941194    INT  nSize;
    1195 
     1195   
    11961196    TRACE("(%p %d)\n", hdsa, nIndex);
    11971197
    11981198    if (!hdsa)
    1199     return -1;
     1199        return -1;
    12001200    if (nIndex < 0 || nIndex >= hdsa->nItemCount)
    1201     return -1;
     1201        return -1;
    12021202
    12031203    /* do we need to move ? */
    12041204    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 
     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   
    12131213    hdsa->nItemCount--;
    1214 
     1214   
    12151215    /* free memory ? */
    12161216    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;
     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;
    12251225    }
    12261226
    … …  
    12471247    TRACE("(%p)\n", hdsa);
    12481248
    1249     if (!hdsa)
    1250     return FALSE;
     1249    if (!hdsa) 
     1250        return FALSE;
    12511251    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
    1252     return FALSE;
     1252        return FALSE;
    12531253
    12541254    hdsa->nItemCount = 0;
    … …  
    12851285    hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
    12861286    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));
     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));
    12921292    }
    12931293
    … …  
    13151315
    13161316    if (!hdpa)
    1317     return FALSE;
     1317        return FALSE;
    13181318
    13191319    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
    1320     return FALSE;
     1320        return FALSE;
    13211321
    13221322    return HeapFree (hdpa->hHeap, 0, hdpa);
    … …  
    13441344
    13451345    if (!hdpa)
    1346     return FALSE;
     1346        return FALSE;
    13471347
    13481348    hdpa->nGrow = max(8, nGrow);
    … …  
    13791379
    13801380    if (!hdpa)
    1381     return NULL;
     1381        return NULL;
    13821382
    13831383    TRACE("(%p %p)\n", hdpa, hdpaNew);
    13841384
    13851385    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;
     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;
    13911391    }
    13921392    else
    1393     hdpaTemp = hdpaNew;
     1393        hdpaTemp = hdpaNew;
    13941394
    13951395    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;
     1396        /* remove old pointer array */
     1397        HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
     1398        hdpaTemp->ptrs = NULL;
     1399        hdpaTemp->nItemCount = 0;
     1400        hdpaTemp->nMaxCount = 0;
    14011401    }
    14021402
    14031403    /* create a new pointer array */
    14041404    nNewItems = hdpaTemp->nGrow *
    1405         ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
     1405                ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
    14061406    nSize = nNewItems * sizeof(LPVOID);
    14071407    hdpaTemp->ptrs =
    1408     (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
     1408        (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
    14091409    hdpaTemp->nMaxCount = nNewItems;
    14101410
    … …  
    14121412    hdpaTemp->nItemCount = hdpa->nItemCount;
    14131413    memmove (hdpaTemp->ptrs, hdpa->ptrs,
    1414          hdpaTemp->nItemCount * sizeof(LPVOID));
     1414             hdpaTemp->nItemCount * sizeof(LPVOID));
    14151415
    14161416    return hdpaTemp;
    … …  
    14381438
    14391439    if (!hdpa)
    1440     return NULL;
     1440        return NULL;
    14411441    if (!hdpa->ptrs) {
    1442     WARN("no pointer array.\n");
    1443     return NULL;
     1442        WARN("no pointer array.\n");
     1443        return NULL;
    14441444    }
    14451445    if ((i < 0) || (i >= hdpa->nItemCount)) {
    1446     WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
    1447     return NULL;
     1446        WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
     1447        return NULL;
    14481448    }
    14491449
    … …  
    14741474
    14751475    if (!hdpa->ptrs)
    1476     return -1;
     1476        return -1;
    14771477
    14781478    for (i = 0; i < hdpa->nItemCount; i++) {
    1479     if (hdpa->ptrs[i] == p)
    1480         return i;
     1479        if (hdpa->ptrs[i] == p)
     1480            return i;
    14811481    }
    14821482
    … …  
    15091509
    15101510    if ((!hdpa) || (i < 0))
    1511     return -1;
     1511        return -1;
    15121512
    15131513    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;
     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;
    15201520        nIndex = 0;
    15211521    }
    15221522    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     }
     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        }
    15501550    }
    15511551
    … …  
    15771577{
    15781578    LPVOID *lpTemp;
    1579 
     1579   
    15801580    TRACE("(%p %d %p)\n", hdpa, i, p);
    15811581
    15821582    if ((!hdpa) || i < 0)
    1583     return FALSE;
    1584 
     1583        return FALSE;
     1584     
    15851585    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     }
     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        }   
    16051605    }
    16061606
    … …  
    16311631    LPVOID *lpDest, *lpSrc, lpTemp = NULL;
    16321632    INT  nSize;
    1633 
     1633   
    16341634    TRACE("(%p %d)\n", hdpa, i);
    16351635
    16361636    if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
    1637     return NULL;
     1637        return NULL;
    16381638
    16391639    lpTemp = hdpa->ptrs[i];
    … …  
    16411641    /* do we need to move ?*/
    16421642    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 
     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   
    16511651    hdpa->nItemCount --;
    1652 
     1652   
    16531653    /* free memory ?*/
    16541654    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;
     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;         
    16641664    }
    16651665
    … …  
    16861686    TRACE("(%p)\n", hdpa);
    16871687
    1688     if (!hdpa)
    1689     return FALSE;
     1688    if (!hdpa) 
     1689        return FALSE;
    16901690
    16911691    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
    1692     return FALSE;
     1692        return FALSE;
    16931693
    16941694    hdpa->nItemCount = 0;
    16951695    hdpa->nMaxCount = hdpa->nGrow * 2;
    16961696    hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1697                      hdpa->nMaxCount * sizeof(LPVOID));
     1697                                     hdpa->nMaxCount * sizeof(LPVOID));
    16981698
    16991699    return TRUE;
    … …  
    17191719static VOID
    17201720DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r,
    1721            PFNDPACOMPARE pfnCompare, LPARAM lParam)
     1721               PFNDPACOMPARE pfnCompare, LPARAM lParam)
    17221722{
    17231723    INT m;
    … …  
    17251725
    17261726    TRACE("l=%i r=%i\n", l, r);
    1727 
     1727 
    17281728    if (l==r)    /* one element is always sorted */
    17291729        return;
    17301730    if (r<l)     /* oops, got it in the wrong order */
    1731     {
     1731        {
    17321732        DPA_QuickSort(lpPtrs, r, l, pfnCompare, lParam);
    17331733        return;
    1734     }
     1734        }
    17351735    m = (l+r)/2; /* divide by two */
    17361736    DPA_QuickSort(lpPtrs, l, m, pfnCompare, lParam);
    … …  
    17381738
    17391739    /* join the two sides */
    1740     while( (l<=m) && (m<r) )
     1740    while( (l<=m) && (m<r) ) 
    17411741    {
    17421742        if(pfnCompare(lpPtrs[l],lpPtrs[m+1],lParam)>0)
    … …  
    17721772{
    17731773    if (!hdpa || !pfnCompare)
    1774     return FALSE;
     1774        return FALSE;
    17751775
    17761776    TRACE("(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
    17771777
    17781778    if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
    1779     DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
    1780                pfnCompare, lParam);
     1779        DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
     1780                       pfnCompare, lParam);
    17811781
    17821782    return TRUE;
    … …  
    18091809INT WINAPI
    18101810DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart,
    1811         PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
     1811            PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
    18121812{
    18131813    if (!hdpa || !pfnCompare || !pFind)
    1814     return -1;
     1814        return -1;
    18151815
    18161816    TRACE("(%p %p %d %p 0x%08lx 0x%08x)\n",
    1817        hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
     1817           hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
    18181818
    18191819    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     }
     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        }
    18511851    }
    18521852    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     }
     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        }
    18671867    }
    18681868
    … …  
    18941894
    18951895    if (hHeap)
    1896     hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
     1896        hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
    18971897    else
    1898     hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
     1898        hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
    18991899
    19001900    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));
     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));
    19071907    }
    19081908
    … …  
    19401940
    19411941    TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
    1942        lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
    1943        lpNotify->dwParam5);
     1942           lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
     1943           lpNotify->dwParam5);
    19441944
    19451945    if (!lpNotify->hwndTo)
    1946     return 0;
     1946        return 0;
    19471947
    19481948    if (lpNotify->hwndFrom == -1) {
    1949     lpNmh = lpHdr;
    1950     idFrom = lpHdr->idFrom;
     1949        lpNmh = lpHdr;
     1950        idFrom = lpHdr->idFrom;
    19511951    }
    19521952    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;
     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;
    19671967    }
    19681968
    … …  
    19871987LRESULT WINAPI
    19881988COMCTL32_SendNotify (HWND hwndFrom, HWND hwndTo,
    1989              UINT uCode, LPNMHDR lpHdr)
     1989                     UINT uCode, LPNMHDR lpHdr)
    19901990{
    19911991    NOTIFYDATA notify;
    19921992
    19931993    TRACE("(0x%04x 0x%04x %d %p)\n",
    1994        hwndFrom, hwndTo, uCode, lpHdr);
     1994           hwndFrom, hwndTo, uCode, lpHdr);
    19951995
    19961996    notify.hwndFrom = hwndFrom;
    … …  
    20202020LRESULT WINAPI
    20212021COMCTL32_SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
    2022                LPNMHDR lpHdr, DWORD dwParam5)
     2022                       LPNMHDR lpHdr, DWORD dwParam5)
    20232023{
    20242024    NOTIFYDATA notify;
    … …  
    20262026
    20272027    TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
    2028        hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
     2028           hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
    20292029
    20302030    hwndNotify = hwndTo;
    20312031    if (!hwndTo) {
    2032     if (IsWindow (hwndFrom)) {
    2033         hwndNotify = GetParent (hwndFrom);
    2034         if (!hwndNotify)
    2035         return 0;
    2036     }
     2032        if (IsWindow (hwndFrom)) {
     2033            hwndNotify = GetParent (hwndFrom);
     2034            if (!hwndNotify)
     2035                return 0;
     2036        }
    20372037    }
    20382038
    … …  
    20692069
    20702070    if (*lpStr2 == 0)
    2071     return ((LPSTR)lpStr1);
     2071        return ((LPSTR)lpStr1);
    20722072    len1 = 0;
    20732073    while (lpStr1[len1] != 0) ++len1;
    … …  
    20752075    while (lpStr2[len2] != 0) ++len2;
    20762076    if (len2 == 0)
    2077     return ((LPSTR)(lpStr1 + len1));
     2077        return ((LPSTR)(lpStr1 + len1));
    20782078    first = tolower (*lpStr2);
    20792079    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);
     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);
    20862086        }
    2087     ++lpStr1; --len1;
     2087        ++lpStr1; --len1;
    20882088    }
    20892089    return (NULL);
    … …  
    21162116 *
    21172117 * 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
     2128VOID WINAPI
     2129DPA_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.
    21182153 *
    21192154 * PARAMS
    … …  
    21232158 *
    21242159 * 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.
    2153  *
    2154  * PARAMS
    2155  *     hdpa     [I] handle to the dynamic pointer array
    2156  *     enumProc [I]
    2157  *     lParam   [I]
    2158  *
    2159  * RETURNS
    21602160 *     Success: TRUE
    21612161 *     Failure: FALSE
    … …  
    21952195
    21962196    if (!hdsa)
    2197     return;
     2197        return;
    21982198    if (hdsa->nItemCount <= 0)
    2199     return;
     2199        return;
    22002200
    22012201    for (i = 0; i < hdsa->nItemCount; i++) {
    2202     LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
    2203     if ((enumProc)(lpItem, lParam) == 0)
    2204         return;
     2202        LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
     2203        if ((enumProc)(lpItem, lParam) == 0)
     2204            return;
    22052205    }
    22062206
    … …  
    23012301        if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
    23022302        lpGotIt = lpStart;
    2303     }
     2303    }   
    23042304    return (LPSTR)lpGotIt;
    23052305}
    … …  
    23552355    if( strchrW(lpSet, *(WORD*)lpLoop))
    23562356      return (INT)(lpLoop-lpStr);
    2357 
     2357 
    23582358  return (INT)(lpLoop-lpStr);
    23592359}
    … …  
    23992399
    24002400    if (IsWindow (hwnd) == FALSE)
    2401     return FALSE;
     2401        return FALSE;
    24022402
    24032403    if (b == 0)
    2404     return FALSE;
     2404        return FALSE;
    24052405
    24062406
Note: See TracChangeset for help on using the changeset viewer.