Ignore:
Timestamp:
Jul 12, 1999, 5:58:51 PM (26 years ago)
Author:
cbratschi
Message:

wine-990704 updates, TBCUSTOMIZE implemented

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/comctl32undoc.c

    r164 r295  
    1 /* $Id: comctl32undoc.c,v 1.7 1999-06-23 19:45:00 achimha Exp $ */
     1/* $Id: comctl32undoc.c,v 1.8 1999-07-12 15:58:46 cbratschi Exp $ */
    22/*
    33 * Undocumented functions from COMCTL32.DLL
    … …  
    1111 *
    1212 */
     13
     14/* CB: todo
     15  - porting/implementing string functions
     16  - DPA_LoadStream
     17  - DPA_SaveStream
     18*/
    1319
    1420#include "comctl32.h"
    … …  
    2834 *     dwFlags  [I] flags
    2935 *     pfnSort  [I] pointer to sort function
    30  *     dwParam5 [I]
     36 *     pfnMerge [I] pointer to merge function
    3137 *     lParam   [I] application specific value
    3238 *
    … …  
    3743BOOL WINAPI
    3844DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
    39            PFNDPACOMPARE pfnCompare, LPVOID pfnParam5, LPARAM lParam)
    40 {
    41     /* LPVOID *pWork1, *pWork2; */
    42     INT  nCount1, nCount2;
     45           PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge, LPARAM lParam)
     46{
     47    LPVOID pWork1, pWork2;
     48    INT nResult;
     49    INT nCount, nIndex;
     50    INT nNewItems;
    4351
    4452//    TRACE (commctrl, "(%p %p %08lx %p %p %08lx): stub!\n",
    45 //         hdpa1, hdpa2, dwFlags, pfnCompare, pfnParam5, lParam);
     53//         hdpa1, hdpa2, dwFlags, pfnCompare, pfnParam5, lParam);
    4654
    4755    if (IsBadWritePtr (hdpa1, sizeof(DPA)))
    48         return FALSE;
     56        return FALSE;
    4957
    5058    if (IsBadWritePtr (hdpa2, sizeof(DPA)))
    51         return FALSE;
     59        return FALSE;
    5260
    5361    if (IsBadCodePtr ((FARPROC)pfnCompare))
    54         return FALSE;
    55 
    56     if (IsBadCodePtr ((FARPROC)pfnParam5))
    57         return FALSE;
     62        return FALSE;
     63
     64    if (IsBadCodePtr ((FARPROC)pfnMerge))
     65        return FALSE;
    5866
    5967    if (dwFlags & DPAM_SORT) {
    60 //      TRACE (commctrl, "sorting dpa's!\n");
    61         DPA_Sort (hdpa1, pfnCompare, lParam);
    62         DPA_Sort (hdpa2, pfnCompare, lParam);
    63     }
    64 
    65     if (hdpa2->nItemCount <= 0)
    66         return TRUE;
    67 
    68     nCount1 = hdpa1->nItemCount - 1;
    69 
    70     nCount2 = hdpa2->nItemCount - 1;
    71 
    72 //    FIXME (commctrl, "nCount1=%d nCount2=%d\n", nCount1, nCount2);
    73 //    FIXME (commctrl, "semi stub!\n");
     68//        TRACE("sorting dpa's!\n");
     69        if (hdpa1->nItemCount > 0)
     70        DPA_Sort (hdpa1, pfnCompare, lParam);
     71//        TRACE ("dpa 1 sorted!\n");
     72        if (hdpa2->nItemCount > 0)
     73        DPA_Sort (hdpa2, pfnCompare, lParam);
     74//        TRACE ("dpa 2 sorted!\n");
     75    }
     76
     77    if (hdpa2->nItemCount < 1)
     78        return TRUE;
     79
     80//    TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
     81//           hdpa1->nItemCount, hdpa2->nItemCount);
     82
     83
     84    /* preliminary hack - simply append the pointer list hdpa2 to hdpa1*/
     85    for (nCount = 0; nCount < hdpa2->nItemCount; nCount++)
     86        DPA_InsertPtr (hdpa1, hdpa1->nItemCount + 1, hdpa2->ptrs[nCount]);
     87
    7488#if 0
    75 
    76     do {
    77 
    78 
    79         if (nResult == 0) {
    80 
    81         }
    82         else if (nResult > 0) {
    83 
    84         }
    85         else {
    86 
    87         }
    88 
    89     }
    90     while (nCount2 >= 0);
    91 
     89    /* incomplete implementation */
     90
     91    pWork1 = &(hdpa1->ptrs[hdpa1->nItemCount - 1]);
     92    pWork2 = &(hdpa2->ptrs[hdpa2->nItemCount - 1]);
     93
     94    nIndex = hdpa1->nItemCount - 1;
     95    nCount = hdpa2->nItemCount - 1;
     96
     97    do
     98    {
     99        nResult = (pfnCompare)(pWork1, pWork2, lParam);
     100
     101        if (nResult == 0)
     102        {
     103            PVOID ptr;
     104
     105            ptr = (pfnMerge)(1, pWork1, pWork2, lParam);
     106            if (!ptr)
     107                return FALSE;
     108
     109            nCount--;
     110            pWork2--;
     111            pWork1 = ptr;
     112        }
     113        else if (nResult < 0)
     114        {
     115            if (!dwFlags & 8)
     116            {
     117                PVOID ptr;
     118
     119                ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
     120
     121                (pfnMerge)(2, ptr, NULL, lParam);
     122            }
     123        }
     124        else
     125        {
     126            if (!dwFlags & 4)
     127            {
     128                PVOID ptr;
     129
     130                ptr = (pfnMerge)(3, pWork2, NULL, lParam);
     131                if (!ptr)
     132                    return FALSE;
     133                DPA_InsertPtr (hdpa1, nIndex, ptr);
     134    }
     135            nCount--;
     136            pWork2--;
     137        }
     138
     139        nIndex--;
     140        pWork1--;
     141
     142    }
     143    while (nCount >= 0);
    92144#endif
    93 
    94145
    95146    return TRUE;
    … …  
    145196
    146197    if (lpSrc)
    147         lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
     198        lpDest = HeapReAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, lpSrc, dwSize);
    148199    else
    149         lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
     200        lpDest = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
    150201
    151202    return lpDest;
    … …  
    210261} MRUINFO, *LPMRUINFO;
    211262
    212  
     263
    213264typedef struct tagMRU
    214265{
    … …  
    223274LPVOID WINAPI
    224275CreateMRUListLazyA (LPMRUINFO lpmi, DWORD dwParam2,
    225                     DWORD dwParam3, DWORD dwParam4);
     276                    DWORD dwParam3, DWORD dwParam4);
    226277
    227278
    … …  
    249300#if 0
    250301    if (!(hmru->dwParam1 & 1001)) {
    251         RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
    252                           hmru->lpszMRUString,
    253                           lstrlenA (hmru->lpszMRUString));
     302        RegSetValueExA (hmru->hKeyMRU, "MRUList", 0, REG_SZ,
     303                          hmru->lpszMRUString,
     304                          lstrlenA (hmru->lpszMRUString));
    254305    }
    255306
    … …  
    269320
    270321//    FIXME (commctrl, "(%lx %lx %lx) empty stub!\n",
    271 //         dwParam1, dwParam2, dwParam3);
     322//         dwParam1, dwParam2, dwParam3);
    272323
    273324    return 0;
    … …  
    280331
    281332//    FIXME (commctrl, "(%lx %lx %lx %lx) empty stub!\n",
    282 //         dwParam1, dwParam2, dwParam3, dwParam4);
     333//         dwParam1, dwParam2, dwParam3, dwParam4);
    283334
    284335    return TRUE;
    … …  
    304355
    305356    if (lpmi) {
    306 //      FIXME (commctrl, "(%lx %lx %lx %lx \"%s\" %lx)\n",
    307 //             lpmi->dwParam1, lpmi->dwParam2, lpmi->dwParam3,
    308 //             (DWORD)lpmi->hkeyMain, lpmi->lpszSubKey, lpmi->dwParam6);
     357//      FIXME (commctrl, "(%lx %lx %lx %lx \"%s\" %lx)\n",
     358//             lpmi->dwParam1, lpmi->dwParam2, lpmi->dwParam3,
     359//             (DWORD)lpmi->hkeyMain, lpmi->lpszSubKey, lpmi->dwParam6);
    309360    }
    310361
    … …  
    338389
    339390    if (!lpDest && lpSrc)
    340         return lstrlenA (lpSrc);
     391        return lstrlenA (lpSrc);
    341392
    342393    if (nMaxLen == 0)
    343         return 0;
     394        return 0;
    344395
    345396    if (lpSrc == NULL) {
    346         lpDest[0] = '\0';
    347         return 0;
     397        lpDest[0] = '\0';
     398        return 0;
    348399    }
    349400
    350401    len = lstrlenA (lpSrc);
    351402    if (len >= nMaxLen)
    352         len = nMaxLen - 1;
     403        len = nMaxLen - 1;
    353404
    354405    RtlMoveMemory (lpDest, lpSrc, len);
    … …  
    373424{
    374425//    TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
    375  
     426
    376427    if (lpSrc) {
    377         LPSTR ptr = COMCTL32_ReAlloc (*lppDest, lstrlenA (lpSrc) + 1);
    378         if (!ptr)
    379             return FALSE;
    380         lstrcpyA (ptr, lpSrc);
    381         *lppDest = ptr;
     428        LPSTR ptr = COMCTL32_ReAlloc (*lppDest, lstrlenA (lpSrc) + 1);
     429        if (!ptr)
     430            return FALSE;
     431        lstrcpyA (ptr, lpSrc);
     432        *lppDest = ptr;
    382433    }
    383434    else {
    384         if (*lppDest) {
    385             COMCTL32_Free (*lppDest);
    386             *lppDest = NULL;
    387         }
     435        if (*lppDest) {
     436            COMCTL32_Free (*lppDest);
     437            *lppDest = NULL;
     438        }
    388439    }
    389440
    … …  
    411462
    412463    if (!lpDest && lpSrc)
    413         return lstrlenW (lpSrc);
     464        return lstrlenW (lpSrc);
    414465
    415466    if (nMaxLen == 0)
    416         return 0;
     467        return 0;
    417468
    418469    if (lpSrc == NULL) {
    419         lpDest[0] = L'\0';
    420         return 0;
     470        lpDest[0] = L'\0';
     471        return 0;
    421472    }
    422473
    423474    len = lstrlenW (lpSrc);
    424475    if (len >= nMaxLen)
    425         len = nMaxLen - 1;
     476        len = nMaxLen - 1;
    426477
    427478    RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
    … …  
    446497{
    447498//    TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
    448  
     499
    449500    if (lpSrc) {
    450         INT len = lstrlenW (lpSrc) + 1;
    451         LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
    452         if (!ptr)
    453             return FALSE;
    454         lstrcpyW (ptr, lpSrc);
    455         *lppDest = ptr;
     501        INT len = lstrlenW (lpSrc) + 1;
     502        LPWSTR ptr = COMCTL32_ReAlloc (*lppDest, len * sizeof(WCHAR));
     503        if (!ptr)
     504            return FALSE;
     505        lstrcpyW (ptr, lpSrc);
     506        *lppDest = ptr;
    456507    }
    457508    else {
    458         if (*lppDest) {
    459             COMCTL32_Free (*lppDest);
    460             *lppDest = NULL;
    461         }
     509        if (*lppDest) {
     510            COMCTL32_Free (*lppDest);
     511            *lppDest = NULL;
     512        }
    462513    }
    463514
    … …  
    494545    if (hdsa)
    495546    {
    496         hdsa->nItemCount = 0;
     547        hdsa->nItemCount = 0;
    497548        hdsa->pData = NULL;
    498         hdsa->nMaxCount = 0;
    499         hdsa->nItemSize = nSize;
    500         hdsa->nGrow = MAX(1, nGrow);
     549        hdsa->nMaxCount = 0;
     550        hdsa->nItemSize = nSize;
     551        hdsa->nGrow = MAX(1, nGrow);
    501552    }
    502553
    … …  
    522573
    523574    if (!hdsa)
    524         return FALSE;
     575        return FALSE;
    525576
    526577    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
    527         return FALSE;
     578        return FALSE;
    528579
    529580    return COMCTL32_Free (hdsa);
    … …  
    532583
    533584/**************************************************************************
    534  * DSA_GetItem [COMCTL32.322] 
     585 * DSA_GetItem [COMCTL32.322]
    535586 *
    536587 * PARAMS
    … …  
    550601
    551602//    TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pDest);
    552    
     603
    553604    if (!hdsa)
    554         return FALSE;
     605        return FALSE;
    555606    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
    556         return FALSE;
     607        return FALSE;
    557608
    558609    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    … …  
    564615
    565616/**************************************************************************
    566  * DSA_GetItemPtr [COMCTL32.323] 
     617 * DSA_GetItemPtr [COMCTL32.323]
    567618 *
    568619 * Retrieves a pointer to the specified item.
    … …  
    585636
    586637    if (!hdsa)
    587         return NULL;
     638        return NULL;
    588639    if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
    589         return NULL;
     640        return NULL;
    590641
    591642    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    592    
     643
    593644//    TRACE (commctrl, "-- ret=%p\n", pSrc);
    594645
    … …  
    598649
    599650/**************************************************************************
    600  * DSA_SetItem [COMCTL32.325] 
     651 * DSA_SetItem [COMCTL32.325]
    601652 *
    602653 * Sets the contents of an item in the array.
    … …  
    617668    INT  nSize, nNewItems;
    618669    LPVOID pDest, lpTemp;
    619    
     670
    620671//    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    621672
    622673    if ((!hdsa) || nIndex < 0)
    623         return FALSE;
    624      
     674        return FALSE;
     675
    625676    if (hdsa->nItemCount <= nIndex) {
    626         /* within the old array */
    627         if (hdsa->nMaxCount > nIndex) {
    628             /* within the allocated space, set a new boundary */
    629             hdsa->nItemCount = nIndex + 1;
    630         }
    631         else {
    632             /* resize the block of memory */
    633             nNewItems =
    634                 hdsa->nGrow * ((INT)((nIndex - 1) / hdsa->nGrow) + 1);
    635             nSize = hdsa->nItemSize * nNewItems;
    636 
    637             lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
    638             if (!lpTemp)
    639                 return FALSE;
    640 
    641             hdsa->nMaxCount = nNewItems;
    642             hdsa->nItemCount = nIndex + 1;
    643             hdsa->pData = lpTemp;
    644         }   
     677        /* within the old array */
     678        if (hdsa->nMaxCount > nIndex) {
     679            /* within the allocated space, set a new boundary */
     680            hdsa->nItemCount = nIndex + 1;
     681        }
     682        else {
     683            /* resize the block of memory */
     684            nNewItems =
     685                hdsa->nGrow * ((INT)((nIndex - 1) / hdsa->nGrow) + 1);
     686            nSize = hdsa->nItemSize * nNewItems;
     687
     688            lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
     689            if (!lpTemp)
     690                return FALSE;
     691
     692            hdsa->nMaxCount = nNewItems;
     693            hdsa->nItemCount = nIndex + 1;
     694            hdsa->pData = lpTemp;
     695        }
    645696    }
    646697
    … …  
    648699    pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    649700//    TRACE("-- move dest=%p src=%p size=%d\n",
    650 //         pDest, pSrc, hdsa->nItemSize);
     701//         pDest, pSrc, hdsa->nItemSize);
    651702    memmove (pDest, pSrc, hdsa->nItemSize);
    652703
    … …  
    656707
    657708/**************************************************************************
    658  * DSA_InsertItem [COMCTL32.325] 
     709 * DSA_InsertItem [COMCTL32.325]
    659710 *
    660711 * PARAMS
    … …  
    674725    LPVOID  lpTemp, lpDest;
    675726    LPDWORD p;
    676    
     727
    677728//    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    678729
    679730    if ((!hdsa) || nIndex < 0)
    680         return -1;
     731        return -1;
    681732
    682733    for (i = 0; i < hdsa->nItemSize; i += 4) {
    683         p = *(DWORD**)((char *) pSrc + i);
    684 //      if (IsBadStringPtrA ((char*)p, 256))
    685 //          TRACE("-- %d=%p\n", i, (DWORD*)p);
    686 //      else
    687 //          TRACE("-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
    688     }
    689    
     734        p = *(DWORD**)((char *) pSrc + i);
     735//      if (IsBadStringPtrA ((char*)p, 256))
     736//          TRACE("-- %d=%p\n", i, (DWORD*)p);
     737//      else
     738//          TRACE("-- %d=%p [%s]\n", i, p, debugstr_a((char*)p));
     739    }
     740
    690741    /* when nIndex > nItemCount then append */
    691742    if (nIndex >= hdsa->nItemCount)
    692         nIndex = hdsa->nItemCount;
     743        nIndex = hdsa->nItemCount;
    693744
    694745    /* do we need to resize ? */
    695746    if (hdsa->nItemCount >= hdsa->nMaxCount) {
    696         nNewItems = hdsa->nMaxCount + hdsa->nGrow;
    697         nSize = hdsa->nItemSize * nNewItems;
    698 
    699         lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
    700         if (!lpTemp)
    701             return -1;
    702 
    703         hdsa->nMaxCount = nNewItems;
    704         hdsa->pData = lpTemp;         
     747        nNewItems = hdsa->nMaxCount + hdsa->nGrow;
     748        nSize = hdsa->nItemSize * nNewItems;
     749
     750        lpTemp = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
     751        if (!lpTemp)
     752            return -1;
     753
     754        hdsa->nMaxCount = nNewItems;
     755        hdsa->pData = lpTemp;
    705756    }
    706757
    707758    /* do we need to move elements ? */
    708759    if (nIndex < hdsa->nItemCount) {
    709         lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    710         lpDest = (char *) lpTemp + hdsa->nItemSize;
    711         nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
    712 //      TRACE("-- move dest=%p src=%p size=%d\n",
    713 //             lpDest, lpTemp, nSize);
    714         memmove (lpDest, lpTemp, nSize);
     760        lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
     761        lpDest = (char *) lpTemp + hdsa->nItemSize;
     762        nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
     763//      TRACE("-- move dest=%p src=%p size=%d\n",
     764//             lpDest, lpTemp, nSize);
     765        memmove (lpDest, lpTemp, nSize);
    715766    }
    716767
    … …  
    719770    lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    720771//    TRACE("-- move dest=%p src=%p size=%d\n",
    721 //         lpDest, pSrc, hdsa->nItemSize);
     772//         lpDest, pSrc, hdsa->nItemSize);
    722773    memmove (lpDest, pSrc, hdsa->nItemSize);
    723774
    … …  
    727778
    728779/**************************************************************************
    729  * DSA_DeleteItem [COMCTL32.326] 
     780 * DSA_DeleteItem [COMCTL32.326]
    730781 *
    731782 * PARAMS
    … …  
    743794    LPVOID lpDest,lpSrc;
    744795    INT  nSize;
    745    
     796
    746797//    TRACE (commctrl, "(%p %d)\n", hdsa, nIndex);
    747798
    748799    if (!hdsa)
    749         return -1;
     800        return -1;
    750801    if (nIndex < 0 || nIndex >= hdsa->nItemCount)
    751         return -1;
     802        return -1;
    752803
    753804    /* do we need to move ? */
    754805    if (nIndex < hdsa->nItemCount - 1) {
    755         lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    756         lpSrc = (char *) lpDest + hdsa->nItemSize;
    757         nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
    758 //      TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
    759 //             lpDest, lpSrc, nSize);
    760         memmove (lpDest, lpSrc, nSize);
    761     }
    762    
     806        lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
     807        lpSrc = (char *) lpDest + hdsa->nItemSize;
     808        nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
     809//      TRACE (commctrl, "-- move dest=%p src=%p size=%d\n",
     810//             lpDest, lpSrc, nSize);
     811        memmove (lpDest, lpSrc, nSize);
     812    }
     813
    763814    hdsa->nItemCount--;
    764    
     815
    765816    /* free memory ? */
    766817    if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
    767         nSize = hdsa->nItemSize * hdsa->nItemCount;
    768 
    769         lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
    770         if (!lpDest)
    771             return -1;
    772 
    773         hdsa->nMaxCount = hdsa->nItemCount;
    774         hdsa->pData = lpDest;
     818        nSize = hdsa->nItemSize * hdsa->nItemCount;
     819
     820        lpDest = (LPVOID)COMCTL32_ReAlloc (hdsa->pData, nSize);
     821        if (!lpDest)
     822            return -1;
     823
     824        hdsa->nMaxCount = hdsa->nItemCount;
     825        hdsa->pData = lpDest;
    775826    }
    776827
    … …  
    797848//    TRACE (commctrl, "(%p)\n", hdsa);
    798849
    799     if (!hdsa) 
    800         return FALSE;
     850    if (!hdsa)
     851        return FALSE;
    801852    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
    802         return FALSE;
     853        return FALSE;
    803854
    804855    hdsa->nItemCount = 0;
    … …  
    835886    hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
    836887    if (hdpa) {
    837         hdpa->nGrow = MAX(8, nGrow);
    838         hdpa->hHeap = COMCTL32_hHeap;
    839         hdpa->nMaxCount = hdpa->nGrow * 2;
    840         hdpa->ptrs =
    841             (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
     888        hdpa->nGrow = MAX(8, nGrow);
     889        hdpa->hHeap = COMCTL32_hHeap;
     890        hdpa->nMaxCount = hdpa->nGrow * 2;
     891        hdpa->ptrs =
     892            (LPVOID*)COMCTL32_Alloc (hdpa->nMaxCount * sizeof(LPVOID));
    842893    }
    843894
    … …  
    865916
    866917    if (!hdpa)
    867         return FALSE;
     918        return FALSE;
    868919
    869920    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
    870         return FALSE;
     921        return FALSE;
    871922
    872923    return HeapFree (hdpa->hHeap, 0, hdpa);
    … …  
    894945
    895946    if (!hdpa)
    896         return FALSE;
     947        return FALSE;
    897948
    898949    hdpa->nGrow = MAX(8, nGrow);
    … …  
    929980
    930981    if (!hdpa)
    931         return NULL;
     982        return NULL;
    932983
    933984//    TRACE (commctrl, "(%p %p)\n", hdpa, hdpaNew);
    934985
    935986    if (!hdpaNew) {
    936         /* create a new DPA */
    937         hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    938                                     sizeof(DPA));
    939         hdpaTemp->hHeap = hdpa->hHeap;
    940         hdpaTemp->nGrow = hdpa->nGrow;
     987        /* create a new DPA */
     988        hdpaTemp = (HDPA)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     989                                    sizeof(DPA));
     990        hdpaTemp->hHeap = hdpa->hHeap;
     991        hdpaTemp->nGrow = hdpa->nGrow;
    941992    }
    942993    else
    943         hdpaTemp = hdpaNew;
     994        hdpaTemp = hdpaNew;
    944995
    945996    if (hdpaTemp->ptrs) {
    946         /* remove old pointer array */
    947         HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
    948         hdpaTemp->ptrs = NULL;
    949         hdpaTemp->nItemCount = 0;
    950         hdpaTemp->nMaxCount = 0;
     997        /* remove old pointer array */
     998        HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
     999        hdpaTemp->ptrs = NULL;
     1000        hdpaTemp->nItemCount = 0;
     1001        hdpaTemp->nMaxCount = 0;
    9511002    }
    9521003
    9531004    /* create a new pointer array */
    9541005    nNewItems = hdpaTemp->nGrow *
    955                 ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
     1006                ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
    9561007    nSize = nNewItems * sizeof(LPVOID);
    9571008    hdpaTemp->ptrs =
    958         (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
     1009        (LPVOID*)HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
    9591010    hdpaTemp->nMaxCount = nNewItems;
    9601011
    … …  
    9621013    hdpaTemp->nItemCount = hdpa->nItemCount;
    9631014    memmove (hdpaTemp->ptrs, hdpa->ptrs,
    964              hdpaTemp->nItemCount * sizeof(LPVOID));
     1015             hdpaTemp->nItemCount * sizeof(LPVOID));
    9651016
    9661017    return hdpaTemp;
    … …  
    9881039
    9891040    if (!hdpa)
    990         return NULL;
     1041        return NULL;
    9911042    if (!hdpa->ptrs)
    992         return NULL;
     1043        return NULL;
    9931044    if ((i < 0) || (i >= hdpa->nItemCount))
    994         return NULL;
     1045        return NULL;
    9951046
    9961047//    TRACE (commctrl, "-- %p\n", hdpa->ptrs[i]);
    … …  
    10201071
    10211072    if (!hdpa->ptrs)
    1022         return -1;
     1073        return -1;
    10231074
    10241075    for (i = 0; i < hdpa->nItemCount; i++) {
    1025         if (hdpa->ptrs[i] == p)
    1026             return i;
     1076        if (hdpa->ptrs[i] == p)
     1077            return i;
    10271078    }
    10281079
    … …  
    10551106
    10561107    if ((!hdpa) || (i < 0))
    1057         return -1;
     1108        return -1;
    10581109
    10591110    if (!hdpa->ptrs) {
    1060         hdpa->ptrs =
    1061             (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1062                                 2 * hdpa->nGrow * sizeof(LPVOID));
    1063         if (!hdpa->ptrs)
    1064             return -1;
    1065         hdpa->nMaxCount = hdpa->nGrow * 2;
     1111        hdpa->ptrs =
     1112            (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1113                                2 * hdpa->nGrow * sizeof(LPVOID));
     1114        if (!hdpa->ptrs)
     1115            return -1;
     1116        hdpa->nMaxCount = hdpa->nGrow * 2;
    10661117        nIndex = 0;
    10671118    }
    10681119    else {
    1069         if (hdpa->nItemCount >= hdpa->nMaxCount) {
    1070 //          TRACE (commctrl, "-- resizing\n");
    1071             nNewItems = hdpa->nMaxCount + hdpa->nGrow;
    1072             nSize = nNewItems * sizeof(LPVOID);
    1073 
    1074             lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1075                                            hdpa->ptrs, nSize);
    1076             if (!lpTemp)
    1077                 return -1;
    1078             hdpa->nMaxCount = nNewItems;
    1079             hdpa->ptrs = lpTemp;
    1080         }
    1081 
    1082         if (i >= hdpa->nItemCount) {
    1083             nIndex = hdpa->nItemCount;
    1084 //          TRACE (commctrl, "-- appending at %d\n", nIndex);
    1085         }
    1086         else {
    1087 //          TRACE (commctrl, "-- inserting at %d\n", i);
    1088             lpTemp = hdpa->ptrs + i;
    1089             lpDest = lpTemp + 1;
    1090             nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
    1091 //          TRACE (commctrl, "-- move dest=%p src=%p size=%x\n",
    1092 //                 lpDest, lpTemp, nSize);
    1093             memmove (lpDest, lpTemp, nSize);
    1094             nIndex = i;
    1095         }
     1120        if (hdpa->nItemCount >= hdpa->nMaxCount) {
     1121//          TRACE (commctrl, "-- resizing\n");
     1122            nNewItems = hdpa->nMaxCount + hdpa->nGrow;
     1123            nSize = nNewItems * sizeof(LPVOID);
     1124
     1125            lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1126                                           hdpa->ptrs, nSize);
     1127            if (!lpTemp)
     1128                return -1;
     1129            hdpa->nMaxCount = nNewItems;
     1130            hdpa->ptrs = lpTemp;
     1131        }
     1132
     1133        if (i >= hdpa->nItemCount) {
     1134            nIndex = hdpa->nItemCount;
     1135//          TRACE (commctrl, "-- appending at %d\n", nIndex);
     1136        }
     1137        else {
     1138//          TRACE (commctrl, "-- inserting at %d\n", i);
     1139            lpTemp = hdpa->ptrs + i;
     1140            lpDest = lpTemp + 1;
     1141            nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
     1142//          TRACE (commctrl, "-- move dest=%p src=%p size=%x\n",
     1143//                 lpDest, lpTemp, nSize);
     1144            memmove (lpDest, lpTemp, nSize);
     1145            nIndex = i;
     1146        }
    10961147    }
    10971148
    … …  
    11231174{
    11241175    LPVOID *lpTemp;
    1125    
     1176
    11261177//    TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p);
    11271178
    11281179    if ((!hdpa) || i < 0)
    1129         return FALSE;
    1130      
     1180        return FALSE;
     1181
    11311182    if (hdpa->nItemCount <= i) {
    1132         /* within the old array */
    1133         if (hdpa->nMaxCount > i) {
    1134             /* within the allocated space, set a new boundary */
    1135             hdpa->nItemCount = i;
    1136         }
    1137         else {
    1138             /* resize the block of memory */
    1139             INT nNewItems =
    1140                 hdpa->nGrow * ((INT)((i - 1) / hdpa->nGrow) + 1);
    1141             INT nSize = nNewItems * sizeof(LPVOID);
    1142 
    1143             lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1144                                            hdpa->ptrs, nSize);
    1145             if (!lpTemp)
    1146                 return FALSE;
    1147 
    1148             hdpa->nItemCount = nNewItems;
    1149             hdpa->ptrs = lpTemp;       
    1150         }   
     1183        /* within the old array */
     1184        if (hdpa->nMaxCount > i) {
     1185            /* within the allocated space, set a new boundary */
     1186            hdpa->nItemCount = i;
     1187        }
     1188        else {
     1189            /* resize the block of memory */
     1190            INT nNewItems =
     1191                hdpa->nGrow * ((INT)((i - 1) / hdpa->nGrow) + 1);
     1192            INT nSize = nNewItems * sizeof(LPVOID);
     1193
     1194            lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1195                                           hdpa->ptrs, nSize);
     1196            if (!lpTemp)
     1197                return FALSE;
     1198
     1199            hdpa->nItemCount = nNewItems;
     1200            hdpa->ptrs = lpTemp;
     1201        }
    11511202    }
    11521203
    … …  
    11771228    LPVOID *lpDest, *lpSrc, lpTemp = NULL;
    11781229    INT  nSize;
    1179    
     1230
    11801231//    TRACE (commctrl, "(%p %d)\n", hdpa, i);
    11811232
    11821233    if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
    1183         return NULL;
     1234        return NULL;
    11841235
    11851236    lpTemp = hdpa->ptrs[i];
    … …  
    11871238    /* do we need to move ?*/
    11881239    if (i < hdpa->nItemCount - 1) {
    1189         lpDest = hdpa->ptrs + i;
    1190         lpSrc = lpDest + 1;
    1191         nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
    1192 //      TRACE (commctrl,"-- move dest=%p src=%p size=%x\n",
    1193 //             lpDest, lpSrc, nSize);
    1194         memmove (lpDest, lpSrc, nSize);
    1195     }
    1196    
     1240        lpDest = hdpa->ptrs + i;
     1241        lpSrc = lpDest + 1;
     1242        nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
     1243//      TRACE (commctrl,"-- move dest=%p src=%p size=%x\n",
     1244//             lpDest, lpSrc, nSize);
     1245        memmove (lpDest, lpSrc, nSize);
     1246    }
     1247
    11971248    hdpa->nItemCount --;
    1198    
     1249
    11991250    /* free memory ?*/
    12001251    if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
    1201         INT nNewItems = MIN(hdpa->nGrow * 2, hdpa->nItemCount);
    1202         nSize = nNewItems * sizeof(LPVOID);
    1203         lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1204                                       hdpa->ptrs, nSize);
    1205         if (!lpDest)
    1206             return NULL;
    1207 
    1208         hdpa->nMaxCount = nNewItems;
    1209         hdpa->ptrs = (LPVOID*)lpDest;         
     1252        INT nNewItems = MIN(hdpa->nGrow * 2, hdpa->nItemCount);
     1253        nSize = nNewItems * sizeof(LPVOID);
     1254        lpDest = (LPVOID)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
     1255                                      hdpa->ptrs, nSize);
     1256        if (!lpDest)
     1257            return NULL;
     1258
     1259        hdpa->nMaxCount = nNewItems;
     1260        hdpa->ptrs = (LPVOID*)lpDest;
    12101261    }
    12111262
    … …  
    12321283//    TRACE (commctrl, "(%p)\n", hdpa);
    12331284
    1234     if (!hdpa) 
    1235         return FALSE;
     1285    if (!hdpa)
     1286        return FALSE;
    12361287
    12371288    if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
    1238         return FALSE;
     1289        return FALSE;
    12391290
    12401291    hdpa->nItemCount = 0;
    12411292    hdpa->nMaxCount = hdpa->nGrow * 2;
    12421293    hdpa->ptrs = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1243                                      hdpa->nMaxCount * sizeof(LPVOID));
     1294                                     hdpa->nMaxCount * sizeof(LPVOID));
    12441295
    12451296    return TRUE;
    … …  
    12651316static VOID
    12661317DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r,
    1267                PFNDPACOMPARE pfnCompare, LPARAM lParam)
     1318               PFNDPACOMPARE pfnCompare, LPARAM lParam)
    12681319{
    12691320    LPVOID t, v;
    … …  
    12711322
    12721323//    TRACE (commctrl, "l=%i r=%i\n", l, r);
    1273  
     1324
    12741325    i = l;
    12751326    j = r;
    12761327    v = lpPtrs[(int)(l+r)/2];
    12771328    do {
    1278         while ((pfnCompare)(lpPtrs[i], v, lParam) > 0) i++;
    1279         while ((pfnCompare)(lpPtrs[j], v, lParam) < 0) j--;
    1280         if (i <= j)
    1281         {
    1282             t = lpPtrs[i];
    1283             lpPtrs[i++] = lpPtrs[j];
    1284             lpPtrs[j--] = t;
    1285         }
     1329        while ((pfnCompare)(lpPtrs[i], v, lParam) > 0) i++;
     1330        while ((pfnCompare)(lpPtrs[j], v, lParam) < 0) j--;
     1331        if (i <= j)
     1332        {
     1333            t = lpPtrs[i];
     1334            lpPtrs[i++] = lpPtrs[j];
     1335            lpPtrs[j--] = t;
     1336        }
    12861337    } while (i <= j);
    12871338    if (l < j) DPA_QuickSort (lpPtrs, l, j, pfnCompare, lParam);
    … …  
    13091360{
    13101361    if (!hdpa || !pfnCompare)
    1311         return FALSE;
     1362        return FALSE;
    13121363
    13131364//    TRACE (commctrl, "(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
    13141365
    13151366    if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
    1316         DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
    1317                        pfnCompare, lParam);
     1367        DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
     1368                       pfnCompare, lParam);
    13181369
    13191370    return TRUE;
    … …  
    13461397INT WINAPI
    13471398DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart,
    1348             PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
     1399            PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
    13491400{
    13501401    if (!hdpa || !pfnCompare || !pFind)
    1351         return -1;
     1402        return -1;
    13521403
    13531404//    TRACE (commctrl, "(%p %p %d %p 0x%08lx 0x%08x)\n",
    1354 //         hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
     1405//         hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
    13551406
    13561407    if (uOptions & DPAS_SORTED) {
    1357         /* array is sorted --> use binary search */
    1358         INT l, r, x, n;
    1359         LPVOID *lpPtr;
    1360 
    1361 //      TRACE (commctrl, "binary search\n");
    1362 
    1363         l = (nStart == -1) ? 0 : nStart;
    1364         r = hdpa->nItemCount - 1;
    1365         lpPtr = hdpa->ptrs;
    1366         while (r >= l) {
    1367             x = (l + r) / 2;
    1368             n = (pfnCompare)(pFind, lpPtr[x], lParam);
    1369             if (n < 0)
    1370                 r = x - 1;
    1371             else
    1372                 l = x + 1;
    1373             if (n == 0) {
    1374 //              TRACE (commctrl, "-- ret=%d\n", n);
    1375                 return n;
    1376             }
    1377         }
    1378 
    1379         if (uOptions & DPAS_INSERTBEFORE) {
    1380 //          TRACE (commctrl, "-- ret=%d\n", r);
    1381             return r;
    1382         }
    1383 
    1384         if (uOptions & DPAS_INSERTAFTER) {
    1385 //          TRACE (commctrl, "-- ret=%d\n", l);
    1386             return l;
    1387         }
     1408        /* array is sorted --> use binary search */
     1409        INT l, r, x, n;
     1410        LPVOID *lpPtr;
     1411
     1412//      TRACE (commctrl, "binary search\n");
     1413
     1414        l = (nStart == -1) ? 0 : nStart;
     1415        r = hdpa->nItemCount - 1;
     1416        lpPtr = hdpa->ptrs;
     1417        while (r >= l) {
     1418            x = (l + r) / 2;
     1419            n = (pfnCompare)(pFind, lpPtr[x], lParam);
     1420            if (n < 0)
     1421                r = x - 1;
     1422            else
     1423                l = x + 1;
     1424            if (n == 0) {
     1425//              TRACE (commctrl, "-- ret=%d\n", n);
     1426                return n;
     1427            }
     1428        }
     1429
     1430        if (uOptions & DPAS_INSERTBEFORE) {
     1431//          TRACE (commctrl, "-- ret=%d\n", r);
     1432            return r;
     1433        }
     1434
     1435        if (uOptions & DPAS_INSERTAFTER) {
     1436//          TRACE (commctrl, "-- ret=%d\n", l);
     1437            return l;
     1438        }
    13881439    }
    13891440    else {
    1390         /* array is not sorted --> use linear search */
    1391         LPVOID *lpPtr;
    1392         INT  nIndex;
    1393 
    1394 //      TRACE (commctrl, "linear search\n");
    1395        
    1396         nIndex = (nStart == -1)? 0 : nStart;
    1397         lpPtr = hdpa->ptrs;
    1398         for (; nIndex < hdpa->nItemCount; nIndex++) {
    1399             if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
    1400 //              TRACE (commctrl, "-- ret=%d\n", nIndex);
    1401                 return nIndex;
    1402             }
    1403         }
     1441        /* array is not sorted --> use linear search */
     1442        LPVOID *lpPtr;
     1443        INT  nIndex;
     1444
     1445//      TRACE (commctrl, "linear search\n");
     1446
     1447        nIndex = (nStart == -1)? 0 : nStart;
     1448        lpPtr = hdpa->ptrs;
     1449        for (; nIndex < hdpa->nItemCount; nIndex++) {
     1450            if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
     1451//              TRACE (commctrl, "-- ret=%d\n", nIndex);
     1452                return nIndex;
     1453            }
     1454        }
    14041455    }
    14051456
    … …  
    14311482
    14321483    if (hHeap)
    1433         hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
     1484        hdpa = (HDPA)HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(DPA));
    14341485    else
    1435         hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
     1486        hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
    14361487
    14371488    if (hdpa) {
    1438         hdpa->nGrow = MIN(8, nGrow);
    1439         hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
    1440         hdpa->nMaxCount = hdpa->nGrow * 2;
    1441         hdpa->ptrs =
    1442             (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
    1443                                 hdpa->nMaxCount * sizeof(LPVOID));
     1489        hdpa->nGrow = MIN(8, nGrow);
     1490        hdpa->hHeap = hHeap ? hHeap : COMCTL32_hHeap;
     1491        hdpa->nMaxCount = hdpa->nGrow * 2;
     1492        hdpa->ptrs =
     1493            (LPVOID*)HeapAlloc (hHeap, HEAP_ZERO_MEMORY,
     1494                                hdpa->nMaxCount * sizeof(LPVOID));
    14441495    }
    14451496
    … …  
    14761527
    14771528//    TRACE (commctrl, "(0x%04x 0x%04x %d %p 0x%08lx)\n",
    1478 //         lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
    1479 //         lpNotify->dwParam5);
     1529//         lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
     1530//         lpNotify->dwParam5);
    14801531
    14811532    if (!lpNotify->hwndTo)
    1482         return 0;
     1533        return 0;
    14831534
    14841535    if (lpNotify->hwndFrom == -1) {
    1485         lpNmh = lpHdr;
    1486         idFrom = lpHdr->idFrom;
     1536        lpNmh = lpHdr;
     1537        idFrom = lpHdr->idFrom;
    14871538    }
    14881539    else {
    1489         if (lpNotify->hwndFrom) {
    1490             HWND hwndParent = GetParent (lpNotify->hwndFrom);
    1491             if (hwndParent) {
    1492                 hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER);
    1493                 if (hwndParent)
    1494                     idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
    1495             }
    1496         }
    1497 
    1498         lpNmh = (lpHdr) ? lpHdr : &nmhdr;
    1499 
    1500         lpNmh->hwndFrom = lpNotify->hwndFrom;
    1501         lpNmh->idFrom = idFrom;
    1502         lpNmh->code = uCode;
     1540        if (lpNotify->hwndFrom) {
     1541            HWND hwndParent = GetParent (lpNotify->hwndFrom);
     1542            if (hwndParent) {
     1543                hwndParent = GetWindow (lpNotify->hwndFrom, GW_OWNER);
     1544                if (hwndParent)
     1545                    idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
     1546            }
     1547        }
     1548
     1549        lpNmh = (lpHdr) ? lpHdr : &nmhdr;
     1550
     1551        lpNmh->hwndFrom = lpNotify->hwndFrom;
     1552        lpNmh->idFrom = idFrom;
     1553        lpNmh->code = uCode;
    15031554    }
    15041555
    … …  
    15231574LRESULT WINAPI
    15241575COMCTL32_SendNotify (HWND hwndFrom, HWND hwndTo,
    1525                      UINT uCode, LPNMHDR lpHdr)
     1576                     UINT uCode, LPNMHDR lpHdr)
    15261577{
    15271578    NOTIFYDATA notify;
    15281579
    15291580//    TRACE (commctrl, "(0x%04x 0x%04x %d %p)\n",
    1530 //         hwndFrom, hwndTo, uCode, lpHdr);
     1581//         hwndFrom, hwndTo, uCode, lpHdr);
    15311582
    15321583    notify.hwndFrom = hwndFrom;
    … …  
    15561607LRESULT WINAPI
    15571608COMCTL32_SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
    1558                        LPNMHDR lpHdr, DWORD dwParam5)
     1609                       LPNMHDR lpHdr, DWORD dwParam5)
    15591610{
    15601611    NOTIFYDATA notify;
    … …  
    15621613
    15631614//    TRACE (commctrl, "(0x%04x 0x%04x %d %p 0x%08lx)\n",
    1564 //         hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
     1615//         hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
    15651616
    15661617    hwndNotify = hwndTo;
    15671618    if (!hwndTo) {
    1568         if (IsWindow (hwndFrom)) {
    1569             hwndNotify = GetParent (hwndFrom);
    1570             if (!hwndNotify)
    1571                 return 0;
    1572         }
     1619        if (IsWindow (hwndFrom)) {
     1620            hwndNotify = GetParent (hwndFrom);
     1621            if (!hwndNotify)
     1622                return 0;
     1623        }
    15731624    }
    15741625
    … …  
    16051656
    16061657    if (*lpStr2 == 0)
    1607         return ((LPSTR)lpStr1);
     1658        return ((LPSTR)lpStr1);
    16081659    len1 = 0;
    16091660    while (lpStr1[len1] != 0) ++len1;
    … …  
    16111662    while (lpStr2[len2] != 0) ++len2;
    16121663    if (len2 == 0)
    1613         return ((LPSTR)(lpStr1 + len1));
     1664        return ((LPSTR)(lpStr1 + len1));
    16141665    first = tolower (*lpStr2);
    16151666    while (len1 >= len2) {
    1616         if (tolower(*lpStr1) == first) {
    1617             for (i = 1; i < len2; ++i)
    1618                 if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
    1619                     break;
    1620             if (i >= len2)
    1621                 return ((LPSTR)lpStr1);
    1622         }
    1623         ++lpStr1; --len1;
     1667        if (tolower(*lpStr1) == first) {
     1668            for (i = 1; i < len2; ++i)
     1669                if (tolower (lpStr1[i]) != tolower(lpStr2[i]))
     1670                    break;
     1671            if (i >= len2)
     1672                return ((LPSTR)lpStr1);
     1673        }
     1674        ++lpStr1; --len1;
    16241675    }
    16251676    return (NULL);
    … …  
    16411692 *
    16421693 * Enumerates all items in a dynamic pointer array.
    1643  *
    1644  * PARAMS
    1645  *     hdpa     [I] handle to the dynamic pointer array
    1646  *     enumProc [I]
    1647  *     lParam   [I]
    1648  *
    1649  * RETURNS
    1650  *     none
    1651  */
    1652 
    1653 VOID WINAPI
    1654 DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
    1655 {
    1656     INT i;
    1657 
    1658 //    TRACE (commctrl, "(%p %p %08lx)\n", hdpa, enumProc, lParam);
    1659 
    1660     if (!hdpa)
    1661         return;
    1662     if (hdpa->nItemCount <= 0)
    1663         return;
    1664 
    1665     for (i = 0; i < hdpa->nItemCount; i++) {
    1666         if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
    1667             return;
    1668     }
    1669 
    1670     return;
    1671 }
    1672 
    1673 
    1674 /**************************************************************************
    1675  * DPA_DestroyCallback [COMCTL32.386]
    1676  *
    1677  * Enumerates all items in a dynamic pointer array and destroys it.
    16781694 *
    16791695 * PARAMS
    … …  
    16831699 *
    16841700 * RETURNS
     1701 *     none
     1702 */
     1703
     1704
     1705VOID WINAPI
     1706DPA_EnumCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
     1707{
     1708    INT i;
     1709
     1710//    TRACE (commctrl, "(%p %p %08lx)\n", hdpa, enumProc, lParam);
     1711
     1712    if (!hdpa)
     1713        return;
     1714    if (hdpa->nItemCount <= 0)
     1715        return;
     1716
     1717    for (i = 0; i < hdpa->nItemCount; i++) {
     1718        if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
     1719            return;
     1720    }
     1721
     1722    return;
     1723}
     1724
     1725
     1726/**************************************************************************
     1727 * DPA_DestroyCallback [COMCTL32.386]
     1728 *
     1729 * Enumerates all items in a dynamic pointer array and destroys it.
     1730 *
     1731 * PARAMS
     1732 *     hdpa     [I] handle to the dynamic pointer array
     1733 *     enumProc [I]
     1734 *     lParam   [I]
     1735 *
     1736 * RETURNS
    16851737 *     Success: TRUE
    16861738 *     Failure: FALSE
    … …  
    17201772
    17211773    if (!hdsa)
    1722         return;
     1774        return;
    17231775    if (hdsa->nItemCount <= 0)
    1724         return;
     1776        return;
    17251777
    17261778    for (i = 0; i < hdsa->nItemCount; i++) {
    1727         LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
    1728         if ((enumProc)(lpItem, lParam) == 0)
    1729             return;
     1779        LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
     1780        if ((enumProc)(lpItem, lParam) == 0)
     1781            return;
    17301782    }
    17311783
    … …  
    17961848 */
    17971849LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch) {
    1798 //  return lstrrchr(lpStart, lpEnd, wMatch); 
     1850//  return lstrrchr(lpStart, lpEnd, wMatch);
    17991851}
    18001852
    … …  
    18041856 */
    18051857LPWSTR WINAPI COMCTL32_StrRChrW( LPCWSTR lpStart, LPCWSTR lpEnd, WORD wMatch) {
    1806 //  return lstrrchrw(lpStart, lpEnd, wMatch); 
     1858//  return lstrrchrw(lpStart, lpEnd, wMatch);
    18071859}
    18081860
    … …  
    18381890//    if( CRTDLL_wcschr(lpSet, *(WORD*)lpLoop))
    18391891//      return (INT)(lpLoop-lpStr);
    1840  
     1892
    18411893//  return (INT)(lpLoop-lpStr);
    18421894}
Note: See TracChangeset for help on using the changeset viewer.