Ignore:
Timestamp:
May 15, 2003, 4:25:14 PM (22 years ago)
Author:
sandervl
Message:

Wine resync

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/comctl32undoc.c

    r9424 r10097  
    3434#endif
    3535
     36#include "config.h"
     37#include "wine/port.h"
     38
    3639#include <string.h>
    3740#include <stdlib.h> /* atoi */
    … …  
    3942#include <limits.h>
    4043
     44#define NONAMELESSUNION
     45#define NONAMELESSSTRUCT
    4146#include "commctrl.h"
    4247#include "objbase.h"
    … …  
    7479typedef HRESULT (CALLBACK *DPALOADPROC)(LPLOADDATA,IStream*,LPARAM);
    7580#endif
    76 
    77 INT __cdecl _wtoi(LPWSTR string);
    7881
    7982/**************************************************************************
    … …  
    283286        }
    284287        nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
    285         TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n", 
     288        TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
    286289              nResult, nIndex, nCount);
    287290
    … …  
    522525VOID MRU_SaveChanged( LPWINEMRULIST mp )
    523526{
    524     INT i, err;
     527    UINT i, err;
    525528    HKEY newkey;
    526529    WCHAR realname[2];
    … …  
    532535
    533536    /* open the sub key */
    534     if ((err = RegOpenKeyExW( mp->extview.hKey, mp->extview.lpszSubKey, 
     537    if ((err = RegOpenKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
    535538                              0, KEY_WRITE, &newkey))) {
    536539        /* not present - what to do ??? */
    … …  
    552555    if (mp->wineFlags & WMRUF_CHANGED) {
    553556        mp->wineFlags &= ~WMRUF_CHANGED;
    554         err = RegSetValueExA(newkey, "MRUList", 0, REG_SZ, 
     557        err = RegSetValueExA(newkey, "MRUList", 0, REG_SZ,
    555558                             mp->realMRU, strlen(mp->realMRU) + 1);
    556559        if (err) {
    … …  
    565568            witem->itemFlag &= ~WMRUIF_CHANGED;
    566569            realname[0] = 'a' + i;
    567             err = RegSetValueExW(newkey, realname, 0, 
    568                                  (mp->extview.dwFlags & MRUF_BINARY_LIST) ? 
     570            err = RegSetValueExW(newkey, realname, 0,
     571                                 (mp->extview.dwFlags & MRUF_BINARY_LIST) ?
    569572                                 REG_BINARY : REG_SZ,
    570573                                 &witem->datastart, witem->size);
    … …  
    590593{
    591594    LPWINEMRULIST mp = (LPWINEMRULIST)hMRUList;
    592     INT i;
     595    UINT i;
    593596
    594597    TRACE("\n");
    … …  
    611614/**************************************************************************
    612615 *                  FindMRUData [COMCTL32.169]
    613  * 
     616 *
    614617 * Searches binary list for item that matches lpData of length cbData.
    615618 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
    … …  
    629632{
    630633    LPWINEMRULIST mp = (LPWINEMRULIST)hList;
    631     INT i, ret;
     634    UINT i, ret;
    632635    LPSTR dataA = NULL;
    633636
    … …  
    646649    for(i=0; i<mp->cursize; i++) {
    647650        if (mp->extview.dwFlags & MRUF_BINARY_LIST) {
    648             if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart, 
     651            if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart,
    649652                                         cbData))
    650653                break;
    … …  
    679682        *lpRegNum = 'a' + i;
    680683
    681     TRACE("(%08x, %p, %ld, %p) returning %d\n",
     684    TRACE("(%p, %p, %ld, %p) returning %d\n",
    682685           hList, lpData, cbData, lpRegNum, ret);
    683686
    … …  
    688691/**************************************************************************
    689692 *              AddMRUData [COMCTL32.167]
    690  * 
     693 *
    691694 * Add item to MRU binary list.  If item already exists in list then it is
    692695 * simply moved up to the top of the list and not added again.  If list is
    … …  
    728731
    729732    /* Allocate space for new item and move in the data */
    730     mp->array[replace] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(cbData + 
     733    mp->array[replace] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(cbData +
    731734                                                               sizeof(WINEMRUITEM));
    732735    witem->itemFlag |= WMRUIF_CHANGED;
    … …  
    740743    }
    741744    mp->realMRU[0] = replace + 'a';
    742     TRACE("(%08x, %p, %ld) adding data, /%c/ now most current\n",
     745    TRACE("(%p, %p, %ld) adding data, /%c/ now most current\n",
    743746          hList, lpData, cbData, replace+'a');
    744747    ret = replace;
    … …  
    754757/**************************************************************************
    755758 *              AddMRUStringW [COMCTL32.401]
    756  * 
     759 *
    757760 * Add item to MRU string list.  If item already exists in list them it is
    758761 * simply moved up to the top of the list and not added again.  If list is
    … …  
    770773AddMRUStringW(HANDLE hList, LPCWSTR lpszString)
    771774{
    772     FIXME("(%08x, %s) empty stub!\n", hList, debugstr_w(lpszString));
     775    FIXME("(%p, %s) empty stub!\n", hList, debugstr_w(lpszString));
    773776
    774777    return 0;
    … …  
    781784AddMRUStringA(HANDLE hList, LPCSTR lpszString)
    782785{
    783     FIXME("(%08x, %s) empty stub!\n", hList, debugstr_a(lpszString));
     786    FIXME("(%p, %s) empty stub!\n", hList, debugstr_a(lpszString));
    784787
    785788    return 0;
    … …  
    801804DelMRUString(HANDLE hList, INT nItemPos)
    802805{
    803     FIXME("(%08x, %d): stub\n", hList, nItemPos);
     806    FIXME("(%p, %d): stub\n", hList, nItemPos);
    804807    return TRUE;
    805808}
    … …  
    817820/**************************************************************************
    818821 *                  FindMRUStringA [COMCTL32.155]
    819  * 
     822 *
    820823 * Searches string list for item that matches lpszString.
    821824 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
    … …  
    848851HANDLE CreateMRUListLazy_common(LPWINEMRULIST mp)
    849852{
    850     INT i, err;
     853    UINT i, err;
    851854    HKEY newkey;
    852855    DWORD datasize, dwdisp;
    … …  
    868871
    869872    /* open the sub key */
    870     if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey, 
     873    if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
    871874                                0,
    872875                                emptyW,
    873                                 REG_OPTION_NON_VOLATILE, 
     876                                REG_OPTION_NON_VOLATILE,
    874877                                KEY_READ | KEY_WRITE,
    875878                                0,
    … …  
    887890    if (newkey) {
    888891        datasize = mp->extview.nMaxItems + 1;
    889         if((err=RegQueryValueExA( newkey, "MRUList", 0, &type, mp->realMRU, 
     892        if((err=RegQueryValueExA( newkey, "MRUList", 0, &type, mp->realMRU,
    890893                                  &datasize))) {
    891894            /* not present - set size to 1 (will become 0 later) */
    … …  
    907910                ERR("Key %s not found 1\n", debugstr_w(realname));
    908911            }
    909             mp->array[i] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(datasize + 
     912            mp->array[i] = witem = (LPWINEMRUITEM)COMCTL32_Alloc(datasize +
    910913                                                                 sizeof(WINEMRUITEM));
    911914            witem->size = datasize;
    912             if(RegQueryValueExW( newkey, realname, 0, &type, 
     915            if(RegQueryValueExW( newkey, realname, 0, &type,
    913916                                 &witem->datastart, &datasize)) {
    914917                /* not present - what to do ??? */
    … …  
    949952    mp->isUnicode = TRUE;
    950953
    951     return CreateMRUListLazy_common(mp);   
     954    return CreateMRUListLazy_common(mp);
    952955}
    953956
    … …  
    10181021 *    of list returns -1.
    10191022 *    If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
    1020  *    the list. 
     1023 *    the list.
    10211024 */
    10221025INT WINAPI EnumMRUListW(HANDLE hList, INT nItemPos, LPVOID lpBuffer,
    … …  
    10331036    TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
    10341037    witem = mp->array[desired];
    1035     datasize = min( witem->size, nBufferSize ); 
     1038    datasize = min( witem->size, nBufferSize );
    10361039    memcpy( lpBuffer, &witem->datastart, datasize);
    1037     TRACE("(%08x, %d, %p, %ld): returning len=%d\n",
     1040    TRACE("(%p, %d, %p, %ld): returning len=%d\n",
    10381041          hList, nItemPos, lpBuffer, nBufferSize, datasize);
    10391042    return datasize;
    … …  
    10421045/**************************************************************************
    10431046 *                EnumMRUListA [COMCTL32.154]
    1044  * 
     1047 *
    10451048 */
    10461049INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer,
    … …  
    10591062    witem = mp->array[desired];
    10601063    if(mp->extview.dwFlags & MRUF_BINARY_LIST) {
    1061         datasize = min( witem->size, nBufferSize ); 
     1064        datasize = min( witem->size, nBufferSize );
    10621065        memcpy( lpBuffer, &witem->datastart, datasize);
    10631066    } else {
    … …  
    10681071                            lpBuffer, datasize, NULL, NULL);
    10691072    }
    1070     TRACE("(%08x, %d, %p, %ld): returning len=%d\n",
     1073    TRACE("(%p, %d, %p, %ld): returning len=%d\n",
    10711074          hList, nItemPos, lpBuffer, nBufferSize, datasize);
    10721075    return datasize;
    10731076}
    1074  
     1077
    10751078
    10761079/**************************************************************************
    … …  
    11281131{
    11291132    TRACE("(%p %p)\n", lppDest, lpSrc);
    1130  
     1133
    11311134    if (lpSrc) {
    11321135        LPSTR ptr = COMCTL32_ReAlloc (*lppDest, strlen (lpSrc) + 1);
    … …  
    12011204{
    12021205    TRACE("(%p %p)\n", lppDest, lpSrc);
    1203  
     1206
    12041207    if (lpSrc) {
    12051208        INT len = strlenW (lpSrc) + 1;
    … …  
    13731376
    13741377/**************************************************************************
    1375  * DSA_GetItem [COMCTL32.322] 
     1378 * DSA_GetItem [COMCTL32.322]
    13761379 *
    13771380 * PARAMS
    … …  
    13911394
    13921395    TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
    1393    
     1396
    13941397    if (!hdsa)
    13951398        return FALSE;
    … …  
    14051408
    14061409/**************************************************************************
    1407  * DSA_GetItemPtr [COMCTL32.323] 
     1410 * DSA_GetItemPtr [COMCTL32.323]
    14081411 *
    14091412 * Retrieves a pointer to the specified item.
    … …  
    14311434
    14321435    pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
    1433    
     1436
    14341437    TRACE("-- ret=%p\n", pSrc);
    14351438
    … …  
    14391442
    14401443/**************************************************************************
    1441  * DSA_SetItem [COMCTL32.325] 
     1444 * DSA_SetItem [COMCTL32.325]
    14421445 *
    14431446 * Sets the contents of an item in the array.
    … …  
    14581461    INT  nSize, nNewItems;
    14591462    LPVOID pDest, lpTemp;
    1460    
     1463
    14611464    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    14621465
    14631466    if ((!hdsa) || nIndex < 0)
    14641467        return FALSE;
    1465      
     1468
    14661469    if (hdsa->nItemCount <= nIndex) {
    14671470        /* within the old array */
    … …  
    14831486            hdsa->nItemCount = nIndex + 1;
    14841487            hdsa->pData = lpTemp;
    1485         }   
     1488        }
    14861489    }
    14871490
    … …  
    14971500
    14981501/**************************************************************************
    1499  * DSA_InsertItem [COMCTL32.324] 
     1502 * DSA_InsertItem [COMCTL32.324]
    15001503 *
    15011504 * PARAMS
    … …  
    15141517    INT   nNewItems, nSize;
    15151518    LPVOID  lpTemp, lpDest;
    1516    
     1519
    15171520    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
    15181521
    … …  
    15341537
    15351538        hdsa->nMaxCount = nNewItems;
    1536         hdsa->pData = lpTemp;         
     1539        hdsa->pData = lpTemp;
    15371540    }
    15381541
    … …  
    15591562
    15601563/**************************************************************************
    1561  * DSA_DeleteItem [COMCTL32.326] 
     1564 * DSA_DeleteItem [COMCTL32.326]
    15621565 *
    15631566 * PARAMS
    … …  
    15751578    LPVOID lpDest,lpSrc;
    15761579    INT  nSize;
    1577    
     1580
    15781581    TRACE("(%p %d)\n", hdsa, nIndex);
    15791582
    … …  
    15921595        memmove (lpDest, lpSrc, nSize);
    15931596    }
    1594    
     1597
    15951598    hdsa->nItemCount--;
    1596    
     1599
    15971600    /* free memory ? */
    15981601    if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
    … …  
    16291632    TRACE("(%p)\n", hdsa);
    16301633
    1631     if (!hdsa) 
     1634    if (!hdsa)
    16321635        return FALSE;
    16331636    if (hdsa->pData && (!COMCTL32_Free (hdsa->pData)))
    … …  
    18151818
    18161819LPVOID WINAPI
    1817 DPA_GetPtr (const HDPA hdpa, INT i)
    1818 {
    1819     TRACE("(%p %d)\n", hdpa, i);
     1820DPA_GetPtr (const HDPA hdpa, INT nIndex)
     1821{
     1822    TRACE("(%p %d)\n", hdpa, nIndex);
    18201823
    18211824    if (!hdpa)
    … …  
    18251828        return NULL;
    18261829    }
    1827     if ((i < 0) || (i >= hdpa->nItemCount)) {
    1828         WARN("not enough pointers in array (%d vs %d).\n",i,hdpa->nItemCount);
     1830    if ((nIndex < 0) || (nIndex >= hdpa->nItemCount)) {
     1831        WARN("not enough pointers in array (%d vs %d).\n",nIndex,hdpa->nItemCount);
    18291832        return NULL;
    18301833    }
    18311834
    1832     TRACE("-- %p\n", hdpa->ptrs[i]);
    1833 
    1834     return hdpa->ptrs[i];
     1835    TRACE("-- %p\n", hdpa->ptrs[nIndex]);
     1836
     1837    return hdpa->ptrs[nIndex];
    18351838}
    18361839
    … …  
    18851888DPA_InsertPtr (const HDPA hdpa, INT i, LPVOID p)
    18861889{
    1887     INT   nNewItems, nSize, nIndex = 0;
    1888     LPVOID  *lpTemp, *lpDest;
    1889 
    18901890    TRACE("(%p %d %p)\n", hdpa, i, p);
    18911891
    1892     if ((!hdpa) || (i < 0))
    1893         return -1;
    1894 
    1895     if (!hdpa->ptrs) {
    1896         hdpa->ptrs =
    1897             (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1898                                 2 * hdpa->nGrow * sizeof(LPVOID));
    1899         if (!hdpa->ptrs)
    1900             return -1;
    1901         hdpa->nMaxCount = hdpa->nGrow * 2;
    1902         nIndex = 0;
    1903     }
    1904     else {
    1905         if (hdpa->nItemCount >= hdpa->nMaxCount) {
    1906             TRACE("-- resizing\n");
    1907             nNewItems = hdpa->nMaxCount + hdpa->nGrow;
    1908             nSize = nNewItems * sizeof(LPVOID);
    1909 
    1910             lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1911                                            hdpa->ptrs, nSize);
    1912             if (!lpTemp)
    1913                 return -1;
    1914             hdpa->nMaxCount = nNewItems;
    1915             hdpa->ptrs = lpTemp;
    1916         }
    1917 
    1918         if (i >= hdpa->nItemCount) {
    1919             nIndex = hdpa->nItemCount;
    1920             TRACE("-- appending at %d\n", nIndex);
    1921         }
    1922         else {
    1923             TRACE("-- inserting at %d\n", i);
    1924             lpTemp = hdpa->ptrs + i;
    1925             lpDest = lpTemp + 1;
    1926             nSize  = (hdpa->nItemCount - i) * sizeof(LPVOID);
    1927             TRACE("-- move dest=%p src=%p size=%x\n",
    1928                    lpDest, lpTemp, nSize);
    1929             memmove (lpDest, lpTemp, nSize);
    1930             nIndex = i;
    1931         }
    1932     }
    1933 
    1934     /* insert item */
    1935     hdpa->nItemCount++;
    1936     hdpa->ptrs[nIndex] = p;
    1937 
    1938     return nIndex;
    1939 }
    1940 
     1892    if (!hdpa || i < 0) return -1;
     1893
     1894    if (i >= 0x7fff)
     1895        i = hdpa->nItemCount;
     1896
     1897    if (i >= hdpa->nItemCount)
     1898        return DPA_SetPtr(hdpa, i, p) ? i : -1;
     1899
     1900    /* create empty spot at the end */
     1901    if (!DPA_SetPtr(hdpa, hdpa->nItemCount, 0)) return -1;
     1902    memmove (hdpa->ptrs + i + 1, hdpa->ptrs + i, (hdpa->nItemCount - i - 1) * sizeof(LPVOID));
     1903    hdpa->ptrs[i] = p;
     1904    return i;
     1905}
    19411906
    19421907/**************************************************************************
    … …  
    19591924{
    19601925    LPVOID *lpTemp;
    1961    
     1926
    19621927    TRACE("(%p %d %p)\n", hdpa, i, p);
    19631928
    1964     if ((!hdpa) || i < 0)
     1929    if (!hdpa || i < 0 || i > 0x7fff)
    19651930        return FALSE;
    1966      
     1931
    19671932    if (hdpa->nItemCount <= i) {
    19681933        /* within the old array */
    1969         if (hdpa->nMaxCount > i) {
    1970             /* within the allocated space, set a new boundary */
    1971             hdpa->nItemCount = i+1;
    1972         }
    1973         else {
     1934        if (hdpa->nMaxCount <= i) {
    19741935            /* resize the block of memory */
    19751936            INT nNewItems =
    … …  
    19771938            INT nSize = nNewItems * sizeof(LPVOID);
    19781939
    1979             lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
    1980                                            hdpa->ptrs, nSize);
     1940            if (hdpa->ptrs)
     1941                lpTemp = (LPVOID*)HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, hdpa->ptrs, nSize);
     1942            else
     1943                lpTemp = (LPVOID*)HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, nSize);
     1944           
    19811945            if (!lpTemp)
    19821946                return FALSE;
    19831947
    1984             hdpa->nItemCount = nNewItems;
    1985             hdpa->ptrs = lpTemp;       
    1986         }   
     1948            hdpa->nMaxCount = nNewItems;
     1949            hdpa->ptrs = lpTemp;
     1950        }
     1951        hdpa->nItemCount = i+1;
    19871952    }
    19881953
    … …  
    20131978    LPVOID *lpDest, *lpSrc, lpTemp = NULL;
    20141979    INT  nSize;
    2015    
     1980
    20161981    TRACE("(%p %d)\n", hdpa, i);
    20171982
    … …  
    20301995        memmove (lpDest, lpSrc, nSize);
    20311996    }
    2032    
     1997
    20331998    hdpa->nItemCount --;
    2034    
     1999
    20352000    /* free memory ?*/
    20362001    if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
    … …  
    20432008
    20442009        hdpa->nMaxCount = nNewItems;
    2045         hdpa->ptrs = (LPVOID*)lpDest;         
     2010        hdpa->ptrs = (LPVOID*)lpDest;
    20462011    }
    20472012
    … …  
    20682033    TRACE("(%p)\n", hdpa);
    20692034
    2070     if (!hdpa) 
     2035    if (!hdpa)
    20712036        return FALSE;
    20722037
    … …  
    21072072
    21082073    TRACE("l=%i r=%i\n", l, r);
    2109  
     2074
    21102075    if (l==r)    /* one element is always sorted */
    21112076        return;
    … …  
    21202085
    21212086    /* join the two sides */
    2122     while( (l<=m) && (m<r) ) 
     2087    while( (l<=m) && (m<r) )
    21232088    {
    21242089        if(pfnCompare(lpPtrs[l],lpPtrs[m+1],lParam)>0)
    … …  
    22382203
    22392204        TRACE("linear search\n");
    2240        
     2205
    22412206        nIndex = (nStart == -1)? 0 : nStart;
    22422207        lpPtr = hdpa->ptrs;
    … …  
    22732238    HDPA hdpa;
    22742239
    2275     TRACE("(%d 0x%x)\n", nGrow, hHeap);
     2240    TRACE("(%d %p)\n", nGrow, hHeap);
    22762241
    22772242    if (hHeap)
    … …  
    23212286    UINT idFrom = 0;
    23222287
    2323     TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
     2288    TRACE("(%p %p %d %p 0x%08lx)\n",
    23242289           lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
    23252290           lpNotify->dwParam5);
    … …  
    23282293        return 0;
    23292294
    2330     if (lpNotify->hwndFrom == -1) {
     2295    if (lpNotify->hwndFrom == (HWND)-1) {
    23312296        lpNmh = lpHdr;
    23322297        idFrom = lpHdr->idFrom;
    … …  
    23742339    NOTIFYDATA notify;
    23752340
    2376     TRACE("(0x%04x 0x%04x %d %p)\n",
     2341    TRACE("(%p %p %d %p)\n",
    23772342           hwndTo, hwndFrom, uCode, lpHdr);
    23782343
    … …  
    24082373    HWND hwndNotify;
    24092374
    2410     TRACE("(0x%04x 0x%04x %d %p 0x%08lx)\n",
     2375    TRACE("(%p %p %d %p 0x%08lx)\n",
    24112376           hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
    24122377
    … …  
    24732438}
    24742439
    2475 
    24762440/**************************************************************************
    24772441 * StrToIntA [COMCTL32.357] Converts a string to a signed integer.
    … …  
    24852449
    24862450/**************************************************************************
     2451 * StrStrIW [COMCTL32.363]
     2452 */
     2453
     2454LPWSTR WINAPI
     2455COMCTL32_StrStrIW (LPCWSTR lpStr1, LPCWSTR lpStr2)
     2456{
     2457    INT len1, len2, i;
     2458    WCHAR  first;
     2459
     2460    if (*lpStr2 == 0)
     2461        return ((LPWSTR)lpStr1);
     2462    len1 = 0;
     2463    while (lpStr1[len1] != 0) ++len1;
     2464    len2 = 0;
     2465    while (lpStr2[len2] != 0) ++len2;
     2466    if (len2 == 0)
     2467        return ((LPWSTR)(lpStr1 + len1));
     2468    first = tolowerW (*lpStr2);
     2469    while (len1 >= len2) {
     2470        if (tolowerW (*lpStr1) == first) {
     2471            for (i = 1; i < len2; ++i)
     2472                if (tolowerW (lpStr1[i]) != tolowerW(lpStr2[i]))
     2473                    break;
     2474            if (i >= len2)
     2475                return ((LPWSTR)lpStr1);
     2476        }
     2477        ++lpStr1; --len1;
     2478    }
     2479    return (NULL);
     2480}
     2481
     2482/**************************************************************************
    24872483 * StrToIntW [COMCTL32.365] Converts a wide char string to a signed integer.
    24882484 */
    … …  
    24912487COMCTL32_StrToIntW (LPWSTR lpString)
    24922488{
    2493     return _wtoi(lpString);
     2489    return atoiW(lpString);
    24942490}
    24952491
    … …  
    25032499 *     hdpa     [I] handle to the dynamic pointer array
    25042500 *     enumProc [I]
    2505  *     lParam   [I] 
     2501 *     lParam   [I]
    25062502 *
    25072503 * RETURNS
    … …  
    26842680        if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
    26852681        lpGotIt = lpStart;
    2686     }   
     2682    }
    26872683    return (LPSTR)lpGotIt;
    26882684}
    … …  
    27382734    if( strchrW(lpSet, *(WORD*)lpLoop))
    27392735      return (INT)(lpLoop-lpStr);
    2740  
     2736
    27412737  return (INT)(lpLoop-lpStr);
    27422738}
    27432739
    27442740/**************************************************************************
    2745  * @ [COMCTL32.410]
     2741 * @ [COMCTL32.415]
    27462742 *
    27472743 * FIXME: What's this supposed to do?
    … …  
    27492745 */
    27502746
    2751 BOOL WINAPI COMCTL32_410( HWND hw, DWORD b, DWORD c, DWORD d) {
    2752 
    2753    FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
    2754 
    2755    return TRUE;
    2756 }
    2757 
    2758 /**************************************************************************
    2759  * @ [COMCTL32.411]
    2760  *
    2761  * FIXME: What's this supposed to do?
    2762  *        Parameter 1 is an HWND, you're on your own for the rest.
    2763  */
    2764 
    2765 BOOL WINAPI COMCTL32_411( HWND hw, DWORD b, DWORD c) {
    2766 
    2767    FIXME("(%x, %lx, %lx): stub!\n", hw, b, c);
    2768 
    2769    return TRUE;
    2770 }
    2771 
    2772 /**************************************************************************
    2773  * @ [COMCTL32.412]
    2774  *
    2775  * FIXME: What's this supposed to do?
    2776  *        Parameter 1 is an HWND, you're on your own for the rest.
    2777  */
    2778 
    2779 BOOL WINAPI COMCTL32_412( HWND hwnd, DWORD b, DWORD c)
    2780 {
    2781     FIXME("(%x, %lx, %lx): stub!\n", hwnd, b, c);
    2782 
    2783     if (IsWindow (hwnd) == FALSE)
    2784         return FALSE;
    2785 
    2786     if (b == 0)
    2787         return FALSE;
    2788 
    2789 
    2790     return TRUE;
    2791 }
    2792 
    2793 /**************************************************************************
    2794  * @ [COMCTL32.413]
    2795  *
    2796  * FIXME: What's this supposed to do?
    2797  *        Parameter 1 is an HWND, you're on your own for the rest.
    2798  */
    2799 
    2800 BOOL WINAPI COMCTL32_413( HWND hw, DWORD b, DWORD c, DWORD d) {
    2801 
    2802    FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
    2803 
    2804    return TRUE;
    2805 }
    2806 
    2807 
    2808 /**************************************************************************
    2809  * @ [COMCTL32.415]
    2810  *
    2811  * FIXME: What's this supposed to do?
    2812  *        Parameter 1 is an HWND, you're on your own for the rest.
    2813  */
    2814 
    28152747BOOL WINAPI COMCTL32_415( HWND hwnd, DWORD b, DWORD c, DWORD d, DWORD e)
    28162748{
    28172749
    2818    FIXME("(%x, %lx, %lx, %lx, %lx): stub!\n", hwnd, b, c, d, e);
     2750   FIXME("(%p, %lx, %lx, %lx, %lx): stub!\n", hwnd, b, c, d, e);
    28192751
    28202752   return TRUE;
Note: See TracChangeset for help on using the changeset viewer.