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