1 /*
2 * Common controls functions
3 *
4 * Copyright 1997 Dimitrie O. Paun
5 * Copyright 1998,2000 Eric Kohl
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * NOTES
22 *
23 * This code was audited for completeness against the documented features
24 * of Comctl32.dll version 6.0 on Oct. 21, 2002, by Christian Neumair.
25 *
26 * Unless otherwise noted, we believe this code to be complete, as per
27 * the specification mentioned above.
28 * If you discover missing features, or bugs, please note them below.
29 *
30 * TODO
31 * -- implement GetMUILanguage + InitMUILanguage
32 * -- finish NOTES for MenuHelp, GetEffectiveClientRect and GetStatusTextW
33 * -- FIXMEs + BUGS (search for them)
34 *
35 * Control Classes
36 * -- ICC_ANIMATE_CLASS
37 * -- ICC_BAR_CLASSES
38 * -- ICC_COOL_CLASSES
39 * -- ICC_DATE_CLASSES
40 * -- ICC_HOTKEY_CLASS
41 * -- ICC_INTERNET_CLASSES
42 * -- ICC_LINK_CLASS
43 * -- ICC_LISTVIEW_CLASSES
44 * -- ICC_NATIVEFNTCTL_CLASS
45 * -- ICC_PAGESCROLLER_CLASS
46 * -- ICC_PROGRESS_CLASS
47 * -- ICC_STANDARD_CLASSES (not yet implemented)
48 * -- ICC_TAB_CLASSES
49 * -- ICC_TREEVIEW_CLASSES
50 * -- ICC_UPDOWN_CLASS
51 * -- ICC_USEREX_CLASSES
52 * -- ICC_WIN95_CLASSES
53 */
54
55 #include <stdarg.h>
56 #include <string.h>
57 #include <stdlib.h>
58
59 #include "windef.h"
60 #include "winbase.h"
61 #include "wingdi.h"
62 #include "winuser.h"
63 #include "winnls.h"
64 #include "commctrl.h"
65 #include "winerror.h"
66 #include "winreg.h"
67 #define NO_SHLWAPI_STREAM
68 #include "shlwapi.h"
69 #include "comctl32.h"
70 #include "wine/debug.h"
71
72 WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
73
74
75 #define NAME "microsoft.windows.common-controls"
76 #define FILE "comctl32.dll"
77 #define VERSION "6.0.2600.2982"
78 #define PUBLIC_KEY "6595b64144ccf1df"
79
80 #ifdef __i386__
81 #define ARCH "x86"
82 #elif defined __x86_64__
83 #define ARCH "amd64"
84 #else
85 #define ARCH "none"
86 #endif
87
88 static const char manifest[] =
89 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"
90 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n"
91 " <assemblyIdentity type=\"win32\" name=\"" NAME "\" version=\"" VERSION "\" processorArchitecture=\"" ARCH "\" publicKeyToken=\"" PUBLIC_KEY "\"/>\n"
92 " <file name=\"" FILE "\">\n"
93 " <windowClass>Button</windowClass>\n"
94 " <windowClass>ButtonListBox</windowClass>\n"
95 " <windowClass>ComboBoxEx32</windowClass>\n"
96 " <windowClass>ComboLBox</windowClass>\n"
97 " <windowClass>Combobox</windowClass>\n"
98 " <windowClass>Edit</windowClass>\n"
99 " <windowClass>Listbox</windowClass>\n"
100 " <windowClass>NativeFontCtl</windowClass>\n"
101 " <windowClass>ReBarWindow32</windowClass>\n"
102 " <windowClass>ScrollBar</windowClass>\n"
103 " <windowClass>Static</windowClass>\n"
104 " <windowClass>SysAnimate32</windowClass>\n"
105 " <windowClass>SysDateTimePick32</windowClass>\n"
106 " <windowClass>SysHeader32</windowClass>\n"
107 " <windowClass>SysIPAddress32</windowClass>\n"
108 " <windowClass>SysLink</windowClass>\n"
109 " <windowClass>SysListView32</windowClass>\n"
110 " <windowClass>SysMonthCal32</windowClass>\n"
111 " <windowClass>SysPager</windowClass>\n"
112 " <windowClass>SysTabControl32</windowClass>\n"
113 " <windowClass>SysTreeView32</windowClass>\n"
114 " <windowClass>ToolbarWindow32</windowClass>\n"
115 " <windowClass>msctls_hotkey32</windowClass>\n"
116 " <windowClass>msctls_progress32</windowClass>\n"
117 " <windowClass>msctls_statusbar32</windowClass>\n"
118 " <windowClass>msctls_trackbar32</windowClass>\n"
119 " <windowClass>msctls_updown32</windowClass>\n"
120 " <windowClass>tooltips_class32</windowClass>\n"
121 " </file>\n"
122 "</assembly>\n";
123
124 static const char manifest_filename[] = ARCH "_" NAME "_" PUBLIC_KEY "_" VERSION "_none_deadbeef.manifest";
125
126 static LRESULT WINAPI COMCTL32_SubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
127
128 static LPWSTR COMCTL32_wSubclass = NULL;
129 HMODULE COMCTL32_hModule = 0;
130 static LANGID COMCTL32_uiLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
131 HBRUSH COMCTL32_hPattern55AABrush = NULL;
132 COMCTL32_SysColor comctl32_color;
133
134 static HBITMAP COMCTL32_hPattern55AABitmap = NULL;
135
136 static const WORD wPattern55AA[] =
137 {
138 0x5555, 0xaaaa, 0x5555, 0xaaaa,
139 0x5555, 0xaaaa, 0x5555, 0xaaaa
140 };
141
142 static const WCHAR strCC32SubclassInfo[] = {
143 'C','C','3','2','S','u','b','c','l','a','s','s','I','n','f','o',0
144 };
145
146 static BOOL create_manifest( BOOL install )
147 {
148 static const WCHAR winsxsW[] = {'\\','w','i','n','s','x','s',0};
149 static const WCHAR manifestsW[] = {'\\','m','a','n','i','f','e','s','t','s','\\',0};
150
151 DWORD len, written;
152 WCHAR *buffer;
153 HANDLE file;
154 BOOL ret = FALSE;
155
156 len = MultiByteToWideChar( CP_UTF8, 0, manifest_filename, sizeof(manifest_filename), NULL, 0 );
157 len += GetWindowsDirectoryW( NULL, 0 );
158 len += lstrlenW(winsxsW);
159 len += lstrlenW(manifestsW);
160 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
161 GetWindowsDirectoryW( buffer, len );
162 lstrcatW( buffer, winsxsW );
163 CreateDirectoryW( buffer, NULL );
164 lstrcatW( buffer, manifestsW );
165 CreateDirectoryW( buffer, NULL );
166 MultiByteToWideChar( CP_UTF8, 0, manifest_filename, sizeof(manifest_filename),
167 buffer + lstrlenW(buffer), len );
168 if (install)
169 {
170 file = CreateFileW( buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
171 if (file != INVALID_HANDLE_VALUE)
172 {
173 ret = (WriteFile( file, manifest, sizeof(manifest)-1, &written, NULL ) &&
174 written == sizeof(manifest)-1);
175 CloseHandle( file );
176 if (!ret) DeleteFileW( buffer );
177 else TRACE("created %s\n", debugstr_w(buffer));
178 }
179 }
180 else ret = DeleteFileW( buffer );
181
182 HeapFree( GetProcessHeap(), 0, buffer );
183 return ret;
184 }
185
186
187 /***********************************************************************
188 * DllMain [Internal]
189 *
190 * Initializes the internal 'COMCTL32.DLL'.
191 *
192 * PARAMS
193 * hinstDLL [I] handle to the 'dlls' instance
194 * fdwReason [I]
195 * lpvReserved [I] reserverd, must be NULL
196 *
197 * RETURNS
198 * Success: TRUE
199 * Failure: FALSE
200 */
201
202 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
203 {
204 TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
205
206 switch (fdwReason) {
207 case DLL_PROCESS_ATTACH:
208 DisableThreadLibraryCalls(hinstDLL);
209
210 COMCTL32_hModule = hinstDLL;
211
212 /* add global subclassing atom (used by 'tooltip' and 'updown') */
213 COMCTL32_wSubclass = (LPWSTR)(DWORD_PTR)GlobalAddAtomW (strCC32SubclassInfo);
214 TRACE("Subclassing atom added: %p\n", COMCTL32_wSubclass);
215
216 /* create local pattern brush */
217 COMCTL32_hPattern55AABitmap = CreateBitmap (8, 8, 1, 1, wPattern55AA);
218 COMCTL32_hPattern55AABrush = CreatePatternBrush (COMCTL32_hPattern55AABitmap);
219
220 /* Get all the colors at DLL load */
221 COMCTL32_RefreshSysColors();
222
223 /* like comctl32 5.82+ register all the common control classes */
224 ANIMATE_Register ();
225 COMBOEX_Register ();
226 DATETIME_Register ();
227 FLATSB_Register ();
228 HEADER_Register ();
229 HOTKEY_Register ();
230 IPADDRESS_Register ();
231 LISTVIEW_Register ();
232 MONTHCAL_Register ();
233 NATIVEFONT_Register ();
234 PAGER_Register ();
235 PROGRESS_Register ();
236 REBAR_Register ();
237 STATUS_Register ();
238 SYSLINK_Register ();
239 TAB_Register ();
240 TOOLBAR_Register ();
241 TOOLTIPS_Register ();
242 TRACKBAR_Register ();
243 TREEVIEW_Register ();
244 UPDOWN_Register ();
245
246 /* subclass user32 controls */
247 THEMING_Initialize ();
248 break;
249
250 case DLL_PROCESS_DETACH:
251 /* clean up subclassing */
252 THEMING_Uninitialize();
253
254 /* unregister all common control classes */
255 ANIMATE_Unregister ();
256 COMBOEX_Unregister ();
257 DATETIME_Unregister ();
258 FLATSB_Unregister ();
259 HEADER_Unregister ();
260 HOTKEY_Unregister ();
261 IPADDRESS_Unregister ();
262 LISTVIEW_Unregister ();
263 MONTHCAL_Unregister ();
264 NATIVEFONT_Unregister ();
265 PAGER_Unregister ();
266 PROGRESS_Unregister ();
267 REBAR_Unregister ();
268 STATUS_Unregister ();
269 SYSLINK_Unregister ();
270 TAB_Unregister ();
271 TOOLBAR_Unregister ();
272 TOOLTIPS_Unregister ();
273 TRACKBAR_Unregister ();
274 TREEVIEW_Unregister ();
275 UPDOWN_Unregister ();
276
277 /* delete local pattern brush */
278 DeleteObject (COMCTL32_hPattern55AABrush);
279 COMCTL32_hPattern55AABrush = NULL;
280 DeleteObject (COMCTL32_hPattern55AABitmap);
281 COMCTL32_hPattern55AABitmap = NULL;
282
283 /* delete global subclassing atom */
284 GlobalDeleteAtom (LOWORD(COMCTL32_wSubclass));
285 TRACE("Subclassing atom deleted: %p\n", COMCTL32_wSubclass);
286 COMCTL32_wSubclass = NULL;
287 break;
288 }
289
290 return TRUE;
291 }
292
293
294 /***********************************************************************
295 * MenuHelp [COMCTL32.2]
296 *
297 * Handles the setting of status bar help messages when the user
298 * selects menu items.
299 *
300 * PARAMS
301 * uMsg [I] message (WM_MENUSELECT) (see NOTES)
302 * wParam [I] wParam of the message uMsg
303 * lParam [I] lParam of the message uMsg
304 * hMainMenu [I] handle to the application's main menu
305 * hInst [I] handle to the module that contains string resources
306 * hwndStatus [I] handle to the status bar window
307 * lpwIDs [I] pointer to an array of integers (see NOTES)
308 *
309 * RETURNS
310 * No return value
311 *
312 * NOTES
313 * The official documentation is incomplete!
314 * This is the correct documentation:
315 *
316 * uMsg:
317 * MenuHelp() does NOT handle WM_COMMAND messages! It only handles
318 * WM_MENUSELECT messages.
319 *
320 * lpwIDs:
321 * (will be written ...)
322 */
323
324 VOID WINAPI
325 MenuHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu,
326 HINSTANCE hInst, HWND hwndStatus, UINT* lpwIDs)
327 {
328 UINT uMenuID = 0;
329
330 if (!IsWindow (hwndStatus))
331 return;
332
333 switch (uMsg) {
334 case WM_MENUSELECT:
335 TRACE("WM_MENUSELECT wParam=0x%lX lParam=0x%lX\n",
336 wParam, lParam);
337
338 if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) {
339 /* menu was closed */
340 TRACE("menu was closed!\n");
341 SendMessageW (hwndStatus, SB_SIMPLE, FALSE, 0);
342 }
343 else {
344 /* menu item was selected */
345 if (HIWORD(wParam) & MF_POPUP)
346 uMenuID = *(lpwIDs+1);
347 else
348 uMenuID = (UINT)LOWORD(wParam);
349 TRACE("uMenuID = %u\n", uMenuID);
350
351 if (uMenuID) {
352 WCHAR szText[256];
353
354 if (!LoadStringW (hInst, uMenuID, szText, sizeof(szText)/sizeof(szText[0])))
355 szText[0] = '\0';
356
357 SendMessageW (hwndStatus, SB_SETTEXTW,
358 255 | SBT_NOBORDERS, (LPARAM)szText);
359 SendMessageW (hwndStatus, SB_SIMPLE, TRUE, 0);
360 }
361 }
362 break;
363
364 case WM_COMMAND :
365 TRACE("WM_COMMAND wParam=0x%lX lParam=0x%lX\n",
366 wParam, lParam);
367 /* WM_COMMAND is not invalid since it is documented
368 * in the windows api reference. So don't output
369 * any FIXME for WM_COMMAND
370 */
371 WARN("We don't care about the WM_COMMAND\n");
372 break;
373
374 default:
375 FIXME("Invalid Message 0x%x!\n", uMsg);
376 break;
377 }
378 }
379
380
381 /***********************************************************************
382 * ShowHideMenuCtl [COMCTL32.3]
383 *
384 * Shows or hides controls and updates the corresponding menu item.
385 *
386 * PARAMS
387 * hwnd [I] handle to the client window.
388 * uFlags [I] menu command id.
389 * lpInfo [I] pointer to an array of integers. (See NOTES.)
390 *
391 * RETURNS
392 * Success: TRUE
393 * Failure: FALSE
394 *
395 * NOTES
396 * The official documentation is incomplete!
397 * This is the correct documentation:
398 *
399 * hwnd
400 * Handle to the window that contains the menu and controls.
401 *
402 * uFlags
403 * Identifier of the menu item to receive or lose a check mark.
404 *
405 * lpInfo
406 * The array of integers contains pairs of values. BOTH values of
407 * the first pair must be the handles to the application's main menu.
408 * Each subsequent pair consists of a menu id and control id.
409 */
410
411 BOOL WINAPI
412 ShowHideMenuCtl (HWND hwnd, UINT_PTR uFlags, LPINT lpInfo)
413 {
414 LPINT lpMenuId;
415
416 TRACE("%p, %lx, %p\n", hwnd, uFlags, lpInfo);
417
418 if (lpInfo == NULL)
419 return FALSE;
420
421 if (!(lpInfo[0]) || !(lpInfo[1]))
422 return FALSE;
423
424 /* search for control */
425 lpMenuId = &lpInfo[2];
426 while (*lpMenuId != uFlags)
427 lpMenuId += 2;
428
429 if (GetMenuState ((HMENU)(DWORD_PTR)lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) {
430 /* uncheck menu item */
431 CheckMenuItem ((HMENU)(DWORD_PTR)lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED);
432
433 /* hide control */
434 lpMenuId++;
435 SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
436 SWP_HIDEWINDOW);
437 }
438 else {
439 /* check menu item */
440 CheckMenuItem ((HMENU)(DWORD_PTR)lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED);
441
442 /* show control */
443 lpMenuId++;
444 SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
445 SWP_SHOWWINDOW);
446 }
447
448 return TRUE;
449 }
450
451
452 /***********************************************************************
453 * GetEffectiveClientRect [COMCTL32.4]
454 *
455 * Calculates the coordinates of a rectangle in the client area.
456 *
457 * PARAMS
458 * hwnd [I] handle to the client window.
459 * lpRect [O] pointer to the rectangle of the client window
460 * lpInfo [I] pointer to an array of integers (see NOTES)
461 *
462 * RETURNS
463 * No return value.
464 *
465 * NOTES
466 * The official documentation is incomplete!
467 * This is the correct documentation:
468 *
469 * lpInfo
470 * (will be written ...)
471 */
472
473 VOID WINAPI
474 GetEffectiveClientRect (HWND hwnd, LPRECT lpRect, const INT *lpInfo)
475 {
476 RECT rcCtrl;
477 const INT *lpRun;
478 HWND hwndCtrl;
479
480 TRACE("(%p %p %p)\n",
481 hwnd, lpRect, lpInfo);
482
483 GetClientRect (hwnd, lpRect);
484 lpRun = lpInfo;
485
486 do {
487 lpRun += 2;
488 if (*lpRun == 0)
489 return;
490 lpRun++;
491 hwndCtrl = GetDlgItem (hwnd, *lpRun);
492 if (GetWindowLongW (hwndCtrl, GWL_STYLE) & WS_VISIBLE) {
493 TRACE("control id 0x%x\n", *lpRun);
494 GetWindowRect (hwndCtrl, &rcCtrl);
495 MapWindowPoints (NULL, hwnd, (LPPOINT)&rcCtrl, 2);
496 SubtractRect (lpRect, lpRect, &rcCtrl);
497 }
498 lpRun++;
499 } while (*lpRun);
500 }
501
502
503 /***********************************************************************
504 * DrawStatusTextW [COMCTL32.@]
505 *
506 * Draws text with borders, like in a status bar.
507 *
508 * PARAMS
509 * hdc [I] handle to the window's display context
510 * lprc [I] pointer to a rectangle
511 * text [I] pointer to the text
512 * style [I] drawing style
513 *
514 * RETURNS
515 * No return value.
516 *
517 * NOTES
518 * The style variable can have one of the following values:
519 * (will be written ...)
520 */
521
522 void WINAPI DrawStatusTextW (HDC hdc, LPCRECT lprc, LPCWSTR text, UINT style)
523 {
524 RECT r = *lprc;
525 UINT border = BDR_SUNKENOUTER;
526
527 if (style & SBT_POPOUT)
528 border = BDR_RAISEDOUTER;
529 else if (style & SBT_NOBORDERS)
530 border = 0;
531
532 DrawEdge (hdc, &r, border, BF_RECT|BF_ADJUST);
533
534 /* now draw text */
535 if (text) {
536 int oldbkmode = SetBkMode (hdc, TRANSPARENT);
537 UINT align = DT_LEFT;
538 int strCnt = 0;
539
540 if (style & SBT_RTLREADING)
541 FIXME("Unsupported RTL style!\n");
542 r.left += 3;
543 do {
544 if (*text == '\t') {
545 if (strCnt) {
546 DrawTextW (hdc, text - strCnt, strCnt, &r, align|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX);
547 strCnt = 0;
548 }
549 if (align==DT_RIGHT) {
550 break;
551 }
552 align = (align==DT_LEFT ? DT_CENTER : DT_RIGHT);
553 } else {
554 strCnt++;
555 }
556 } while(*text++);
557
558 if (strCnt) DrawTextW (hdc, text - strCnt, -1, &r, align|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX);
559 SetBkMode(hdc, oldbkmode);
560 }
561 }
562
563
564 /***********************************************************************
565 * DrawStatusText [COMCTL32.@]
566 * DrawStatusTextA [COMCTL32.5]
567 *
568 * Draws text with borders, like in a status bar.
569 *
570 * PARAMS
571 * hdc [I] handle to the window's display context
572 * lprc [I] pointer to a rectangle
573 * text [I] pointer to the text
574 * style [I] drawing style
575 *
576 * RETURNS
577 * No return value.
578 */
579
580 void WINAPI DrawStatusTextA (HDC hdc, LPCRECT lprc, LPCSTR text, UINT style)
581 {
582 INT len;
583 LPWSTR textW = NULL;
584
585 if ( text ) {
586 if ( (len = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 )) ) {
587 if ( (textW = Alloc( len * sizeof(WCHAR) )) )
588 MultiByteToWideChar( CP_ACP, 0, text, -1, textW, len );
589 }
590 }
591 DrawStatusTextW( hdc, lprc, textW, style );
592 Free( textW );
593 }
594
595
596 /***********************************************************************
597 * CreateStatusWindow [COMCTL32.@]
598 * CreateStatusWindowA [COMCTL32.6]
599 *
600 * Creates a status bar
601 *
602 * PARAMS
603 * style [I] window style
604 * text [I] pointer to the window text
605 * parent [I] handle to the parent window
606 * wid [I] control id of the status bar
607 *
608 * RETURNS
609 * Success: handle to the status window
610 * Failure: 0
611 */
612
613 HWND WINAPI
614 CreateStatusWindowA (LONG style, LPCSTR text, HWND parent, UINT wid)
615 {
616 return CreateWindowA(STATUSCLASSNAMEA, text, style,
617 CW_USEDEFAULT, CW_USEDEFAULT,
618 CW_USEDEFAULT, CW_USEDEFAULT,
619 parent, (HMENU)(DWORD_PTR)wid, 0, 0);
620 }
621
622
623 /***********************************************************************
624 * CreateStatusWindowW [COMCTL32.@]
625 *
626 * Creates a status bar control
627 *
628 * PARAMS
629 * style [I] window style
630 * text [I] pointer to the window text
631 * parent [I] handle to the parent window
632 * wid [I] control id of the status bar
633 *
634 * RETURNS
635 * Success: handle to the status window
636 * Failure: 0
637 */
638
639 HWND WINAPI
640 CreateStatusWindowW (LONG style, LPCWSTR text, HWND parent, UINT wid)
641 {
642 return CreateWindowW(STATUSCLASSNAMEW, text, style,
643 CW_USEDEFAULT, CW_USEDEFAULT,
644 CW_USEDEFAULT, CW_USEDEFAULT,
645 parent, (HMENU)(DWORD_PTR)wid, 0, 0);
646 }
647
648
649 /***********************************************************************
650 * CreateUpDownControl [COMCTL32.16]
651 *
652 * Creates an up-down control
653 *
654 * PARAMS
655 * style [I] window styles
656 * x [I] horizontal position of the control
657 * y [I] vertical position of the control
658 * cx [I] with of the control
659 * cy [I] height of the control
660 * parent [I] handle to the parent window
661 * id [I] the control's identifier
662 * inst [I] handle to the application's module instance
663 * buddy [I] handle to the buddy window, can be NULL
664 * maxVal [I] upper limit of the control
665 * minVal [I] lower limit of the control
666 * curVal [I] current value of the control
667 *
668 * RETURNS
669 * Success: handle to the updown control
670 * Failure: 0
671 */
672
673 HWND WINAPI
674 CreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
675 HWND parent, INT id, HINSTANCE inst,
676 HWND buddy, INT maxVal, INT minVal, INT curVal)
677 {
678 HWND hUD =
679 CreateWindowW (UPDOWN_CLASSW, 0, style, x, y, cx, cy,
680 parent, (HMENU)(DWORD_PTR)id, inst, 0);
681 if (hUD) {
682 SendMessageW (hUD, UDM_SETBUDDY, (WPARAM)buddy, 0);
683 SendMessageW (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
684 SendMessageW (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));
685 }
686
687 return hUD;
688 }
689
690
691 /***********************************************************************
692 * InitCommonControls [COMCTL32.17]
693 *
694 * Registers the common controls.
695 *
696 * PARAMS
697 * No parameters.
698 *
699 * RETURNS
700 * No return values.
701 *
702 * NOTES
703 * This function is just a dummy - all the controls are registered at
704 * the DLL's initialization. See InitCommonContolsEx for details.
705 */
706
707 VOID WINAPI
708 InitCommonControls (void)
709 {
710 }
711
712
713 /***********************************************************************
714 * InitCommonControlsEx [COMCTL32.@]
715 *
716 * Registers the common controls.
717 *
718 * PARAMS
719 * lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure.
720 *
721 * RETURNS
722 * Success: TRUE
723 * Failure: FALSE
724 *
725 * NOTES
726 * Probably all versions of comctl32 initializes the Win95 controls in DllMain
727 * during DLL initialization. Starting from comctl32 v5.82 all the controls
728 * are initialized there. We follow this behaviour and this function is just
729 * a dummy.
730 *
731 * Note: when writing programs under Windows, if you don't call any function
732 * from comctl32 the linker may not link this DLL. If InitCommonControlsEx
733 * was the only comctl32 function you were calling and you remove it you may
734 * have a false impression that InitCommonControlsEx actually did something.
735 */
736
737 BOOL WINAPI
738 InitCommonControlsEx (const INITCOMMONCONTROLSEX *lpInitCtrls)
739 {
740 if (!lpInitCtrls || lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX))
741 return FALSE;
742
743 TRACE("(0x%08x)\n", lpInitCtrls->dwICC);
744 return TRUE;
745 }
746
747
748 /***********************************************************************
749 * CreateToolbarEx [COMCTL32.@]
750 *
751 * Creates a toolbar window.
752 *
753 * PARAMS
754 * hwnd
755 * style
756 * wID
757 * nBitmaps
758 * hBMInst
759 * wBMID
760 * lpButtons
761 * iNumButtons
762 * dxButton
763 * dyButton
764 * dxBitmap
765 * dyBitmap
766 * uStructSize
767 *
768 * RETURNS
769 * Success: handle to the tool bar control
770 * Failure: 0
771 */
772
773 HWND WINAPI
774 CreateToolbarEx (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
775 HINSTANCE hBMInst, UINT_PTR wBMID, LPCTBBUTTON lpButtons,
776 INT iNumButtons, INT dxButton, INT dyButton,
777 INT dxBitmap, INT dyBitmap, UINT uStructSize)
778 {
779 HWND hwndTB;
780
781 hwndTB =
782 CreateWindowExW(0, TOOLBARCLASSNAMEW, NULL, style|WS_CHILD, 0,0,100,30,
783 hwnd, (HMENU)(DWORD_PTR)wID, COMCTL32_hModule, NULL);
784 if(hwndTB) {
785 TBADDBITMAP tbab;
786
787 SendMessageW (hwndTB, TB_BUTTONSTRUCTSIZE, uStructSize, 0);
788
789 /* set bitmap and button size */
790 /*If CreateToolbarEx receives 0, windows sets default values*/
791 if (dxBitmap < 0)
792 dxBitmap = 16;
793 if (dyBitmap < 0)
794 dyBitmap = 16;
795 if (dxBitmap == 0 || dyBitmap == 0)
796 dxBitmap = dyBitmap = 16;
797 SendMessageW(hwndTB, TB_SETBITMAPSIZE, 0, MAKELPARAM(dxBitmap, dyBitmap));
798
799 if (dxButton < 0)
800 dxButton = dxBitmap;
801 if (dyButton < 0)
802 dyButton = dyBitmap;
803 /* TB_SETBUTTONSIZE -> TB_SETBITMAPSIZE bug introduced for Windows compatibility */
804 if (dxButton != 0 && dyButton != 0)
805 SendMessageW(hwndTB, TB_SETBITMAPSIZE, 0, MAKELPARAM(dxButton, dyButton));
806
807
808 /* add bitmaps */
809 if (nBitmaps > 0 || hBMInst == HINST_COMMCTRL)
810 {
811 tbab.hInst = hBMInst;
812 tbab.nID = wBMID;
813
814 SendMessageW (hwndTB, TB_ADDBITMAP, nBitmaps, (LPARAM)&tbab);
815 }
816 /* add buttons */
817 if(iNumButtons > 0)
818 SendMessageW (hwndTB, TB_ADDBUTTONSW, iNumButtons, (LPARAM)lpButtons);
819 }
820
821 return hwndTB;
822 }
823
824
825 /***********************************************************************
826 * CreateMappedBitmap [COMCTL32.8]
827 *
828 * Loads a bitmap resource using a colour map.
829 *
830 * PARAMS
831 * hInstance [I] Handle to the module containing the bitmap.
832 * idBitmap [I] The bitmap resource ID.
833 * wFlags [I] CMB_MASKED for using bitmap as a mask or 0 for normal.
834 * lpColorMap [I] Colour information needed for the bitmap or NULL (uses system colours).
835 * iNumMaps [I] Number of COLORMAP's pointed to by lpColorMap.
836 *
837 * RETURNS
838 * Success: handle to the new bitmap
839 * Failure: 0
840 */
841
842 HBITMAP WINAPI
843 CreateMappedBitmap (HINSTANCE hInstance, INT_PTR idBitmap, UINT wFlags,
844 LPCOLORMAP lpColorMap, INT iNumMaps)
845 {
846 HGLOBAL hglb;
847 HRSRC hRsrc;
848 const BITMAPINFOHEADER *lpBitmap;
849 LPBITMAPINFOHEADER lpBitmapInfo;
850 UINT nSize, nColorTableSize, iColor;
851 RGBQUAD *pColorTable;
852 INT i, iMaps, nWidth, nHeight;
853 HDC hdcScreen;
854 HBITMAP hbm;
855 LPCOLORMAP sysColorMap;
856 COLORREF cRef;
857 COLORMAP internalColorMap[4] =
858 {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
859
860 /* initialize pointer to colortable and default color table */
861 if (lpColorMap) {
862 iMaps = iNumMaps;
863 sysColorMap = lpColorMap;
864 }
865 else {
866 internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT);
867 internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW);
868 internalColorMap[2].to = GetSysColor (COLOR_BTNFACE);
869 internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT);
870 iMaps = 4;
871 sysColorMap = internalColorMap;
872 }
873
874 hRsrc = FindResourceW (hInstance, (LPWSTR)idBitmap, (LPWSTR)RT_BITMAP);
875 if (hRsrc == 0)
876 return 0;
877 hglb = LoadResource (hInstance, hRsrc);
878 if (hglb == 0)
879 return 0;
880 lpBitmap = LockResource (hglb);
881 if (lpBitmap == NULL)
882 return 0;
883
884 if (lpBitmap->biSize >= sizeof(BITMAPINFOHEADER) && lpBitmap->biClrUsed)
885 nColorTableSize = lpBitmap->biClrUsed;
886 else if (lpBitmap->biBitCount <= 8)
887 nColorTableSize = (1 << lpBitmap->biBitCount);
888 else
889 nColorTableSize = 0;
890 nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD);
891 lpBitmapInfo = GlobalAlloc (GMEM_FIXED, nSize);
892 if (lpBitmapInfo == NULL)
893 return 0;
894 RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize);
895
896 pColorTable = (RGBQUAD*)(((LPBYTE)lpBitmapInfo) + lpBitmapInfo->biSize);
897
898 for (iColor = 0; iColor < nColorTableSize; iColor++) {
899 for (i = 0; i < iMaps; i++) {
900 cRef = RGB(pColorTable[iColor].rgbRed,
901 pColorTable[iColor].rgbGreen,
902 pColorTable[iColor].rgbBlue);
903 if ( cRef == sysColorMap[i].from) {
904 #if 0
905 if (wFlags & CBS_MASKED) {
906 if (sysColorMap[i].to != COLOR_BTNTEXT)
907 pColorTable[iColor] = RGB(255, 255, 255);
908 }
909 else
910 #endif
911 pColorTable[iColor].rgbBlue = GetBValue(sysColorMap[i].to);
912 pColorTable[iColor].rgbGreen = GetGValue(sysColorMap[i].to);
913 pColorTable[iColor].rgbRed = GetRValue(sysColorMap[i].to);
914 break;
915 }
916 }
917 }
918 nWidth = lpBitmapInfo->biWidth;
919 nHeight = lpBitmapInfo->biHeight;
920 hdcScreen = GetDC (NULL);
921 hbm = CreateCompatibleBitmap (hdcScreen, nWidth, nHeight);
922 if (hbm) {
923 HDC hdcDst = CreateCompatibleDC (hdcScreen);
924 HBITMAP hbmOld = SelectObject (hdcDst, hbm);
925 const BYTE *lpBits = (const BYTE *)(lpBitmap + 1);
926 lpBits += nColorTableSize * sizeof(RGBQUAD);
927 StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
928 lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS,
929 SRCCOPY);
930 SelectObject (hdcDst, hbmOld);
931 DeleteDC (hdcDst);
932 }
933 ReleaseDC (NULL, hdcScreen);
934 GlobalFree (lpBitmapInfo);
935 FreeResource (hglb);
936
937 return hbm;
938 }
939
940
941 /***********************************************************************
942 * CreateToolbar [COMCTL32.7]
943 *
944 * Creates a toolbar control.
945 *
946 * PARAMS
947 * hwnd
948 * style
949 * wID
950 * nBitmaps
951 * hBMInst
952 * wBMID
953 * lpButtons
954 * iNumButtons
955 *
956 * RETURNS
957 * Success: handle to the tool bar control
958 * Failure: 0
959 *
960 * NOTES
961 * Do not use this functions anymore. Use CreateToolbarEx instead.
962 */
963
964 HWND WINAPI
965 CreateToolbar (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
966 HINSTANCE hBMInst, UINT wBMID,
967 LPCTBBUTTON lpButtons,INT iNumButtons)
968 {
969 return CreateToolbarEx (hwnd, style | CCS_NODIVIDER, wID, nBitmaps,
970 hBMInst, wBMID, lpButtons,
971 iNumButtons, 0, 0, 0, 0, CCSIZEOF_STRUCT(TBBUTTON, dwData));
972 }
973
974
975 /***********************************************************************
976 * DllGetVersion [COMCTL32.@]
977 *
978 * Retrieves version information of the 'COMCTL32.DLL'
979 *
980 * PARAMS
981 * pdvi [O] pointer to version information structure.
982 *
983 * RETURNS
984 * Success: S_OK
985 * Failure: E_INVALIDARG
986 *
987 * NOTES
988 * Returns version of a comctl32.dll from IE4.01 SP1.
989 */
990
991 HRESULT WINAPI DllGetVersion (DLLVERSIONINFO *pdvi)
992 {
993 if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
994 WARN("wrong DLLVERSIONINFO size from app\n");
995 return E_INVALIDARG;
996 }
997
998 pdvi->dwMajorVersion = COMCTL32_VERSION;
999 pdvi->dwMinorVersion = COMCTL32_VERSION_MINOR;
1000 pdvi->dwBuildNumber = 2919;
1001 pdvi->dwPlatformID = 6304;
1002
1003 TRACE("%u.%u.%u.%u\n",
1004 pdvi->dwMajorVersion, pdvi->dwMinorVersion,
1005 pdvi->dwBuildNumber, pdvi->dwPlatformID);
1006
1007 return S_OK;
1008 }
1009
1010 /***********************************************************************
1011 * DllInstall (COMCTL32.@)
1012 *
1013 * Installs the ComCtl32 DLL.
1014 *
1015 * RETURNS
1016 * Success: S_OK
1017 * Failure: A HRESULT error
1018 */
1019 HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
1020 {
1021 TRACE("(%u, %s): stub\n", bInstall, debugstr_w(cmdline));
1022 if (!create_manifest( bInstall )) return HRESULT_FROM_WIN32(GetLastError());
1023 return S_OK;
1024 }
1025
1026 /***********************************************************************
1027 * _TrackMouseEvent [COMCTL32.@]
1028 *
1029 * Requests notification of mouse events
1030 *
1031 * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
1032 * to the hwnd specified in the ptme structure. After the event message
1033 * is posted to the hwnd, the entry in the queue is removed.
1034 *
1035 * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
1036 * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
1037 * immediately and the TME_LEAVE flag being ignored.
1038 *
1039 * PARAMS
1040 * ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
1041 *
1042 * RETURNS
1043 * Success: non-zero
1044 * Failure: zero
1045 *
1046 * IMPLEMENTATION moved to USER32.TrackMouseEvent
1047 *
1048 */
1049
1050 BOOL WINAPI
1051 _TrackMouseEvent (TRACKMOUSEEVENT *ptme)
1052 {
1053 return TrackMouseEvent (ptme);
1054 }
1055
1056 /*************************************************************************
1057 * GetMUILanguage [COMCTL32.@]
1058 *
1059 * Returns the user interface language in use by the current process.
1060 *
1061 * RETURNS
1062 * Language ID in use by the current process.
1063 */
1064 LANGID WINAPI GetMUILanguage (VOID)
1065 {
1066 return COMCTL32_uiLang;
1067 }
1068
1069
1070 /*************************************************************************
1071 * InitMUILanguage [COMCTL32.@]
1072 *
1073 * Sets the user interface language to be used by the current process.
1074 *
1075 * RETURNS
1076 * Nothing.
1077 */
1078 VOID WINAPI InitMUILanguage (LANGID uiLang)
1079 {
1080 COMCTL32_uiLang = uiLang;
1081 }
1082
1083
1084 /***********************************************************************
1085 * SetWindowSubclass [COMCTL32.410]
1086 *
1087 * Starts a window subclass
1088 *
1089 * PARAMS
1090 * hWnd [in] handle to window subclass.
1091 * pfnSubclass [in] Pointer to new window procedure.
1092 * uIDSubclass [in] Unique identifier of sublass together with pfnSubclass.
1093 * dwRef [in] Reference data to pass to window procedure.
1094 *
1095 * RETURNS
1096 * Success: non-zero
1097 * Failure: zero
1098 *
1099 * BUGS
1100 * If an application manually subclasses a window after subclassing it with
1101 * this API and then with this API again, then none of the previous
1102 * subclasses get called or the original window procedure.
1103 */
1104
1105 BOOL WINAPI SetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
1106 UINT_PTR uIDSubclass, DWORD_PTR dwRef)
1107 {
1108 LPSUBCLASS_INFO stack;
1109 LPSUBCLASSPROCS proc;
1110
1111 TRACE ("(%p, %p, %lx, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef);
1112
1113 /* Since the window procedure that we set here has two additional arguments,
1114 * we can't simply set it as the new window procedure of the window. So we
1115 * set our own window procedure and then calculate the other two arguments
1116 * from there. */
1117
1118 /* See if we have been called for this window */
1119 stack = GetPropW (hWnd, COMCTL32_wSubclass);
1120 if (!stack) {
1121 /* allocate stack */
1122 stack = Alloc (sizeof(SUBCLASS_INFO));
1123 if (!stack) {
1124 ERR ("Failed to allocate our Subclassing stack\n");
1125 return FALSE;
1126 }
1127 SetPropW (hWnd, COMCTL32_wSubclass, stack);
1128
1129 /* set window procedure to our own and save the current one */
1130 if (IsWindowUnicode (hWnd))
1131 stack->origproc = (WNDPROC)SetWindowLongPtrW (hWnd, GWLP_WNDPROC,
1132 (DWORD_PTR)COMCTL32_SubclassProc);
1133 else
1134 stack->origproc = (WNDPROC)SetWindowLongPtrA (hWnd, GWLP_WNDPROC,
1135 (DWORD_PTR)COMCTL32_SubclassProc);
1136 }
1137 else {
1138 /* Check to see if we have called this function with the same uIDSubClass
1139 * and pfnSubclass */
1140 proc = stack->SubclassProcs;
1141 while (proc) {
1142 if ((proc->id == uIDSubclass) &&
1143 (proc->subproc == pfnSubclass)) {
1144 proc->ref = dwRef;
1145 return TRUE;
1146 }
1147 proc = proc->next;
1148 }
1149 }
1150
1151 proc = Alloc(sizeof(SUBCLASSPROCS));
1152 if (!proc) {
1153 ERR ("Failed to allocate subclass entry in stack\n");
1154 if (IsWindowUnicode (hWnd))
1155 SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1156 else
1157 SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1158 Free (stack);
1159 RemovePropW( hWnd, COMCTL32_wSubclass );
1160 return FALSE;
1161 }
1162
1163 proc->subproc = pfnSubclass;
1164 proc->ref = dwRef;
1165 proc->id = uIDSubclass;
1166 proc->next = stack->SubclassProcs;
1167 stack->SubclassProcs = proc;
1168
1169 return TRUE;
1170 }
1171
1172
1173 /***********************************************************************
1174 * GetWindowSubclass [COMCTL32.411]
1175 *
1176 * Gets the Reference data from a subclass.
1177 *
1178 * PARAMS
1179 * hWnd [in] Handle to window which were subclassing
1180 * pfnSubclass [in] Pointer to the subclass procedure
1181 * uID [in] Unique indentifier of the subclassing procedure
1182 * pdwRef [out] Pointer to the reference data
1183 *
1184 * RETURNS
1185 * Success: Non-zero
1186 * Failure: 0
1187 */
1188
1189 BOOL WINAPI GetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
1190 UINT_PTR uID, DWORD_PTR *pdwRef)
1191 {
1192 const SUBCLASS_INFO *stack;
1193 const SUBCLASSPROCS *proc;
1194
1195 TRACE ("(%p, %p, %lx, %p)\n", hWnd, pfnSubclass, uID, pdwRef);
1196
1197 /* See if we have been called for this window */
1198 stack = GetPropW (hWnd, COMCTL32_wSubclass);
1199 if (!stack)
1200 return FALSE;
1201
1202 proc = stack->SubclassProcs;
1203 while (proc) {
1204 if ((proc->id == uID) &&
1205 (proc->subproc == pfnSubclass)) {
1206 *pdwRef = proc->ref;
1207 return TRUE;
1208 }
1209 proc = proc->next;
1210 }
1211
1212 return FALSE;
1213 }
1214
1215
1216 /***********************************************************************
1217 * RemoveWindowSubclass [COMCTL32.412]
1218 *
1219 * Removes a window subclass.
1220 *
1221 * PARAMS
1222 * hWnd [in] Handle to the window were subclassing
1223 * pfnSubclass [in] Pointer to the subclass procedure
1224 * uID [in] Unique identifier of this subclass
1225 *
1226 * RETURNS
1227 * Success: non-zero
1228 * Failure: zero
1229 */
1230
1231 BOOL WINAPI RemoveWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uID)
1232 {
1233 LPSUBCLASS_INFO stack;
1234 LPSUBCLASSPROCS prevproc = NULL;
1235 LPSUBCLASSPROCS proc;
1236 BOOL ret = FALSE;
1237
1238 TRACE ("(%p, %p, %lx)\n", hWnd, pfnSubclass, uID);
1239
1240 /* Find the Subclass to remove */
1241 stack = GetPropW (hWnd, COMCTL32_wSubclass);
1242 if (!stack)
1243 return FALSE;
1244
1245 proc = stack->SubclassProcs;
1246 while (proc) {
1247 if ((proc->id == uID) &&
1248 (proc->subproc == pfnSubclass)) {
1249
1250 if (!prevproc)
1251 stack->SubclassProcs = proc->next;
1252 else
1253 prevproc->next = proc->next;
1254
1255 if (stack->stackpos == proc)
1256 stack->stackpos = stack->stackpos->next;
1257
1258 Free (proc);
1259 ret = TRUE;
1260 break;
1261 }
1262 prevproc = proc;
1263 proc = proc->next;
1264 }
1265
1266 if (!stack->SubclassProcs && !stack->running) {
1267 TRACE("Last Subclass removed, cleaning up\n");
1268 /* clean up our heap and reset the original window procedure */
1269 if (IsWindowUnicode (hWnd))
1270 SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1271 else
1272 SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1273 Free (stack);
1274 RemovePropW( hWnd, COMCTL32_wSubclass );
1275 }
1276
1277 return ret;
1278 }
1279
1280 /***********************************************************************
1281 * COMCTL32_SubclassProc (internal)
1282 *
1283 * Window procedure for all subclassed windows.
1284 * Saves the current subclassing stack position to support nested messages
1285 */
1286 static LRESULT WINAPI COMCTL32_SubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1287 {
1288 LPSUBCLASS_INFO stack;
1289 LPSUBCLASSPROCS proc;
1290 LRESULT ret;
1291
1292 TRACE ("(%p, 0x%08x, 0x%08lx, 0x%08lx)\n", hWnd, uMsg, wParam, lParam);
1293
1294 stack = GetPropW (hWnd, COMCTL32_wSubclass);
1295 if (!stack) {
1296 ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd);
1297 return 0;
1298 }
1299
1300 /* Save our old stackpos to properly handle nested messages */
1301 proc = stack->stackpos;
1302 stack->stackpos = stack->SubclassProcs;
1303 stack->running++;
1304 ret = DefSubclassProc(hWnd, uMsg, wParam, lParam);
1305 stack->running--;
1306 stack->stackpos = proc;
1307
1308 if (!stack->SubclassProcs && !stack->running) {
1309 TRACE("Last Subclass removed, cleaning up\n");
1310 /* clean up our heap and reset the original window procedure */
1311 if (IsWindowUnicode (hWnd))
1312 SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1313 else
1314 SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
1315 Free (stack);
1316 RemovePropW( hWnd, COMCTL32_wSubclass );
1317 }
1318 return ret;
1319 }
1320
1321 /***********************************************************************
1322 * DefSubclassProc [COMCTL32.413]
1323 *
1324 * Calls the next window procedure (ie. the one before this subclass)
1325 *
1326 * PARAMS
1327 * hWnd [in] The window that we're subclassing
1328 * uMsg [in] Message
1329 * wParam [in] WPARAM
1330 * lParam [in] LPARAM
1331 *
1332 * RETURNS
1333 * Success: non-zero
1334 * Failure: zero
1335 */
1336
1337 LRESULT WINAPI DefSubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1338 {
1339 LPSUBCLASS_INFO stack;
1340 LRESULT ret;
1341
1342 TRACE ("(%p, 0x%08x, 0x%08lx, 0x%08lx)\n", hWnd, uMsg, wParam, lParam);
1343
1344 /* retrieve our little stack from the Properties */
1345 stack = GetPropW (hWnd, COMCTL32_wSubclass);
1346 if (!stack) {
1347 ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd);
1348 return 0;
1349 }
1350
1351 /* If we are at the end of stack then we have to call the original
1352 * window procedure */
1353 if (!stack->stackpos) {
1354 if (IsWindowUnicode (hWnd))
1355 ret = CallWindowProcW (stack->origproc, hWnd, uMsg, wParam, lParam);
1356 else
1357 ret = CallWindowProcA (stack->origproc, hWnd, uMsg, wParam, lParam);
1358 } else {
1359 const SUBCLASSPROCS *proc = stack->stackpos;
1360 stack->stackpos = stack->stackpos->next;
1361 /* call the Subclass procedure from the stack */
1362 ret = proc->subproc (hWnd, uMsg, wParam, lParam,
1363 proc->id, proc->ref);
1364 }
1365
1366 return ret;
1367 }
1368
1369
1370 /***********************************************************************
1371 * COMCTL32_CreateToolTip [NOT AN API]
1372 *
1373 * Creates a tooltip for the control specified in hwnd and does all
1374 * necessary setup and notifications.
1375 *
1376 * PARAMS
1377 * hwndOwner [I] Handle to the window that will own the tool tip.
1378 *
1379 * RETURNS
1380 * Success: Handle of tool tip window.
1381 * Failure: NULL
1382 */
1383
1384 HWND
1385 COMCTL32_CreateToolTip(HWND hwndOwner)
1386 {
1387 HWND hwndToolTip;
1388
1389 hwndToolTip = CreateWindowExW(0, TOOLTIPS_CLASSW, NULL, WS_POPUP,
1390 CW_USEDEFAULT, CW_USEDEFAULT,
1391 CW_USEDEFAULT, CW_USEDEFAULT, hwndOwner,
1392 0, 0, 0);
1393
1394 /* Send NM_TOOLTIPSCREATED notification */
1395 if (hwndToolTip)
1396 {
1397 NMTOOLTIPSCREATED nmttc;
1398 /* true owner can be different if hwndOwner is a child window */
1399 HWND hwndTrueOwner = GetWindow(hwndToolTip, GW_OWNER);
1400 nmttc.hdr.hwndFrom = hwndTrueOwner;
1401 nmttc.hdr.idFrom = GetWindowLongPtrW(hwndTrueOwner, GWLP_ID);
1402 nmttc.hdr.code = NM_TOOLTIPSCREATED;
1403 nmttc.hwndToolTips = hwndToolTip;
1404
1405 SendMessageW(GetParent(hwndTrueOwner), WM_NOTIFY,
1406 GetWindowLongPtrW(hwndTrueOwner, GWLP_ID), (LPARAM)&nmttc);
1407 }
1408
1409 return hwndToolTip;
1410 }
1411
1412
1413 /***********************************************************************
1414 * COMCTL32_RefreshSysColors [NOT AN API]
1415 *
1416 * Invoked on any control recognizing a WM_SYSCOLORCHANGE message to
1417 * refresh the color values in the color structure
1418 *
1419 * PARAMS
1420 * none
1421 *
1422 * RETURNS
1423 * none
1424 */
1425
1426 VOID
1427 COMCTL32_RefreshSysColors(void)
1428 {
1429 comctl32_color.clrBtnHighlight = GetSysColor (COLOR_BTNHIGHLIGHT);
1430 comctl32_color.clrBtnShadow = GetSysColor (COLOR_BTNSHADOW);
1431 comctl32_color.clrBtnText = GetSysColor (COLOR_BTNTEXT);
1432 comctl32_color.clrBtnFace = GetSysColor (COLOR_BTNFACE);
1433 comctl32_color.clrHighlight = GetSysColor (COLOR_HIGHLIGHT);
1434 comctl32_color.clrHighlightText = GetSysColor (COLOR_HIGHLIGHTTEXT);
1435 comctl32_color.clrHotTrackingColor = GetSysColor (COLOR_HOTLIGHT);
1436 comctl32_color.clr3dHilight = GetSysColor (COLOR_3DHILIGHT);
1437 comctl32_color.clr3dShadow = GetSysColor (COLOR_3DSHADOW);
1438 comctl32_color.clr3dDkShadow = GetSysColor (COLOR_3DDKSHADOW);
1439 comctl32_color.clr3dFace = GetSysColor (COLOR_3DFACE);
1440 comctl32_color.clrWindow = GetSysColor (COLOR_WINDOW);
1441 comctl32_color.clrWindowText = GetSysColor (COLOR_WINDOWTEXT);
1442 comctl32_color.clrGrayText = GetSysColor (COLOR_GRAYTEXT);
1443 comctl32_color.clrActiveCaption = GetSysColor (COLOR_ACTIVECAPTION);
1444 comctl32_color.clrInfoBk = GetSysColor (COLOR_INFOBK);
1445 comctl32_color.clrInfoText = GetSysColor (COLOR_INFOTEXT);
1446 }
1447
1448 /***********************************************************************
1449 * COMCTL32_DrawInsertMark [NOT AN API]
1450 *
1451 * Draws an insertion mark (which looks similar to an 'I').
1452 *
1453 * PARAMS
1454 * hDC [I] Device context to draw onto.
1455 * lpRect [I] Co-ordinates of insertion mark.
1456 * clrInsertMark [I] Colour of the insertion mark.
1457 * bHorizontal [I] True if insert mark should be drawn horizontally,
1458 * vertical otherwise.
1459 *
1460 * RETURNS
1461 * none
1462 *
1463 * NOTES
1464 * Draws up to but not including the bottom co-ordinate when drawing
1465 * vertically or the right co-ordinate when horizontal.
1466 */
1467 void COMCTL32_DrawInsertMark(HDC hDC, const RECT *lpRect, COLORREF clrInsertMark, BOOL bHorizontal)
1468 {
1469 HPEN hPen = CreatePen(PS_SOLID, 1, clrInsertMark);
1470 HPEN hOldPen;
1471 static const DWORD adwPolyPoints[] = {4,4,4};
1472 LONG lCentre = (bHorizontal ?
1473 lpRect->top + (lpRect->bottom - lpRect->top)/2 :
1474 lpRect->left + (lpRect->right - lpRect->left)/2);
1475 LONG l1 = (bHorizontal ? lpRect->left : lpRect->top);
1476 LONG l2 = (bHorizontal ? lpRect->right : lpRect->bottom);
1477 const POINT aptInsertMark[] =
1478 {
1479 /* top (V) or left (H) arrow */
1480 {lCentre , l1 + 2},
1481 {lCentre - 2, l1 },
1482 {lCentre + 3, l1 },
1483 {lCentre + 1, l1 + 2},
1484 /* middle line */
1485 {lCentre , l2 - 2},
1486 {lCentre , l1 - 1},
1487 {lCentre + 1, l1 - 1},
1488 {lCentre + 1, l2 - 2},
1489 /* bottom (V) or right (H) arrow */
1490 {lCentre , l2 - 3},
1491 {lCentre - 2, l2 - 1},
1492 {lCentre + 3, l2 - 1},
1493 {lCentre + 1, l2 - 3},
1494 };
1495 hOldPen = SelectObject(hDC, hPen);
1496 PolyPolyline(hDC, aptInsertMark, adwPolyPoints, sizeof(adwPolyPoints)/sizeof(adwPolyPoints[0]));
1497 SelectObject(hDC, hOldPen);
1498 DeleteObject(hPen);
1499 }
1500
1501 /***********************************************************************
1502 * COMCTL32_EnsureBitmapSize [internal]
1503 *
1504 * If needed, enlarge the bitmap so that the width is at least cxMinWidth and
1505 * the height is at least cyMinHeight. If the bitmap already has these
1506 * dimensions nothing changes.
1507 *
1508 * PARAMS
1509 * hBitmap [I/O] Bitmap to modify. The handle may change
1510 * cxMinWidth [I] If the width of the bitmap is smaller, then it will
1511 * be enlarged to this value
1512 * cyMinHeight [I] If the height of the bitmap is smaller, then it will
1513 * be enlarged to this value
1514 * cyBackground [I] The color with which the new area will be filled
1515 *
1516 * RETURNS
1517 * none
1518 */
1519 void COMCTL32_EnsureBitmapSize(HBITMAP *pBitmap, int cxMinWidth, int cyMinHeight, COLORREF crBackground)
1520 {
1521 int cxNew, cyNew;
1522 BITMAP bmp;
1523 HBITMAP hNewBitmap;
1524 HBITMAP hNewDCBitmap, hOldDCBitmap;
1525 HBRUSH hNewDCBrush;
1526 HDC hdcNew, hdcOld;
1527
1528 if (!GetObjectW(*pBitmap, sizeof(BITMAP), &bmp))
1529 return;
1530 cxNew = (cxMinWidth > bmp.bmWidth ? cxMinWidth : bmp.bmWidth);
1531 cyNew = (cyMinHeight > bmp.bmHeight ? cyMinHeight : bmp.bmHeight);
1532 if (cxNew == bmp.bmWidth && cyNew == bmp.bmHeight)
1533 return;
1534
1535 hdcNew = CreateCompatibleDC(NULL);
1536 hNewBitmap = CreateBitmap(cxNew, cyNew, bmp.bmPlanes, bmp.bmBitsPixel, NULL);
1537 hNewDCBitmap = SelectObject(hdcNew, hNewBitmap);
1538 hNewDCBrush = SelectObject(hdcNew, CreateSolidBrush(crBackground));
1539
1540 hdcOld = CreateCompatibleDC(NULL);
1541 hOldDCBitmap = SelectObject(hdcOld, *pBitmap);
1542
1543 BitBlt(hdcNew, 0, 0, bmp.bmWidth, bmp.bmHeight, hdcOld, 0, 0, SRCCOPY);
1544 if (bmp.bmWidth < cxMinWidth)
1545 PatBlt(hdcNew, bmp.bmWidth, 0, cxNew, bmp.bmHeight, PATCOPY);
1546 if (bmp.bmHeight < cyMinHeight)
1547 PatBlt(hdcNew, 0, bmp.bmHeight, bmp.bmWidth, cyNew, PATCOPY);
1548 if (bmp.bmWidth < cxMinWidth && bmp.bmHeight < cyMinHeight)
1549 PatBlt(hdcNew, bmp.bmWidth, bmp.bmHeight, cxNew, cyNew, PATCOPY);
1550
1551 SelectObject(hdcNew, hNewDCBitmap);
1552 DeleteObject(SelectObject(hdcNew, hNewDCBrush));
1553 DeleteDC(hdcNew);
1554 SelectObject(hdcOld, hOldDCBitmap);
1555 DeleteDC(hdcOld);
1556
1557 DeleteObject(*pBitmap);
1558 *pBitmap = hNewBitmap;
1559 return;
1560 }
1561
1562 void COMCTL32_GetFontMetrics(HFONT hFont, TEXTMETRICW *ptm)
1563 {
1564 HDC hdc = GetDC(NULL);
1565 HFONT hOldFont;
1566
1567 hOldFont = SelectObject(hdc, hFont);
1568 GetTextMetricsW(hdc, ptm);
1569 SelectObject(hdc, hOldFont);
1570 ReleaseDC(NULL, hdc);
1571 }
1572
1573 #ifndef OCM__BASE /* avoid including olectl.h */
1574 #define OCM__BASE (WM_USER+0x1c00)
1575 #endif
1576
1577 /***********************************************************************
1578 * COMCTL32_IsReflectedMessage [internal]
1579 *
1580 * Some parents reflect notify messages - for some messages sent by the child,
1581 * they send it back with the message code increased by OCM__BASE (0x2000).
1582 * This allows better subclassing of controls. We don't need to handle such
1583 * messages but we don't want to print ERRs for them, so this helper function
1584 * identifies them.
1585 *
1586 * Some of the codes are in the CCM_FIRST..CCM_LAST range, but there is no
1587 * colision with defined CCM_ codes.
1588 */
1589 BOOL COMCTL32_IsReflectedMessage(UINT uMsg)
1590 {
1591 switch (uMsg)
1592 {
1593 case OCM__BASE + WM_COMMAND:
1594 case OCM__BASE + WM_CTLCOLORBTN:
1595 case OCM__BASE + WM_CTLCOLOREDIT:
1596 case OCM__BASE + WM_CTLCOLORDLG:
1597 case OCM__BASE + WM_CTLCOLORLISTBOX:
1598 case OCM__BASE + WM_CTLCOLORMSGBOX:
1599 case OCM__BASE + WM_CTLCOLORSCROLLBAR:
1600 case OCM__BASE + WM_CTLCOLORSTATIC:
1601 case OCM__BASE + WM_DRAWITEM:
1602 case OCM__BASE + WM_MEASUREITEM:
1603 case OCM__BASE + WM_DELETEITEM:
1604 case OCM__BASE + WM_VKEYTOITEM:
1605 case OCM__BASE + WM_CHARTOITEM:
1606 case OCM__BASE + WM_COMPAREITEM:
1607 case OCM__BASE + WM_HSCROLL:
1608 case OCM__BASE + WM_VSCROLL:
1609 case OCM__BASE + WM_PARENTNOTIFY:
1610 case OCM__BASE + WM_NOTIFY:
1611 return TRUE;
1612 default:
1613 return FALSE;
1614 }
1615 }
1616
1617 /***********************************************************************
1618 * MirrorIcon [COMCTL32.414]
1619 *
1620 * Mirrors an icon so that it will appear correctly on a mirrored DC.
1621 *
1622 * PARAMS
1623 * phicon1 [I/O] Icon.
1624 * phicon2 [I/O] Icon.
1625 *
1626 * RETURNS
1627 * Success: TRUE.
1628 * Failure: FALSE.
1629 */
1630 BOOL WINAPI MirrorIcon(HICON *phicon1, HICON *phicon2)
1631 {
1632 FIXME("(%p, %p): stub\n", phicon1, phicon2);
1633 return FALSE;
1634 }
1635
1636 static inline int IsDelimiter(WCHAR c)
1637 {
1638 switch(c)
1639 {
1640 case '/':
1641 case '\\':
1642 case '.':
1643 case ' ':
1644 return TRUE;
1645 }
1646 return FALSE;
1647 }
1648
1649 static int CALLBACK PathWordBreakProc(LPCWSTR lpch, int ichCurrent, int cch, int code)
1650 {
1651 if (code == WB_ISDELIMITER)
1652 return IsDelimiter(lpch[ichCurrent]);
1653 else
1654 {
1655 int dir = (code == WB_LEFT) ? -1 : 1;
1656 for(; 0 <= ichCurrent && ichCurrent < cch; ichCurrent += dir)
1657 if (IsDelimiter(lpch[ichCurrent])) return ichCurrent;
1658 }
1659 return ichCurrent;
1660 }
1661
1662 /***********************************************************************
1663 * SetPathWordBreakProc [COMCTL32.384]
1664 *
1665 * Sets the word break procedure for an edit control to one that understands
1666 * paths so that the user can jump over directories.
1667 *
1668 * PARAMS
1669 * hwnd [I] Handle to edit control.
1670 * bSet [I] If this is TRUE then the word break proc is set, otherwise it is removed.
1671 *
1672 * RETURNS
1673 * Result from EM_SETWORDBREAKPROC message.
1674 */
1675 LRESULT WINAPI SetPathWordBreakProc(HWND hwnd, BOOL bSet)
1676 {
1677 return SendMessageW(hwnd, EM_SETWORDBREAKPROC, 0,
1678 (LPARAM)(bSet ? PathWordBreakProc : NULL));
1679 }
1680
1681 /***********************************************************************
1682 * DrawShadowText [COMCTL32.@]
1683 *
1684 * Draw text with shadow.
1685 */
1686 int WINAPI DrawShadowText(HDC hdc, LPCWSTR pszText, UINT cch, RECT *rect, DWORD dwFlags,
1687 COLORREF crText, COLORREF crShadow, int ixOffset, int iyOffset)
1688 {
1689 FIXME("(%p, %s, %d, %p, %d, 0x%08x, 0x%08x, %d, %d): stub\n", hdc, debugstr_w(pszText), cch, rect, dwFlags,
1690 crText, crShadow, ixOffset, iyOffset);
1691 return DrawTextW(hdc, pszText, cch, rect, DT_LEFT);
1692 }
1693
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.