projects / reactos.git / blob
? search:


4a4d6fbd9215fa720c56bd3b5404cbf45f35cb9c
[reactos.git] / reactos / dll / win32 / 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 *| LPCTSTR 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 struct tagCREATEMRULISTA
210 {
211 DWORD cbSize;
212 DWORD nMaxItems;
213 DWORD dwFlags;
214 HKEY hKey;
215 LPCSTR lpszSubKey;
216 PROC lpfnCompare;
217 } CREATEMRULISTA, *LPCREATEMRULISTA;
218
219 typedef struct tagCREATEMRULISTW
220 {
221 DWORD cbSize;
222 DWORD nMaxItems;
223 DWORD dwFlags;
224 HKEY hKey;
225 LPCWSTR lpszSubKey;
226 PROC lpfnCompare;
227 } CREATEMRULISTW, *LPCREATEMRULISTW;
228
229 /* dwFlags */
230 #define MRUF_STRING_LIST 0 /* list will contain strings */
231 #define MRUF_BINARY_LIST 1 /* list will contain binary data */
232 #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
233
234 /* If list is a string list lpfnCompare has the following prototype
235 * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
236 * for binary lists the prototype is
237 * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
238 * where cbData is the no. of bytes to compare.
239 * Need to check what return value means identical - 0?
240 */
241
242 typedef struct tagWINEMRUITEM
243 {
244 DWORD size; /* size of data stored */
245 DWORD itemFlag; /* flags */
246 BYTE datastart;
247 } WINEMRUITEM, *LPWINEMRUITEM;
248
249 /* itemFlag */
250 #define WMRUIF_CHANGED 0x0001 /* this dataitem changed */
251
252 typedef struct tagWINEMRULIST
253 {
254 CREATEMRULISTW extview; /* original create information */
255 BOOL isUnicode; /* is compare fn Unicode */
256 DWORD wineFlags; /* internal flags */
257 DWORD cursize; /* current size of realMRU */
258 LPWSTR realMRU; /* pointer to string of index names */
259 LPWINEMRUITEM *array; /* array of pointers to data */
260 /* in 'a' to 'z' order */
261 } WINEMRULIST, *LPWINEMRULIST;
262
263 /* wineFlags */
264 #define WMRUF_CHANGED 0x0001 /* MRU list has changed */
265
266 /**************************************************************************
267 * MRU_SaveChanged (internal)
268 *
269 * Local MRU saving code
270 */
271 static void MRU_SaveChanged ( LPWINEMRULIST mp )
272 {
273 UINT i, err;
274 HKEY newkey;
275 WCHAR realname[2];
276 LPWINEMRUITEM witem;
277
278 /* or should we do the following instead of RegOpenKeyEx:
279 */
280
281 /* open the sub key */
282 if ((err = RegOpenKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
283 0, KEY_WRITE, &newkey))) {
284 /* not present - what to do ??? */
285 ERR("Could not open key, error=%d, attempting to create\n",
286 err);
287 if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
288 0,
289 NULL,
290 REG_OPTION_NON_VOLATILE,
291 KEY_READ | KEY_WRITE,
292 0,
293 &newkey,
294 0))) {
295 ERR("failed to create key /%s/, err=%d\n",
296 debugstr_w(mp->extview.lpszSubKey), err);
297 return;
298 }
299 }
300 if (mp->wineFlags & WMRUF_CHANGED) {
301 mp->wineFlags &= ~WMRUF_CHANGED;
302 err = RegSetValueExW(newkey, strMRUList, 0, REG_SZ, (LPBYTE)mp->realMRU,
303 (strlenW(mp->realMRU) + 1)*sizeof(WCHAR));
304 if (err) {
305 ERR("error saving MRUList, err=%d\n", err);
306 }
307 TRACE("saving MRUList=/%s/\n", debugstr_w(mp->realMRU));
308 }
309 realname[1] = 0;
310 for(i=0; i<mp->cursize; i++) {
311 witem = mp->array[i];
312 if (witem->itemFlag & WMRUIF_CHANGED) {
313 witem->itemFlag &= ~WMRUIF_CHANGED;
314 realname[0] = 'a' + i;
315 err = RegSetValueExW(newkey, realname, 0,
316 (mp->extview.dwFlags & MRUF_BINARY_LIST) ?
317 REG_BINARY : REG_SZ,
318 &witem->datastart, witem->size);
319 if (err) {
320 ERR("error saving /%s/, err=%d\n", debugstr_w(realname), err);
321 }
322 TRACE("saving value for name /%s/ size=%ld\n",
323 debugstr_w(realname), witem->size);
324 }
325 }
326 RegCloseKey( newkey );
327 }
328
329 /**************************************************************************
330 * FreeMRUList [COMCTL32.152]
331 *
332 * Frees a most-recently-used items list.
333 *
334 * PARAMS
335 * hMRUList [I] Handle to list.
336 *
337 * RETURNS
338 * Nothing.
339 */
340 void WINAPI FreeMRUList (HANDLE hMRUList)
341 {
342 LPWINEMRULIST mp = (LPWINEMRULIST)hMRUList;
343 UINT i;
344
345 TRACE("(%p)\n", hMRUList);
346 if (!hMRUList)
347 return;
348
349 if (mp->wineFlags & WMRUF_CHANGED) {
350 /* need to open key and then save the info */
351 MRU_SaveChanged( mp );
352 }
353
354 for(i=0; i<mp->extview.nMaxItems; i++) {
355 if (mp->array[i])
356 Free(mp->array[i]);
357 }
358 Free(mp->realMRU);
359 Free(mp->array);
360 Free((LPWSTR)mp->extview.lpszSubKey);
361 Free(mp);
362 }
363
364
365 /**************************************************************************
366 * FindMRUData [COMCTL32.169]
367 *
368 * Searches binary list for item that matches lpData of length cbData.
369 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
370 * corresponding to item's reg. name will be stored in it ('a' -> 0).
371 *
372 * PARAMS
373 * hList [I] list handle
374 * lpData [I] data to find
375 * cbData [I] length of data
376 * lpRegNum [O] position in registry (maybe NULL)
377 *
378 * RETURNS
379 * Position in list 0 -> MRU. -1 if item not found.
380 */
381 INT WINAPI FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData,
382 LPINT lpRegNum)
383 {
384 LPWINEMRULIST mp = (LPWINEMRULIST)hList;
385 INT ret;
386 UINT i;
387 LPSTR dataA = NULL;
388
389 if (!mp->extview.lpfnCompare)
390 return -1;
391
392 if(!(mp->extview.dwFlags & MRUF_BINARY_LIST) && !mp->isUnicode) {
393 DWORD len = WideCharToMultiByte(CP_ACP, 0, lpData, -1,
394 NULL, 0, NULL, NULL);
395 dataA = Alloc(len);
396 WideCharToMultiByte(CP_ACP, 0, lpData, -1, dataA, len, NULL, NULL);
397 }
398
399 for(i=0; i<mp->cursize; i++) {
400 if (mp->extview.dwFlags & MRUF_BINARY_LIST) {
401 if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart,
402 cbData))
403 break;
404 }
405 else {
406 if(mp->isUnicode) {
407 if (!mp->extview.lpfnCompare(lpData, &mp->array[i]->datastart))
408 break;
409 } else {
410 DWORD len = WideCharToMultiByte(CP_ACP, 0,
411 (LPWSTR)&mp->array[i]->datastart, -1,
412 NULL, 0, NULL, NULL);
413 LPSTR itemA = Alloc(len);
414 INT cmp;
415 WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&mp->array[i]->datastart, -1,
416 itemA, len, NULL, NULL);
417
418 cmp = mp->extview.lpfnCompare(dataA, itemA);
419 Free(itemA);
420 if(!cmp)
421 break;
422 }
423 }
424 }
425 if(dataA)
426 Free(dataA);
427 if (i < mp->cursize)
428 ret = i;
429 else
430 ret = -1;
431 if (lpRegNum && (ret != -1))
432 *lpRegNum = 'a' + i;
433
434 TRACE("(%p, %p, %ld, %p) returning %d\n",
435 hList, lpData, cbData, lpRegNum, ret);
436
437 return ret;
438 }
439
440
441 /**************************************************************************
442 * AddMRUData [COMCTL32.167]
443 *
444 * Add item to MRU binary list. If item already exists in list then it is
445 * simply moved up to the top of the list and not added again. If list is
446 * full then the least recently used item is removed to make room.
447 *
448 * PARAMS
449 * hList [I] Handle to list.
450 * lpData [I] ptr to data to add.
451 * cbData [I] no. of bytes of data.
452 *
453 * RETURNS
454 * No. corresponding to registry name where value is stored 'a' -> 0 etc.
455 * -1 on error.
456 */
457 INT WINAPI AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData)
458 {
459 LPWINEMRULIST mp = (LPWINEMRULIST)hList;
460 LPWINEMRUITEM witem;
461 INT i, replace;
462
463 if ((replace = FindMRUData (hList, lpData, cbData, NULL)) >= 0) {
464 /* Item exists, just move it to the front */
465 LPWSTR pos = strchrW(mp->realMRU, replace + 'a');
466 while (pos > mp->realMRU)
467 {
468 pos[0] = pos[-1];
469 pos--;
470 }
471 }
472 else {
473 /* either add a new entry or replace oldest */
474 if (mp->cursize < mp->extview.nMaxItems) {
475 /* Add in a new item */
476 replace = mp->cursize;
477 mp->cursize++;
478 }
479 else {
480 /* get the oldest entry and replace data */
481 replace = mp->realMRU[mp->cursize - 1] - 'a';
482 Free(mp->array[replace]);
483 }
484
485 /* Allocate space for new item and move in the data */
486 mp->array[replace] = witem = Alloc(cbData + sizeof(WINEMRUITEM));
487 witem->itemFlag |= WMRUIF_CHANGED;
488 witem->size = cbData;
489 memcpy( &witem->datastart, lpData, cbData);
490
491 /* now rotate MRU list */
492 for(i=mp->cursize-1; i>=1; i--)
493 mp->realMRU[i] = mp->realMRU[i-1];
494 }
495
496 /* The new item gets the front spot */
497 mp->wineFlags |= WMRUF_CHANGED;
498 mp->realMRU[0] = replace + 'a';
499
500 TRACE("(%p, %p, %ld) adding data, /%c/ now most current\n",
501 hList, lpData, cbData, replace+'a');
502
503 if (!(mp->extview.dwFlags & MRUF_DELAYED_SAVE)) {
504 /* save changed stuff right now */
505 MRU_SaveChanged( mp );
506 }
507
508 return replace;
509 }
510
511 /**************************************************************************
512 * AddMRUStringW [COMCTL32.401]
513 *
514 * Add an item to an MRU string list.
515 *
516 * PARAMS
517 * hList [I] Handle to list.
518 * lpszString [I] The string to add.
519 *
520 * RETURNS
521 * Success: The number corresponding to the registry name where the string
522 * has been stored (0 maps to 'a', 1 to 'b' and so on).
523 * Failure: -1, if hList is NULL or memory allocation fails. If lpszString
524 * is invalid, the function returns 0, and GetLastError() returns
525 * ERROR_INVALID_PARAMETER. The last error value is set only in
526 * this case.
527 *
528 * NOTES
529 * -If lpszString exists in the list already, it is moved to the top of the
530 * MRU list (it is not duplicated).
531 * -If the list is full the least recently used list entry is replaced with
532 * lpszString.
533 * -If this function returns 0 you should check the last error value to
534 * ensure the call really succeeded.
535 */
536 INT WINAPI AddMRUStringW(HANDLE hList, LPCWSTR lpszString)
537 {
538 TRACE("(%p,%s)\n", hList, debugstr_w(lpszString));
539
540 if (!hList)
541 return -1;
542
543 if (!lpszString || IsBadStringPtrW(lpszString, -1))
544 {
545 SetLastError(ERROR_INVALID_PARAMETER);
546 return 0;
547 }
548
549 return AddMRUData(hList, lpszString,
550 (strlenW(lpszString) + 1) * sizeof(WCHAR));
551 }
552
553 /**************************************************************************
554 * AddMRUStringA [COMCTL32.153]
555 *
556 * See AddMRUStringW.
557 */
558 INT WINAPI AddMRUStringA(HANDLE hList, LPCSTR lpszString)
559 {
560 DWORD len;
561 LPWSTR stringW;
562 INT ret;
563
564 TRACE("(%p,%s)\n", hList, debugstr_a(lpszString));
565
566 if (!hList)
567 return -1;
568
569 if (IsBadStringPtrA(lpszString, -1))
570 {
571 SetLastError(ERROR_INVALID_PARAMETER);
572 return 0;
573 }
574
575 len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0) * sizeof(WCHAR);
576 stringW = Alloc(len);
577 if (!stringW)
578 return -1;
579
580 MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len/sizeof(WCHAR));
581 ret = AddMRUData(hList, stringW, len);
582 Free(stringW);
583 return ret;
584 }
585
586 /**************************************************************************
587 * DelMRUString [COMCTL32.156]
588 *
589 * Removes item from either string or binary list (despite its name)
590 *
591 * PARAMS
592 * hList [I] list handle
593 * nItemPos [I] item position to remove 0 -> MRU
594 *
595 * RETURNS
596 * TRUE if successful, FALSE if nItemPos is out of range.
597 */
598 BOOL WINAPI DelMRUString(HANDLE hList, INT nItemPos)
599 {
600 FIXME("(%p, %d): stub\n", hList, nItemPos);
601 return TRUE;
602 }
603
604 /**************************************************************************
605 * FindMRUStringW [COMCTL32.402]
606 *
607 * See FindMRUStringA.
608 */
609 INT WINAPI FindMRUStringW (HANDLE hList, LPCWSTR lpszString, LPINT lpRegNum)
610 {
611 return FindMRUData(hList, lpszString,
612 (lstrlenW(lpszString) + 1) * sizeof(WCHAR), lpRegNum);
613 }
614
615 /**************************************************************************
616 * FindMRUStringA [COMCTL32.155]
617 *
618 * Searches string list for item that matches lpszString.
619 * Returns position in list order 0 -> MRU and if lpRegNum != NULL then value
620 * corresponding to item's reg. name will be stored in it ('a' -> 0).
621 *
622 * PARAMS
623 * hList [I] list handle
624 * lpszString [I] string to find
625 * lpRegNum [O] position in registry (maybe NULL)
626 *
627 * RETURNS
628 * Position in list 0 -> MRU. -1 if item not found.
629 */
630 INT WINAPI FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum)
631 {
632 DWORD len = MultiByteToWideChar(CP_ACP, 0, lpszString, -1, NULL, 0);
633 LPWSTR stringW = Alloc(len * sizeof(WCHAR));
634 INT ret;
635
636 MultiByteToWideChar(CP_ACP, 0, lpszString, -1, stringW, len);
637 ret = FindMRUData(hList, stringW, len * sizeof(WCHAR), lpRegNum);
638 Free(stringW);
639 return ret;
640 }
641
642 /*************************************************************************
643 * CreateMRUListLazy_common (internal)
644 */
645 static HANDLE CreateMRUListLazy_common(LPWINEMRULIST mp)
646 {
647 UINT i, err;
648 HKEY newkey;
649 DWORD datasize, dwdisp;
650 WCHAR realname[2];
651 LPWINEMRUITEM witem;
652 DWORD type;
653
654 /* get space to save indices that will turn into names
655 * but in order of most to least recently used
656 */
657 mp->realMRU = Alloc((mp->extview.nMaxItems + 2) * sizeof(WCHAR));
658
659 /* get space to save pointers to actual data in order of
660 * 'a' to 'z' (0 to n).
661 */
662 mp->array = Alloc(mp->extview.nMaxItems * sizeof(LPVOID));
663
664 /* open the sub key */
665 if ((err = RegCreateKeyExW( mp->extview.hKey, mp->extview.lpszSubKey,
666 0,
667 NULL,
668 REG_OPTION_NON_VOLATILE,
669 KEY_READ | KEY_WRITE,
670 0,
671 &newkey,
672 &dwdisp))) {
673 /* error - what to do ??? */
674 ERR("(%lu %lu %lx %p %s %p): Could not open key, error=%d\n",
675 mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
676 mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
677 mp->extview.lpfnCompare, err);
678 return 0;
679 }
680
681 /* get values from key 'MRUList' */
682 if (newkey) {
683 datasize = (mp->extview.nMaxItems + 1) * sizeof(WCHAR);
684 if((err=RegQueryValueExW( newkey, strMRUList, 0, &type,
685 (LPBYTE)mp->realMRU, &datasize))) {
686 /* not present - set size to 1 (will become 0 later) */
687 datasize = 1;
688 *mp->realMRU = 0;
689 }
690 else
691 datasize /= sizeof(WCHAR);
692
693 TRACE("MRU list = %s, datasize = %ld\n", debugstr_w(mp->realMRU), datasize);
694
695 mp->cursize = datasize - 1;
696 /* datasize now has number of items in the MRUList */
697
698 /* get actual values for each entry */
699 realname[1] = 0;
700 for(i=0; i<mp->cursize; i++) {
701 realname[0] = 'a' + i;
702 if(RegQueryValueExW( newkey, realname, 0, &type, 0, &datasize)) {
703 /* not present - what to do ??? */
704 ERR("Key %s not found 1\n", debugstr_w(realname));
705 }
706 mp->array[i] = witem = Alloc(datasize + sizeof(WINEMRUITEM));
707 witem->size = datasize;
708 if(RegQueryValueExW( newkey, realname, 0, &type,
709 &witem->datastart, &datasize)) {
710 /* not present - what to do ??? */
711 ERR("Key %s not found 2\n", debugstr_w(realname));
712 }
713 }
714 RegCloseKey( newkey );
715 }
716 else
717 mp->cursize = 0;
718
719 TRACE("(%lu %lu %lx %p %s %p): Current Size = %ld\n",
720 mp->extview.cbSize, mp->extview.nMaxItems, mp->extview.dwFlags,
721 mp->extview.hKey, debugstr_w(mp->extview.lpszSubKey),
722 mp->extview.lpfnCompare, mp->cursize);
723 return (HANDLE)mp;
724 }
725
726 /**************************************************************************
727 * CreateMRUListLazyW [COMCTL32.404]
728 *
729 * See CreateMRUListLazyA.
730 */
731 HANDLE WINAPI CreateMRUListLazyW (LPCREATEMRULISTW lpcml, DWORD dwParam2,
732 DWORD dwParam3, DWORD dwParam4)
733 {
734 LPWINEMRULIST mp;
735
736 /* Native does not check for a NULL lpcml */
737
738 if (lpcml->cbSize != sizeof(CREATEMRULISTW) || !lpcml->hKey ||
739 IsBadStringPtrW(lpcml->lpszSubKey, -1))
740 return NULL;
741
742 mp = Alloc(sizeof(WINEMRULIST));
743 memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
744 mp->extview.lpszSubKey = Alloc((strlenW(lpcml->lpszSubKey) + 1) * sizeof(WCHAR));
745 strcpyW((LPWSTR)mp->extview.lpszSubKey, lpcml->lpszSubKey);
746 mp->isUnicode = TRUE;
747
748 return CreateMRUListLazy_common(mp);
749 }
750
751 /**************************************************************************
752 * CreateMRUListLazyA [COMCTL32.157]
753 *
754 * Creates a most-recently-used list.
755 *
756 * PARAMS
757 * lpcml [I] ptr to CREATEMRULIST structure.
758 * dwParam2 [I] Unknown
759 * dwParam3 [I] Unknown
760 * dwParam4 [I] Unknown
761 *
762 * RETURNS
763 * Handle to MRU list.
764 */
765 HANDLE WINAPI CreateMRUListLazyA (LPCREATEMRULISTA lpcml, DWORD dwParam2,
766 DWORD dwParam3, DWORD dwParam4)
767 {
768 LPWINEMRULIST mp;
769 DWORD len;
770
771 /* Native does not check for a NULL lpcml */
772
773 if (lpcml->cbSize != sizeof(CREATEMRULISTA) || !lpcml->hKey ||
774 IsBadStringPtrA(lpcml->lpszSubKey, -1))
775 return 0;
776
777 mp = Alloc(sizeof(WINEMRULIST));
778 memcpy(&mp->extview, lpcml, sizeof(CREATEMRULISTW));
779 len = MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1, NULL, 0);
780 mp->extview.lpszSubKey = Alloc(len * sizeof(WCHAR));
781 MultiByteToWideChar(CP_ACP, 0, lpcml->lpszSubKey, -1,
782 (LPWSTR)mp->extview.lpszSubKey, len);
783 mp->isUnicode = FALSE;
784 return CreateMRUListLazy_common(mp);
785 }
786
787 /**************************************************************************
788 * CreateMRUListW [COMCTL32.400]
789 *
790 * See CreateMRUListA.
791 */
792 HANDLE WINAPI CreateMRUListW (LPCREATEMRULISTW lpcml)
793 {
794 return CreateMRUListLazyW(lpcml, 0, 0, 0);
795 }
796
797 /**************************************************************************
798 * CreateMRUListA [COMCTL32.151]
799 *
800 * Creates a most-recently-used list.
801 *
802 * PARAMS
803 * lpcml [I] ptr to CREATEMRULIST structure.
804 *
805 * RETURNS
806 * Handle to MRU list.
807 */
808 HANDLE WINAPI CreateMRUListA (LPCREATEMRULISTA lpcml)
809 {
810 return CreateMRUListLazyA (lpcml, 0, 0, 0);
811 }
812
813
814 /**************************************************************************
815 * EnumMRUListW [COMCTL32.403]
816 *
817 * Enumerate item in a most-recenty-used list
818 *
819 * PARAMS
820 * hList [I] list handle
821 * nItemPos [I] item position to enumerate
822 * lpBuffer [O] buffer to receive item
823 * nBufferSize [I] size of buffer
824 *
825 * RETURNS
826 * For binary lists specifies how many bytes were copied to buffer, for
827 * string lists specifies full length of string. Enumerating past the end
828 * of list returns -1.
829 * If lpBuffer == NULL or nItemPos is -ve return value is no. of items in
830 * the list.
831 */
832 INT WINAPI EnumMRUListW (HANDLE hList, INT nItemPos, LPVOID lpBuffer,
833 DWORD nBufferSize)
834 {
835 LPWINEMRULIST mp = (LPWINEMRULIST) hList;
836 LPWINEMRUITEM witem;
837 INT desired, datasize;
838
839 if (nItemPos >= mp->cursize) return -1;
840 if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
841 desired = mp->realMRU[nItemPos];
842 desired -= 'a';
843 TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
844 witem = mp->array[desired];
845 datasize = min( witem->size, nBufferSize );
846 memcpy( lpBuffer, &witem->datastart, datasize);
847 TRACE("(%p, %d, %p, %ld): returning len=%d\n",
848 hList, nItemPos, lpBuffer, nBufferSize, datasize);
849 return datasize;
850 }
851
852 /**************************************************************************
853 * EnumMRUListA [COMCTL32.154]
854 *
855 * See EnumMRUListW.
856 */
857 INT WINAPI EnumMRUListA (HANDLE hList, INT nItemPos, LPVOID lpBuffer,
858 DWORD nBufferSize)
859 {
860 LPWINEMRULIST mp = (LPWINEMRULIST) hList;
861 LPWINEMRUITEM witem;
862 INT desired, datasize;
863 DWORD lenA;
864
865 if (nItemPos >= mp->cursize) return -1;
866 if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
867 desired = mp->realMRU[nItemPos];
868 desired -= 'a';
869 TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
870 witem = mp->array[desired];
871 if(mp->extview.dwFlags & MRUF_BINARY_LIST) {
872 datasize = min( witem->size, nBufferSize );
873 memcpy( lpBuffer, &witem->datastart, datasize);
874 } else {
875 lenA = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
876 NULL, 0, NULL, NULL);
877 datasize = min( witem->size, nBufferSize );
878 WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
879 lpBuffer, datasize, NULL, NULL);
880 }
881 TRACE("(%p, %d, %p, %ld): returning len=%d\n",
882 hList, nItemPos, lpBuffer, nBufferSize, datasize);
883 return datasize;
884 }
885
886
887 /**************************************************************************
888 * Str_GetPtrA [COMCTL32.233]
889 *
890 * Copies a string into a destination buffer.
891 *
892 * PARAMS
893 * lpSrc [I] Source string
894 * lpDest [O] Destination buffer
895 * nMaxLen [I] Size of buffer in characters
896 *
897 * RETURNS
898 * The number of characters copied.
899 */
900 INT WINAPI Str_GetPtrA (LPCSTR lpSrc, LPSTR lpDest, INT nMaxLen)
901 {
902 INT len;
903
904 TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
905
906 if (!lpDest && lpSrc)
907 return strlen (lpSrc);
908
909 if (nMaxLen == 0)
910 return 0;
911
912 if (lpSrc == NULL) {
913 lpDest[0] = '\0';
914 return 0;
915 }
916
917 len = strlen (lpSrc);
918 if (len >= nMaxLen)
919 len = nMaxLen - 1;
920
921 RtlMoveMemory (lpDest, lpSrc, len);
922 lpDest[len] = '\0';
923
924 return len;
925 }
926
927
928 /**************************************************************************
929 * Str_SetPtrA [COMCTL32.234]
930 *
931 * Makes a copy of a string, allocating memory if necessary.
932 *
933 * PARAMS
934 * lppDest [O] Pointer to destination string
935 * lpSrc [I] Source string
936 *
937 * RETURNS
938 * Success: TRUE
939 * Failure: FALSE
940 *
941 * NOTES
942 * Set lpSrc to NULL to free the memory allocated by a previous call
943 * to this function.
944 */
945 BOOL WINAPI Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc)
946 {
947 TRACE("(%p %p)\n", lppDest, lpSrc);
948
949 if (lpSrc) {
950 LPSTR ptr = ReAlloc (*lppDest, strlen (lpSrc) + 1);
951 if (!ptr)
952 return FALSE;
953 strcpy (ptr, lpSrc);
954 *lppDest = ptr;
955 }
956 else {
957 if (*lppDest) {
958 Free (*lppDest);
959 *lppDest = NULL;
960 }
961 }
962
963 return TRUE;
964 }
965
966
967 /**************************************************************************
968 * Str_GetPtrW [COMCTL32.235]
969 *
970 * See Str_GetPtrA.
971 */
972 INT WINAPI Str_GetPtrW (LPCWSTR lpSrc, LPWSTR lpDest, INT nMaxLen)
973 {
974 INT len;
975
976 TRACE("(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
977
978 if (!lpDest && lpSrc)
979 return strlenW (lpSrc);
980
981 if (nMaxLen == 0)
982 return 0;
983
984 if (lpSrc == NULL) {
985 lpDest[0] = L'\0';
986 return 0;
987 }
988
989 len = strlenW (lpSrc);
990 if (len >= nMaxLen)
991 len = nMaxLen - 1;
992
993 RtlMoveMemory (lpDest, lpSrc, len*sizeof(WCHAR));
994 lpDest[len] = L'\0';
995
996 return len;
997 }
998
999
1000 /**************************************************************************
1001 * Str_SetPtrW [COMCTL32.236]
1002 *
1003 * See Str_SetPtrA.
1004 */
1005 BOOL WINAPI Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc)
1006 {
1007 TRACE("(%p %p)\n", lppDest, lpSrc);
1008
1009 if (lpSrc) {
1010 INT len = strlenW (lpSrc) + 1;
1011 LPWSTR ptr = ReAlloc (*lppDest, len * sizeof(WCHAR));
1012 if (!ptr)
1013 return FALSE;
1014 strcpyW (ptr, lpSrc);
1015 *lppDest = ptr;
1016 }
1017 else {
1018 if (*lppDest) {
1019 Free (*lppDest);
1020 *lppDest = NULL;
1021 }
1022 }
1023
1024 return TRUE;
1025 }
1026
1027
1028 /**************************************************************************
1029 * Str_GetPtrWtoA [internal]
1030 *
1031 * Converts a unicode string into a multi byte string
1032 *
1033 * PARAMS
1034 * lpSrc [I] Pointer to the unicode source string
1035 * lpDest [O] Pointer to caller supplied storage for the multi byte string
1036 * nMaxLen [I] Size, in bytes, of the destination buffer
1037 *
1038 * RETURNS
1039 * Length, in bytes, of the converted string.
1040 */
1041
1042 INT Str_GetPtrWtoA (LPCWSTR lpSrc, LPSTR lpDest, INT nMaxLen)
1043 {
1044 INT len;
1045
1046 TRACE("(%s %p %d)\n", debugstr_w(lpSrc), lpDest, nMaxLen);
1047
1048 if (!lpDest && lpSrc)
1049 return WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
1050
1051 if (nMaxLen == 0)
1052 return 0;
1053
1054 if (lpSrc == NULL) {
1055 lpDest[0] = '\0';
1056 return 0;
1057 }
1058
1059 len = WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, 0, 0, NULL, NULL);
1060 if (len >= nMaxLen)
1061 len = nMaxLen - 1;
1062
1063 WideCharToMultiByte(CP_ACP, 0, lpSrc, -1, lpDest, len, NULL, NULL);
1064 lpDest[len] = '\0';
1065
1066 return len;
1067 }
1068
1069
1070 /**************************************************************************
1071 * Str_SetPtrAtoW [internal]
1072 *
1073 * Converts a multi byte string to a unicode string.
1074 * If the pointer to the destination buffer is NULL a buffer is allocated.
1075 * If the destination buffer is too small to keep the converted multi byte
1076 * string the destination buffer is reallocated. If the source pointer is
1077 * NULL, the destination buffer is freed.
1078 *
1079 * PARAMS
1080 * lppDest [I/O] pointer to a pointer to the destination buffer
1081 * lpSrc [I] pointer to a multi byte string
1082 *
1083 * RETURNS
1084 * TRUE: conversion successful
1085 * FALSE: error
1086 */
1087 BOOL Str_SetPtrAtoW (LPWSTR *lppDest, LPCSTR lpSrc)
1088 {
1089 TRACE("(%p %s)\n", lppDest, lpSrc);
1090
1091 if (lpSrc) {
1092 INT len = MultiByteToWideChar(CP_ACP,0,lpSrc,-1,NULL,0);
1093 LPWSTR ptr = ReAlloc (*lppDest, len*sizeof(WCHAR));
1094
1095 if (!ptr)
1096 return FALSE;
1097 MultiByteToWideChar(CP_ACP,0,lpSrc,-1,ptr,len);
1098 *lppDest = ptr;
1099 }
1100 else {
1101 if (*lppDest) {
1102 Free (*lppDest);
1103 *lppDest = NULL;
1104 }
1105 }
1106
1107 return TRUE;
1108 }
1109
1110 /**************************************************************************
1111 * Str_SetPtrWtoA [internal]
1112 *
1113 * Converts a unicode string to a multi byte string.
1114 * If the pointer to the destination buffer is NULL a buffer is allocated.
1115 * If the destination buffer is too small to keep the converted wide
1116 * string the destination buffer is reallocated. If the source pointer is
1117 * NULL, the destination buffer is freed.
1118 *
1119 * PARAMS
1120 * lppDest [I/O] pointer to a pointer to the destination buffer
1121 * lpSrc [I] pointer to a wide string
1122 *
1123 * RETURNS
1124 * TRUE: conversion successful
1125 * FALSE: error
1126 */
1127 BOOL Str_SetPtrWtoA (LPSTR *lppDest, LPCWSTR lpSrc)
1128 {
1129 TRACE("(%p %s)\n", lppDest, debugstr_w(lpSrc));
1130
1131 if (lpSrc) {
1132 INT len = WideCharToMultiByte(CP_ACP,0,lpSrc,-1,NULL,0,NULL,FALSE);
1133 LPSTR ptr = ReAlloc (*lppDest, len*sizeof(CHAR));
1134
1135 if (!ptr)
1136 return FALSE;
1137 WideCharToMultiByte(CP_ACP,0,lpSrc,-1,ptr,len,NULL,FALSE);
1138 *lppDest = ptr;
1139 }
1140 else {
1141 if (*lppDest) {
1142 Free (*lppDest);
1143 *lppDest = NULL;
1144 }
1145 }
1146
1147 return TRUE;
1148 }
1149
1150
1151 /**************************************************************************
1152 * Notification functions
1153 */
1154
1155 typedef struct tagNOTIFYDATA
1156 {
1157 HWND hwndFrom;
1158 HWND hwndTo;
1159 DWORD dwParam3;
1160 DWORD dwParam4;
1161 DWORD dwParam5;
1162 DWORD dwParam6;
1163 } NOTIFYDATA, *LPNOTIFYDATA;
1164
1165
1166 /**************************************************************************
1167 * DoNotify [Internal]
1168 */
1169
1170 static LRESULT DoNotify (LPNOTIFYDATA lpNotify, UINT uCode, LPNMHDR lpHdr)
1171 {
1172 NMHDR nmhdr;
1173 LPNMHDR lpNmh = NULL;
1174 UINT idFrom = 0;
1175
1176 TRACE("(%p %p %d %p 0x%08lx)\n",
1177 lpNotify->hwndFrom, lpNotify->hwndTo, uCode, lpHdr,
1178 lpNotify->dwParam5);
1179
1180 if (!lpNotify->hwndTo)
1181 return 0;
1182
1183 if (lpNotify->hwndFrom == (HWND)-1) {
1184 lpNmh = lpHdr;
1185 idFrom = lpHdr->idFrom;
1186 }
1187 else {
1188 if (lpNotify->hwndFrom)
1189 idFrom = GetDlgCtrlID (lpNotify->hwndFrom);
1190
1191 lpNmh = (lpHdr) ? lpHdr : &nmhdr;
1192
1193 lpNmh->hwndFrom = lpNotify->hwndFrom;
1194 lpNmh->idFrom = idFrom;
1195 lpNmh->code = uCode;
1196 }
1197
1198 return SendMessageW (lpNotify->hwndTo, WM_NOTIFY, idFrom, (LPARAM)lpNmh);
1199 }
1200
1201
1202 /**************************************************************************
1203 * SendNotify [COMCTL32.341]
1204 *
1205 * Sends a WM_NOTIFY message to the specified window.
1206 *
1207 * PARAMS
1208 * hwndTo [I] Window to receive the message
1209 * hwndFrom [I] Window that the message is from (see notes)
1210 * uCode [I] Notification code
1211 * lpHdr [I] The NMHDR and any additional information to send or NULL
1212 *
1213 * RETURNS
1214 * Success: return value from notification
1215 * Failure: 0
1216 *
1217 * NOTES
1218 * If hwndFrom is -1 then the identifier of the control sending the
1219 * message is taken from the NMHDR structure.
1220 * If hwndFrom is not -1 then lpHdr can be NULL.
1221 */
1222 LRESULT WINAPI SendNotify (HWND hwndTo, HWND hwndFrom, UINT uCode, LPNMHDR lpHdr)
1223 {
1224 NOTIFYDATA notify;
1225
1226 TRACE("(%p %p %d %p)\n",
1227 hwndTo, hwndFrom, uCode, lpHdr);
1228
1229 notify.hwndFrom = hwndFrom;
1230 notify.hwndTo = hwndTo;
1231 notify.dwParam5 = 0;
1232 notify.dwParam6 = 0;
1233
1234 return DoNotify (&notify, uCode, lpHdr);
1235 }
1236
1237
1238 /**************************************************************************
1239 * SendNotifyEx [COMCTL32.342]
1240 *
1241 * Sends a WM_NOTIFY message to the specified window.
1242 *
1243 * PARAMS
1244 * hwndFrom [I] Window to receive the message
1245 * hwndTo [I] Window that the message is from
1246 * uCode [I] Notification code
1247 * lpHdr [I] The NMHDR and any additional information to send or NULL
1248 * dwParam5 [I] Unknown
1249 *
1250 * RETURNS
1251 * Success: return value from notification
1252 * Failure: 0
1253 *
1254 * NOTES
1255 * If hwndFrom is -1 then the identifier of the control sending the
1256 * message is taken from the NMHDR structure.
1257 * If hwndFrom is not -1 then lpHdr can be NULL.
1258 */
1259 LRESULT WINAPI SendNotifyEx (HWND hwndTo, HWND hwndFrom, UINT uCode,
1260 LPNMHDR lpHdr, DWORD dwParam5)
1261 {
1262 NOTIFYDATA notify;
1263 HWND hwndNotify;
1264
1265 TRACE("(%p %p %d %p 0x%08lx)\n",
1266 hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
1267
1268 hwndNotify = hwndTo;
1269 if (!hwndTo) {
1270 if (IsWindow (hwndFrom)) {
1271 hwndNotify = GetParent (hwndFrom);
1272 if (!hwndNotify)
1273 return 0;
1274 }
1275 }
1276
1277 notify.hwndFrom = hwndFrom;
1278 notify.hwndTo = hwndNotify;
1279 notify.dwParam5 = dwParam5;
1280 notify.dwParam6 = 0;
1281
1282 return DoNotify (&notify, uCode, lpHdr);
1283 }
A free Windows-compatible Operating System