source: trunk/src/comctl32/commctrl.c@ 8382

Last change on this file since 8382 was 8382, checked in by sandervl, 23 years ago

merge with latest Wine
File size: 28.9 KB
Line 
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22#include <string.h>
23#include <stdlib.h>
24
25#include "winbase.h"
26#include "commctrl.h"
27#include "winerror.h"
28#include "winreg.h"
29#define NO_SHLWAPI_STREAM
30#include "shlwapi.h"
31#include "comctl32.h"
32#include "wine/debug.h"
33
34WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
35
36extern void ANIMATE_Register(void);
37extern void ANIMATE_Unregister(void);
38extern void COMBOEX_Register(void);
39extern void COMBOEX_Unregister(void);
40extern void DATETIME_Register(void);
41extern void DATETIME_Unregister(void);
42extern void FLATSB_Register(void);
43extern void FLATSB_Unregister(void);
44extern void HEADER_Register(void);
45extern void HEADER_Unregister(void);
46extern void HOTKEY_Register(void);
47extern void HOTKEY_Unregister(void);
48extern void IPADDRESS_Register(void);
49extern void IPADDRESS_Unregister(void);
50extern void LISTVIEW_Register(void);
51extern void LISTVIEW_Unregister(void);
52extern void MONTHCAL_Register(void);
53extern void MONTHCAL_Unregister(void);
54extern void NATIVEFONT_Register(void);
55extern void NATIVEFONT_Unregister(void);
56extern void PAGER_Register(void);
57extern void PAGER_Unregister(void);
58extern void PROGRESS_Register(void);
59extern void PROGRESS_Unregister(void);
60extern void REBAR_Register(void);
61extern void REBAR_Unregister(void);
62extern void STATUS_Register(void);
63extern void STATUS_Unregister(void);
64extern void TAB_Register(void);
65extern void TAB_Unregister(void);
66extern void TOOLBAR_Register(void);
67extern void TOOLBAR_Unregister(void);
68extern void TOOLTIPS_Register(void);
69extern void TOOLTIPS_Unregister(void);
70extern void TRACKBAR_Register(void);
71extern void TRACKBAR_Unregister(void);
72extern void TREEVIEW_Register(void);
73extern void TREEVIEW_Unregister(void);
74extern void UPDOWN_Register(void);
75extern void UPDOWN_Unregister(void);
76
77
78HANDLE COMCTL32_hHeap = (HANDLE)NULL;
79LPSTR COMCTL32_aSubclass = (LPSTR)NULL;
80HMODULE COMCTL32_hModule = 0;
81LANGID COMCTL32_uiLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
82HBRUSH COMCTL32_hPattern55AABrush = (HANDLE)NULL;
83COMCTL32_SysColor comctl32_color;
84
85static HBITMAP COMCTL32_hPattern55AABitmap = (HANDLE)NULL;
86
87static const WORD wPattern55AA[] =
88{
89 0x5555, 0xaaaa, 0x5555, 0xaaaa,
90 0x5555, 0xaaaa, 0x5555, 0xaaaa
91};
92
93
94/***********************************************************************
95 * COMCTL32_LibMain [Internal] Initializes the internal 'COMCTL32.DLL'.
96 *
97 * PARAMS
98 * hinstDLL [I] handle to the 'dlls' instance
99 * fdwReason [I]
100 * lpvReserved [I] reserverd, must be NULL
101 *
102 * RETURNS
103 * Success: TRUE
104 * Failure: FALSE
105 */
106
107BOOL WINAPI
108COMCTL32_LibMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
109{
110 TRACE("%x,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
111
112 switch (fdwReason) {
113 case DLL_PROCESS_ATTACH:
114 COMCTL32_hModule = (HMODULE)hinstDLL;
115
116 /* create private heap */
117 COMCTL32_hHeap = HeapCreate (0, 0x10000, 0);
118 TRACE("Heap created: 0x%x\n", COMCTL32_hHeap);
119
120 /* add global subclassing atom (used by 'tooltip' and 'updown') */
121 COMCTL32_aSubclass = (LPSTR)(DWORD)GlobalAddAtomA ("CC32SubclassInfo");
122 TRACE("Subclassing atom added: %p\n", COMCTL32_aSubclass);
123
124 /* create local pattern brush */
125 COMCTL32_hPattern55AABitmap = CreateBitmap (8, 8, 1, 1, wPattern55AA);
126 COMCTL32_hPattern55AABrush = CreatePatternBrush (COMCTL32_hPattern55AABitmap);
127
128 /* Get all the colors at DLL load */
129 COMCTL32_RefreshSysColors();
130
131 /* register all Win95 common control classes */
132 ANIMATE_Register ();
133 FLATSB_Register ();
134 HEADER_Register ();
135 HOTKEY_Register ();
136 LISTVIEW_Register ();
137 PROGRESS_Register ();
138 STATUS_Register ();
139 TAB_Register ();
140 TOOLBAR_Register ();
141 TOOLTIPS_Register ();
142 TRACKBAR_Register ();
143 TREEVIEW_Register ();
144 UPDOWN_Register ();
145 break;
146
147 case DLL_PROCESS_DETACH:
148 /* unregister all common control classes */
149 ANIMATE_Unregister ();
150 COMBOEX_Unregister ();
151 DATETIME_Unregister ();
152 FLATSB_Unregister ();
153 HEADER_Unregister ();
154 HOTKEY_Unregister ();
155 IPADDRESS_Unregister ();
156 LISTVIEW_Unregister ();
157 MONTHCAL_Unregister ();
158 NATIVEFONT_Unregister ();
159 PAGER_Unregister ();
160 PROGRESS_Unregister ();
161 REBAR_Unregister ();
162 STATUS_Unregister ();
163 TAB_Unregister ();
164 TOOLBAR_Unregister ();
165 TOOLTIPS_Unregister ();
166 TRACKBAR_Unregister ();
167 TREEVIEW_Unregister ();
168 UPDOWN_Unregister ();
169
170 /* delete local pattern brush */
171 DeleteObject (COMCTL32_hPattern55AABrush);
172 COMCTL32_hPattern55AABrush = (HANDLE)NULL;
173 DeleteObject (COMCTL32_hPattern55AABitmap);
174 COMCTL32_hPattern55AABitmap = (HANDLE)NULL;
175
176 /* delete global subclassing atom */
177 GlobalDeleteAtom (LOWORD(COMCTL32_aSubclass));
178 TRACE("Subclassing atom deleted: %p\n", COMCTL32_aSubclass);
179 COMCTL32_aSubclass = (LPSTR)NULL;
180
181 /* destroy private heap */
182 HeapDestroy (COMCTL32_hHeap);
183 TRACE("Heap destroyed: 0x%x\n", COMCTL32_hHeap);
184 COMCTL32_hHeap = (HANDLE)NULL;
185 break;
186 }
187
188 return TRUE;
189}
190
191
192/***********************************************************************
193 * MenuHelp [COMCTL32.2]
194 *
195 * PARAMS
196 * uMsg [I] message (WM_MENUSELECT) (see NOTES)
197 * wParam [I] wParam of the message uMsg
198 * lParam [I] lParam of the message uMsg
199 * hMainMenu [I] handle to the application's main menu
200 * hInst [I] handle to the module that contains string resources
201 * hwndStatus [I] handle to the status bar window
202 * lpwIDs [I] pointer to an array of integers (see NOTES)
203 *
204 * RETURNS
205 * No return value
206 *
207 * NOTES
208 * The official documentation is incomplete!
209 * This is the correct documentation:
210 *
211 * uMsg:
212 * MenuHelp() does NOT handle WM_COMMAND messages! It only handles
213 * WM_MENUSELECT messages.
214 *
215 * lpwIDs:
216 * (will be written ...)
217 */
218
219VOID WINAPI
220MenuHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu,
221 HINSTANCE hInst, HWND hwndStatus, LPUINT lpwIDs)
222{
223 UINT uMenuID = 0;
224
225 if (!IsWindow (hwndStatus))
226 return;
227
228 switch (uMsg) {
229 case WM_MENUSELECT:
230 TRACE("WM_MENUSELECT wParam=0x%X lParam=0x%lX\n",
231 wParam, lParam);
232
233 if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) {
234 /* menu was closed */
235 TRACE("menu was closed!\n");
236 SendMessageA (hwndStatus, SB_SIMPLE, FALSE, 0);
237 }
238 else {
239 /* menu item was selected */
240 if (HIWORD(wParam) & MF_POPUP)
241 uMenuID = (UINT)*(lpwIDs+1);
242 else
243 uMenuID = (UINT)LOWORD(wParam);
244 TRACE("uMenuID = %u\n", uMenuID);
245
246 if (uMenuID) {
247 CHAR szText[256];
248
249 if (!LoadStringA (hInst, uMenuID, szText, 256))
250 szText[0] = '\0';
251
252 SendMessageA (hwndStatus, SB_SETTEXTA,
253 255 | SBT_NOBORDERS, (LPARAM)szText);
254 SendMessageA (hwndStatus, SB_SIMPLE, TRUE, 0);
255 }
256 }
257 break;
258
259 case WM_COMMAND :
260 TRACE("WM_COMMAND wParam=0x%X lParam=0x%lX\n",
261 wParam, lParam);
262 /* WM_COMMAND is not invalid since it is documented
263 * in the windows api reference. So don't output
264 * any FIXME for WM_COMMAND
265 */
266 WARN("We don't care about the WM_COMMAND\n");
267 break;
268
269 default:
270 FIXME("Invalid Message 0x%x!\n", uMsg);
271 break;
272 }
273}
274
275
276/***********************************************************************
277 * ShowHideMenuCtl [COMCTL32.3]
278 *
279 * Shows or hides controls and updates the corresponding menu item.
280 *
281 * PARAMS
282 * hwnd [I] handle to the client window.
283 * uFlags [I] menu command id.
284 * lpInfo [I] pointer to an array of integers. (See NOTES.)
285 *
286 * RETURNS
287 * Success: TRUE
288 * Failure: FALSE
289 *
290 * NOTES
291 * The official documentation is incomplete!
292 * This is the correct documentation:
293 *
294 * hwnd
295 * Handle to the window that contains the menu and controls.
296 *
297 * uFlags
298 * Identifier of the menu item to receive or loose a check mark.
299 *
300 * lpInfo
301 * The array of integers contains pairs of values. BOTH values of
302 * the first pair must be the handles to the application's main menu.
303 * Each subsequent pair consists of a menu id and control id.
304 */
305
306BOOL WINAPI
307ShowHideMenuCtl (HWND hwnd, UINT uFlags, LPINT lpInfo)
308{
309 LPINT lpMenuId;
310
311 TRACE("%x, %x, %p\n", hwnd, uFlags, lpInfo);
312
313 if (lpInfo == NULL)
314 return FALSE;
315
316 if (!(lpInfo[0]) || !(lpInfo[1]))
317 return FALSE;
318
319 /* search for control */
320 lpMenuId = &lpInfo[2];
321 while (*lpMenuId != uFlags)
322 lpMenuId += 2;
323
324 if (GetMenuState (lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) {
325 /* uncheck menu item */
326 CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED);
327
328 /* hide control */
329 lpMenuId++;
330 SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
331 SWP_HIDEWINDOW);
332 }
333 else {
334 /* check menu item */
335 CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED);
336
337 /* show control */
338 lpMenuId++;
339 SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
340 SWP_SHOWWINDOW);
341 }
342
343 return TRUE;
344}
345
346
347/***********************************************************************
348 * GetEffectiveClientRect [COMCTL32.4]
349 *
350 * PARAMS
351 * hwnd [I] handle to the client window.
352 * lpRect [O] pointer to the rectangle of the client window
353 * lpInfo [I] pointer to an array of integers (see NOTES)
354 *
355 * RETURNS
356 * No return value.
357 *
358 * NOTES
359 * The official documentation is incomplete!
360 * This is the correct documentation:
361 *
362 * lpInfo
363 * (will be written...)
364 */
365
366VOID WINAPI
367GetEffectiveClientRect (HWND hwnd, LPRECT lpRect, LPINT lpInfo)
368{
369 RECT rcCtrl;
370 INT *lpRun;
371 HWND hwndCtrl;
372
373 TRACE("(0x%08lx 0x%08lx 0x%08lx)\n",
374 (DWORD)hwnd, (DWORD)lpRect, (DWORD)lpInfo);
375
376 GetClientRect (hwnd, lpRect);
377 lpRun = lpInfo;
378
379 do {
380 lpRun += 2;
381 if (*lpRun == 0)
382 return;
383 lpRun++;
384 hwndCtrl = GetDlgItem (hwnd, *lpRun);
385 if (GetWindowLongA (hwndCtrl, GWL_STYLE) & WS_VISIBLE) {
386 TRACE("control id 0x%x\n", *lpRun);
387 GetWindowRect (hwndCtrl, &rcCtrl);
388 MapWindowPoints ((HWND)0, hwnd, (LPPOINT)&rcCtrl, 2);
389 SubtractRect (lpRect, lpRect, &rcCtrl);
390 }
391 lpRun++;
392 } while (*lpRun);
393}
394
395
396/***********************************************************************
397 * DrawStatusTextW [COMCTL32.28]
398 *
399 * Draws text with borders, like in a status bar.
400 *
401 * PARAMS
402 * hdc [I] handle to the window's display context
403 * lprc [I] pointer to a rectangle
404 * text [I] pointer to the text
405 * style [I] drawing style
406 *
407 * RETURNS
408 * No return value.
409 *
410 * NOTES
411 * The style variable can have one of the following values:
412 * (will be written ...)
413 */
414
415void WINAPI DrawStatusTextW (HDC hdc, LPRECT lprc, LPCWSTR text, UINT style)
416{
417 RECT r = *lprc;
418 UINT border = BDR_SUNKENOUTER;
419
420 if (style & SBT_POPOUT)
421 border = BDR_RAISEDOUTER;
422 else if (style & SBT_NOBORDERS)
423 border = 0;
424
425 DrawEdge (hdc, &r, border, BF_RECT|BF_ADJUST);
426
427 /* now draw text */
428 if (text) {
429 int oldbkmode = SetBkMode (hdc, TRANSPARENT);
430 UINT align = DT_LEFT;
431 if (*text == L'\t') {
432 text++;
433 align = DT_CENTER;
434 if (*text == L'\t') {
435 text++;
436 align = DT_RIGHT;
437 }
438 }
439 r.left += 3;
440 if (style & SBT_RTLREADING)
441 FIXME("Usupported RTL style!");
442 DrawTextW (hdc, text, -1, &r, align|DT_VCENTER|DT_SINGLELINE);
443 SetBkMode(hdc, oldbkmode);
444 }
445}
446
447
448/***********************************************************************
449 * DrawStatusText [COMCTL32.27]
450 * DrawStatusTextA [COMCTL32.5]
451 *
452 * Draws text with borders, like in a status bar.
453 *
454 * PARAMS
455 * hdc [I] handle to the window's display context
456 * lprc [I] pointer to a rectangle
457 * text [I] pointer to the text
458 * style [I] drawing style
459 *
460 * RETURNS
461 * No return value.
462 */
463
464void WINAPI DrawStatusTextA (HDC hdc, LPRECT lprc, LPCSTR text, UINT style)
465{
466 INT len;
467 LPWSTR textW = NULL;
468
469 if ( text ) {
470 if ( (len = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 )) ) {
471 if ( (textW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )) )
472 MultiByteToWideChar( CP_ACP, 0, text, -1, textW, len );
473 }
474 }
475 DrawStatusTextW( hdc, lprc, textW, style );
476 HeapFree( GetProcessHeap(), 0, textW );
477}
478
479
480/***********************************************************************
481 * CreateStatusWindow [COMCTL32.21]
482 * CreateStatusWindowA [COMCTL32.6]
483 *
484 * Creates a status bar
485 *
486 * PARAMS
487 * style [I] window style
488 * text [I] pointer to the window text
489 * parent [I] handle to the parent window
490 * wid [I] control id of the status bar
491 *
492 * RETURNS
493 * Success: handle to the status window
494 * Failure: 0
495 */
496
497HWND WINAPI
498CreateStatusWindowA (INT style, LPCSTR text, HWND parent, UINT wid)
499{
500 return CreateWindowA(STATUSCLASSNAMEA, text, style,
501 CW_USEDEFAULT, CW_USEDEFAULT,
502 CW_USEDEFAULT, CW_USEDEFAULT,
503 parent, wid, 0, 0);
504}
505
506
507/***********************************************************************
508 * CreateStatusWindowW [COMCTL32.22] Creates a status bar control
509 *
510 * PARAMS
511 * style [I] window style
512 * text [I] pointer to the window text
513 * parent [I] handle to the parent window
514 * wid [I] control id of the status bar
515 *
516 * RETURNS
517 * Success: handle to the status window
518 * Failure: 0
519 */
520
521HWND WINAPI
522CreateStatusWindowW (INT style, LPCWSTR text, HWND parent, UINT wid)
523{
524 return CreateWindowW(STATUSCLASSNAMEW, text, style,
525 CW_USEDEFAULT, CW_USEDEFAULT,
526 CW_USEDEFAULT, CW_USEDEFAULT,
527 parent, wid, 0, 0);
528}
529
530
531/***********************************************************************
532 * CreateUpDownControl [COMCTL32.16] Creates an up-down control
533 *
534 * PARAMS
535 * style [I] window styles
536 * x [I] horizontal position of the control
537 * y [I] vertical position of the control
538 * cx [I] with of the control
539 * cy [I] height of the control
540 * parent [I] handle to the parent window
541 * id [I] the control's identifier
542 * inst [I] handle to the application's module instance
543 * buddy [I] handle to the buddy window, can be NULL
544 * maxVal [I] upper limit of the control
545 * minVal [I] lower limit of the control
546 * curVal [I] current value of the control
547 *
548 * RETURNS
549 * Success: handle to the updown control
550 * Failure: 0
551 */
552
553HWND WINAPI
554CreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
555 HWND parent, INT id, HINSTANCE inst,
556 HWND buddy, INT maxVal, INT minVal, INT curVal)
557{
558 HWND hUD =
559 CreateWindowA (UPDOWN_CLASSA, 0, style, x, y, cx, cy,
560 parent, id, inst, 0);
561 if (hUD) {
562 SendMessageA (hUD, UDM_SETBUDDY, buddy, 0);
563 SendMessageA (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
564 SendMessageA (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));
565 }
566
567 return hUD;
568}
569
570
571/***********************************************************************
572 * InitCommonControls [COMCTL32.17]
573 *
574 * Registers the common controls.
575 *
576 * PARAMS
577 * No parameters.
578 *
579 * RETURNS
580 * No return values.
581 *
582 * NOTES
583 * This function is just a dummy.
584 * The Win95 controls are registered at the DLL's initialization.
585 * To register other controls InitCommonControlsEx() must be used.
586 */
587
588VOID WINAPI
589InitCommonControls (void)
590{
591}
592
593
594/***********************************************************************
595 * InitCommonControlsEx [COMCTL32.84]
596 *
597 * Registers the common controls.
598 *
599 * PARAMS
600 * lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure.
601 *
602 * RETURNS
603 * Success: TRUE
604 * Failure: FALSE
605 *
606 * NOTES
607 * Only the additional common controls are registered by this function.
608 * The Win95 controls are registered at the DLL's initialization.
609 */
610
611BOOL WINAPI
612InitCommonControlsEx (LPINITCOMMONCONTROLSEX lpInitCtrls)
613{
614 INT cCount;
615 DWORD dwMask;
616
617 if (!lpInitCtrls)
618 return FALSE;
619 if (lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX))
620 return FALSE;
621
622 TRACE("(0x%08lx)\n", lpInitCtrls->dwICC);
623
624 for (cCount = 0; cCount < 32; cCount++) {
625 dwMask = 1 << cCount;
626 if (!(lpInitCtrls->dwICC & dwMask))
627 continue;
628
629 switch (lpInitCtrls->dwICC & dwMask) {
630 /* dummy initialization */
631 case ICC_ANIMATE_CLASS:
632 case ICC_BAR_CLASSES:
633 case ICC_LISTVIEW_CLASSES:
634 case ICC_TREEVIEW_CLASSES:
635 case ICC_TAB_CLASSES:
636 case ICC_UPDOWN_CLASS:
637 case ICC_PROGRESS_CLASS:
638 case ICC_HOTKEY_CLASS:
639 break;
640
641 /* advanced classes - not included in Win95 */
642 case ICC_DATE_CLASSES:
643 MONTHCAL_Register ();
644 DATETIME_Register ();
645 break;
646
647 case ICC_USEREX_CLASSES:
648 COMBOEX_Register ();
649 break;
650
651 case ICC_COOL_CLASSES:
652 REBAR_Register ();
653 break;
654
655 case ICC_INTERNET_CLASSES:
656 IPADDRESS_Register ();
657 break;
658
659 case ICC_PAGESCROLLER_CLASS:
660 PAGER_Register ();
661 break;
662
663 case ICC_NATIVEFNTCTL_CLASS:
664 NATIVEFONT_Register ();
665 break;
666
667 default:
668 FIXME("Unknown class! dwICC=0x%lX\n", dwMask);
669 break;
670 }
671 }
672
673 return TRUE;
674}
675
676
677/***********************************************************************
678 * CreateToolbarEx [COMCTL32.23] Creates a tool bar window
679 *
680 * PARAMS
681 * hwnd
682 * style
683 * wID
684 * nBitmaps
685 * hBMInst
686 * wBMID
687 * lpButtons
688 * iNumButtons
689 * dxButton
690 * dyButton
691 * dxBitmap
692 * dyBitmap
693 * uStructSize
694 *
695 * RETURNS
696 * Success: handle to the tool bar control
697 * Failure: 0
698 */
699
700HWND WINAPI
701CreateToolbarEx (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
702 HINSTANCE hBMInst, UINT wBMID, LPCTBBUTTON lpButtons,
703 INT iNumButtons, INT dxButton, INT dyButton,
704 INT dxBitmap, INT dyBitmap, UINT uStructSize)
705{
706 HWND hwndTB;
707
708 /* If not position is specified then put it at the top */
709 if ((style & CCS_BOTTOM) == 0) {
710 style|=CCS_TOP;
711 }
712
713 hwndTB =
714 CreateWindowExA (0, TOOLBARCLASSNAMEA, "", style|WS_CHILD, 0, 0, 0, 0,
715 hwnd, (HMENU)wID, 0, NULL);
716 if(hwndTB) {
717 TBADDBITMAP tbab;
718
719 SendMessageA (hwndTB, TB_BUTTONSTRUCTSIZE,
720 (WPARAM)uStructSize, 0);
721
722 /* set bitmap and button size */
723 /*If CreateToolbarEx receives 0, windows sets default values*/
724 if (dxBitmap <= 0)
725 dxBitmap = 16;
726 if (dyBitmap <= 0)
727 dyBitmap = 15;
728 SendMessageA (hwndTB, TB_SETBITMAPSIZE, 0,
729 MAKELPARAM((WORD)dxBitmap, (WORD)dyBitmap));
730
731 if (dxButton <= 0)
732 dxButton = 24;
733 if (dyButton <= 0)
734 dyButton = 22;
735 SendMessageA (hwndTB, TB_SETBUTTONSIZE, 0,
736 MAKELPARAM((WORD)dxButton, (WORD)dyButton));
737
738
739 /* add bitmaps */
740 if (nBitmaps > 0)
741 {
742 tbab.hInst = hBMInst;
743 tbab.nID = wBMID;
744
745 SendMessageA (hwndTB, TB_ADDBITMAP,
746 (WPARAM)nBitmaps, (LPARAM)&tbab);
747 }
748 /* add buttons */
749 if(iNumButtons > 0)
750 SendMessageA (hwndTB, TB_ADDBUTTONSA,
751 (WPARAM)iNumButtons, (LPARAM)lpButtons);
752 }
753
754 return hwndTB;
755}
756
757
758/***********************************************************************
759 * CreateMappedBitmap [COMCTL32.8]
760 *
761 * PARAMS
762 * hInstance [I]
763 * idBitmap [I]
764 * wFlags [I]
765 * lpColorMap [I]
766 * iNumMaps [I]
767 *
768 * RETURNS
769 * Success: handle to the new bitmap
770 * Failure: 0
771 */
772
773HBITMAP WINAPI
774CreateMappedBitmap (HINSTANCE hInstance, INT idBitmap, UINT wFlags,
775 LPCOLORMAP lpColorMap, INT iNumMaps)
776{
777 HGLOBAL hglb;
778 HRSRC hRsrc;
779 LPBITMAPINFOHEADER lpBitmap, lpBitmapInfo;
780 UINT nSize, nColorTableSize;
781 RGBQUAD *pColorTable;
782 INT iColor, i, iMaps, nWidth, nHeight;
783 HDC hdcScreen;
784 HBITMAP hbm;
785 LPCOLORMAP sysColorMap;
786 COLORREF cRef;
787 COLORMAP internalColorMap[4] =
788 {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
789
790 /* initialize pointer to colortable and default color table */
791 if (lpColorMap) {
792 iMaps = iNumMaps;
793 sysColorMap = lpColorMap;
794 }
795 else {
796 internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT);
797 internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW);
798 internalColorMap[2].to = GetSysColor (COLOR_BTNFACE);
799 internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT);
800 iMaps = 4;
801 sysColorMap = (LPCOLORMAP)internalColorMap;
802 }
803
804 hRsrc = FindResourceA (hInstance, (LPSTR)idBitmap, RT_BITMAPA);
805 if (hRsrc == 0)
806 return 0;
807 hglb = LoadResource (hInstance, hRsrc);
808 if (hglb == 0)
809 return 0;
810 lpBitmap = (LPBITMAPINFOHEADER)LockResource (hglb);
811 if (lpBitmap == NULL)
812 return 0;
813
814 nColorTableSize = (1 << lpBitmap->biBitCount);
815 nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD);
816 lpBitmapInfo = (LPBITMAPINFOHEADER)GlobalAlloc (GMEM_FIXED, nSize);
817 if (lpBitmapInfo == NULL)
818 return 0;
819 RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize);
820
821 pColorTable = (RGBQUAD*)(((LPBYTE)lpBitmapInfo)+(UINT)lpBitmapInfo->biSize);
822
823 for (iColor = 0; iColor < nColorTableSize; iColor++) {
824 for (i = 0; i < iMaps; i++) {
825 cRef = RGB(pColorTable[iColor].rgbRed,
826 pColorTable[iColor].rgbGreen,
827 pColorTable[iColor].rgbBlue);
828 if ( cRef == sysColorMap[i].from) {
829#if 0
830 if (wFlags & CBS_MASKED) {
831 if (sysColorMap[i].to != COLOR_BTNTEXT)
832 pColorTable[iColor] = RGB(255, 255, 255);
833 }
834 else
835#endif
836 pColorTable[iColor].rgbBlue = GetBValue(sysColorMap[i].to);
837 pColorTable[iColor].rgbGreen = GetGValue(sysColorMap[i].to);
838 pColorTable[iColor].rgbRed = GetRValue(sysColorMap[i].to);
839 break;
840 }
841 }
842 }
843 nWidth = (INT)lpBitmapInfo->biWidth;
844 nHeight = (INT)lpBitmapInfo->biHeight;
845 hdcScreen = GetDC ((HWND)0);
846 hbm = CreateCompatibleBitmap (hdcScreen, nWidth, nHeight);
847 if (hbm) {
848 HDC hdcDst = CreateCompatibleDC (hdcScreen);
849 HBITMAP hbmOld = SelectObject (hdcDst, hbm);
850 LPBYTE lpBits = (LPBYTE)(lpBitmap + 1);
851 lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
852 StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
853 lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS,
854 SRCCOPY);
855 SelectObject (hdcDst, hbmOld);
856 DeleteDC (hdcDst);
857 }
858 ReleaseDC ((HWND)0, hdcScreen);
859 GlobalFree ((HGLOBAL)lpBitmapInfo);
860 FreeResource (hglb);
861
862 return hbm;
863}
864
865
866/***********************************************************************
867 * CreateToolbar [COMCTL32.7] Creates a tool bar control
868 *
869 * PARAMS
870 * hwnd
871 * style
872 * wID
873 * nBitmaps
874 * hBMInst
875 * wBMID
876 * lpButtons
877 * iNumButtons
878 *
879 * RETURNS
880 * Success: handle to the tool bar control
881 * Failure: 0
882 *
883 * NOTES
884 * Do not use this functions anymore. Use CreateToolbarEx instead.
885 */
886
887HWND WINAPI
888CreateToolbar (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
889 HINSTANCE hBMInst, UINT wBMID,
890 LPCOLDTBBUTTON lpButtons,INT iNumButtons)
891{
892 return CreateToolbarEx (hwnd, style | CCS_NODIVIDER, wID, nBitmaps,
893 hBMInst, wBMID, (LPCTBBUTTON)lpButtons,
894 iNumButtons, 0, 0, 0, 0, sizeof (OLDTBBUTTON));
895}
896
897
898/***********************************************************************
899 * DllGetVersion [COMCTL32.25]
900 *
901 * Retrieves version information of the 'COMCTL32.DLL'
902 *
903 * PARAMS
904 * pdvi [O] pointer to version information structure.
905 *
906 * RETURNS
907 * Success: S_OK
908 * Failure: E_INVALIDARG
909 *
910 * NOTES
911 * Returns version of a comctl32.dll from IE4.01 SP1.
912 */
913
914HRESULT WINAPI
915COMCTL32_DllGetVersion (DLLVERSIONINFO *pdvi)
916{
917 if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
918 WARN("wrong DLLVERSIONINFO size from app\n");
919 return E_INVALIDARG;
920 }
921
922 pdvi->dwMajorVersion = COMCTL32_VERSION;
923 pdvi->dwMinorVersion = COMCTL32_VERSION_MINOR;
924 pdvi->dwBuildNumber = 2919;
925 pdvi->dwPlatformID = 6304;
926
927 TRACE("%lu.%lu.%lu.%lu\n",
928 pdvi->dwMajorVersion, pdvi->dwMinorVersion,
929 pdvi->dwBuildNumber, pdvi->dwPlatformID);
930
931 return S_OK;
932}
933
934/***********************************************************************
935 * DllInstall (COMCTL32.26)
936 */
937HRESULT WINAPI COMCTL32_DllInstall(BOOL bInstall, LPCWSTR cmdline)
938{
939 FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
940 debugstr_w(cmdline));
941
942 return S_OK;
943}
944
945/***********************************************************************
946 * _TrackMouseEvent [COMCTL32.91]
947 *
948 * Requests notification of mouse events
949 *
950 * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
951 * to the hwnd specified in the ptme structure. After the event message
952 * is posted to the hwnd, the entry in the queue is removed.
953 *
954 * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
955 * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
956 * immediately and the TME_LEAVE flag being ignored.
957 *
958 * PARAMS
959 * ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
960 *
961 * RETURNS
962 * Success: non-zero
963 * Failure: zero
964 *
965 * IMPLEMENTATION moved to USER32.TrackMouseEvent
966 *
967 */
968
969BOOL WINAPI
970_TrackMouseEvent (TRACKMOUSEEVENT *ptme)
971{
972 return TrackMouseEvent (ptme);
973}
974
975/*************************************************************************
976 * GetMUILanguage [COMCTL32.39]
977 *
978 * FIXME: What's this supposed to do? Apparently some i18n thing.
979 *
980 */
981LANGID WINAPI GetMUILanguage (VOID)
982{
983 return COMCTL32_uiLang;
984}
985
986
987/*************************************************************************
988 * InitMUILanguage [COMCTL32.85]
989 *
990 * FIXME: What's this supposed to do? Apparently some i18n thing.
991 *
992 */
993
994VOID WINAPI InitMUILanguage (LANGID uiLang)
995{
996 COMCTL32_uiLang = uiLang;
997}
998
999
1000/***********************************************************************
1001 * COMCTL32_CreateToolTip [NOT AN API]
1002 *
1003 * Creates a tooltip for the control specified in hwnd and does all
1004 * necessary setup and notifications.
1005 *
1006 * PARAMS
1007 * hwndOwner [I] Handle to the window that will own the tool tip.
1008 *
1009 * RETURNS
1010 * Success: Handle of tool tip window.
1011 * Failure: NULL
1012 */
1013HWND
1014COMCTL32_CreateToolTip(HWND hwndOwner)
1015{
1016 HWND hwndToolTip;
1017
1018 hwndToolTip = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0,
1019 CW_USEDEFAULT, CW_USEDEFAULT,
1020 CW_USEDEFAULT, CW_USEDEFAULT, hwndOwner,
1021 0, 0, 0);
1022
1023 /* Send NM_TOOLTIPSCREATED notification */
1024 if (hwndToolTip)
1025 {
1026 NMTOOLTIPSCREATED nmttc;
1027 /* true owner can be different if hwndOwner is a child window */
1028 HWND hwndTrueOwner = GetWindow(hwndToolTip, GW_OWNER);
1029 nmttc.hdr.hwndFrom = hwndTrueOwner;
1030 nmttc.hdr.idFrom = GetWindowLongA(hwndTrueOwner, GWL_ID);
1031 nmttc.hdr.code = NM_TOOLTIPSCREATED;
1032 nmttc.hwndToolTips = hwndToolTip;
1033
1034 SendMessageA(GetParent(hwndTrueOwner), WM_NOTIFY,
1035 (WPARAM)GetWindowLongA(hwndTrueOwner, GWL_ID),
1036 (LPARAM)&nmttc);
1037 }
1038
1039 return hwndToolTip;
1040}
1041
1042
1043/***********************************************************************
1044 * COMCTL32_RefreshSysColors [NOT AN API]
1045 *
1046 * Invoked on any control recognizing a WM_SYSCOLORCHANGE message to
1047 * refresh the color values in the color structure
1048 *
1049 * PARAMS
1050 * none
1051 *
1052 * RETURNS
1053 * none
1054 */
1055VOID
1056COMCTL32_RefreshSysColors(void)
1057{
1058 comctl32_color.clrBtnHighlight = GetSysColor (COLOR_BTNHIGHLIGHT);
1059 comctl32_color.clrBtnShadow = GetSysColor (COLOR_BTNSHADOW);
1060 comctl32_color.clrBtnText = GetSysColor (COLOR_BTNTEXT);
1061 comctl32_color.clrBtnFace = GetSysColor (COLOR_BTNFACE);
1062 comctl32_color.clrHighlight = GetSysColor (COLOR_HIGHLIGHT);
1063 comctl32_color.clrHighlightText = GetSysColor (COLOR_HIGHLIGHTTEXT);
1064 comctl32_color.clr3dHilight = GetSysColor (COLOR_3DHILIGHT);
1065 comctl32_color.clr3dShadow = GetSysColor (COLOR_3DSHADOW);
1066 comctl32_color.clr3dDkShadow = GetSysColor (COLOR_3DDKSHADOW);
1067 comctl32_color.clr3dFace = GetSysColor (COLOR_3DFACE);
1068 comctl32_color.clrWindow = GetSysColor (COLOR_WINDOW);
1069 comctl32_color.clrWindowText = GetSysColor (COLOR_WINDOWTEXT);
1070 comctl32_color.clrGrayText = GetSysColor (COLOR_GRAYTEXT);
1071 comctl32_color.clrActiveCaption = GetSysColor (COLOR_ACTIVECAPTION);
1072 comctl32_color.clrInfoBk = GetSysColor (COLOR_INFOBK);
1073 comctl32_color.clrInfoText = GetSysColor (COLOR_INFOTEXT);
1074}
Note: See TracBrowser for help on using the repository browser.