comctl32/tests: Avoid uninitialized variable warning in GetWidthBytes().
[wine] / 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 static const WCHAR strMRUList[] = { 'M','R','U','L','i','s','t',0 };
59
60 /**************************************************************************
61  * Alloc [COMCTL32.71]
62  *
63  * Allocates memory block from the dll's private heap
64  *
65  * PARAMS
66  *     dwSize [I] size of the allocated memory block
67  *
68  * RETURNS
69  *     Success: pointer to allocated memory block
70  *     Failure: NULL
71  */
72 LPVOID WINAPI Alloc (DWORD dwSize)
73 {
74     return LocalAlloc( LMEM_ZEROINIT, dwSize );
75 }
76
77
78 /**************************************************************************
79  * ReAlloc [COMCTL32.72]
80  *
81  * Changes the size of an allocated memory block or allocates a memory
82  * block using the dll's private heap.
83  *
84  * PARAMS
85  *     lpSrc  [I] pointer to memory block which will be resized
86  *     dwSize [I] new size of the memory block.
87  *
88  * RETURNS
89  *     Success: pointer to the resized memory block
90  *     Failure: NULL
91  *
92  * NOTES
93  *     If lpSrc is a NULL-pointer, then ReAlloc allocates a memory
94  *     block like Alloc.
95  */
96 LPVOID WINAPI ReAlloc (LPVOID lpSrc, DWORD dwSize)
97 {
98     if (lpSrc)
99         return LocalReAlloc( lpSrc, dwSize, LMEM_ZEROINIT | LMEM_MOVEABLE );
100     else
101         return LocalAlloc( LMEM_ZEROINIT, dwSize);
102 }
103
104
105 /**************************************************************************
106  * Free [COMCTL32.73]
107  *
108  * Frees an allocated memory block from the dll's private heap.
109  *
110  * PARAMS
111  *     lpMem [I] pointer to memory block which will be freed
112  *
113  * RETURNS
114  *     Success: TRUE
115  *     Failure: FALSE
116  */
117 BOOL WINAPI Free (LPVOID lpMem)
118 {
119     return !LocalFree( lpMem );
120 }
121
122
123 /**************************************************************************
124  * GetSize [COMCTL32.74]
125  *
126  * Retrieves the size of the specified memory block from the dll's
127  * private heap.
128  *
129  * PARAMS
130  *     lpMem [I] pointer to an allocated memory block
131  *
132  * RETURNS
133  *     Success: size of the specified memory block
134  *     Failure: 0
135  */
136 DWORD WINAPI GetSize (LPVOID lpMem)
137 {
138     return LocalSize( lpMem );
139 }
140
141
142 /**************************************************************************
143  * MRU-Functions  {COMCTL32}
144  *
145  * NOTES
146  * The MRU-Api is a set of functions to manipulate lists of M.R.U. (Most Recently
147  * Used) items. It is an undocumented Api that is used (at least) by the shell
148  * and explorer to implement their recent documents feature.
149  *
150  * Since these functions are undocumented, they are unsupported by MS and
151  * may change at any time.
152  *
153  * Internally, the list is implemented as a last in, last out list of items
154  * persisted into the system registry under a caller chosen key. Each list
155  * item is given a one character identifier in the Ascii range from 'a' to
156  * '}'. A list of the identifiers in order from newest to oldest is stored
157  * under the same key in a value named "MRUList".
158  *
159  * Items are re-ordered by changing the order of the values in the MRUList
160  * value. When a new item is added, it becomes the new value of the oldest
161  * identifier, and that identifier is moved to the front of the MRUList value.
162  * 
163  * Wine stores MRU-lists in the same registry format as Windows, so when
164  * switching between the builtin and native comctl32.dll no problems or
165  * incompatibilities should occur.
166  *
167  * The following undocumented structure is used to create an MRU-list:
168  *|typedef INT (CALLBACK *MRUStringCmpFn)(LPCTSTR lhs, LPCTSTR rhs);
169  *|typedef INT (CALLBACK *MRUBinaryCmpFn)(LPCVOID lhs, LPCVOID rhs, DWORD length);
170  *|
171  *|typedef struct tagCREATEMRULIST
172  *|{
173  *|    DWORD   cbSize;
174  *|    DWORD   nMaxItems;
175  *|    DWORD   dwFlags;
176  *|    HKEY    hKey;
177  *|    LPTSTR  lpszSubKey;
178  *|    PROC    lpfnCompare;
179  *|} CREATEMRULIST, *LPCREATEMRULIST;
180  *
181  * MEMBERS
182  *  cbSize      [I] The size of the CREATEMRULIST structure. This must be set
183  *                  to sizeof(CREATEMRULIST) by the caller.
184  *  nMaxItems   [I] The maximum number of items allowed in the list. Because
185  *                  of the limited number of identifiers, this should be set to
186  *                  a value from 1 to 30 by the caller.
187  *  dwFlags     [I] If bit 0 is set, the list will be used to store binary
188  *                  data, otherwise it is assumed to store strings. If bit 1
189  *                  is set, every change made to the list will be reflected in
190  *                  the registry immediately, otherwise changes will only be
191  *                  written when the list is closed.
192  *  hKey        [I] The registry key that the list should be written under.
193  *                  This must be supplied by the caller.
194  *  lpszSubKey  [I] A caller supplied name of a subkey under hKey to write
195  *                  the list to. This may not be blank.
196  *  lpfnCompare [I] A caller supplied comparison function, which may be either
197  *                  an MRUStringCmpFn if dwFlags does not have bit 0 set, or a
198  *                  MRUBinaryCmpFn otherwise.
199  *
200  * FUNCTIONS
201  *  - Create an MRU-list with CreateMRUList() or CreateMRUListLazy().
202  *  - Add items to an MRU-list with AddMRUString() or AddMRUData().
203  *  - Remove items from an MRU-list with DelMRUString().
204  *  - Find data in an MRU-list with FindMRUString() or FindMRUData().
205  *  - Iterate through an MRU-list with EnumMRUList().
206  *  - Free an MRU-list with FreeMRUList().
207  */
208
209 typedef INT (CALLBACK *MRUStringCmpFnA)(LPCSTR lhs, LPCSTR rhs);
210 typedef INT (CALLBACK *MRUStringCmpFnW)(LPCWSTR lhs, LPCWSTR rhs);
211 typedef INT (CALLBACK *MRUBinaryCmpFn)(LPCVOID lhs, LPCVOID rhs, DWORD length);
212
213 typedef struct tagCREATEMRULISTA
214 {
215     DWORD  cbSize;
216     DWORD  nMaxItems;
217     DWORD  dwFlags;
218     HKEY   hKey;
219     LPSTR  lpszSubKey;
220     union
221     {
222         MRUStringCmpFnA string_cmpfn;
223         MRUBinaryCmpFn  binary_cmpfn;
224     } u;
225 } CREATEMRULISTA, *LPCREATEMRULISTA;
226
227 typedef struct tagCREATEMRULISTW
228 {
229     DWORD   cbSize;
230     DWORD   nMaxItems;
231     DWORD   dwFlags;
232     HKEY    hKey;
233     LPWSTR  lpszSubKey;
234     union
235     {
236         MRUStringCmpFnW string_cmpfn;
237         MRUBinaryCmpFn  binary_cmpfn;
238     } u;
239 } CREATEMRULISTW, *LPCREATEMRULISTW;
240
241 /* dwFlags */
242 #define MRUF_STRING_LIST  0 /* list will contain strings */
243 #define MRUF_BINARY_LIST  1 /* list will contain binary data */
244 #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
245
246 /* If list is a string list lpfnCompare has the following prototype
247  * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
248  * for binary lists the prototype is
249  * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
250  * where cbData is the no. of bytes to compare.
251  * Need to check what return value means identical - 0?
252  */
253
254 typedef struct tagWINEMRUITEM
255 {
256     DWORD          size;        /* size of data stored               */
257     DWORD          itemFlag;    /* flags                             */
258     BYTE           datastart;
259 } WINEMRUITEM, *LPWINEMRUITEM;
260
261 /* itemFlag */
262 #define WMRUIF_CHANGED   0x0001 /* this dataitem changed             */
263
264 typedef struct tagWINEMRULIST
265 {
266     CREATEMRULISTW extview;     /* original create information       */
267     BOOL           isUnicode;   /* is compare fn Unicode */
268     DWORD          wineFlags;   /* internal flags                    */
269     DWORD          cursize;     /* current size of realMRU           */
270     LPWSTR         realMRU;     /* pointer to string of index names  */
271     LPWINEMRUITEM  *array;      /* array of pointers to data         */
272                                 /* in 'a' to 'z' order               */
273 } WINEMRULIST, *LPWINEMRULIST;
274
275 /* wineFlags */
276 #define WMRUF_CHANGED  0x0001   /* MRU list has changed              */
277
278 /**************************************************************************
279  *              MRU_SaveChanged (internal)
280  *
281  * Local MRU saving code
282  */
283 static void MRU_SaveChanged ( LPWINEMRULIST mp )
284 {
285     UINT i, err;
286     HKEY newkey;
287     WCHAR realname[2];
288     LPWINEMRUITEM witem;
289
290     /* or should we do the following instead of RegOpenKeyEx:
291      */
292
293     /* open the sub key */
294     if ((err = RegOpenKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
295                               0, KEY_WRITE, &newkey))) {
296         /* not present - what to do ??? */
297         ERR("Could not open key, error=%d, attempting to create\n",
298             err);
299         if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
300                                     0,
301                                     NULL,
302                                     REG_OPTION_NON_VOLATILE,
303                                     KEY_READ | KEY_WRITE,
304                                     0,
305                                     &newkey,
306                                     0))) {
307             ERR("failed to create key /%s/, err=%d\n",
308                 debugstr_w(mp->extview.lpszSubKey), err);
309             return;
310         }
311     }
312     if (mp->wineFlags & WMRUF_CHANGED) {
313         mp->wineFlags &= ~WMRUF_CHANGED;
314         err = RegSetValueExW(newkey, strMRUList, 0, REG_SZ, (LPBYTE)mp->realMRU,
315                              (strlenW(mp->realMRU) + 1)*sizeof(WCHAR));
316         if (err) {
317             ERR("error saving MRUList, err=%d\n", err);
318         }
319         TRACE("saving MRUList=/%s/\n", debugstr_w(mp->realMRU));
320     }
321     realname[1] = 0;
322     for(i=0; i<mp->cursize; i++) {
323         witem = mp->array[i];
324         if (witem->itemFlag & WMRUIF_CHANGED) {
325             witem->itemFlag &= ~WMRUIF_CHANGED;
326             realname[0] = 'a' + i;
327             err = RegSetValueExW(newkey, realname, 0,
328                                  (mp->extview.dwFlags & MRUF_BINARY_LIST) ?
329                                  REG_BINARY : REG_SZ,
330                                  &witem->datastart, witem->size);
331             if (err) {
332                 ERR("error saving /%s/, err=%d\n", debugstr_w(realname), err);
333             }
334             TRACE("saving value for name /%s/ size=%d\n",
335                   debugstr_w(realname), witem->size);
336         }
337     }
338     RegCloseKey( newkey );
339 }
340
341 /**************************************************************************
342  *              FreeMRUList [COMCTL32.152]
343  *
344  * Frees a most-recently-used items list.
345  *
346  * PARAMS
347  *     hMRUList [I] Handle to list.
348  *
349  * RETURNS
350  *     Nothing.
351  */
352 void WINAPI FreeMRUList (HANDLE hMRUList)
353 {
354     LPWINEMRULIST mp = hMRUList;
355     UINT i;
356
357     TRACE("(%p)\n", hMRUList);
358     if (!hMRUList)
359         return;
360
361     if (mp->wineFlags & WMRUF_CHANGED) {
362         /* need to open key and then save the info */
363         MRU_SaveChanged( mp );
364     }
365
366     for(i=0; i<mp->extview.nMaxItems; i++)
367         Free(mp->array[i]);
368
369     Free(mp->realMRU);
370     Free(mp->array);
371     Free(mp->extview.lpszSubKey);
372     Free(mp);
373 }
374
375
376 /**************************************************************************
377  *                  FindMRUData [COMCTL32.169]
378  *
379  * Searches binary list for item that matches lpData of length cbData.
380  * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
381  * corresponding to item's reg. name will be stored in it ('a' -> 0).
382  *
383  * PARAMS
384  *    hList [I] list handle
385  *    lpData [I] data to find
386  *    cbData [I] length of data
387  *    lpRegNum [O] position in registry (maybe NULL)
388  *
389  * RETURNS
390  *    Position in list 0 -> MRU.  -1 if item not found.
391  */
392 INT WINAPI FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData,
393                         LPINT lpRegNum)
394 {
395     const WINEMRULIST *mp = hList;
396     INT ret;
397     UINT i;
398     LPSTR dataA = NULL;
399
400     if (!mp || !mp->extview.u.string_cmpfn)
401         return -1;
402
403     if(!(mp->extview.dwFlags & MRUF_BINARY_LIST) && !mp->isUnicode) {
404         DWORD len = WideCharToMultiByte(CP_ACP, 0, lpData, -1,
405                                         NULL, 0, NULL, NULL);
406         dataA = Alloc(len);
407         WideCharToMultiByte(CP_ACP, 0, lpData, -1, dataA, len, NULL, NULL);
408     }
409
410     for(i=0; i<mp->cursize; i++) {
411         if (mp->extview.dwFlags & MRUF_BINARY_LIST) {
412             if (!mp->extview.u.binary_cmpfn(lpData, &mp->array[i]->datastart, cbData))
413                 break;
414         }
415         else {
416             if(mp->isUnicode) {
417                 if (!mp->extview.u.string_cmpfn(lpData, (LPWSTR)&mp->array[i]->datastart))
418                     break;
419             } else {
420                 DWORD len = WideCharToMultiByte(CP_ACP, 0,
421                                                 (LPWSTR)&mp->array[i]->datastart, -1,
422                                                 NULL, 0, NULL, NULL);
423                 LPSTR itemA = Alloc(len);
424                 INT cmp;
425                 WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&mp->array[i]->datastart, -1,
426                                     itemA, len, NULL, NULL);
427
428                 cmp = mp->extview.u.string_cmpfn((LPWSTR)dataA, (LPWSTR)itemA);
429                 Free(itemA);
430                 if(!cmp)
431                     break;
432             }
433         }
434     }
435     Free(dataA);
436     if (i < mp->cursize)
437         ret = i;
438     else
439         ret = -1;
440     if (lpRegNum && (ret != -1))
441         *lpRegNum = 'a' + i;
442
443     TRACE("(%p, %p, %d, %p) returning %d\n",
444            hList, lpData, cbData, lpRegNum, ret);
445
446     return ret;
447 }
448
449
450 /**************************************************************************
451  *              AddMRUData [COMCTL32.167]
452  *
453  * Add item to MRU binary list.  If item already exists in list then it is
454  * simply moved up to the top of the list and not added again.  If list is
455  * full then the least recently used item is removed to make room.
456  *
457  * PARAMS
458  *     hList [I] Handle to list.
459  *     lpData [I] ptr to data to add.
460  *     cbData [I] no. of bytes of data.
461  *
462  * RETURNS
463  *     No. corresponding to registry name where value is stored 'a' -> 0 etc.
464  *     -1 on error.
465  */
466 INT WINAPI AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData)
467 {
468     LPWINEMRULIST mp = hList;
469     LPWINEMRUITEM witem;
470     INT i, replace;
471
472     if ((replace = FindMRUData (hList, lpData, cbData, NULL)) >= 0) {
473         /* Item exists, just move it to the front */
474         LPWSTR pos = strchrW(mp->realMRU, replace + 'a');
475         while (pos > mp->realMRU)
476         {
477             pos[0] = pos[-1];
478             pos--;
479         }
480     }
481     else {
482         /* either add a new entry or replace oldest */
483         if (mp->cursize < mp->extview.nMaxItems) {
484             /* Add in a new item */
485             replace = mp->cursize;
486             mp->cursize++;
487         }
488         else {
489             /* get the oldest entry and replace data */
490             replace = mp->realMRU[mp->cursize - 1] - 'a';
491             Free(mp->array[replace]);
492         }
493
494         /* Allocate space for new item and move in the data */
495         mp->array[replace] = witem = Alloc(cbData + sizeof(WINEMRUITEM));
496         witem->itemFlag |= WMRUIF_CHANGED;
497         witem->size = cbData;
498         memcpy( &witem->datastart, lpData, cbData);
499
500         /* now rotate MRU list */
501         for(i=mp->cursize-1; i>=1; i--)
502             mp->realMRU[i] = mp->realMRU[i-1];
503     }
504
505     /* The new item gets the front spot */
506     mp->wineFlags |= WMRUF_CHANGED;
507     mp->realMRU[0] = replace + 'a';
508
509     TRACE("(%p, %p, %d) adding data, /%c/ now most current\n",
510           hList, lpData, cbData, replace+'a');
511
512     if (!(mp->extview.dwFlags & MRUF_DELAYED_SAVE)) {
513         /* save changed stuff right now */
514         MRU_SaveChanged( mp );
515     }
516
517     return replace;
518 }
519
520 /**************************************************************************
521  *              AddMRUStringW [COMCTL32.401]
522  *
523  * Add an item to an MRU string list.
524  *
525  * PARAMS
526  *     hList      [I] Handle to list.
527  *     lpszString [I] The string to add.
528  *
529  * RETURNS
530  *   Success: The number corresponding to the registry name where the string
531  *            has been stored (0 maps to 'a', 1 to 'b' and so on).
532  *   Failure: -1, if hList is NULL or memory allocation fails. If lpszString
533  *            is invalid, the function returns 0, and GetLastError() returns
534  *            ERROR_INVALID_PARAMETER. The last error value is set only in
535  *            this case.
536  *
537  * NOTES
538  *  -If lpszString exists in the list already, it is moved to the top of the
539  *   MRU list (it is not duplicated).
540  *  -If the list is full the least recently used list entry is replaced with
541  *   lpszString.
542  *  -If this function returns 0 you should check the last error value to
543  *   ensure the call really succeeded.
544  */
545 INT WINAPI AddMRUStringW(HANDLE hList, LPCWSTR lpszString)
546 {
547     TRACE("(%p,%s)\n", hList, debugstr_w(lpszString));
548
549     if (!hList)
550         return -1;
551
552     if (!lpszString || IsBadStringPtrW(lpszString, -1))
553     {
554         SetLastError(ERROR_INVALID_PARAMETER);
555         return 0;
556     }
557
558     return AddMRUData(hList, lpszString,
559                       (strlenW(lpszString) + 1) * sizeof(WCHAR));
560 }
561
562 /**************************************************************************
563  *              AddMRUStringA [COMCTL32.153]
564  *
565  * See AddMRUStringW.
566  */
567 INT WINAPI AddMRUStringA(HANDLE hList, LPCSTR lpszString)
568 {
569     DWORD len;
570     LPWSTR stringW;
571     INT ret;
572
573     TRACE("(%p,%s)\n", hList, debugstr_a(lpszString));
574
575     if (!hList)
576         return -1;
577
578     if (IsBadStringPtrA(lpszString, -1))
579     {
580         SetLastError(ERROR_INVALID_PARAMETER);
581         return 0;
582     }
583
584     len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0) * sizeof(WCHAR);
585     stringW = Alloc(len);
586     if (!stringW)
587         return -1;
588
589     MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len/sizeof(WCHAR));
590     ret = AddMRUData(hList, stringW, len);
591     Free(stringW);
592     return ret;
593 }
594
595 /**************************************************************************
596  *              DelMRUString [COMCTL32.156]
597  *
598  * Removes item from either string or binary list (despite its name)
599  *
600  * PARAMS
601  *    hList [I] list handle
602  *    nItemPos [I] item position to remove 0 -> MRU
603  *
604  * RETURNS
605  *    TRUE if successful, FALSE if nItemPos is out of range.
606  */
607 BOOL WINAPI DelMRUString(HANDLE hList, INT nItemPos)
608 {
609     FIXME("(%p, %d): stub\n", hList, nItemPos);
610     return TRUE;
611 }
612
613 /**************************************************************************
614  *                  FindMRUStringW [COMCTL32.402]
615  *
616  * See FindMRUStringA.
617  */
618 INT WINAPI FindMRUStringW (HANDLE hList, LPCWSTR lpszString, LPINT lpRegNum)
619 {
620   return FindMRUData(hList, lpszString,
621                      (lstrlenW(lpszString) + 1) * sizeof(WCHAR), lpRegNum);
622 }
623
624 /**************************************************************************
625  *                  FindMRUStringA [COMCTL32.155]
626  *
627  * Searches string list for item that matches lpszString.
628  * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
629  * corresponding to item's reg. name will be stored in it ('a' -> 0).
630  *
631  * PARAMS
632  *    hList [I] list handle
633  *    lpszString [I] string to find
634  *    lpRegNum [O] position in registry (maybe NULL)
635  *
636  * RETURNS
637  *    Position in list 0 -> MRU.  -1 if item not found.
638  */
639 INT WINAPI FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum)
640 {
641     DWORD len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0);
642     LPWSTR stringW = Alloc(len * sizeof(WCHAR));
643     INT ret;
644
645     MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len);
646     ret = FindMRUData(hList, stringW, len * sizeof(WCHAR), lpRegNum);
647     Free(stringW);
648     return ret;
649 }
650
651 /*************************************************************************
652  *                 CreateMRUListLazy_common (internal)
653  */
654 static HANDLE CreateMRUListLazy_common(LPWINEMRULIST mp)
655 {
656     UINT i, err;
657     HKEY newkey;
658     DWORD datasize, dwdisp;
659     WCHAR realname[2];
660     LPWINEMRUITEM witem;
661     DWORD type;
662
663     /* get space to save indices that will turn into names
664      * but in order of most to least recently used
665      */
666     mp->realMRU = Alloc((mp->extview.nMaxItems + 2) * sizeof(WCHAR));
667
668     /* get space to save pointers to actual data in order of
669      * 'a' to 'z' (0 to n).
670      */
671     mp->array = Alloc(mp->extview.nMaxItems * sizeof(LPVOID));
672
673     /* open the sub key */
674     if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
675                                 0,
676                                 NULL,
677                                 REG_OPTION_NON_VOLATILE,
678                                 KEY_READ | KEY_WRITE,
679                                 0,
680                                 &newkey,
681                                 &dwdisp))) {
682         /* error - what to do ??? */
683         ERR("(%u %u %x %p %s %p): Could not open key, error=%d\n",
684             mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
685             mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
686             mp->extview.u.string_cmpfn, err);
687         return 0;
688     }
689
690     /* get values from key 'MRUList' */
691     if (newkey) {
692         datasize = (mp->extview.nMaxItems + 1) * sizeof(WCHAR);
693         if((err=RegQueryValueExW( newkey, strMRUList, 0, &type,
694                                   (LPBYTE)mp->realMRU, &datasize))) {
695             /* not present - set size to 1 (will become 0 later) */
696             datasize = 1;
697             *mp->realMRU = 0;
698         }
699         else
700             datasize /= sizeof(WCHAR);
701
702         TRACE("MRU list = %s, datasize = %d\n", debugstr_w(mp->realMRU), datasize);
703
704         mp->cursize = datasize - 1;
705         /* datasize now has number of items in the MRUList */
706
707         /* get actual values for each entry */
708         realname[1] = 0;
709         for(i=0; i<mp->cursize; i++) {
710             realname[0] = 'a' + i;
711             if(RegQueryValueExW( newkey, realname, 0, &type, 0, &datasize)) {
712                 /* not present - what to do ??? */
713                 ERR("Key %s not found 1\n", debugstr_w(realname));
714             }
715             mp->array[i] = witem = Alloc(datasize + sizeof(WINEMRUITEM));
716             witem->size = datasize;
717             if(RegQueryValueExW( newkey, realname, 0, &type,
718                                  &witem->datastart, &datasize)) {
719                 /* not present - what to do ??? */
720                 ERR("Key %s not found 2\n", debugstr_w(realname));
721             }
722         }
723         RegCloseKey( newkey );
724     }
725     else
726         mp->cursize = 0;
727
728     TRACE("(%u %u %x %p %s %p): Current Size = %d\n",
729           mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
730           mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
731           mp->extview.u.string_cmpfn, mp->cursize);
732     return mp;
733 }
734
735 /**************************************************************************
736  *                  CreateMRUListLazyW [COMCTL32.404]
737  *
738  * See CreateMRUListLazyA.
739  */
740 HANDLE WINAPI CreateMRUListLazyW (const CREATEMRULISTW *lpcml, DWORD dwParam2,
741                                   DWORD dwParam3, DWORD dwParam4)
742 {
743     LPWINEMRULIST mp;
744
745     /* Native does not check for a NULL lpcml */
746
747     if (lpcml->cbSize != sizeof(CREATEMRULISTW) || !lpcml->hKey ||
748         IsBadStringPtrW(lpcml->lpszSubKey, -1))
749         return NULL;
750
751     mp = Alloc(sizeof(WINEMRULIST));
752     memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
753     mp->extview.lpszSubKey = Alloc((strlenW(lpcml->lpszSubKey) + 1) * sizeof(WCHAR));
754     strcpyW(mp->extview.lpszSubKey, lpcml->lpszSubKey);
755     mp->isUnicode = TRUE;
756
757     return CreateMRUListLazy_common(mp);
758 }
759
760 /**************************************************************************
761  *                  CreateMRUListLazyA [COMCTL32.157]
762  *
763  * Creates a most-recently-used list.
764  *
765  * PARAMS
766  *     lpcml    [I] ptr to CREATEMRULIST structure.
767  *     dwParam2 [I] Unknown
768  *     dwParam3 [I] Unknown
769  *     dwParam4 [I] Unknown
770  *
771  * RETURNS
772  *     Handle to MRU list.
773  */
774 HANDLE WINAPI CreateMRUListLazyA (const CREATEMRULISTA *lpcml, DWORD dwParam2,
775                                   DWORD dwParam3, DWORD dwParam4)
776 {
777     LPWINEMRULIST mp;
778     DWORD len;
779
780     /* Native does not check for a NULL lpcml */
781
782     if (lpcml->cbSize != sizeof(CREATEMRULISTA) || !lpcml->hKey ||
783         IsBadStringPtrA(lpcml->lpszSubKey, -1))
784         return 0;
785
786     mp = Alloc(sizeof(WINEMRULIST));
787     memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
788     len = MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1, NULL, 0);
789     mp->extview.lpszSubKey = Alloc(len * sizeof(WCHAR));
790     MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1,
791                         mp->extview.lpszSubKey, len);
792     mp->isUnicode = FALSE;
793     return CreateMRUListLazy_common(mp);
794 }
795
796 /**************************************************************************
797  *              CreateMRUListW [COMCTL32.400]
798  *
799  * See CreateMRUListA.
800  */
801 HANDLE WINAPI CreateMRUListW (const CREATEMRULISTW *lpcml)
802 {
803     return CreateMRUListLazyW(lpcml, 0, 0, 0);
804 }
805
806 /**************************************************************************
807  *              CreateMRUListA [COMCTL32.151]
808  *
809  * Creates a most-recently-used list.
810  *
811  * PARAMS
812  *     lpcml [I] ptr to CREATEMRULIST structure.
813  *
814  * RETURNS
815  *     Handle to MRU list.
816  */
817 HANDLE WINAPI CreateMRUListA (const CREATEMRULISTA *lpcml)
818 {
819      return CreateMRUListLazyA (lpcml, 0, 0, 0);
820 }
821
822
823 /**************************************************************************
824  *                EnumMRUListW [COMCTL32.403]
825  *
826  * Enumerate item in a most-recently-used list
827  *
828  * PARAMS
829  *    hList [I] list handle
830  *    nItemPos [I] item position to enumerate
831  *    lpBuffer [O] buffer to receive item
832  *    nBufferSize [I] size of buffer
833  *
834  * RETURNS
835  *    For binary lists specifies how many bytes were copied to buffer, for
836  *    string lists specifies full length of string.  Enumerating past the end
837  *    of list returns -1.
838  *    If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
839  *    the list.
840  */
841 INT WINAPI EnumMRUListW (HANDLE hList, INT nItemPos, LPVOID lpBuffer,
842                          DWORD nBufferSize)
843 {
844     const WINEMRULIST *mp = hList;
845     const WINEMRUITEM *witem;
846     INT desired, datasize;
847
848     if (!mp) return -1;
849     if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
850     if (nItemPos >= mp->cursize) return -1;
851     desired = mp->realMRU[nItemPos];
852     desired -= 'a';
853     TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
854     witem = mp->array[desired];
855     datasize = min( witem->size, nBufferSize );
856     memcpy( lpBuffer, &witem->datastart, datasize);
857     TRACE("(%p, %d, %p, %d): returning len=%d\n",
858           hList, nItemPos, lpBuffer, nBufferSize, datasize);
859     return datasize;
860 }
861
862 /**************************************************************************
863  *                EnumMRUListA [COMCTL32.154]
864  *
865  * See EnumMRUListW.
866  */
867 INT WINAPI EnumMRUListA (HANDLE hList, INT nItemPos, LPVOID lpBuffer,
868                          DWORD nBufferSize)
869 {
870     const WINEMRULIST *mp = hList;
871     LPWINEMRUITEM witem;
872     INT desired, datasize;
873     DWORD lenA;
874
875     if (!mp) return -1;
876     if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
877     if (nItemPos >= mp->cursize) return -1;
878     desired = mp->realMRU[nItemPos];
879     desired -= 'a';
880     TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
881     witem = mp->array[desired];
882     if(mp->extview.dwFlags & MRUF_BINARY_LIST) {
883         datasize = min( witem->size, nBufferSize );
884         memcpy( lpBuffer, &witem->datastart, datasize);
885     } else {
886         lenA = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
887                                    NULL, 0, NULL, NULL);
888         datasize = min( lenA, nBufferSize );
889         WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
890                             lpBuffer, datasize, NULL, NULL);
891         ((char *)lpBuffer)[ datasize - 1 ] = '\0';
892         datasize = lenA - 1;
893     }
894     TRACE("(%p, %d, %p, %d): returning len=%d\n",
895           hList, nItemPos, lpBuffer, nBufferSize, datasize);
896     return datasize;
897 }
898
899 /**************************************************************************
900  * Str_GetPtrWtoA [internal]
901  *
902  * Converts a unicode string into a multi byte string
903  *
904  * PARAMS
905  *     lpSrc   [I] Pointer to the unicode source string
906  *     lpDest  [O] Pointer to caller supplied storage for the multi byte string
907  *     nMaxLen [I] Size, in bytes, of the destination buffer
908  *
909  * RETURNS
910  *     Length, in bytes, of the converted string.
911  */
912
913 INT Str_GetPtrWtoA (LPCWSTR lpSrc, LPSTR lpDest, INT nMaxLen)
914 {
915     INT len;
916
917     TRACE("(%s %p %d)\n", debugstr_w(lpSrc), lpDest, nMaxLen);
918
919     if (!lpDest && lpSrc)
920         return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
921
922     if (nMaxLen == 0)
923         return 0;
924
925     if (lpSrc == NULL) {
926         lpDest[0] = '\0';
927         return 0;
928     }
929
930     len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
931     if (len >= nMaxLen)
932         len = nMaxLen - 1;
933
934     WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
935     lpDest[len] = '\0';
936
937     return len;
938 }
939
940 /**************************************************************************
941  * Str_GetPtrAtoW [internal]
942  *
943  * Converts a multibyte string into a unicode string
944  *
945  * PARAMS
946  *     lpSrc   [I] Pointer to the multibyte source string
947  *     lpDest  [O] Pointer to caller supplied storage for the unicode string
948  *     nMaxLen [I] Size, in characters, of the destination buffer
949  *
950  * RETURNS
951  *     Length, in characters, of the converted string.
952  */
953
954 INT Str_GetPtrAtoW (LPCSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
955 {
956     INT len;
957
958     TRACE("(%s %p %d)\n", debugstr_a(lpSrc), lpDest, nMaxLen);
959
960     if (!lpDest && lpSrc)
961         return MultiByteToWideChar(CP_ACP, 0, lpSrc, -1, 0, 0);
962
963     if (nMaxLen == 0)
964         return 0;
965
966     if (lpSrc == NULL) {
967         lpDest[0] = '\0';
968         return 0;
969     }
970
971     len = MultiByteToWideChar(CP_ACP, 0, lpSrc, -1, 0, 0);
972     if (len >= nMaxLen)
973         len = nMaxLen - 1;
974
975     MultiByteToWideChar(CP_ACP, 0, lpSrc, -1, lpDest, len);
976     lpDest[len] = '\0';
977
978     return len;
979 }
980
981
982 /**************************************************************************
983  * Str_SetPtrAtoW [internal]
984  *
985  * Converts a multi byte string to a unicode string.
986  * If the pointer to the destination buffer is NULL a buffer is allocated.
987  * If the destination buffer is too small to keep the converted multi byte
988  * string the destination buffer is reallocated. If the source pointer is
989  * NULL, the destination buffer is freed.
990  *
991  * PARAMS
992  *     lppDest [I/O] pointer to a pointer to the destination buffer
993  *     lpSrc   [I] pointer to a multi byte string
994  *
995  * RETURNS
996  *     TRUE: conversion successful
997  *     FALSE: error
998  */
999 BOOL Str_SetPtrAtoW (LPWSTR *lppDest, LPCSTR lpSrc)
1000 {
1001     TRACE("(%p %s)\n", lppDest, lpSrc);
1002
1003     if (lpSrc) {
1004         INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
1005         LPWSTR ptr = ReAlloc (*lppDest, len*sizeof(WCHAR));
1006
1007         if (!ptr)
1008             return FALSE;
1009         MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
1010         *lppDest = ptr;
1011     }
1012     else {
1013         Free (*lppDest);
1014         *lppDest = NULL;
1015     }
1016
1017     return TRUE;
1018 }
1019
1020 /**************************************************************************
1021  * Str_SetPtrWtoA [internal]
1022  *
1023  * Converts a unicode string to a multi byte string.
1024  * If the pointer to the destination buffer is NULL a buffer is allocated.
1025  * If the destination buffer is too small to keep the converted wide
1026  * string the destination buffer is reallocated. If the source pointer is
1027  * NULL, the destination buffer is freed.
1028  *
1029  * PARAMS
1030  *     lppDest [I/O] pointer to a pointer to the destination buffer
1031  *     lpSrc   [I] pointer to a wide string
1032  *
1033  * RETURNS
1034  *     TRUE: conversion successful
1035  *     FALSE: error
1036  */
1037 BOOL Str_SetPtrWtoA (LPSTR *lppDest, LPCWSTR lpSrc)
1038 {
1039     TRACE("(%p %s)\n", lppDest, debugstr_w(lpSrc));
1040
1041     if (lpSrc) {
1042         INT len = WideCharToMultiByte(CP_ACP,0,lpSrc,-1,NULL,0,NULL,FALSE);
1043         LPSTR ptr = ReAlloc (*lppDest, len*sizeof(CHAR));
1044
1045         if (!ptr)
1046             return FALSE;
1047         WideCharToMultiByte(CP_ACP,0,lpSrc,-1,ptr,len,NULL,FALSE);
1048         *lppDest = ptr;
1049     }
1050     else {
1051         Free (*lppDest);
1052         *lppDest = NULL;
1053     }
1054
1055     return TRUE;
1056 }
1057
1058
1059 /**************************************************************************
1060  * Notification functions
1061  */
1062
1063 typedef struct tagNOTIFYDATA
1064 {
1065     HWND hwndFrom;
1066     HWND hwndTo;
1067     DWORD  dwParam3;
1068     DWORD  dwParam4;
1069     DWORD  dwParam5;
1070     DWORD  dwParam6;
1071 } NOTIFYDATA, *LPNOTIFYDATA;
1072
1073
1074 /**************************************************************************
1075  * DoNotify [Internal]
1076  */
1077
1078 static LRESULT DoNotify (const NOTIFYDATA *lpNotify, UINT uCode, LPNMHDR lpHdr)
1079 {
1080     NMHDR nmhdr;
1081     LPNMHDR lpNmh = NULL;
1082     UINT idFrom = 0;
1083
1084     TRACE("(%p %p %d %p 0x%08x)\n",
1085            lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
1086            lpNotify->dwParam5);
1087
1088     if (!lpNotify->hwndTo)
1089         return 0;
1090
1091     if (lpNotify->hwndFrom == (HWND)-1) {
1092         lpNmh = lpHdr;
1093         idFrom = lpHdr->idFrom;
1094     }
1095     else {
1096         if (lpNotify->hwndFrom)
1097             idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
1098
1099         lpNmh = (lpHdr) ? lpHdr : &nmhdr;
1100
1101         lpNmh->hwndFrom = lpNotify->hwndFrom;
1102         lpNmh->idFrom = idFrom;
1103         lpNmh->code = uCode;
1104     }
1105
1106     return SendMessageW (lpNotify->hwndTo, WM_NOTIFY, idFrom, (LPARAM)lpNmh);
1107 }
1108
1109
1110 /**************************************************************************
1111  * SendNotify [COMCTL32.341]
1112  *
1113  * Sends a WM_NOTIFY message to the specified window.
1114  *
1115  * PARAMS
1116  *     hwndTo   [I] Window to receive the message
1117  *     hwndFrom [I] Window that the message is from (see notes)
1118  *     uCode    [I] Notification code
1119  *     lpHdr    [I] The NMHDR and any additional information to send or NULL
1120  *
1121  * RETURNS
1122  *     Success: return value from notification
1123  *     Failure: 0
1124  *
1125  * NOTES
1126  *     If hwndFrom is -1 then the identifier of the control sending the
1127  *     message is taken from the NMHDR structure.
1128  *     If hwndFrom is not -1 then lpHdr can be NULL.
1129  */
1130 LRESULT WINAPI SendNotify (HWND hwndTo, HWND hwndFrom, UINT uCode, LPNMHDR lpHdr)
1131 {
1132     NOTIFYDATA notify;
1133
1134     TRACE("(%p %p %d %p)\n",
1135            hwndTo, hwndFrom, uCode, lpHdr);
1136
1137     notify.hwndFrom = hwndFrom;
1138     notify.hwndTo   = hwndTo;
1139     notify.dwParam5 = 0;
1140     notify.dwParam6 = 0;
1141
1142     return DoNotify (&notify, uCode, lpHdr);
1143 }
1144
1145
1146 /**************************************************************************
1147  * SendNotifyEx [COMCTL32.342]
1148  *
1149  * Sends a WM_NOTIFY message to the specified window.
1150  *
1151  * PARAMS
1152  *     hwndFrom [I] Window to receive the message
1153  *     hwndTo   [I] Window that the message is from
1154  *     uCode    [I] Notification code
1155  *     lpHdr    [I] The NMHDR and any additional information to send or NULL
1156  *     dwParam5 [I] Unknown
1157  *
1158  * RETURNS
1159  *     Success: return value from notification
1160  *     Failure: 0
1161  *
1162  * NOTES
1163  *     If hwndFrom is -1 then the identifier of the control sending the
1164  *     message is taken from the NMHDR structure.
1165  *     If hwndFrom is not -1 then lpHdr can be NULL.
1166  */
1167 LRESULT WINAPI SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
1168                              LPNMHDR lpHdr, DWORD dwParam5)
1169 {
1170     NOTIFYDATA notify;
1171     HWND hwndNotify;
1172
1173     TRACE("(%p %p %d %p 0x%08x)\n",
1174            hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
1175
1176     hwndNotify = hwndTo;
1177     if (!hwndTo) {
1178         if (IsWindow (hwndFrom)) {
1179             hwndNotify = GetParent (hwndFrom);
1180             if (!hwndNotify)
1181                 return 0;
1182         }
1183     }
1184
1185     notify.hwndFrom = hwndFrom;
1186     notify.hwndTo   = hwndNotify;
1187     notify.dwParam5 = dwParam5;
1188     notify.dwParam6 = 0;
1189
1190     return DoNotify (&notify, uCode, lpHdr);
1191 }