git.oblomov.eu Git - wine/blob - dlls/comctl32/comctl32undoc.c

   1 /*
   2  * Undocumented functions from COMCTL32.DLL
   3  *
   4  * Copyright 1998 Eric Kohl
   5  *           1998 Juergen Schmied <j.schmied@metronet.de>
   6  *           2000 Eric Kohl for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  * NOTES
  23  *     All of these functions are UNDOCUMENTED!! And I mean UNDOCUMENTED!!!!
  24  *     Do NOT rely on names or contents of undocumented structures and types!!!
  25  *     These functions are used by EXPLORER.EXE, IEXPLORE.EXE and
  26  *     COMCTL32.DLL (internally).
  27  *
  28  */
  29 #include "config.h"
  30 #include "wine/port.h"
  31
  32 #include <stdarg.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35 #include <limits.h>
  36
  37 #define COBJMACROS
  38 #define NONAMELESSUNION
  39 #define NONAMELESSSTRUCT
  40
  41 #include "windef.h"
  42 #include "winbase.h"
  43 #include "wingdi.h"
  44 #include "winuser.h"
  45 #include "winnls.h"
  46 #include "winreg.h"
  47 #include "commctrl.h"
  48 #include "objbase.h"
  49 #include "winerror.h"
  50
  51 #include "wine/unicode.h"
  52 #include "comctl32.h"
  53
  54 #include "wine/debug.h"
  55
  56 WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
  57
  58 struct _DSA
  59 {
  60     INT  nItemCount;
  61     LPVOID pData;
  62     INT  nMaxCount;
  63     INT  nItemSize;
  64     INT  nGrow;
  65 };
  66
  67 struct _DPA
  68 {
  69     INT    nItemCount;
  70     LPVOID   *ptrs;
  71     HANDLE hHeap;
  72     INT    nGrow;
  73     INT    nMaxCount;
  74 };
  75
  76 typedef struct _STREAMDATA
  77 {
  78     DWORD dwSize;
  79     DWORD dwData2;
  80     DWORD dwItems;
  81 } STREAMDATA, *PSTREAMDATA;
  82
  83 typedef struct _LOADDATA
  84 {
  85     INT   nCount;
  86     PVOID ptr;
  87 } LOADDATA, *LPLOADDATA;
  88
  89 typedef HRESULT (CALLBACK *DPALOADPROC)(LPLOADDATA,IStream*,LPARAM);
  90
  91 static const WCHAR strMRUList[] = { 'M','R','U','L','i','s','t',0 };
  92
  93 /**************************************************************************
  94  * DPA_LoadStream [COMCTL32.9]
  95  *
  96  * Loads a dynamic pointer array from a stream
  97  *
  98  * PARAMS
  99  *     phDpa    [O] pointer to a handle to a dynamic pointer array
 100  *     loadProc [I] pointer to a callback function
 101  *     pStream  [I] pointer to a stream
 102  *     lParam   [I] application specific value
 103  *
 104  * RETURNS
 105  *     Success: TRUE
 106  *     Failure: FALSE
 107  *
 108  * NOTES
 109  *     No more information available yet!
 110  */
 111 HRESULT WINAPI DPA_LoadStream (HDPA *phDpa, DPALOADPROC loadProc,
 112                                IStream *pStream, LPARAM lParam)
 113 {
 114     HRESULT errCode;
 115     LARGE_INTEGER position;
 116     ULARGE_INTEGER newPosition;
 117     STREAMDATA  streamData;
 118     LOADDATA loadData;
 119     ULONG ulRead;
 120     HDPA hDpa;
 121     PVOID *ptr;
 122
 123     FIXME ("phDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
 124            phDpa, loadProc, pStream, lParam);
 125
 126     if (!phDpa || !loadProc || !pStream)
 127         return E_INVALIDARG;
 128
 129     *phDpa = (HDPA)NULL;
 130
 131     position.QuadPart = 0;
 132
 133     /*
 134      * Zero out our streamData
 135      */
 136     memset(&streamData,0,sizeof(STREAMDATA));
 137
 138     errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &newPosition);
 139     if (errCode != S_OK)
 140         return errCode;
 141
 142     errCode = IStream_Read (pStream, &streamData, sizeof(STREAMDATA), &ulRead);
 143     if (errCode != S_OK)
 144         return errCode;
 145
 146     FIXME ("dwSize=%lu dwData2=%lu dwItems=%lu\n",
 147            streamData.dwSize, streamData.dwData2, streamData.dwItems);
 148
 149     if ( ulRead < sizeof(STREAMDATA) ||
 150     lParam < sizeof(STREAMDATA) ||
 151         streamData.dwSize < sizeof(STREAMDATA) ||
 152         streamData.dwData2 < 1) {
 153         errCode = E_FAIL;
 154     }
 155
 156     if (streamData.dwItems > (UINT_MAX / 2 / sizeof(VOID*))) /* 536870911 */
 157         return E_OUTOFMEMORY;
 158
 159     /* create the dpa */
 160     hDpa = DPA_Create (streamData.dwItems);
 161     if (!hDpa)
 162         return E_OUTOFMEMORY;
 163
 164     if (!DPA_Grow (hDpa, streamData.dwItems))
 165         return E_OUTOFMEMORY;
 166
 167     /* load data from the stream into the dpa */
 168     ptr = hDpa->ptrs;
 169     for (loadData.nCount = 0; loadData.nCount < streamData.dwItems; loadData.nCount++) {
 170         errCode = (loadProc)(&loadData, pStream, lParam);
 171         if (errCode != S_OK) {
 172             errCode = S_FALSE;
 173             break;
 174         }
 175
 176         *ptr = loadData.ptr;
 177         ptr++;
 178     }
 179
 180     /* set the number of items */
 181     hDpa->nItemCount = loadData.nCount;
 182
 183     /* store the handle to the dpa */
 184     *phDpa = hDpa;
 185     FIXME ("new hDpa=%p, errorcode=%lx\n", hDpa, errCode);
 186
 187     return errCode;
 188 }
 189
 190
 191 /**************************************************************************
 192  * DPA_SaveStream [COMCTL32.10]
 193  *
 194  * Saves a dynamic pointer array to a stream
 195  *
 196  * PARAMS
 197  *     hDpa     [I] handle to a dynamic pointer array
 198  *     loadProc [I] pointer to a callback function
 199  *     pStream  [I] pointer to a stream
 200  *     lParam   [I] application specific value
 201  *
 202  * RETURNS
 203  *     Success: TRUE
 204  *     Failure: FALSE
 205  *
 206  * NOTES
 207  *     No more information available yet!
 208  */
 209 HRESULT WINAPI DPA_SaveStream (const HDPA hDpa, DPALOADPROC loadProc,
 210                                IStream *pStream, LPARAM lParam)
 211 {
 212
 213     FIXME ("hDpa=%p loadProc=%p pStream=%p lParam=%lx\n",
 214            hDpa, loadProc, pStream, lParam);
 215
 216     return E_FAIL;
 217 }
 218
 219
 220 /**************************************************************************
 221  * DPA_Merge [COMCTL32.11]
 222  *
 223  * Merge two dynamic pointers arrays.
 224  *
 225  * PARAMS
 226  *     hdpa1       [I] handle to a dynamic pointer array
 227  *     hdpa2       [I] handle to a dynamic pointer array
 228  *     dwFlags     [I] flags
 229  *     pfnCompare  [I] pointer to sort function
 230  *     pfnMerge    [I] pointer to merge function
 231  *     lParam      [I] application specific value
 232  *
 233  * RETURNS
 234  *     Success: TRUE
 235  *     Failure: FALSE
 236  *
 237  * NOTES
 238  *     No more information available yet!
 239  */
 240 BOOL WINAPI DPA_Merge (const HDPA hdpa1, const HDPA hdpa2, DWORD dwFlags,
 241                        PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge,
 242                        LPARAM lParam)
 243 {
 244     INT nCount;
 245     LPVOID *pWork1, *pWork2;
 246     INT nResult, i;
 247     INT nIndex;
 248
 249     TRACE("%p %p %08lx %p %p %08lx)\n",
 250            hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
 251
 252     if (IsBadWritePtr (hdpa1, sizeof(*hdpa1)))
 253         return FALSE;
 254
 255     if (IsBadWritePtr (hdpa2, sizeof(*hdpa2)))
 256         return FALSE;
 257
 258     if (IsBadCodePtr ((FARPROC)pfnCompare))
 259         return FALSE;
 260
 261     if (IsBadCodePtr ((FARPROC)pfnMerge))
 262         return FALSE;
 263
 264     if (!(dwFlags & DPAM_NOSORT)) {
 265         TRACE("sorting dpa's!\n");
 266         if (hdpa1->nItemCount > 0)
 267         DPA_Sort (hdpa1, pfnCompare, lParam);
 268         TRACE ("dpa 1 sorted!\n");
 269         if (hdpa2->nItemCount > 0)
 270         DPA_Sort (hdpa2, pfnCompare, lParam);
 271         TRACE ("dpa 2 sorted!\n");
 272     }
 273
 274     if (hdpa2->nItemCount < 1)
 275         return TRUE;
 276
 277     TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
 278            hdpa1->nItemCount, hdpa2->nItemCount);
 279
 280
 281     /* working but untrusted implementation */
 282
 283     pWork1 = &(hdpa1->ptrs[hdpa1->nItemCount - 1]);
 284     pWork2 = &(hdpa2->ptrs[hdpa2->nItemCount - 1]);
 285
 286     nIndex = hdpa1->nItemCount - 1;
 287     nCount = hdpa2->nItemCount - 1;
 288
 289     do
 290     {
 291         if (nIndex < 0) {
 292             if ((nCount >= 0) && (dwFlags & DPAM_INSERT)) {
 293                 /* Now insert the remaining new items into DPA 1 */
 294                 TRACE("%d items to be inserted at start of DPA 1\n",
 295                       nCount+1);
 296                 for (i=nCount; i>=0; i--) {
 297                     PVOID ptr;
 298
 299                     ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
 300                     if (!ptr)
 301                         return FALSE;
 302                     DPA_InsertPtr (hdpa1, 0, ptr);
 303                     pWork2--;
 304                 }
 305             }
 306             break;
 307         }
 308         nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
 309         TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
 310               nResult, nIndex, nCount);
 311
 312         if (nResult == 0)
 313         {
 314             PVOID ptr;
 315
 316             ptr = (pfnMerge)(1, *pWork1, *pWork2, lParam);
 317             if (!ptr)
 318                 return FALSE;
 319
 320             nCount--;
 321             pWork2--;
 322             *pWork1 = ptr;
 323             nIndex--;
 324             pWork1--;
 325         }
 326         else if (nResult > 0)
 327         {
 328             /* item in DPA 1 missing from DPA 2 */
 329             if (dwFlags & DPAM_DELETE)
 330             {
 331                 /* Now delete the extra item in DPA1 */
 332                 PVOID ptr;
 333
 334                 ptr = DPA_DeletePtr (hdpa1, hdpa1->nItemCount - 1);
 335
 336                 (pfnMerge)(2, ptr, NULL, lParam);
 337             }
 338             nIndex--;
 339             pWork1--;
 340         }
 341         else
 342         {
 343             /* new item in DPA 2 */
 344             if (dwFlags & DPAM_INSERT)
 345             {
 346                 /* Now insert the new item in DPA 1 */
 347                 PVOID ptr;
 348
 349                 ptr = (pfnMerge)(3, *pWork2, NULL, lParam);
 350                 if (!ptr)
 351                     return FALSE;
 352                 DPA_InsertPtr (hdpa1, nIndex+1, ptr);
 353             }
 354             nCount--;
 355             pWork2--;
 356         }
 357
 358     }
 359     while (nCount >= 0);
 360
 361     return TRUE;
 362 }
 363
 364
 365 /**************************************************************************
 366  * Alloc [COMCTL32.71]
 367  *
 368  * Allocates memory block from the dll's private heap
 369  *
 370  * PARAMS
 371  *     dwSize [I] size of the allocated memory block
 372  *
 373  * RETURNS
 374  *     Success: pointer to allocated memory block
 375  *     Failure: NULL
 376  */
 377 LPVOID WINAPI Alloc (DWORD dwSize)
 378 {
 379     return LocalAlloc( LMEM_ZEROINIT, dwSize );
 380 }
 381
 382
 383 /**************************************************************************
 384  * ReAlloc [COMCTL32.72]
 385  *
 386  * Changes the size of an allocated memory block or allocates a memory
 387  * block using the dll's private heap.
 388  *
 389  * PARAMS
 390  *     lpSrc  [I] pointer to memory block which will be resized
 391  *     dwSize [I] new size of the memory block.
 392  *
 393  * RETURNS
 394  *     Success: pointer to the resized memory block
 395  *     Failure: NULL
 396  *
 397  * NOTES
 398  *     If lpSrc is a NULL-pointer, then ReAlloc allocates a memory
 399  *     block like Alloc.
 400  */
 401 LPVOID WINAPI ReAlloc (LPVOID lpSrc, DWORD dwSize)
 402 {
 403     if (lpSrc)
 404         return LocalReAlloc( lpSrc, dwSize, LMEM_ZEROINIT );
 405     else
 406         return LocalAlloc( LMEM_ZEROINIT, dwSize);
 407 }
 408
 409
 410 /**************************************************************************
 411  * Free [COMCTL32.73]
 412  *
 413  * Frees an allocated memory block from the dll's private heap.
 414  *
 415  * PARAMS
 416  *     lpMem [I] pointer to memory block which will be freed
 417  *
 418  * RETURNS
 419  *     Success: TRUE
 420  *     Failure: FALSE
 421  */
 422 BOOL WINAPI Free (LPVOID lpMem)
 423 {
 424     return !LocalFree( lpMem );
 425 }
 426
 427
 428 /**************************************************************************
 429  * GetSize [COMCTL32.74]
 430  *
 431  * Retrieves the size of the specified memory block from the dll's
 432  * private heap.
 433  *
 434  * PARAMS
 435  *     lpMem [I] pointer to an allocated memory block
 436  *
 437  * RETURNS
 438  *     Success: size of the specified memory block
 439  *     Failure: 0
 440  */
 441 DWORD WINAPI GetSize (LPVOID lpMem)
 442 {
 443     return LocalSize( lpMem );
 444 }
 445
 446
 447 /**************************************************************************
 448  * MRU-Functions  {COMCTL32}
 449  *
 450  * NOTES
 451  * The MRU-Api is a set of functions to manipulate lists of M.R.U. (Most Recently
 452  * Used) items. It is an undocumented Api that is used (at least) by the shell
 453  * and explorer to implement their recent documents feature.
 454  *
 455  * Since these functions are undocumented, they are unsupported by MS and
 456  * may change at any time.
 457  *
 458  * Internally, the list is implemented as a last in, last out list of items
 459  * persisted into the system registry under a caller chosen key. Each list
 460  * item is given a one character identifier in the Ascii range from 'a' to
 461  * '}'. A list of the identifiers in order from newest to oldest is stored
 462  * under the same key in a value named "MRUList".
 463  *
 464  * Items are re-ordered by changing the order of the values in the MRUList
 465  * value. When a new item is added, it becomes the new value of the oldest
 466  * identifier, and that identifier is moved to the front of the MRUList value.
 467  *
 468  * Wine stores MRU-lists in the same registry format as Windows, so when
 469  * switching between the builtin and native comctl32.dll no problems or
 470  * incompatibilities should occur.
 471  *
 472  * The following undocumented structure is used to create an MRU-list:
 473  *|typedef INT (CALLBACK *MRUStringCmpFn)(LPCTSTR lhs, LPCTSTR rhs);
 474  *|typedef INT (CALLBACK *MRUBinaryCmpFn)(LPCVOID lhs, LPCVOID rhs, DWORD length);
 475  *|
 476  *|typedef struct tagCREATEMRULIST
 477  *|{
 478  *|    DWORD   cbSize;
 479  *|    DWORD   nMaxItems;
 480  *|    DWORD   dwFlags;
 481  *|    HKEY    hKey;
 482  *|    LPCTSTR lpszSubKey;
 483  *|    PROC    lpfnCompare;
 484  *|} CREATEMRULIST, *LPCREATEMRULIST;
 485  *
 486  * MEMBERS
 487  *  cbSize      [I] The size of the CREATEMRULIST structure. This must be set
 488  *                  to sizeof(CREATEMRULIST) by the caller.
 489  *  nMaxItems   [I] The maximum number of items allowed in the list. Because
 490  *                  of the limited number of identifiers, this should be set to
 491  *                  a value from 1 to 30 by the caller.
 492  *  dwFlags     [I] If bit 0 is set, the list will be used to store binary
 493  *                  data, otherwise it is assumed to store strings. If bit 1
 494  *                  is set, every change made to the list will be reflected in
 495  *                  the registry immediately, otherwise changes will only be
 496  *                  written when the list is closed.
 497  *  hKey        [I] The registry key that the list should be written under.
 498  *                  This must be supplied by the caller.
 499  *  lpszSubKey  [I] A caller supplied name of a subkey under hKey to write
 500  *                  the list to. This may not be blank.
 501  *  lpfnCompare [I] A caller supplied comparison function, which may be either
 502  *                  an MRUStringCmpFn if dwFlags does not have bit 0 set, or a
 503  *                  MRUBinaryCmpFn otherwise.
 504  *
 505  * FUNCTIONS
 506  *  - Create an MRU-list with CreateMRUList() or CreateMRUListLazy().
 507  *  - Add items to an MRU-list with AddMRUString() or AddMRUData().
 508  *  - Remove items from an MRU-list with DelMRUString().
 509  *  - Find data in an MRU-list with FindMRUString() or FindMRUData().
 510  *  - Iterate through an MRU-list with EnumMRUList().
 511  *  - Free an MRU-list with FreeMRUList().
 512  */
 513
 514 typedef struct tagCREATEMRULISTA
 515 {
 516     DWORD  cbSize;
 517     DWORD  nMaxItems;
 518     DWORD  dwFlags;
 519     HKEY   hKey;
 520     LPCSTR lpszSubKey;
 521     PROC   lpfnCompare;
 522 } CREATEMRULISTA, *LPCREATEMRULISTA;
 523
 524 typedef struct tagCREATEMRULISTW
 525 {
 526     DWORD   cbSize;
 527     DWORD   nMaxItems;
 528     DWORD   dwFlags;
 529     HKEY    hKey;
 530     LPCWSTR lpszSubKey;
 531     PROC    lpfnCompare;
 532 } CREATEMRULISTW, *LPCREATEMRULISTW;
 533
 534 /* dwFlags */
 535 #define MRUF_STRING_LIST  0 /* list will contain strings */
 536 #define MRUF_BINARY_LIST  1 /* list will contain binary data */
 537 #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
 538
 539 /* If list is a string list lpfnCompare has the following prototype
 540  * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
 541  * for binary lists the prototype is
 542  * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
 543  * where cbData is the no. of bytes to compare.
 544  * Need to check what return value means identical - 0?
 545  */
 546
 547 typedef struct tagWINEMRUITEM
 548 {
 549     DWORD          size;        /* size of data stored               */
 550     DWORD          itemFlag;    /* flags                             */
 551     BYTE           datastart;
 552 } WINEMRUITEM, *LPWINEMRUITEM;
 553
 554 /* itemFlag */
 555 #define WMRUIF_CHANGED   0x0001 /* this dataitem changed             */
 556
 557 typedef struct tagWINEMRULIST
 558 {
 559     CREATEMRULISTW extview;     /* original create information       */
 560     BOOL           isUnicode;   /* is compare fn Unicode */
 561     DWORD          wineFlags;   /* internal flags                    */
 562     DWORD          cursize;     /* current size of realMRU           */
 563     LPWSTR         realMRU;     /* pointer to string of index names  */
 564     LPWINEMRUITEM  *array;      /* array of pointers to data         */
 565                                 /* in 'a' to 'z' order               */
 566 } WINEMRULIST, *LPWINEMRULIST;
 567
 568 /* wineFlags */
 569 #define WMRUF_CHANGED  0x0001   /* MRU list has changed              */
 570
 571 /**************************************************************************
 572  *              MRU_SaveChanged (internal)
 573  *
 574  * Local MRU saving code
 575  */
 576 static void MRU_SaveChanged ( LPWINEMRULIST mp )
 577 {
 578     UINT i, err;
 579     HKEY newkey;
 580     WCHAR realname[2];
 581     LPWINEMRUITEM witem;
 582     static const WCHAR emptyW[] = {'\0'};
 583
 584     /* or should we do the following instead of RegOpenKeyEx:
 585      */
 586
 587     /* open the sub key */
 588     if ((err = RegOpenKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
 589                               0, KEY_WRITE, &newkey))) {
 590         /* not present - what to do ??? */
 591         ERR("Could not open key, error=%d, attempting to create\n",
 592             err);
 593         if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
 594                                     0,
 595                                     emptyW,
 596                                     REG_OPTION_NON_VOLATILE,
 597                                     KEY_READ | KEY_WRITE,
 598                                     0,
 599                                     &newkey,
 600                                     0))) {
 601             ERR("failed to create key /%s/, err=%d\n",
 602                 debugstr_w(mp->extview.lpszSubKey), err);
 603             return;
 604         }
 605     }
 606     if (mp->wineFlags & WMRUF_CHANGED) {
 607         mp->wineFlags &= ~WMRUF_CHANGED;
 608         err = RegSetValueExW(newkey, strMRUList, 0, REG_SZ, (LPBYTE)mp->realMRU,
 609                              (strlenW(mp->realMRU) + 1)*sizeof(WCHAR));
 610         if (err) {
 611             ERR("error saving MRUList, err=%d\n", err);
 612         }
 613         TRACE("saving MRUList=/%s/\n", debugstr_w(mp->realMRU));
 614     }
 615     realname[1] = 0;
 616     for(i=0; i<mp->cursize; i++) {
 617         witem = mp->array[i];
 618         if (witem->itemFlag & WMRUIF_CHANGED) {
 619             witem->itemFlag &= ~WMRUIF_CHANGED;
 620             realname[0] = 'a' + i;
 621             err = RegSetValueExW(newkey, realname, 0,
 622                                  (mp->extview.dwFlags & MRUF_BINARY_LIST) ?
 623                                  REG_BINARY : REG_SZ,
 624                                  &witem->datastart, witem->size);
 625             if (err) {
 626                 ERR("error saving /%s/, err=%d\n", debugstr_w(realname), err);
 627             }
 628             TRACE("saving value for name /%s/ size=%ld\n",
 629                   debugstr_w(realname), witem->size);
 630         }
 631     }
 632     RegCloseKey( newkey );
 633 }
 634
 635 /**************************************************************************
 636  *              FreeMRUList [COMCTL32.152]
 637  *
 638  * Frees a most-recently-used items list.
 639  *
 640  * PARAMS
 641  *     hMRUList [I] Handle to list.
 642  *
 643  * RETURNS
 644  *     Nothing.
 645  */
 646 void WINAPI FreeMRUList (HANDLE hMRUList)
 647 {
 648     LPWINEMRULIST mp = (LPWINEMRULIST)hMRUList;
 649     UINT i;
 650
 651     TRACE("(%p)\n", hMRUList);
 652     if (!hMRUList)
 653         return;
 654
 655     if (mp->wineFlags & WMRUF_CHANGED) {
 656         /* need to open key and then save the info */
 657         MRU_SaveChanged( mp );
 658     }
 659
 660     for(i=0; i<mp->extview.nMaxItems; i++) {
 661         if (mp->array[i])
 662             Free(mp->array[i]);
 663     }
 664     Free(mp->realMRU);
 665     Free(mp->array);
 666     Free((LPWSTR)mp->extview.lpszSubKey);
 667     Free(mp);
 668 }
 669
 670
 671 /**************************************************************************
 672  *                  FindMRUData [COMCTL32.169]
 673  *
 674  * Searches binary list for item that matches lpData of length cbData.
 675  * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
 676  * corresponding to item's reg. name will be stored in it ('a' -> 0).
 677  *
 678  * PARAMS
 679  *    hList [I] list handle
 680  *    lpData [I] data to find
 681  *    cbData [I] length of data
 682  *    lpRegNum [O] position in registry (maybe NULL)
 683  *
 684  * RETURNS
 685  *    Position in list 0 -> MRU.  -1 if item not found.
 686  */
 687 INT WINAPI FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData,
 688                         LPINT lpRegNum)
 689 {
 690     LPWINEMRULIST mp = (LPWINEMRULIST)hList;
 691     INT ret;
 692     UINT i;
 693     LPSTR dataA = NULL;
 694
 695     if (!mp->extview.lpfnCompare) {
 696         ERR("MRU list not properly created. No compare procedure.\n");
 697         return -1;
 698     }
 699
 700     if(!(mp->extview.dwFlags & MRUF_BINARY_LIST) && !mp->isUnicode) {
 701         DWORD len = WideCharToMultiByte(CP_ACP, 0, lpData, -1,
 702                                         NULL, 0, NULL, NULL);
 703         dataA = Alloc(len);
 704         WideCharToMultiByte(CP_ACP, 0, lpData, -1, dataA, len, NULL, NULL);
 705     }
 706
 707     for(i=0; i<mp->cursize; i++) {
 708         if (mp->extview.dwFlags & MRUF_BINARY_LIST) {
 709             if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart,
 710                                          cbData))
 711                 break;
 712         }
 713         else {
 714             if(mp->isUnicode) {
 715                 if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart))
 716                     break;
 717             } else {
 718                 DWORD len = WideCharToMultiByte(CP_ACP, 0,
 719                                                 (LPWSTR)&mp->array[i]->datastart, -1,
 720                                                 NULL, 0, NULL, NULL);
 721                 LPSTR itemA = Alloc(len);
 722                 INT cmp;
 723                 WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&mp->array[i]->datastart, -1,
 724                                     itemA, len, NULL, NULL);
 725
 726                 cmp = mp->extview.lpfnCompare(dataA, itemA);
 727                 Free(itemA);
 728                 if(!cmp)
 729                     break;
 730             }
 731         }
 732     }
 733     if(dataA)
 734         Free(dataA);
 735     if (i < mp->cursize)
 736         ret = i;
 737     else
 738         ret = -1;
 739     if (lpRegNum && (ret != -1))
 740         *lpRegNum = 'a' + i;
 741
 742     TRACE("(%p, %p, %ld, %p) returning %d\n",
 743            hList, lpData, cbData, lpRegNum, ret);
 744
 745     return ret;
 746 }
 747
 748
 749 /**************************************************************************
 750  *              AddMRUData [COMCTL32.167]
 751  *
 752  * Add item to MRU binary list.  If item already exists in list then it is
 753  * simply moved up to the top of the list and not added again.  If list is
 754  * full then the least recently used item is removed to make room.
 755  *
 756  * PARAMS
 757  *     hList [I] Handle to list.
 758  *     lpData [I] ptr to data to add.
 759  *     cbData [I] no. of bytes of data.
 760  *
 761  * RETURNS
 762  *     No. corresponding to registry name where value is stored 'a' -> 0 etc.
 763  *     -1 on error.
 764  */
 765 INT WINAPI AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData)
 766 {
 767     LPWINEMRULIST mp = (LPWINEMRULIST)hList;
 768     LPWINEMRUITEM witem;
 769     INT i, replace;
 770
 771     if ((replace = FindMRUData (hList, lpData, cbData, NULL)) >= 0) {
 772         /* Item exists, just move it to the front */
 773         LPWSTR pos = strchrW(mp->realMRU, replace + 'a');
 774         while (pos > mp->realMRU)
 775         {
 776             pos[0] = pos[-1];
 777             pos--;
 778         }
 779     }
 780     else {
 781         /* either add a new entry or replace oldest */
 782         if (mp->cursize < mp->extview.nMaxItems) {
 783             /* Add in a new item */
 784             replace = mp->cursize;
 785             mp->cursize++;
 786         }
 787         else {
 788             /* get the oldest entry and replace data */
 789             replace = mp->realMRU[mp->cursize - 1] - 'a';
 790             Free(mp->array[replace]);
 791         }
 792
 793         /* Allocate space for new item and move in the data */
 794         mp->array[replace] = witem = Alloc(cbData + sizeof(WINEMRUITEM));
 795         witem->itemFlag |= WMRUIF_CHANGED;
 796         witem->size = cbData;
 797         memcpy( &witem->datastart, lpData, cbData);
 798
 799         /* now rotate MRU list */
 800         for(i=mp->cursize-1; i>=1; i--)
 801             mp->realMRU[i] = mp->realMRU[i-1];
 802     }
 803
 804     /* The new item gets the front spot */
 805     mp->wineFlags |= WMRUF_CHANGED;
 806     mp->realMRU[0] = replace + 'a';
 807
 808     TRACE("(%p, %p, %ld) adding data, /%c/ now most current\n",
 809           hList, lpData, cbData, replace+'a');
 810
 811     if (!(mp->extview.dwFlags & MRUF_DELAYED_SAVE)) {
 812         /* save changed stuff right now */
 813         MRU_SaveChanged( mp );
 814     }
 815
 816     return replace;
 817 }
 818
 819 /**************************************************************************
 820  *              AddMRUStringW [COMCTL32.401]
 821  *
 822  * Add an item to an MRU string list.
 823  *
 824  * PARAMS
 825  *     hList      [I] Handle to list.
 826  *     lpszString [I] The string to add.
 827  *
 828  * RETURNS
 829  *   Success: The number corresponding to the registry name where the string
 830  *            has been stored (0 maps to 'a', 1 to 'b' and so on).
 831  *   Failure: -1, if hList is NULL or memory allocation fails. If lpszString
 832  *            is invalid, the function returns 0, and GetLastError() returns
 833  *            ERROR_INVALID_PARAMETER. The last error value is set only in
 834  *            this case.
 835  *
 836  * NOTES
 837  *  -If lpszString exists in the list already, it is moved to the top of the
 838  *   MRU list (it is not duplicated).
 839  *  -If the list is full the least recently used list entry is replaced with
 840  *   lpszString.
 841  *  -If this function returns 0 you should check the last error value to
 842  *   ensure the call really succeeded.
 843  */
 844 INT WINAPI AddMRUStringW(HANDLE hList, LPCWSTR lpszString)
 845 {
 846     TRACE("(%p,%s)\n", hList, debugstr_w(lpszString));
 847
 848     if (!hList)
 849         return -1;
 850
 851     if (!lpszString || IsBadStringPtrW(lpszString, -1))
 852     {
 853         SetLastError(ERROR_INVALID_PARAMETER);
 854         return 0;
 855     }
 856
 857     return AddMRUData(hList, lpszString,
 858                       (strlenW(lpszString) + 1) * sizeof(WCHAR));
 859 }
 860
 861 /**************************************************************************
 862  *              AddMRUStringA [COMCTL32.153]
 863  *
 864  * See AddMRUStringW.
 865  */
 866 INT WINAPI AddMRUStringA(HANDLE hList, LPCSTR lpszString)
 867 {
 868     DWORD len;
 869     LPWSTR stringW;
 870     INT ret;
 871
 872     TRACE("(%p,%s)\n", hList, debugstr_a(lpszString));
 873
 874     if (!hList)
 875         return -1;
 876
 877     if (IsBadStringPtrA(lpszString, -1))
 878     {
 879         SetLastError(ERROR_INVALID_PARAMETER);
 880         return 0;
 881     }
 882
 883     len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0) * sizeof(WCHAR);
 884     stringW = Alloc(len);
 885     if (!stringW)
 886         return -1;
 887
 888     MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len);
 889     ret = AddMRUData(hList, stringW, len);
 890     Free(stringW);
 891     return ret;
 892 }
 893
 894 /**************************************************************************
 895  *              DelMRUString [COMCTL32.156]
 896  *
 897  * Removes item from either string or binary list (despite its name)
 898  *
 899  * PARAMS
 900  *    hList [I] list handle
 901  *    nItemPos [I] item position to remove 0 -> MRU
 902  *
 903  * RETURNS
 904  *    TRUE if successful, FALSE if nItemPos is out of range.
 905  */
 906 BOOL WINAPI DelMRUString(HANDLE hList, INT nItemPos)
 907 {
 908     FIXME("(%p, %d): stub\n", hList, nItemPos);
 909     return TRUE;
 910 }
 911
 912 /**************************************************************************
 913  *                  FindMRUStringW [COMCTL32.402]
 914  *
 915  * See FindMRUStringA.
 916  */
 917 INT WINAPI FindMRUStringW (HANDLE hList, LPCWSTR lpszString, LPINT lpRegNum)
 918 {
 919   return FindMRUData(hList, lpszString,
 920                      (lstrlenW(lpszString) + 1) * sizeof(WCHAR), lpRegNum);
 921 }
 922
 923 /**************************************************************************
 924  *                  FindMRUStringA [COMCTL32.155]
 925  *
 926  * Searches string list for item that matches lpszString.
 927  * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
 928  * corresponding to item's reg. name will be stored in it ('a' -> 0).
 929  *
 930  * PARAMS
 931  *    hList [I] list handle
 932  *    lpszString [I] string to find
 933  *    lpRegNum [O] position in registry (maybe NULL)
 934  *
 935  * RETURNS
 936  *    Position in list 0 -> MRU.  -1 if item not found.
 937  */
 938 INT WINAPI FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum)
 939 {
 940     DWORD len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0);
 941     LPWSTR stringW = Alloc(len * sizeof(WCHAR));
 942     INT ret;
 943
 944     MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len);
 945     ret = FindMRUData(hList, stringW, len * sizeof(WCHAR), lpRegNum);
 946     Free(stringW);
 947     return ret;
 948 }
 949
 950 /*************************************************************************
 951  *                 CreateMRUListLazy_common (internal)
 952  */
 953 static HANDLE CreateMRUListLazy_common(LPWINEMRULIST mp)
 954 {
 955     UINT i, err;
 956     HKEY newkey;
 957     DWORD datasize, dwdisp;
 958     WCHAR realname[2];
 959     LPWINEMRUITEM witem;
 960     DWORD type;
 961     static const WCHAR emptyW[] = {'\0'};
 962
 963     /* get space to save indices that will turn into names
 964      * but in order of most to least recently used
 965      */
 966     mp->realMRU = Alloc((mp->extview.nMaxItems + 2) * sizeof(WCHAR));
 967
 968     /* get space to save pointers to actual data in order of
 969      * 'a' to 'z' (0 to n).
 970      */
 971     mp->array = Alloc(mp->extview.nMaxItems * sizeof(LPVOID));
 972
 973     /* open the sub key */
 974     if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
 975                                 0,
 976                                 emptyW,
 977                                 REG_OPTION_NON_VOLATILE,
 978                                 KEY_READ | KEY_WRITE,
 979                                 0,
 980                                 &newkey,
 981                                 &dwdisp))) {
 982         /* error - what to do ??? */
 983         ERR("(%lu %lu %lx %lx \"%s\" %p): Could not open key, error=%d\n",
 984             mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
 985             (DWORD)mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
 986                                  mp->extview.lpfnCompare, err);
 987         return 0;
 988     }
 989
 990     /* get values from key 'MRUList' */
 991     if (newkey) {
 992         datasize = mp->extview.nMaxItems + 1;
 993         if((err=RegQueryValueExW( newkey, strMRUList, 0, &type,
 994                                   (LPBYTE)mp->realMRU, &datasize))) {
 995             /* not present - set size to 1 (will become 0 later) */
 996             datasize = 1;
 997             *mp->realMRU = 0;
 998         }
 999
1000         TRACE("MRU list = %s, datasize = %ld\n", debugstr_w(mp->realMRU), datasize);
1001
1002         mp->cursize = datasize - 1;
1003         /* datasize now has number of items in the MRUList */
1004
1005         /* get actual values for each entry */
1006         realname[1] = 0;
1007         for(i=0; i<mp->cursize; i++) {
1008             realname[0] = 'a' + i;
1009             if(RegQueryValueExW( newkey, realname, 0, &type, 0, &datasize)) {
1010                 /* not present - what to do ??? */
1011                 ERR("Key %s not found 1\n", debugstr_w(realname));
1012             }
1013             mp->array[i] = witem = Alloc(datasize + sizeof(WINEMRUITEM));
1014             witem->size = datasize;
1015             if(RegQueryValueExW( newkey, realname, 0, &type,
1016                                  &witem->datastart, &datasize)) {
1017                 /* not present - what to do ??? */
1018                 ERR("Key %s not found 2\n", debugstr_w(realname));
1019             }
1020         }
1021         RegCloseKey( newkey );
1022     }
1023     else
1024         mp->cursize = 0;
1025
1026     TRACE("(%lu %lu %lx %lx \"%s\" %p): Current Size = %ld\n",
1027           mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
1028           (DWORD)mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
1029           mp->extview.lpfnCompare, mp->cursize);
1030     return (HANDLE)mp;
1031 }
1032
1033 /**************************************************************************
1034  *                  CreateMRUListLazyW [COMCTL32.404]
1035  *
1036  * See CreateMRUListLazyA.
1037  */
1038 HANDLE WINAPI CreateMRUListLazyW (LPCREATEMRULISTW lpcml, DWORD dwParam2,
1039                                   DWORD dwParam3, DWORD dwParam4)
1040 {
1041     LPWINEMRULIST mp;
1042
1043     /* Native does not check for a NULL lpcml */
1044
1045     if (lpcml->cbSize != sizeof(CREATEMRULISTW) || !lpcml->hKey ||
1046         IsBadStringPtrW(lpcml->lpszSubKey, -1))
1047         return NULL;
1048
1049     mp = Alloc(sizeof(WINEMRULIST));
1050     memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
1051     mp->extview.lpszSubKey = Alloc((strlenW(lpcml->lpszSubKey) + 1) * sizeof(WCHAR));
1052     strcpyW((LPWSTR)mp->extview.lpszSubKey, lpcml->lpszSubKey);
1053     mp->isUnicode = TRUE;
1054
1055     return CreateMRUListLazy_common(mp);
1056 }
1057
1058 /**************************************************************************
1059  *                  CreateMRUListLazyA [COMCTL32.157]
1060  *
1061  * Creates a most-recently-used list.
1062  *
1063  * PARAMS
1064  *     lpcml    [I] ptr to CREATEMRULIST structure.
1065  *     dwParam2 [I] Unknown
1066  *     dwParam3 [I] Unknown
1067  *     dwParam4 [I] Unknown
1068  *
1069  * RETURNS
1070  *     Handle to MRU list.
1071  */
1072 HANDLE WINAPI CreateMRUListLazyA (LPCREATEMRULISTA lpcml, DWORD dwParam2,
1073                                   DWORD dwParam3, DWORD dwParam4)
1074 {
1075     LPWINEMRULIST mp;
1076     DWORD len;
1077
1078     /* Native does not check for a NULL lpcml */
1079
1080     if (lpcml->cbSize != sizeof(CREATEMRULISTA) || !lpcml->hKey ||
1081         IsBadStringPtrA(lpcml->lpszSubKey, -1))
1082         return 0;
1083
1084     mp = Alloc(sizeof(WINEMRULIST));
1085     memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
1086     len = MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1, NULL, 0);
1087     mp->extview.lpszSubKey = Alloc(len * sizeof(WCHAR));
1088     MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1,
1089                         (LPWSTR)mp->extview.lpszSubKey, len);
1090     mp->isUnicode = FALSE;
1091     return CreateMRUListLazy_common(mp);
1092 }
1093
1094 /**************************************************************************
1095  *              CreateMRUListW [COMCTL32.400]
1096  *
1097  * See CreateMRUListA.
1098  */
1099 HANDLE WINAPI CreateMRUListW (LPCREATEMRULISTW lpcml)
1100 {
1101     return CreateMRUListLazyW(lpcml, 0, 0, 0);
1102 }
1103
1104 /**************************************************************************
1105  *              CreateMRUListA [COMCTL32.151]
1106  *
1107  * Creates a most-recently-used list.
1108  *
1109  * PARAMS
1110  *     lpcml [I] ptr to CREATEMRULIST structure.
1111  *
1112  * RETURNS
1113  *     Handle to MRU list.
1114  */
1115 HANDLE WINAPI CreateMRUListA (LPCREATEMRULISTA lpcml)
1116 {
1117      return CreateMRUListLazyA (lpcml, 0, 0, 0);
1118 }
1119
1120
1121 /**************************************************************************
1122  *                EnumMRUListW [COMCTL32.403]
1123  *
1124  * Enumerate item in a most-recenty-used list
1125  *
1126  * PARAMS
1127  *    hList [I] list handle
1128  *    nItemPos [I] item position to enumerate
1129  *    lpBuffer [O] buffer to receive item
1130  *    nBufferSize [I] size of buffer
1131  *
1132  * RETURNS
1133  *    For binary lists specifies how many bytes were copied to buffer, for
1134  *    string lists specifies full length of string.  Enumerating past the end
1135  *    of list returns -1.
1136  *    If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
1137  *    the list.
1138  */
1139 INT WINAPI EnumMRUListW (HANDLE hList, INT nItemPos, LPVOID lpBuffer,
1140                          DWORD nBufferSize)
1141 {
1142     LPWINEMRULIST mp = (LPWINEMRULIST) hList;
1143     LPWINEMRUITEM witem;
1144     INT desired, datasize;
1145
1146     if (nItemPos >= mp->cursize) return -1;
1147     if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
1148     desired = mp->realMRU[nItemPos];
1149     desired -= 'a';
1150     TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
1151     witem = mp->array[desired];
1152     datasize = min( witem->size, nBufferSize );
1153     memcpy( lpBuffer, &witem->datastart, datasize);
1154     TRACE("(%p, %d, %p, %ld): returning len=%d\n",
1155           hList, nItemPos, lpBuffer, nBufferSize, datasize);
1156     return datasize;
1157 }
1158
1159 /**************************************************************************
1160  *                EnumMRUListA [COMCTL32.154]
1161  *
1162  * See EnumMRUListW.
1163  */
1164 INT WINAPI EnumMRUListA (HANDLE hList, INT nItemPos, LPVOID lpBuffer,
1165                          DWORD nBufferSize)
1166 {
1167     LPWINEMRULIST mp = (LPWINEMRULIST) hList;
1168     LPWINEMRUITEM witem;
1169     INT desired, datasize;
1170     DWORD lenA;
1171
1172     if (nItemPos >= mp->cursize) return -1;
1173     if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
1174     desired = mp->realMRU[nItemPos];
1175     desired -= 'a';
1176     TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
1177     witem = mp->array[desired];
1178     if(mp->extview.dwFlags & MRUF_BINARY_LIST) {
1179         datasize = min( witem->size, nBufferSize );
1180         memcpy( lpBuffer, &witem->datastart, datasize);
1181     } else {
1182         lenA = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
1183                                    NULL, 0, NULL, NULL);
1184         datasize = min( witem->size, nBufferSize );
1185         WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
1186                             lpBuffer, datasize, NULL, NULL);
1187     }
1188     TRACE("(%p, %d, %p, %ld): returning len=%d\n",
1189           hList, nItemPos, lpBuffer, nBufferSize, datasize);
1190     return datasize;
1191 }
1192
1193
1194 /**************************************************************************
1195  * Str_GetPtrA [COMCTL32.233]
1196  *
1197  * Copies a string into a destination buffer.
1198  *
1199  * PARAMS
1200  *     lpSrc   [I] Source string
1201  *     lpDest  [O] Destination buffer
1202  *     nMaxLen [I] Size of buffer in characters
1203  *
1204  * RETURNS
1205  *     The number of characters copied.
1206  */
1207 INT WINAPI Str_GetPtrA (LPCSTR lpSrc, LPSTR lpDest, INT nMaxLen)
1208 {
1209     INT len;
1210
1211     TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
1212
1213     if (!lpDest && lpSrc)
1214         return strlen (lpSrc);
1215
1216     if (nMaxLen == 0)
1217         return 0;
1218
1219     if (lpSrc == NULL) {
1220         lpDest[0] = '\0';
1221         return 0;
1222     }
1223
1224     len = strlen (lpSrc);
1225     if (len >= nMaxLen)
1226         len = nMaxLen - 1;
1227
1228     RtlMoveMemory (lpDest, lpSrc, len);
1229     lpDest[len] = '\0';
1230
1231     return len;
1232 }
1233
1234
1235 /**************************************************************************
1236  * Str_SetPtrA [COMCTL32.234]
1237  *
1238  * Makes a copy of a string, allocating memory if necessary.
1239  *
1240  * PARAMS
1241  *     lppDest [O] Pointer to destination string
1242  *     lpSrc   [I] Source string
1243  *
1244  * RETURNS
1245  *     Success: TRUE
1246  *     Failure: FALSE
1247  *
1248  * NOTES
1249  *     Set lpSrc to NULL to free the memory allocated by a previous call
1250  *     to this function.
1251  */
1252 BOOL WINAPI Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc)
1253 {
1254     TRACE("(%p %p)\n", lppDest, lpSrc);
1255
1256     if (lpSrc) {
1257         LPSTR ptr = ReAlloc (*lppDest, strlen (lpSrc) + 1);
1258         if (!ptr)
1259             return FALSE;
1260         strcpy (ptr, lpSrc);
1261         *lppDest = ptr;
1262     }
1263     else {
1264         if (*lppDest) {
1265             Free (*lppDest);
1266             *lppDest = NULL;
1267         }
1268     }
1269
1270     return TRUE;
1271 }
1272
1273
1274 /**************************************************************************
1275  * Str_GetPtrW [COMCTL32.235]
1276  *
1277  * See Str_GetPtrA.
1278  */
1279 INT WINAPI Str_GetPtrW (LPCWSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
1280 {
1281     INT len;
1282
1283     TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
1284
1285     if (!lpDest && lpSrc)
1286         return strlenW (lpSrc);
1287
1288     if (nMaxLen == 0)
1289         return 0;
1290
1291     if (lpSrc == NULL) {
1292         lpDest[0] = L'\0';
1293         return 0;
1294     }
1295
1296     len = strlenW (lpSrc);
1297     if (len >= nMaxLen)
1298         len = nMaxLen - 1;
1299
1300     RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
1301     lpDest[len] = L'\0';
1302
1303     return len;
1304 }
1305
1306
1307 /**************************************************************************
1308  * Str_SetPtrW [COMCTL32.236]
1309  *
1310  * See Str_SetPtrA.
1311  */
1312 BOOL WINAPI Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc)
1313 {
1314     TRACE("(%p %p)\n", lppDest, lpSrc);
1315
1316     if (lpSrc) {
1317         INT len = strlenW (lpSrc) + 1;
1318         LPWSTR ptr = ReAlloc (*lppDest, len * sizeof(WCHAR));
1319         if (!ptr)
1320             return FALSE;
1321         strcpyW (ptr, lpSrc);
1322         *lppDest = ptr;
1323     }
1324     else {
1325         if (*lppDest) {
1326             Free (*lppDest);
1327             *lppDest = NULL;
1328         }
1329     }
1330
1331     return TRUE;
1332 }
1333
1334
1335 /**************************************************************************
1336  * Str_GetPtrWtoA [internal]
1337  *
1338  * Converts a unicode string into a multi byte string
1339  *
1340  * PARAMS
1341  *     lpSrc   [I] Pointer to the unicode source string
1342  *     lpDest  [O] Pointer to caller supplied storage for the multi byte string
1343  *     nMaxLen [I] Size, in bytes, of the destination buffer
1344  *
1345  * RETURNS
1346  *     Length, in bytes, of the converted string.
1347  */
1348
1349 INT Str_GetPtrWtoA (LPCWSTR lpSrc, LPSTR lpDest, INT nMaxLen)
1350 {
1351     INT len;
1352
1353     TRACE("(%s %p %d)\n", debugstr_w(lpSrc), lpDest, nMaxLen);
1354
1355     if (!lpDest && lpSrc)
1356         return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
1357
1358     if (nMaxLen == 0)
1359         return 0;
1360
1361     if (lpSrc == NULL) {
1362         lpDest[0] = '\0';
1363         return 0;
1364     }
1365
1366     len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
1367     if (len >= nMaxLen)
1368         len = nMaxLen - 1;
1369
1370     WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
1371     lpDest[len] = '\0';
1372
1373     return len;
1374 }
1375
1376
1377 /**************************************************************************
1378  * Str_SetPtrAtoW [internal]
1379  *
1380  * Converts a multi byte string to a unicode string.
1381  * If the pointer to the destination buffer is NULL a buffer is allocated.
1382  * If the destination buffer is too small to keep the converted multi byte
1383  * string the destination buffer is reallocated. If the source pointer is
1384  * NULL, the destination buffer is freed.
1385  *
1386  * PARAMS
1387  *     lppDest [I/O] pointer to a pointer to the destination buffer
1388  *     lpSrc   [I] pointer to a multi byte string
1389  *
1390  * RETURNS
1391  *     TRUE: conversion successful
1392  *     FALSE: error
1393  */
1394 BOOL Str_SetPtrAtoW (LPWSTR *lppDest, LPCSTR lpSrc)
1395 {
1396     TRACE("(%p %s)\n", lppDest, lpSrc);
1397
1398     if (lpSrc) {
1399         INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
1400         LPWSTR ptr = ReAlloc (*lppDest, len*sizeof(WCHAR));
1401
1402         if (!ptr)
1403             return FALSE;
1404         MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
1405         *lppDest = ptr;
1406     }
1407     else {
1408         if (*lppDest) {
1409             Free (*lppDest);
1410             *lppDest = NULL;
1411         }
1412     }
1413
1414     return TRUE;
1415 }
1416
1417
1418 /**************************************************************************
1419  * DSA_Create [COMCTL32.320]
1420  *
1421  * Creates a dynamic storage array
1422  *
1423  * PARAMS
1424  *     nSize [I] size of the array elements
1425  *     nGrow [I] number of elements by which the array grows when it is filled
1426  *
1427  * RETURNS
1428  *     Success: pointer to an array control structure. Use this like a handle.
1429  *     Failure: NULL
1430  *
1431  * NOTES
1432  *     The DSA_ functions can be used to create and manipulate arrays of
1433  *     fixed-size memory blocks. These arrays can store any kind of data
1434  *     (e.g. strings and icons).
1435  */
1436 HDSA WINAPI DSA_Create (INT nSize, INT nGrow)
1437 {
1438     HDSA hdsa;
1439
1440     TRACE("(size=%d grow=%d)\n", nSize, nGrow);
1441
1442     hdsa = Alloc (sizeof(*hdsa));
1443     if (hdsa)
1444     {
1445         hdsa->nItemCount = 0;
1446         hdsa->pData = NULL;
1447         hdsa->nMaxCount = 0;
1448         hdsa->nItemSize = nSize;
1449         hdsa->nGrow = max(1, nGrow);
1450     }
1451
1452     return hdsa;
1453 }
1454
1455
1456 /**************************************************************************
1457  * DSA_Destroy [COMCTL32.321]
1458  *
1459  * Destroys a dynamic storage array
1460  *
1461  * PARAMS
1462  *     hdsa [I] pointer to the array control structure
1463  *
1464  * RETURNS
1465  *     Success: TRUE
1466  *     Failure: FALSE
1467  */
1468 BOOL WINAPI DSA_Destroy (const HDSA hdsa)
1469 {
1470     TRACE("(%p)\n", hdsa);
1471
1472     if (!hdsa)
1473         return FALSE;
1474
1475     if (hdsa->pData && (!Free (hdsa->pData)))
1476         return FALSE;
1477
1478     return Free (hdsa);
1479 }
1480
1481
1482 /**************************************************************************
1483  * DSA_GetItem [COMCTL32.322]
1484  *
1485  * Copies the specified item into a caller-supplied buffer.
1486  *
1487  * PARAMS
1488  *     hdsa   [I] pointer to the array control structure
1489  *     nIndex [I] number of the Item to get
1490  *     pDest  [O] destination buffer. Has to be >= dwElementSize.
1491  *
1492  * RETURNS
1493  *     Success: TRUE
1494  *     Failure: FALSE
1495  */
1496 BOOL WINAPI DSA_GetItem (const HDSA hdsa, INT nIndex, LPVOID pDest)
1497 {
1498     LPVOID pSrc;
1499
1500     TRACE("(%p %d %p)\n", hdsa, nIndex, pDest);
1501
1502     if (!hdsa)
1503         return FALSE;
1504     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
1505         return FALSE;
1506
1507     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1508     memmove (pDest, pSrc, hdsa->nItemSize);
1509
1510     return TRUE;
1511 }
1512
1513
1514 /**************************************************************************
1515  * DSA_GetItemPtr [COMCTL32.323]
1516  *
1517  * Retrieves a pointer to the specified item.
1518  *
1519  * PARAMS
1520  *     hdsa   [I] pointer to the array control structure
1521  *     nIndex [I] index of the desired item
1522  *
1523  * RETURNS
1524  *     Success: pointer to an item
1525  *     Failure: NULL
1526  */
1527 LPVOID WINAPI DSA_GetItemPtr (const HDSA hdsa, INT nIndex)
1528 {
1529     LPVOID pSrc;
1530
1531     TRACE("(%p %d)\n", hdsa, nIndex);
1532
1533     if (!hdsa)
1534         return NULL;
1535     if ((nIndex < 0) || (nIndex >= hdsa->nItemCount))
1536         return NULL;
1537
1538     pSrc = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1539
1540     TRACE("-- ret=%p\n", pSrc);
1541
1542     return pSrc;
1543 }
1544
1545
1546 /**************************************************************************
1547  * DSA_SetItem [COMCTL32.325]
1548  *
1549  * Sets the contents of an item in the array.
1550  *
1551  * PARAMS
1552  *     hdsa   [I] pointer to the array control structure
1553  *     nIndex [I] index for the item
1554  *     pSrc   [I] pointer to the new item data
1555  *
1556  * RETURNS
1557  *     Success: TRUE
1558  *     Failure: FALSE
1559  */
1560 BOOL WINAPI DSA_SetItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
1561 {
1562     INT  nSize, nNewItems;
1563     LPVOID pDest, lpTemp;
1564
1565     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
1566
1567     if ((!hdsa) || nIndex < 0)
1568         return FALSE;
1569
1570     if (hdsa->nItemCount <= nIndex) {
1571         /* within the old array */
1572         if (hdsa->nMaxCount > nIndex) {
1573             /* within the allocated space, set a new boundary */
1574             hdsa->nItemCount = nIndex + 1;
1575         }
1576         else {
1577             /* resize the block of memory */
1578             nNewItems =
1579                 hdsa->nGrow * ((INT)(((nIndex + 1) - 1) / hdsa->nGrow) + 1);
1580             nSize = hdsa->nItemSize * nNewItems;
1581
1582             lpTemp = ReAlloc (hdsa->pData, nSize);
1583             if (!lpTemp)
1584                 return FALSE;
1585
1586             hdsa->nMaxCount = nNewItems;
1587             hdsa->nItemCount = nIndex + 1;
1588             hdsa->pData = lpTemp;
1589         }
1590     }
1591
1592     /* put the new entry in */
1593     pDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1594     TRACE("-- move dest=%p src=%p size=%d\n",
1595            pDest, pSrc, hdsa->nItemSize);
1596     memmove (pDest, pSrc, hdsa->nItemSize);
1597
1598     return TRUE;
1599 }
1600
1601
1602 /**************************************************************************
1603  * DSA_InsertItem [COMCTL32.324]
1604  *
1605  * Inserts an item into the array at the specified index.
1606  *
1607  * PARAMS
1608  *     hdsa   [I] pointer to the array control structure
1609  *     nIndex [I] index for the new item
1610  *     pSrc   [I] pointer to the element
1611  *
1612  * RETURNS
1613  *     Success: position of the new item
1614  *     Failure: -1
1615  */
1616 INT WINAPI DSA_InsertItem (const HDSA hdsa, INT nIndex, LPVOID pSrc)
1617 {
1618     INT   nNewItems, nSize;
1619     LPVOID  lpTemp, lpDest;
1620
1621     TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
1622
1623     if ((!hdsa) || nIndex < 0)
1624         return -1;
1625
1626     /* when nIndex >= nItemCount then append */
1627     if (nIndex >= hdsa->nItemCount)
1628         nIndex = hdsa->nItemCount;
1629
1630     /* do we need to resize ? */
1631     if (hdsa->nItemCount >= hdsa->nMaxCount) {
1632         nNewItems = hdsa->nMaxCount + hdsa->nGrow;
1633         nSize = hdsa->nItemSize * nNewItems;
1634
1635         lpTemp = ReAlloc (hdsa->pData, nSize);
1636         if (!lpTemp)
1637             return -1;
1638
1639         hdsa->nMaxCount = nNewItems;
1640         hdsa->pData = lpTemp;
1641     }
1642
1643     /* do we need to move elements ? */
1644     if (nIndex < hdsa->nItemCount) {
1645         lpTemp = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1646         lpDest = (char *) lpTemp + hdsa->nItemSize;
1647         nSize = (hdsa->nItemCount - nIndex) * hdsa->nItemSize;
1648         TRACE("-- move dest=%p src=%p size=%d\n",
1649                lpDest, lpTemp, nSize);
1650         memmove (lpDest, lpTemp, nSize);
1651     }
1652
1653     /* ok, we can put the new Item in */
1654     hdsa->nItemCount++;
1655     lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1656     TRACE("-- move dest=%p src=%p size=%d\n",
1657            lpDest, pSrc, hdsa->nItemSize);
1658     memmove (lpDest, pSrc, hdsa->nItemSize);
1659
1660     return nIndex;
1661 }
1662
1663
1664 /**************************************************************************
1665  * DSA_DeleteItem [COMCTL32.326]
1666  *
1667  * Deletes the specified item from the array.
1668  *
1669  * PARAMS
1670  *     hdsa   [I] pointer to the array control structure
1671  *     nIndex [I] index for the element to delete
1672  *
1673  * RETURNS
1674  *     Success: number of the deleted element
1675  *     Failure: -1
1676  */
1677 INT WINAPI DSA_DeleteItem (const HDSA hdsa, INT nIndex)
1678 {
1679     LPVOID lpDest,lpSrc;
1680     INT  nSize;
1681
1682     TRACE("(%p %d)\n", hdsa, nIndex);
1683
1684     if (!hdsa)
1685         return -1;
1686     if (nIndex < 0 || nIndex >= hdsa->nItemCount)
1687         return -1;
1688
1689     /* do we need to move ? */
1690     if (nIndex < hdsa->nItemCount - 1) {
1691         lpDest = (char *) hdsa->pData + (hdsa->nItemSize * nIndex);
1692         lpSrc = (char *) lpDest + hdsa->nItemSize;
1693         nSize = hdsa->nItemSize * (hdsa->nItemCount - nIndex - 1);
1694         TRACE("-- move dest=%p src=%p size=%d\n",
1695                lpDest, lpSrc, nSize);
1696         memmove (lpDest, lpSrc, nSize);
1697     }
1698
1699     hdsa->nItemCount--;
1700
1701     /* free memory ? */
1702     if ((hdsa->nMaxCount - hdsa->nItemCount) >= hdsa->nGrow) {
1703         nSize = hdsa->nItemSize * hdsa->nItemCount;
1704
1705         lpDest = ReAlloc (hdsa->pData, nSize);
1706         if (!lpDest)
1707             return -1;
1708
1709         hdsa->nMaxCount = hdsa->nItemCount;
1710         hdsa->pData = lpDest;
1711     }
1712
1713     return nIndex;
1714 }
1715
1716
1717 /**************************************************************************
1718  * DSA_DeleteAllItems [COMCTL32.327]
1719  *
1720  * Removes all items and reinitializes the array.
1721  *
1722  * PARAMS
1723  *     hdsa [I] pointer to the array control structure
1724  *
1725  * RETURNS
1726  *     Success: TRUE
1727  *     Failure: FALSE
1728  */
1729 BOOL WINAPI DSA_DeleteAllItems (const HDSA hdsa)
1730 {
1731     TRACE("(%p)\n", hdsa);
1732
1733     if (!hdsa)
1734         return FALSE;
1735     if (hdsa->pData && (!Free (hdsa->pData)))
1736         return FALSE;
1737
1738     hdsa->nItemCount = 0;
1739     hdsa->pData = NULL;
1740     hdsa->nMaxCount = 0;
1741
1742     return TRUE;
1743 }
1744
1745
1746 /**************************************************************************
1747  * DPA_Destroy [COMCTL32.329]
1748  *
1749  * Destroys a dynamic pointer array
1750  *
1751  * PARAMS
1752  *     hdpa [I] handle (pointer) to the pointer array
1753  *
1754  * RETURNS
1755  *     Success: TRUE
1756  *     Failure: FALSE
1757  */
1758 BOOL WINAPI DPA_Destroy (const HDPA hdpa)
1759 {
1760     TRACE("(%p)\n", hdpa);
1761
1762     if (!hdpa)
1763         return FALSE;
1764
1765     if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
1766         return FALSE;
1767
1768     return HeapFree (hdpa->hHeap, 0, hdpa);
1769 }
1770
1771
1772 /**************************************************************************
1773  * DPA_Grow [COMCTL32.330]
1774  *
1775  * Sets the growth amount.
1776  *
1777  * PARAMS
1778  *     hdpa  [I] handle (pointer) to the existing (source) pointer array
1779  *     nGrow [I] number of items by which the array grows when it's too small
1780  *
1781  * RETURNS
1782  *     Success: TRUE
1783  *     Failure: FALSE
1784  */
1785 BOOL WINAPI DPA_Grow (const HDPA hdpa, INT nGrow)
1786 {
1787     TRACE("(%p %d)\n", hdpa, nGrow);
1788
1789     if (!hdpa)
1790         return FALSE;
1791
1792     hdpa->nGrow = max(8, nGrow);
1793
1794     return TRUE;
1795 }
1796
1797
1798 /**************************************************************************
1799  * DPA_Clone [COMCTL32.331]
1800  *
1801  * Copies a pointer array to an other one or creates a copy
1802  *
1803  * PARAMS
1804  *     hdpa    [I] handle (pointer) to the existing (source) pointer array
1805  *     hdpaNew [O] handle (pointer) to the destination pointer array
1806  *
1807  * RETURNS
1808  *     Success: pointer to the destination pointer array.
1809  *     Failure: NULL
1810  *
1811  * NOTES
1812  *     - If the 'hdpaNew' is a NULL-Pointer, a copy of the source pointer
1813  *       array will be created and it's handle (pointer) is returned.
1814  *     - If 'hdpa' is a NULL-Pointer, the original implementation crashes,
1815  *       this implementation just returns NULL.
1816  */
1817 HDPA WINAPI DPA_Clone (const HDPA hdpa, const HDPA hdpaNew)
1818 {
1819     INT nNewItems, nSize;
1820     HDPA hdpaTemp;
1821
1822     if (!hdpa)
1823         return NULL;
1824
1825     TRACE("(%p %p)\n", hdpa, hdpaNew);
1826
1827     if (!hdpaNew) {
1828         /* create a new DPA */
1829         hdpaTemp = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
1830                                     sizeof(*hdpaTemp));
1831         hdpaTemp->hHeap = hdpa->hHeap;
1832         hdpaTemp->nGrow = hdpa->nGrow;
1833     }
1834     else
1835         hdpaTemp = hdpaNew;
1836
1837     if (hdpaTemp->ptrs) {
1838         /* remove old pointer array */
1839         HeapFree (hdpaTemp->hHeap, 0, hdpaTemp->ptrs);
1840         hdpaTemp->ptrs = NULL;
1841         hdpaTemp->nItemCount = 0;
1842         hdpaTemp->nMaxCount = 0;
1843     }
1844
1845     /* create a new pointer array */
1846     nNewItems = hdpaTemp->nGrow *
1847                 ((INT)((hdpa->nItemCount - 1) / hdpaTemp->nGrow) + 1);
1848     nSize = nNewItems * sizeof(LPVOID);
1849     hdpaTemp->ptrs = HeapAlloc (hdpaTemp->hHeap, HEAP_ZERO_MEMORY, nSize);
1850     hdpaTemp->nMaxCount = nNewItems;
1851
1852     /* clone the pointer array */
1853     hdpaTemp->nItemCount = hdpa->nItemCount;
1854     memmove (hdpaTemp->ptrs, hdpa->ptrs,
1855              hdpaTemp->nItemCount * sizeof(LPVOID));
1856
1857     return hdpaTemp;
1858 }
1859
1860
1861 /**************************************************************************
1862  * DPA_GetPtr [COMCTL32.332]
1863  *
1864  * Retrieves a pointer from a dynamic pointer array
1865  *
1866  * PARAMS
1867  *     hdpa   [I] handle (pointer) to the pointer array
1868  *     nIndex [I] array index of the desired pointer
1869  *
1870  * RETURNS
1871  *     Success: pointer
1872  *     Failure: NULL
1873  */
1874 LPVOID WINAPI DPA_GetPtr (const HDPA hdpa, INT nIndex)
1875 {
1876     TRACE("(%p %d)\n", hdpa, nIndex);
1877
1878     if (!hdpa)
1879         return NULL;
1880     if (!hdpa->ptrs) {
1881         WARN("no pointer array.\n");
1882         return NULL;
1883     }
1884     if ((nIndex < 0) || (nIndex >= hdpa->nItemCount)) {
1885         WARN("not enough pointers in array (%d vs %d).\n",nIndex,hdpa->nItemCount);
1886         return NULL;
1887     }
1888
1889     TRACE("-- %p\n", hdpa->ptrs[nIndex]);
1890
1891     return hdpa->ptrs[nIndex];
1892 }
1893
1894
1895 /**************************************************************************
1896  * DPA_GetPtrIndex [COMCTL32.333]
1897  *
1898  * Retrieves the index of the specified pointer
1899  *
1900  * PARAMS
1901  *     hdpa   [I] handle (pointer) to the pointer array
1902  *     p      [I] pointer
1903  *
1904  * RETURNS
1905  *     Success: index of the specified pointer
1906  *     Failure: -1
1907  */
1908 INT WINAPI DPA_GetPtrIndex (const HDPA hdpa, LPVOID p)
1909 {
1910     INT i;
1911
1912     if (!hdpa || !hdpa->ptrs)
1913         return -1;
1914
1915     for (i = 0; i < hdpa->nItemCount; i++) {
1916         if (hdpa->ptrs[i] == p)
1917             return i;
1918     }
1919
1920     return -1;
1921 }
1922
1923
1924 /**************************************************************************
1925  * DPA_InsertPtr [COMCTL32.334]
1926  *
1927  * Inserts a pointer into a dynamic pointer array
1928  *
1929  * PARAMS
1930  *     hdpa [I] handle (pointer) to the array
1931  *     i    [I] array index
1932  *     p    [I] pointer to insert
1933  *
1934  * RETURNS
1935  *     Success: index of the inserted pointer
1936  *     Failure: -1
1937  */
1938 INT WINAPI DPA_InsertPtr (const HDPA hdpa, INT i, LPVOID p)
1939 {
1940     TRACE("(%p %d %p)\n", hdpa, i, p);
1941
1942     if (!hdpa || i < 0) return -1;
1943
1944     if (i >= 0x7fff)
1945         i = hdpa->nItemCount;
1946
1947     if (i >= hdpa->nItemCount)
1948         return DPA_SetPtr(hdpa, i, p) ? i : -1;
1949
1950     /* create empty spot at the end */
1951     if (!DPA_SetPtr(hdpa, hdpa->nItemCount, 0)) return -1;
1952     memmove (hdpa->ptrs + i + 1, hdpa->ptrs + i, (hdpa->nItemCount - i - 1) * sizeof(LPVOID));
1953     hdpa->ptrs[i] = p;
1954     return i;
1955 }
1956
1957 /**************************************************************************
1958  * DPA_SetPtr [COMCTL32.335]
1959  *
1960  * Sets a pointer in the pointer array
1961  *
1962  * PARAMS
1963  *     hdpa [I] handle (pointer) to the pointer array
1964  *     i    [I] index of the pointer that will be set
1965  *     p    [I] pointer to be set
1966  *
1967  * RETURNS
1968  *     Success: TRUE
1969  *     Failure: FALSE
1970  */
1971 BOOL WINAPI DPA_SetPtr (const HDPA hdpa, INT i, LPVOID p)
1972 {
1973     LPVOID *lpTemp;
1974
1975     TRACE("(%p %d %p)\n", hdpa, i, p);
1976
1977     if (!hdpa || i < 0 || i > 0x7fff)
1978         return FALSE;
1979
1980     if (hdpa->nItemCount <= i) {
1981         /* within the old array */
1982         if (hdpa->nMaxCount <= i) {
1983             /* resize the block of memory */
1984             INT nNewItems =
1985                 hdpa->nGrow * ((INT)(((i+1) - 1) / hdpa->nGrow) + 1);
1986             INT nSize = nNewItems * sizeof(LPVOID);
1987
1988             if (hdpa->ptrs)
1989                 lpTemp = HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, hdpa->ptrs, nSize);
1990             else
1991                 lpTemp = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, nSize);
1992
1993             if (!lpTemp)
1994                 return FALSE;
1995
1996             hdpa->nMaxCount = nNewItems;
1997             hdpa->ptrs = lpTemp;
1998         }
1999         hdpa->nItemCount = i+1;
2000     }
2001
2002     /* put the new entry in */
2003     hdpa->ptrs[i] = p;
2004
2005     return TRUE;
2006 }
2007
2008
2009 /**************************************************************************
2010  * DPA_DeletePtr [COMCTL32.336]
2011  *
2012  * Removes a pointer from the pointer array.
2013  *
2014  * PARAMS
2015  *     hdpa [I] handle (pointer) to the pointer array
2016  *     i    [I] index of the pointer that will be deleted
2017  *
2018  * RETURNS
2019  *     Success: deleted pointer
2020  *     Failure: NULL
2021  */
2022 LPVOID WINAPI DPA_DeletePtr (const HDPA hdpa, INT i)
2023 {
2024     LPVOID *lpDest, *lpSrc, lpTemp = NULL;
2025     INT  nSize;
2026
2027     TRACE("(%p %d)\n", hdpa, i);
2028
2029     if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
2030         return NULL;
2031
2032     lpTemp = hdpa->ptrs[i];
2033
2034     /* do we need to move ?*/
2035     if (i < hdpa->nItemCount - 1) {
2036         lpDest = hdpa->ptrs + i;
2037         lpSrc = lpDest + 1;
2038         nSize = (hdpa->nItemCount - i - 1) * sizeof(LPVOID);
2039         TRACE("-- move dest=%p src=%p size=%x\n",
2040                lpDest, lpSrc, nSize);
2041         memmove (lpDest, lpSrc, nSize);
2042     }
2043
2044     hdpa->nItemCount --;
2045
2046     /* free memory ?*/
2047     if ((hdpa->nMaxCount - hdpa->nItemCount) >= hdpa->nGrow) {
2048         INT nNewItems = max(hdpa->nGrow * 2, hdpa->nItemCount);
2049         nSize = nNewItems * sizeof(LPVOID);
2050         lpDest = HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
2051                                       hdpa->ptrs, nSize);
2052         if (!lpDest)
2053             return NULL;
2054
2055         hdpa->nMaxCount = nNewItems;
2056         hdpa->ptrs = (LPVOID*)lpDest;
2057     }
2058
2059     return lpTemp;
2060 }
2061
2062
2063 /**************************************************************************
2064  * DPA_DeleteAllPtrs [COMCTL32.337]
2065  *
2066  * Removes all pointers and reinitializes the array.
2067  *
2068  * PARAMS
2069  *     hdpa [I] handle (pointer) to the pointer array
2070  *
2071  * RETURNS
2072  *     Success: TRUE
2073  *     Failure: FALSE
2074  */
2075 BOOL WINAPI DPA_DeleteAllPtrs (const HDPA hdpa)
2076 {
2077     TRACE("(%p)\n", hdpa);
2078
2079     if (!hdpa)
2080         return FALSE;
2081
2082     if (hdpa->ptrs && (!HeapFree (hdpa->hHeap, 0, hdpa->ptrs)))
2083         return FALSE;
2084
2085     hdpa->nItemCount = 0;
2086     hdpa->nMaxCount = hdpa->nGrow * 2;
2087     hdpa->ptrs = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
2088                                      hdpa->nMaxCount * sizeof(LPVOID));
2089
2090     return TRUE;
2091 }
2092
2093
2094 /**************************************************************************
2095  * DPA_QuickSort [Internal]
2096  *
2097  * Ordinary quicksort (used by DPA_Sort).
2098  *
2099  * PARAMS
2100  *     lpPtrs     [I] pointer to the pointer array
2101  *     l          [I] index of the "left border" of the partition
2102  *     r          [I] index of the "right border" of the partition
2103  *     pfnCompare [I] pointer to the compare function
2104  *     lParam     [I] user defined value (3rd parameter in compare function)
2105  *
2106  * RETURNS
2107  *     NONE
2108  */
2109 static VOID DPA_QuickSort (LPVOID *lpPtrs, INT l, INT r,
2110                            PFNDPACOMPARE pfnCompare, LPARAM lParam)
2111 {
2112     INT m;
2113     LPVOID t;
2114
2115     TRACE("l=%i r=%i\n", l, r);
2116
2117     if (l==r)    /* one element is always sorted */
2118         return;
2119     if (r<l)     /* oops, got it in the wrong order */
2120         {
2121         DPA_QuickSort(lpPtrs, r, l, pfnCompare, lParam);
2122         return;
2123         }
2124     m = (l+r)/2; /* divide by two */
2125     DPA_QuickSort(lpPtrs, l, m, pfnCompare, lParam);
2126     DPA_QuickSort(lpPtrs, m+1, r, pfnCompare, lParam);
2127
2128     /* join the two sides */
2129     while( (l<=m) && (m<r) )
2130     {
2131         if(pfnCompare(lpPtrs[l],lpPtrs[m+1],lParam)>0)
2132         {
2133             t = lpPtrs[m+1];
2134             memmove(&lpPtrs[l+1],&lpPtrs[l],(m-l+1)*sizeof(lpPtrs[l]));
2135             lpPtrs[l] = t;
2136
2137             m++;
2138         }
2139         l++;
2140     }
2141 }
2142
2143
2144 /**************************************************************************
2145  * DPA_Sort [COMCTL32.338]
2146  *
2147  * Sorts a pointer array using a user defined compare function
2148  *
2149  * PARAMS
2150  *     hdpa       [I] handle (pointer) to the pointer array
2151  *     pfnCompare [I] pointer to the compare function
2152  *     lParam     [I] user defined value (3rd parameter of compare function)
2153  *
2154  * RETURNS
2155  *     Success: TRUE
2156  *     Failure: FALSE
2157  */
2158 BOOL WINAPI DPA_Sort (const HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam)
2159 {
2160     if (!hdpa || !pfnCompare)
2161         return FALSE;
2162
2163     TRACE("(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
2164
2165     if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
2166         DPA_QuickSort (hdpa->ptrs, 0, hdpa->nItemCount - 1,
2167                        pfnCompare, lParam);
2168
2169     return TRUE;
2170 }
2171
2172
2173 /**************************************************************************
2174  * DPA_Search [COMCTL32.339]
2175  *
2176  * Searches a pointer array for a specified pointer
2177  *
2178  * PARAMS
2179  *     hdpa       [I] handle (pointer) to the pointer array
2180  *     pFind      [I] pointer to search for
2181  *     nStart     [I] start index
2182  *     pfnCompare [I] pointer to the compare function
2183  *     lParam     [I] user defined value (3rd parameter of compare function)
2184  *     uOptions   [I] search options
2185  *
2186  * RETURNS
2187  *     Success: index of the pointer in the array.
2188  *     Failure: -1
2189  *
2190  * NOTES
2191  *     Binary search taken from R.Sedgewick "Algorithms in C"!
2192  *     Function is NOT tested!
2193  *     If something goes wrong, blame HIM not ME! (Eric Kohl)
2194  */
2195 INT WINAPI DPA_Search (const HDPA hdpa, LPVOID pFind, INT nStart,
2196                        PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
2197 {
2198     if (!hdpa || !pfnCompare || !pFind)
2199         return -1;
2200
2201     TRACE("(%p %p %d %p 0x%08lx 0x%08x)\n",
2202            hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
2203
2204     if (uOptions & DPAS_SORTED) {
2205         /* array is sorted --> use binary search */
2206         INT l, r, x, n;
2207         LPVOID *lpPtr;
2208
2209         TRACE("binary search\n");
2210
2211         l = (nStart == -1) ? 0 : nStart;
2212         r = hdpa->nItemCount - 1;
2213         lpPtr = hdpa->ptrs;
2214         while (r >= l) {
2215             x = (l + r) / 2;
2216             n = (pfnCompare)(pFind, lpPtr[x], lParam);
2217             if (n < 0)
2218                 r = x - 1;
2219             else
2220                 l = x + 1;
2221             if (n == 0) {
2222                 TRACE("-- ret=%d\n", n);
2223                 return n;
2224             }
2225         }
2226
2227         if (uOptions & DPAS_INSERTBEFORE) {
2228             if (r == -1) r = 0;
2229             TRACE("-- ret=%d\n", r);
2230             return r;
2231         }
2232
2233         if (uOptions & DPAS_INSERTAFTER) {
2234             TRACE("-- ret=%d\n", l);
2235             return l;
2236         }
2237     }
2238     else {
2239         /* array is not sorted --> use linear search */
2240         LPVOID *lpPtr;
2241         INT  nIndex;
2242
2243         TRACE("linear search\n");
2244
2245         nIndex = (nStart == -1)? 0 : nStart;
2246         lpPtr = hdpa->ptrs;
2247         for (; nIndex < hdpa->nItemCount; nIndex++) {
2248             if ((pfnCompare)(pFind, lpPtr[nIndex], lParam) == 0) {
2249                 TRACE("-- ret=%d\n", nIndex);
2250                 return nIndex;
2251             }
2252         }
2253     }
2254
2255     TRACE("-- not found: ret=-1\n");
2256     return -1;
2257 }
2258
2259
2260 /**************************************************************************
2261  * DPA_CreateEx [COMCTL32.340]
2262  *
2263  * Creates a dynamic pointer array using the specified size and heap.
2264  *
2265  * PARAMS
2266  *     nGrow [I] number of items by which the array grows when it is filled
2267  *     hHeap [I] handle to the heap where the array is stored
2268  *
2269  * RETURNS
2270  *     Success: handle (pointer) to the pointer array.
2271  *     Failure: NULL
2272  *
2273  * NOTES
2274  *     The DPA_ functions can be used to create and manipulate arrays of
2275  *     pointers.
2276  */
2277 HDPA WINAPI DPA_CreateEx (INT nGrow, HANDLE hHeap)
2278 {
2279     HDPA hdpa;
2280
2281     TRACE("(%d %p)\n", nGrow, hHeap);
2282
2283     if (hHeap)
2284         hdpa = HeapAlloc (hHeap, HEAP_ZERO_MEMORY, sizeof(*hdpa));
2285     else
2286         hdpa = Alloc (sizeof(*hdpa));
2287
2288     if (hdpa) {
2289         hdpa->nGrow = max(8, nGrow);
2290         hdpa->hHeap = hHeap ? hHeap : GetProcessHeap();
2291         hdpa->nMaxCount = hdpa->nGrow * 2;
2292         hdpa->ptrs = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY,
2293                                 hdpa->nMaxCount * sizeof(LPVOID));
2294     }
2295
2296     TRACE("-- %p\n", hdpa);
2297
2298     return hdpa;
2299 }
2300
2301
2302 /**************************************************************************
2303  * DPA_Create [COMCTL32.328]
2304  *
2305  * Creates a dynamic pointer array.
2306  *
2307  * PARAMS
2308  *     nGrow [I] number of items by which the array grows when it is filled
2309  *
2310  * RETURNS
2311  *     Success: handle (pointer) to the pointer array.
2312  *     Failure: NULL
2313  *
2314  * NOTES
2315  *     The DPA_ functions can be used to create and manipulate arrays of
2316  *     pointers.
2317  */
2318 HDPA WINAPI DPA_Create (INT nGrow)
2319 {
2320     return DPA_CreateEx( nGrow, 0 );
2321 }
2322
2323
2324 /**************************************************************************
2325  * Notification functions
2326  */
2327
2328 typedef struct tagNOTIFYDATA
2329 {
2330     HWND hwndFrom;
2331     HWND hwndTo;
2332     DWORD  dwParam3;
2333     DWORD  dwParam4;
2334     DWORD  dwParam5;
2335     DWORD  dwParam6;
2336 } NOTIFYDATA, *LPNOTIFYDATA;
2337
2338
2339 /**************************************************************************
2340  * DoNotify [Internal]
2341  */
2342
2343 static LRESULT DoNotify (LPNOTIFYDATA lpNotify, UINT uCode, LPNMHDR lpHdr)
2344 {
2345     NMHDR nmhdr;
2346     LPNMHDR lpNmh = NULL;
2347     UINT idFrom = 0;
2348
2349     TRACE("(%p %p %d %p 0x%08lx)\n",
2350            lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
2351            lpNotify->dwParam5);
2352
2353     if (!lpNotify->hwndTo)
2354         return 0;
2355
2356     if (lpNotify->hwndFrom == (HWND)-1) {
2357         lpNmh = lpHdr;
2358         idFrom = lpHdr->idFrom;
2359     }
2360     else {
2361         if (lpNotify->hwndFrom)
2362             idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
2363
2364         lpNmh = (lpHdr) ? lpHdr : &nmhdr;
2365
2366         lpNmh->hwndFrom = lpNotify->hwndFrom;
2367         lpNmh->idFrom = idFrom;
2368         lpNmh->code = uCode;
2369     }
2370
2371     return SendMessageW (lpNotify->hwndTo, WM_NOTIFY, idFrom, (LPARAM)lpNmh);
2372 }
2373
2374
2375 /**************************************************************************
2376  * SendNotify [COMCTL32.341]
2377  *
2378  * Sends a WM_NOTIFY message to the specified window.
2379  *
2380  * PARAMS
2381  *     hwndTo   [I] Window to receive the message
2382  *     hwndFrom [I] Window that the message is from (see notes)
2383  *     uCode    [I] Notification code
2384  *     lpHdr    [I] The NMHDR and any additional information to send or NULL
2385  *
2386  * RETURNS
2387  *     Success: return value from notification
2388  *     Failure: 0
2389  *
2390  * NOTES
2391  *     If hwndFrom is -1 then the identifier of the control sending the
2392  *     message is taken from the NMHDR structure.
2393  *     If hwndFrom is not -1 then lpHdr can be NULL.
2394  */
2395 LRESULT WINAPI SendNotify (HWND hwndTo, HWND hwndFrom, UINT uCode, LPNMHDR lpHdr)
2396 {
2397     NOTIFYDATA notify;
2398
2399     TRACE("(%p %p %d %p)\n",
2400            hwndTo, hwndFrom, uCode, lpHdr);
2401
2402     notify.hwndFrom = hwndFrom;
2403     notify.hwndTo   = hwndTo;
2404     notify.dwParam5 = 0;
2405     notify.dwParam6 = 0;
2406
2407     return DoNotify (&notify, uCode, lpHdr);
2408 }
2409
2410
2411 /**************************************************************************
2412  * SendNotifyEx [COMCTL32.342]
2413  *
2414  * Sends a WM_NOTIFY message to the specified window.
2415  *
2416  * PARAMS
2417  *     hwndFrom [I] Window to receive the message
2418  *     hwndTo   [I] Window that the message is from
2419  *     uCode    [I] Notification code
2420  *     lpHdr    [I] The NMHDR and any additional information to send or NULL
2421  *     dwParam5 [I] Unknown
2422  *
2423  * RETURNS
2424  *     Success: return value from notification
2425  *     Failure: 0
2426  *
2427  * NOTES
2428  *     If hwndFrom is -1 then the identifier of the control sending the
2429  *     message is taken from the NMHDR structure.
2430  *     If hwndFrom is not -1 then lpHdr can be NULL.
2431  */
2432 LRESULT WINAPI SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
2433                              LPNMHDR lpHdr, DWORD dwParam5)
2434 {
2435     NOTIFYDATA notify;
2436     HWND hwndNotify;
2437
2438     TRACE("(%p %p %d %p 0x%08lx)\n",
2439            hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
2440
2441     hwndNotify = hwndTo;
2442     if (!hwndTo) {
2443         if (IsWindow (hwndFrom)) {
2444             hwndNotify = GetParent (hwndFrom);
2445             if (!hwndNotify)
2446                 return 0;
2447         }
2448     }
2449
2450     notify.hwndFrom = hwndFrom;
2451     notify.hwndTo   = hwndNotify;
2452     notify.dwParam5 = dwParam5;
2453     notify.dwParam6 = 0;
2454
2455     return DoNotify (&notify, uCode, lpHdr);
2456 }
2457
2458
2459
2460
2461 /**************************************************************************
2462  * DPA_EnumCallback [COMCTL32.385]
2463  *
2464  * Enumerates all items in a dynamic pointer array.
2465  *
2466  * PARAMS
2467  *     hdpa     [I] handle to the dynamic pointer array
2468  *     enumProc [I]
2469  *     lParam   [I]
2470  *
2471  * RETURNS
2472  *     none
2473  */
2474 VOID WINAPI DPA_EnumCallback (HDPA hdpa, PFNDPAENUMCALLBACK enumProc,
2475                               LPVOID lParam)
2476 {
2477     INT i;
2478
2479     TRACE("(%p %p %p)\n", hdpa, enumProc, lParam);
2480
2481     if (!hdpa)
2482         return;
2483     if (hdpa->nItemCount <= 0)
2484         return;
2485
2486     for (i = 0; i < hdpa->nItemCount; i++) {
2487         if ((enumProc)(hdpa->ptrs[i], lParam) == 0)
2488             return;
2489     }
2490
2491     return;
2492 }
2493
2494
2495 /**************************************************************************
2496  * DPA_DestroyCallback [COMCTL32.386]
2497  *
2498  * Enumerates all items in a dynamic pointer array and destroys it.
2499  *
2500  * PARAMS
2501  *     hdpa     [I] handle to the dynamic pointer array
2502  *     enumProc [I]
2503  *     lParam   [I]
2504  *
2505  * RETURNS
2506  *     none
2507  */
2508 void WINAPI DPA_DestroyCallback (HDPA hdpa, PFNDPAENUMCALLBACK enumProc,
2509                                  LPVOID lParam)
2510 {
2511     TRACE("(%p %p %p)\n", hdpa, enumProc, lParam);
2512
2513     DPA_EnumCallback (hdpa, enumProc, lParam);
2514     DPA_Destroy (hdpa);
2515 }
2516
2517
2518 /**************************************************************************
2519  * DSA_EnumCallback [COMCTL32.387]
2520  *
2521  * Enumerates all items in a dynamic storage array.
2522  *
2523  * PARAMS
2524  *     hdsa     [I] handle to the dynamic storage array
2525  *     enumProc [I]
2526  *     lParam   [I]
2527  *
2528  * RETURNS
2529  *     none
2530  */
2531 VOID WINAPI DSA_EnumCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
2532                               LPVOID lParam)
2533 {
2534     INT i;
2535
2536     TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
2537
2538     if (!hdsa)
2539         return;
2540     if (hdsa->nItemCount <= 0)
2541         return;
2542
2543     for (i = 0; i < hdsa->nItemCount; i++) {
2544         LPVOID lpItem = DSA_GetItemPtr (hdsa, i);
2545         if ((enumProc)(lpItem, lParam) == 0)
2546             return;
2547     }
2548
2549     return;
2550 }
2551
2552
2553 /**************************************************************************
2554  * DSA_DestroyCallback [COMCTL32.388]
2555  *
2556  * Enumerates all items in a dynamic storage array and destroys it.
2557  *
2558  * PARAMS
2559  *     hdsa     [I] handle to the dynamic storage array
2560  *     enumProc [I]
2561  *     lParam   [I]
2562  *
2563  * RETURNS
2564  *     none
2565  */
2566 void WINAPI DSA_DestroyCallback (HDSA hdsa, PFNDSAENUMCALLBACK enumProc,
2567                                  LPVOID lParam)
2568 {
2569     TRACE("(%p %p %p)\n", hdsa, enumProc, lParam);
2570
2571     DSA_EnumCallback (hdsa, enumProc, lParam);
2572     DSA_Destroy (hdsa);
2573 }