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( witem->size, nBufferSize );
889 WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
890 lpBuffer, datasize, NULL, NULL);
891 }
892 TRACE("(%p, %d, %p, %d): returning len=%d\n",
893 hList, nItemPos, lpBuffer, nBufferSize, datasize);
894 return datasize;
895 }
896
897 /**************************************************************************
898 * Str_GetPtrWtoA [internal]
899 *
900 * Converts a unicode string into a multi byte string
901 *
902 * PARAMS
903 * lpSrc [I] Pointer to the unicode source string
904 * lpDest [O] Pointer to caller supplied storage for the multi byte string
905 * nMaxLen [I] Size, in bytes, of the destination buffer
906 *
907 * RETURNS
908 * Length, in bytes, of the converted string.
909 */
910
911 INT Str_GetPtrWtoA (LPCWSTR lpSrc, LPSTR lpDest, INT nMaxLen)
912 {
913 INT len;
914
915 TRACE("(%s %p %d)\n", debugstr_w(lpSrc), lpDest, nMaxLen);
916
917 if (!lpDest && lpSrc)
918 return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
919
920 if (nMaxLen == 0)
921 return 0;
922
923 if (lpSrc == NULL) {
924 lpDest[0] = '\0';
925 return 0;
926 }
927
928 len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
929 if (len >= nMaxLen)
930 len = nMaxLen - 1;
931
932 WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
933 lpDest[len] = '\0';
934
935 return len;
936 }
937
938 /**************************************************************************
939 * Str_GetPtrAtoW [internal]
940 *
941 * Converts a multibyte string into a unicode string
942 *
943 * PARAMS
944 * lpSrc [I] Pointer to the multibyte source string
945 * lpDest [O] Pointer to caller supplied storage for the unicode string
946 * nMaxLen [I] Size, in characters, of the destination buffer
947 *
948 * RETURNS
949 * Length, in characters, of the converted string.
950 */
951
952 INT Str_GetPtrAtoW (LPCSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
953 {
954 INT len;
955
956 TRACE("(%s %p %d)\n", debugstr_a(lpSrc), lpDest, nMaxLen);
957
958 if (!lpDest && lpSrc)
959 return MultiByteToWideChar(CP_ACP, 0, lpSrc, -1, 0, 0);
960
961 if (nMaxLen == 0)
962 return 0;
963
964 if (lpSrc == NULL) {
965 lpDest[0] = '\0';
966 return 0;
967 }
968
969 len = MultiByteToWideChar(CP_ACP, 0, lpSrc, -1, 0, 0);
970 if (len >= nMaxLen)
971 len = nMaxLen - 1;
972
973 MultiByteToWideChar(CP_ACP, 0, lpSrc, -1, lpDest, len);
974 lpDest[len] = '\0';
975
976 return len;
977 }
978
979
980 /**************************************************************************
981 * Str_SetPtrAtoW [internal]
982 *
983 * Converts a multi byte string to a unicode string.
984 * If the pointer to the destination buffer is NULL a buffer is allocated.
985 * If the destination buffer is too small to keep the converted multi byte
986 * string the destination buffer is reallocated. If the source pointer is
987 * NULL, the destination buffer is freed.
988 *
989 * PARAMS
990 * lppDest [I/O] pointer to a pointer to the destination buffer
991 * lpSrc [I] pointer to a multi byte string
992 *
993 * RETURNS
994 * TRUE: conversion successful
995 * FALSE: error
996 */
997 BOOL Str_SetPtrAtoW (LPWSTR *lppDest, LPCSTR lpSrc)
998 {
999 TRACE("(%p %s)\n", lppDest, lpSrc);
1000
1001 if (lpSrc) {
1002 INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
1003 LPWSTR ptr = ReAlloc (*lppDest, len*sizeof(WCHAR));
1004
1005 if (!ptr)
1006 return FALSE;
1007 MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
1008 *lppDest = ptr;
1009 }
1010 else {
1011 Free (*lppDest);
1012 *lppDest = NULL;
1013 }
1014
1015 return TRUE;
1016 }
1017
1018 /**************************************************************************
1019 * Str_SetPtrWtoA [internal]
1020 *
1021 * Converts a unicode string to a multi byte string.
1022 * If the pointer to the destination buffer is NULL a buffer is allocated.
1023 * If the destination buffer is too small to keep the converted wide
1024 * string the destination buffer is reallocated. If the source pointer is
1025 * NULL, the destination buffer is freed.
1026 *
1027 * PARAMS
1028 * lppDest [I/O] pointer to a pointer to the destination buffer
1029 * lpSrc [I] pointer to a wide string
1030 *
1031 * RETURNS
1032 * TRUE: conversion successful
1033 * FALSE: error
1034 */
1035 BOOL Str_SetPtrWtoA (LPSTR *lppDest, LPCWSTR lpSrc)
1036 {
1037 TRACE("(%p %s)\n", lppDest, debugstr_w(lpSrc));
1038
1039 if (lpSrc) {
1040 INT len = WideCharToMultiByte(CP_ACP,0,lpSrc,-1,NULL,0,NULL,FALSE);
1041 LPSTR ptr = ReAlloc (*lppDest, len*sizeof(CHAR));
1042
1043 if (!ptr)
1044 return FALSE;
1045 WideCharToMultiByte(CP_ACP,0,lpSrc,-1,ptr,len,NULL,FALSE);
1046 *lppDest = ptr;
1047 }
1048 else {
1049 Free (*lppDest);
1050 *lppDest = NULL;
1051 }
1052
1053 return TRUE;
1054 }
1055
1056
1057 /**************************************************************************
1058 * Notification functions
1059 */
1060
1061 typedef struct tagNOTIFYDATA
1062 {
1063 HWND hwndFrom;
1064 HWND hwndTo;
1065 DWORD dwParam3;
1066 DWORD dwParam4;
1067 DWORD dwParam5;
1068 DWORD dwParam6;
1069 } NOTIFYDATA, *LPNOTIFYDATA;
1070
1071
1072 /**************************************************************************
1073 * DoNotify [Internal]
1074 */
1075
1076 static LRESULT DoNotify (const NOTIFYDATA *lpNotify, UINT uCode, LPNMHDR lpHdr)
1077 {
1078 NMHDR nmhdr;
1079 LPNMHDR lpNmh = NULL;
1080 UINT idFrom = 0;
1081
1082 TRACE("(%p %p %d %p 0x%08x)\n",
1083 lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
1084 lpNotify->dwParam5);
1085
1086 if (!lpNotify->hwndTo)
1087 return 0;
1088
1089 if (lpNotify->hwndFrom == (HWND)-1) {
1090 lpNmh = lpHdr;
1091 idFrom = lpHdr->idFrom;
1092 }
1093 else {
1094 if (lpNotify->hwndFrom)
1095 idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
1096
1097 lpNmh = (lpHdr) ? lpHdr : &nmhdr;
1098
1099 lpNmh->hwndFrom = lpNotify->hwndFrom;
1100 lpNmh->idFrom = idFrom;
1101 lpNmh->code = uCode;
1102 }
1103
1104 return SendMessageW (lpNotify->hwndTo, WM_NOTIFY, idFrom, (LPARAM)lpNmh);
1105 }
1106
1107
1108 /**************************************************************************
1109 * SendNotify [COMCTL32.341]
1110 *
1111 * Sends a WM_NOTIFY message to the specified window.
1112 *
1113 * PARAMS
1114 * hwndTo [I] Window to receive the message
1115 * hwndFrom [I] Window that the message is from (see notes)
1116 * uCode [I] Notification code
1117 * lpHdr [I] The NMHDR and any additional information to send or NULL
1118 *
1119 * RETURNS
1120 * Success: return value from notification
1121 * Failure: 0
1122 *
1123 * NOTES
1124 * If hwndFrom is -1 then the identifier of the control sending the
1125 * message is taken from the NMHDR structure.
1126 * If hwndFrom is not -1 then lpHdr can be NULL.
1127 */
1128 LRESULT WINAPI SendNotify (HWND hwndTo, HWND hwndFrom, UINT uCode, LPNMHDR lpHdr)
1129 {
1130 NOTIFYDATA notify;
1131
1132 TRACE("(%p %p %d %p)\n",
1133 hwndTo, hwndFrom, uCode, lpHdr);
1134
1135 notify.hwndFrom = hwndFrom;
1136 notify.hwndTo = hwndTo;
1137 notify.dwParam5 = 0;
1138 notify.dwParam6 = 0;
1139
1140 return DoNotify (¬ify, uCode, lpHdr);
1141 }
1142
1143
1144 /**************************************************************************
1145 * SendNotifyEx [COMCTL32.342]
1146 *
1147 * Sends a WM_NOTIFY message to the specified window.
1148 *
1149 * PARAMS
1150 * hwndFrom [I] Window to receive the message
1151 * hwndTo [I] Window that the message is from
1152 * uCode [I] Notification code
1153 * lpHdr [I] The NMHDR and any additional information to send or NULL
1154 * dwParam5 [I] Unknown
1155 *
1156 * RETURNS
1157 * Success: return value from notification
1158 * Failure: 0
1159 *
1160 * NOTES
1161 * If hwndFrom is -1 then the identifier of the control sending the
1162 * message is taken from the NMHDR structure.
1163 * If hwndFrom is not -1 then lpHdr can be NULL.
1164 */
1165 LRESULT WINAPI SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
1166 LPNMHDR lpHdr, DWORD dwParam5)
1167 {
1168 NOTIFYDATA notify;
1169 HWND hwndNotify;
1170
1171 TRACE("(%p %p %d %p 0x%08x)\n",
1172 hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
1173
1174 hwndNotify = hwndTo;
1175 if (!hwndTo) {
1176 if (IsWindow (hwndFrom)) {
1177 hwndNotify = GetParent (hwndFrom);
1178 if (!hwndNotify)
1179 return 0;
1180 }
1181 }
1182
1183 notify.hwndFrom = hwndFrom;
1184 notify.hwndTo = hwndNotify;
1185 notify.dwParam5 = dwParam5;
1186 notify.dwParam6 = 0;
1187
1188 return DoNotify (¬ify, uCode, lpHdr);
1189 }
1190
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.