Added 'wine' prefix to libwine_unicode exports.
[wine] / dlls / comctl32 / commctrl.c
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  * 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 belive 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  *   -- LibMain => DLLMain ("DLLMain takes over the functionality of both the
33  *                           LibMain and the WEP function.", MSDN)
34  *   -- finish NOTES for MenuHelp, GetEffectiveClientRect and GetStatusTextW
35  *   -- FIXMEs + BUGS (search for them)
36  *
37  * Control Classes
38  *   -- ICC_ANIMATE_CLASS
39  *   -- ICC_BAR_CLASSES
40  *   -- ICC_COOL_CLASSES
41  *   -- ICC_DATE_CLASSES
42  *   -- ICC_HOTKEY_CLASS
43  *   -- ICC_INTERNET_CLASSES
44  *   -- ICC_LINK_CLASS (not yet implemented)
45  *   -- ICC_LISTVIEW_CLASSES
46  *   -- ICC_NATIVEFNTCTL_CLASS
47  *   -- ICC_PAGESCROLLER_CLASS
48  *   -- ICC_PROGRESS_CLASS
49  *   -- ICC_STANDARD_CLASSES (not yet implemented)
50  *   -- ICC_TAB_CLASSES
51  *   -- ICC_TREEVIEW_CLASSES
52  *   -- ICC_UPDOWN_CLASS
53  *   -- ICC_USEREX_CLASSES
54  *   -- ICC_WIN95_CLASSES
55  */
56
57 #include <string.h>
58 #include <stdlib.h>
59
60 #include "winbase.h"
61 #include "commctrl.h"
62 #include "winerror.h"
63 #include "winreg.h"
64 #define NO_SHLWAPI_STREAM
65 #include "shlwapi.h"
66 #include "comctl32.h"
67 #include "wine/debug.h"
68
69 WINE_DEFAULT_DEBUG_CHANNEL(commctrl);
70
71 extern void ANIMATE_Register(void);
72 extern void ANIMATE_Unregister(void);
73 extern void COMBOEX_Register(void);
74 extern void COMBOEX_Unregister(void);
75 extern void DATETIME_Register(void);
76 extern void DATETIME_Unregister(void);
77 extern void FLATSB_Register(void);
78 extern void FLATSB_Unregister(void);
79 extern void HEADER_Register(void);
80 extern void HEADER_Unregister(void);
81 extern void HOTKEY_Register(void);
82 extern void HOTKEY_Unregister(void);
83 extern void IPADDRESS_Register(void);
84 extern void IPADDRESS_Unregister(void);
85 extern void LISTVIEW_Register(void);
86 extern void LISTVIEW_Unregister(void);
87 extern void MONTHCAL_Register(void);
88 extern void MONTHCAL_Unregister(void);
89 extern void NATIVEFONT_Register(void);
90 extern void NATIVEFONT_Unregister(void);
91 extern void PAGER_Register(void);
92 extern void PAGER_Unregister(void);
93 extern void PROGRESS_Register(void);
94 extern void PROGRESS_Unregister(void);
95 extern void REBAR_Register(void);
96 extern void REBAR_Unregister(void);
97 extern void STATUS_Register(void);
98 extern void STATUS_Unregister(void);
99 extern void TAB_Register(void);
100 extern void TAB_Unregister(void);
101 extern void TOOLBAR_Register(void);
102 extern void TOOLBAR_Unregister(void);
103 extern void TOOLTIPS_Register(void);
104 extern void TOOLTIPS_Unregister(void);
105 extern void TRACKBAR_Register(void);
106 extern void TRACKBAR_Unregister(void);
107 extern void TREEVIEW_Register(void);
108 extern void TREEVIEW_Unregister(void);
109 extern void UPDOWN_Register(void);
110 extern void UPDOWN_Unregister(void);
111
112
113 HANDLE COMCTL32_hHeap = NULL;
114 LPSTR    COMCTL32_aSubclass = NULL;
115 HMODULE COMCTL32_hModule = 0;
116 LANGID  COMCTL32_uiLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
117 HBRUSH  COMCTL32_hPattern55AABrush = NULL;
118 COMCTL32_SysColor  comctl32_color;
119
120 static HBITMAP COMCTL32_hPattern55AABitmap = NULL;
121
122 static const WORD wPattern55AA[] =
123 {
124     0x5555, 0xaaaa, 0x5555, 0xaaaa,
125     0x5555, 0xaaaa, 0x5555, 0xaaaa
126 };
127
128
129 /***********************************************************************
130  * DllMain [Internal] Initializes the internal 'COMCTL32.DLL'.
131  *
132  * PARAMS
133  *     hinstDLL    [I] handle to the 'dlls' instance
134  *     fdwReason   [I]
135  *     lpvReserved [I] reserverd, must be NULL
136  *
137  * RETURNS
138  *     Success: TRUE
139  *     Failure: FALSE
140  */
141
142 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
143 {
144     TRACE("%p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
145
146     switch (fdwReason) {
147         case DLL_PROCESS_ATTACH:
148             COMCTL32_hModule = (HMODULE)hinstDLL;
149
150             /* create private heap */
151             COMCTL32_hHeap = HeapCreate (0, 0x10000, 0);
152             TRACE("Heap created: %p\n", COMCTL32_hHeap);
153
154             /* add global subclassing atom (used by 'tooltip' and 'updown') */
155             COMCTL32_aSubclass = (LPSTR)(DWORD)GlobalAddAtomA ("CC32SubclassInfo");
156             TRACE("Subclassing atom added: %p\n", COMCTL32_aSubclass);
157
158             /* create local pattern brush */
159             COMCTL32_hPattern55AABitmap = CreateBitmap (8, 8, 1, 1, wPattern55AA);
160             COMCTL32_hPattern55AABrush = CreatePatternBrush (COMCTL32_hPattern55AABitmap);
161
162             /* Get all the colors at DLL load */
163             COMCTL32_RefreshSysColors();
164
165             /* register all Win95 common control classes */
166             ANIMATE_Register ();
167             FLATSB_Register ();
168             HEADER_Register ();
169             HOTKEY_Register ();
170             LISTVIEW_Register ();
171             PROGRESS_Register ();
172             STATUS_Register ();
173             TAB_Register ();
174             TOOLBAR_Register ();
175             TOOLTIPS_Register ();
176             TRACKBAR_Register ();
177             TREEVIEW_Register ();
178             UPDOWN_Register ();
179             break;
180
181         case DLL_PROCESS_DETACH:
182             /* unregister all common control classes */
183             ANIMATE_Unregister ();
184             COMBOEX_Unregister ();
185             DATETIME_Unregister ();
186             FLATSB_Unregister ();
187             HEADER_Unregister ();
188             HOTKEY_Unregister ();
189             IPADDRESS_Unregister ();
190             LISTVIEW_Unregister ();
191             MONTHCAL_Unregister ();
192             NATIVEFONT_Unregister ();
193             PAGER_Unregister ();
194             PROGRESS_Unregister ();
195             REBAR_Unregister ();
196             STATUS_Unregister ();
197             TAB_Unregister ();
198             TOOLBAR_Unregister ();
199             TOOLTIPS_Unregister ();
200             TRACKBAR_Unregister ();
201             TREEVIEW_Unregister ();
202             UPDOWN_Unregister ();
203
204             /* delete local pattern brush */
205             DeleteObject (COMCTL32_hPattern55AABrush);
206             COMCTL32_hPattern55AABrush = NULL;
207             DeleteObject (COMCTL32_hPattern55AABitmap);
208             COMCTL32_hPattern55AABitmap = NULL;
209
210             /* delete global subclassing atom */
211             GlobalDeleteAtom (LOWORD(COMCTL32_aSubclass));
212             TRACE("Subclassing atom deleted: %p\n", COMCTL32_aSubclass);
213             COMCTL32_aSubclass = NULL;
214
215             /* destroy private heap */
216             HeapDestroy (COMCTL32_hHeap);
217             TRACE("Heap destroyed: %p\n", COMCTL32_hHeap);
218             COMCTL32_hHeap = NULL;
219             break;
220     }
221
222     return TRUE;
223 }
224
225
226 /***********************************************************************
227  * MenuHelp [COMCTL32.2]
228  *
229  * PARAMS
230  *     uMsg       [I] message (WM_MENUSELECT) (see NOTES)
231  *     wParam     [I] wParam of the message uMsg
232  *     lParam     [I] lParam of the message uMsg
233  *     hMainMenu  [I] handle to the application's main menu
234  *     hInst      [I] handle to the module that contains string resources
235  *     hwndStatus [I] handle to the status bar window
236  *     lpwIDs     [I] pointer to an array of integers (see NOTES)
237  *
238  * RETURNS
239  *     No return value
240  *
241  * NOTES
242  *     The official documentation is incomplete!
243  *     This is the correct documentation:
244  *
245  *     uMsg:
246  *     MenuHelp() does NOT handle WM_COMMAND messages! It only handles
247  *     WM_MENUSELECT messages.
248  *
249  *     lpwIDs:
250  *     (will be written ...)
251  */
252
253 VOID WINAPI
254 MenuHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu,
255           HINSTANCE hInst, HWND hwndStatus, UINT* lpwIDs)
256 {
257     UINT uMenuID = 0;
258
259     if (!IsWindow (hwndStatus))
260         return;
261
262     switch (uMsg) {
263         case WM_MENUSELECT:
264             TRACE("WM_MENUSELECT wParam=0x%X lParam=0x%lX\n",
265                    wParam, lParam);
266
267             if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) {
268                 /* menu was closed */
269                 TRACE("menu was closed!\n");
270                 SendMessageA (hwndStatus, SB_SIMPLE, FALSE, 0);
271             }
272             else {
273                 /* menu item was selected */
274                 if (HIWORD(wParam) & MF_POPUP)
275                     uMenuID = (UINT)*(lpwIDs+1);
276                 else
277                     uMenuID = (UINT)LOWORD(wParam);
278                 TRACE("uMenuID = %u\n", uMenuID);
279
280                 if (uMenuID) {
281                     CHAR szText[256];
282
283                     if (!LoadStringA (hInst, uMenuID, szText, 256))
284                         szText[0] = '\0';
285
286                     SendMessageA (hwndStatus, SB_SETTEXTA,
287                                     255 | SBT_NOBORDERS, (LPARAM)szText);
288                     SendMessageA (hwndStatus, SB_SIMPLE, TRUE, 0);
289                 }
290             }
291             break;
292
293         case WM_COMMAND :
294             TRACE("WM_COMMAND wParam=0x%X lParam=0x%lX\n",
295                    wParam, lParam);
296             /* WM_COMMAND is not invalid since it is documented
297              * in the windows api reference. So don't output
298              * any FIXME for WM_COMMAND
299              */
300             WARN("We don't care about the WM_COMMAND\n");
301             break;
302
303         default:
304             FIXME("Invalid Message 0x%x!\n", uMsg);
305             break;
306     }
307 }
308
309
310 /***********************************************************************
311  * ShowHideMenuCtl [COMCTL32.3]
312  *
313  * Shows or hides controls and updates the corresponding menu item.
314  *
315  * PARAMS
316  *     hwnd   [I] handle to the client window.
317  *     uFlags [I] menu command id.
318  *     lpInfo [I] pointer to an array of integers. (See NOTES.)
319  *
320  * RETURNS
321  *     Success: TRUE
322  *     Failure: FALSE
323  *
324  * NOTES
325  *     The official documentation is incomplete!
326  *     This is the correct documentation:
327  *
328  *     hwnd
329  *     Handle to the window that contains the menu and controls.
330  *
331  *     uFlags
332  *     Identifier of the menu item to receive or loose a check mark.
333  *
334  *     lpInfo
335  *     The array of integers contains pairs of values. BOTH values of
336  *     the first pair must be the handles to the application's main menu.
337  *     Each subsequent pair consists of a menu id and control id.
338  */
339
340 BOOL WINAPI
341 ShowHideMenuCtl (HWND hwnd, UINT uFlags, LPINT lpInfo)
342 {
343     LPINT lpMenuId;
344
345     TRACE("%p, %x, %p\n", hwnd, uFlags, lpInfo);
346
347     if (lpInfo == NULL)
348         return FALSE;
349
350     if (!(lpInfo[0]) || !(lpInfo[1]))
351         return FALSE;
352
353     /* search for control */
354     lpMenuId = &lpInfo[2];
355     while (*lpMenuId != uFlags)
356         lpMenuId += 2;
357
358     if (GetMenuState ((HMENU)lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) {
359         /* uncheck menu item */
360         CheckMenuItem ((HMENU)lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED);
361
362         /* hide control */
363         lpMenuId++;
364         SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
365                         SWP_HIDEWINDOW);
366     }
367     else {
368         /* check menu item */
369         CheckMenuItem ((HMENU)lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED);
370
371         /* show control */
372         lpMenuId++;
373         SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0,
374                         SWP_SHOWWINDOW);
375     }
376
377     return TRUE;
378 }
379
380
381 /***********************************************************************
382  * GetEffectiveClientRect [COMCTL32.4]
383  *
384  * PARAMS
385  *     hwnd   [I] handle to the client window.
386  *     lpRect [O] pointer to the rectangle of the client window
387  *     lpInfo [I] pointer to an array of integers (see NOTES)
388  *
389  * RETURNS
390  *     No return value.
391  *
392  * NOTES
393  *     The official documentation is incomplete!
394  *     This is the correct documentation:
395  *
396  *     lpInfo
397  *     (will be written ...)
398  */
399
400 VOID WINAPI
401 GetEffectiveClientRect (HWND hwnd, LPRECT lpRect, LPINT lpInfo)
402 {
403     RECT rcCtrl;
404     INT  *lpRun;
405     HWND hwndCtrl;
406
407     TRACE("(0x%08lx 0x%08lx 0x%08lx)\n",
408            (DWORD)hwnd, (DWORD)lpRect, (DWORD)lpInfo);
409
410     GetClientRect (hwnd, lpRect);
411     lpRun = lpInfo;
412
413     do {
414         lpRun += 2;
415         if (*lpRun == 0)
416             return;
417         lpRun++;
418         hwndCtrl = GetDlgItem (hwnd, *lpRun);
419         if (GetWindowLongA (hwndCtrl, GWL_STYLE) & WS_VISIBLE) {
420             TRACE("control id 0x%x\n", *lpRun);
421             GetWindowRect (hwndCtrl, &rcCtrl);
422             MapWindowPoints (NULL, hwnd, (LPPOINT)&rcCtrl, 2);
423             SubtractRect (lpRect, lpRect, &rcCtrl);
424         }
425         lpRun++;
426     } while (*lpRun);
427 }
428
429
430 /***********************************************************************
431  * DrawStatusTextW [COMCTL32.@]
432  *
433  * Draws text with borders, like in a status bar.
434  *
435  * PARAMS
436  *     hdc   [I] handle to the window's display context
437  *     lprc  [I] pointer to a rectangle
438  *     text  [I] pointer to the text
439  *     style [I] drawing style
440  *
441  * RETURNS
442  *     No return value.
443  *
444  * NOTES
445  *     The style variable can have one of the following values:
446  *     (will be written ...)
447  */
448
449 void WINAPI DrawStatusTextW (HDC hdc, LPRECT lprc, LPCWSTR text, UINT style)
450 {
451     RECT r = *lprc;
452     UINT border = BDR_SUNKENOUTER;
453
454     if (style & SBT_POPOUT)
455         border = BDR_RAISEDOUTER;
456     else if (style & SBT_NOBORDERS)
457         border = 0;
458
459     DrawEdge (hdc, &r, border, BF_RECT|BF_ADJUST);
460
461     /* now draw text */
462     if (text) {
463         int oldbkmode = SetBkMode (hdc, TRANSPARENT);
464         UINT align = DT_LEFT;
465         if (*text == L'\t') {
466             text++;
467             align = DT_CENTER;
468             if (*text == L'\t') {
469                 text++;
470                 align = DT_RIGHT;
471             }
472         }
473         r.left += 3;
474         if (style & SBT_RTLREADING)
475             FIXME("Unsupported RTL style!\n");
476         DrawTextW (hdc, text, -1, &r, align|DT_VCENTER|DT_SINGLELINE);
477         SetBkMode(hdc, oldbkmode);
478     }
479 }
480
481
482 /***********************************************************************
483  * DrawStatusText  [COMCTL32.@]
484  * DrawStatusTextA [COMCTL32.5]
485  *
486  * Draws text with borders, like in a status bar.
487  *
488  * PARAMS
489  *     hdc   [I] handle to the window's display context
490  *     lprc  [I] pointer to a rectangle
491  *     text  [I] pointer to the text
492  *     style [I] drawing style
493  *
494  * RETURNS
495  *     No return value.
496  */
497
498 void WINAPI DrawStatusTextA (HDC hdc, LPRECT lprc, LPCSTR text, UINT style)
499 {
500     INT len;
501     LPWSTR textW = NULL;
502
503     if ( text ) {
504         if ( (len = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 )) ) {
505             if ( (textW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )) )
506                 MultiByteToWideChar( CP_ACP, 0, text, -1, textW, len );
507         }
508     }
509     DrawStatusTextW( hdc, lprc, textW, style );
510     HeapFree( GetProcessHeap(), 0, textW );
511 }
512
513
514 /***********************************************************************
515  * CreateStatusWindow  [COMCTL32.@]
516  * CreateStatusWindowA [COMCTL32.6]
517  *
518  * Creates a status bar
519  *
520  * PARAMS
521  *     style  [I] window style
522  *     text   [I] pointer to the window text
523  *     parent [I] handle to the parent window
524  *     wid    [I] control id of the status bar
525  *
526  * RETURNS
527  *     Success: handle to the status window
528  *     Failure: 0
529  */
530
531 HWND WINAPI
532 CreateStatusWindowA (INT style, LPCSTR text, HWND parent, UINT wid)
533 {
534     return CreateWindowA(STATUSCLASSNAMEA, text, style,
535                            CW_USEDEFAULT, CW_USEDEFAULT,
536                            CW_USEDEFAULT, CW_USEDEFAULT,
537                            parent, (HMENU)wid, 0, 0);
538 }
539
540
541 /***********************************************************************
542  * CreateStatusWindowW [COMCTL32.@] Creates a status bar control
543  *
544  * PARAMS
545  *     style  [I] window style
546  *     text   [I] pointer to the window text
547  *     parent [I] handle to the parent window
548  *     wid    [I] control id of the status bar
549  *
550  * RETURNS
551  *     Success: handle to the status window
552  *     Failure: 0
553  */
554
555 HWND WINAPI
556 CreateStatusWindowW (INT style, LPCWSTR text, HWND parent, UINT wid)
557 {
558     return CreateWindowW(STATUSCLASSNAMEW, text, style,
559                            CW_USEDEFAULT, CW_USEDEFAULT,
560                            CW_USEDEFAULT, CW_USEDEFAULT,
561                            parent, (HMENU)wid, 0, 0);
562 }
563
564
565 /***********************************************************************
566  * CreateUpDownControl [COMCTL32.16] Creates an up-down control
567  *
568  * PARAMS
569  *     style  [I] window styles
570  *     x      [I] horizontal position of the control
571  *     y      [I] vertical position of the control
572  *     cx     [I] with of the control
573  *     cy     [I] height of the control
574  *     parent [I] handle to the parent window
575  *     id     [I] the control's identifier
576  *     inst   [I] handle to the application's module instance
577  *     buddy  [I] handle to the buddy window, can be NULL
578  *     maxVal [I] upper limit of the control
579  *     minVal [I] lower limit of the control
580  *     curVal [I] current value of the control
581  *
582  * RETURNS
583  *     Success: handle to the updown control
584  *     Failure: 0
585  */
586
587 HWND WINAPI
588 CreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy,
589                      HWND parent, INT id, HINSTANCE inst,
590                      HWND buddy, INT maxVal, INT minVal, INT curVal)
591 {
592     HWND hUD =
593         CreateWindowA (UPDOWN_CLASSA, 0, style, x, y, cx, cy,
594                          parent, (HMENU)id, inst, 0);
595     if (hUD) {
596         SendMessageA (hUD, UDM_SETBUDDY, (WPARAM)buddy, 0);
597         SendMessageA (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
598         SendMessageA (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));
599     }
600
601     return hUD;
602 }
603
604
605 /***********************************************************************
606  * InitCommonControls [COMCTL32.17]
607  *
608  * Registers the common controls.
609  *
610  * PARAMS
611  *     No parameters.
612  *
613  * RETURNS
614  *     No return values.
615  *
616  * NOTES
617  *     This function is just a dummy.
618  *     The Win95 controls are registered at the DLL's initialization.
619  *     To register other controls InitCommonControlsEx() must be used.
620  */
621
622 VOID WINAPI
623 InitCommonControls (void)
624 {
625 }
626
627
628 /***********************************************************************
629  * InitCommonControlsEx [COMCTL32.@]
630  *
631  * Registers the common controls.
632  *
633  * PARAMS
634  *     lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure.
635  *
636  * RETURNS
637  *     Success: TRUE
638  *     Failure: FALSE
639  *
640  * NOTES
641  *     Only the additional common controls are registered by this function.
642  *     The Win95 controls are registered at the DLL's initialization.
643  *
644  * FIXME
645  *     implement the following control classes:
646  *       ICC_LINK_CLASS
647  *       ICC_STANDARD_CLASSES
648  */
649
650 BOOL WINAPI
651 InitCommonControlsEx (LPINITCOMMONCONTROLSEX lpInitCtrls)
652 {
653     INT cCount;
654     DWORD dwMask;
655
656     if (!lpInitCtrls)
657         return FALSE;
658     if (lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX))
659         return FALSE;
660
661     TRACE("(0x%08lx)\n", lpInitCtrls->dwICC);
662
663     for (cCount = 0; cCount < 32; cCount++) {
664         dwMask = 1 << cCount;
665         if (!(lpInitCtrls->dwICC & dwMask))
666             continue;
667
668         switch (lpInitCtrls->dwICC & dwMask) {
669             /* dummy initialization */
670             case ICC_ANIMATE_CLASS:
671             case ICC_BAR_CLASSES:
672             case ICC_LISTVIEW_CLASSES:
673             case ICC_TREEVIEW_CLASSES:
674             case ICC_TAB_CLASSES:
675             case ICC_UPDOWN_CLASS:
676             case ICC_PROGRESS_CLASS:
677             case ICC_HOTKEY_CLASS:
678                 break;
679
680             /* advanced classes - not included in Win95 */
681             case ICC_DATE_CLASSES:
682                 MONTHCAL_Register ();
683                 DATETIME_Register ();
684                 break;
685
686             case ICC_USEREX_CLASSES:
687                 COMBOEX_Register ();
688                 break;
689
690             case ICC_COOL_CLASSES:
691                 REBAR_Register ();
692                 break;
693
694             case ICC_INTERNET_CLASSES:
695                 IPADDRESS_Register ();
696                 break;
697
698             case ICC_PAGESCROLLER_CLASS:
699                 PAGER_Register ();
700                 break;
701
702             case ICC_NATIVEFNTCTL_CLASS:
703                 NATIVEFONT_Register ();
704                 break;
705
706             default:
707                 FIXME("Unknown class! dwICC=0x%lX\n", dwMask);
708                 break;
709         }
710     }
711
712     return TRUE;
713 }
714
715
716 /***********************************************************************
717  * CreateToolbarEx [COMCTL32.@] Creates a tool bar window
718  *
719  * PARAMS
720  *     hwnd
721  *     style
722  *     wID
723  *     nBitmaps
724  *     hBMInst
725  *     wBMID
726  *     lpButtons
727  *     iNumButtons
728  *     dxButton
729  *     dyButton
730  *     dxBitmap
731  *     dyBitmap
732  *     uStructSize
733  *
734  * RETURNS
735  *     Success: handle to the tool bar control
736  *     Failure: 0
737  */
738
739 HWND WINAPI
740 CreateToolbarEx (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
741                  HINSTANCE hBMInst, UINT wBMID, LPCTBBUTTON lpButtons,
742                  INT iNumButtons, INT dxButton, INT dyButton,
743                  INT dxBitmap, INT dyBitmap, UINT uStructSize)
744 {
745     HWND hwndTB;
746
747     /* If not position is specified then put it at the top */
748     if ((style & CCS_BOTTOM) == 0) {
749       style|=CCS_TOP;
750     }
751
752     hwndTB =
753         CreateWindowExA (0, TOOLBARCLASSNAMEA, "", style|WS_CHILD, 0, 0, 0, 0,
754                            hwnd, (HMENU)wID, 0, NULL);
755     if(hwndTB) {
756         TBADDBITMAP tbab;
757
758         SendMessageA (hwndTB, TB_BUTTONSTRUCTSIZE,
759                         (WPARAM)uStructSize, 0);
760
761        /* set bitmap and button size */
762        /*If CreateToolbarEx receives 0, windows sets default values*/
763        if (dxBitmap <= 0)
764            dxBitmap = 16;
765        if (dyBitmap <= 0)
766            dyBitmap = 15;
767        SendMessageA (hwndTB, TB_SETBITMAPSIZE, 0,
768                        MAKELPARAM((WORD)dxBitmap, (WORD)dyBitmap));
769
770        if (dxButton <= 0)
771            dxButton = 24;
772        if (dyButton <= 0)
773            dyButton = 22;
774        SendMessageA (hwndTB, TB_SETBUTTONSIZE, 0,
775                        MAKELPARAM((WORD)dxButton, (WORD)dyButton));
776
777
778         /* add bitmaps */
779         if (nBitmaps > 0)
780         {
781         tbab.hInst = hBMInst;
782         tbab.nID   = wBMID;
783
784         SendMessageA (hwndTB, TB_ADDBITMAP,
785                         (WPARAM)nBitmaps, (LPARAM)&tbab);
786         }
787         /* add buttons */
788         if(iNumButtons > 0)
789         SendMessageA (hwndTB, TB_ADDBUTTONSA,
790                         (WPARAM)iNumButtons, (LPARAM)lpButtons);
791     }
792
793     return hwndTB;
794 }
795
796
797 /***********************************************************************
798  * CreateMappedBitmap [COMCTL32.8]
799  *
800  * PARAMS
801  *     hInstance  [I]
802  *     idBitmap   [I]
803  *     wFlags     [I]
804  *     lpColorMap [I]
805  *     iNumMaps   [I]
806  *
807  * RETURNS
808  *     Success: handle to the new bitmap
809  *     Failure: 0
810  */
811
812 HBITMAP WINAPI
813 CreateMappedBitmap (HINSTANCE hInstance, INT idBitmap, UINT wFlags,
814                     LPCOLORMAP lpColorMap, INT iNumMaps)
815 {
816     HGLOBAL hglb;
817     HRSRC hRsrc;
818     LPBITMAPINFOHEADER lpBitmap, lpBitmapInfo;
819     UINT nSize, nColorTableSize;
820     RGBQUAD *pColorTable;
821     INT iColor, i, iMaps, nWidth, nHeight;
822     HDC hdcScreen;
823     HBITMAP hbm;
824     LPCOLORMAP sysColorMap;
825     COLORREF cRef;
826     COLORMAP internalColorMap[4] =
827         {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
828
829     /* initialize pointer to colortable and default color table */
830     if (lpColorMap) {
831         iMaps = iNumMaps;
832         sysColorMap = lpColorMap;
833     }
834     else {
835         internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT);
836         internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW);
837         internalColorMap[2].to = GetSysColor (COLOR_BTNFACE);
838         internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT);
839         iMaps = 4;
840         sysColorMap = (LPCOLORMAP)internalColorMap;
841     }
842
843     hRsrc = FindResourceA (hInstance, (LPSTR)idBitmap, RT_BITMAPA);
844     if (hRsrc == 0)
845         return 0;
846     hglb = LoadResource (hInstance, hRsrc);
847     if (hglb == 0)
848         return 0;
849     lpBitmap = (LPBITMAPINFOHEADER)LockResource (hglb);
850     if (lpBitmap == NULL)
851         return 0;
852
853     nColorTableSize = (1 << lpBitmap->biBitCount);
854     nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD);
855     lpBitmapInfo = (LPBITMAPINFOHEADER)GlobalAlloc (GMEM_FIXED, nSize);
856     if (lpBitmapInfo == NULL)
857         return 0;
858     RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize);
859
860     pColorTable = (RGBQUAD*)(((LPBYTE)lpBitmapInfo)+(UINT)lpBitmapInfo->biSize);
861
862     for (iColor = 0; iColor < nColorTableSize; iColor++) {
863         for (i = 0; i < iMaps; i++) {
864             cRef = RGB(pColorTable[iColor].rgbRed,
865                        pColorTable[iColor].rgbGreen,
866                        pColorTable[iColor].rgbBlue);
867             if ( cRef  == sysColorMap[i].from) {
868 #if 0
869                 if (wFlags & CBS_MASKED) {
870                     if (sysColorMap[i].to != COLOR_BTNTEXT)
871                         pColorTable[iColor] = RGB(255, 255, 255);
872                 }
873                 else
874 #endif
875                     pColorTable[iColor].rgbBlue  = GetBValue(sysColorMap[i].to);
876                     pColorTable[iColor].rgbGreen = GetGValue(sysColorMap[i].to);
877                     pColorTable[iColor].rgbRed   = GetRValue(sysColorMap[i].to);
878                 break;
879             }
880         }
881     }
882     nWidth  = (INT)lpBitmapInfo->biWidth;
883     nHeight = (INT)lpBitmapInfo->biHeight;
884     hdcScreen = GetDC (NULL);
885     hbm = CreateCompatibleBitmap (hdcScreen, nWidth, nHeight);
886     if (hbm) {
887         HDC hdcDst = CreateCompatibleDC (hdcScreen);
888         HBITMAP hbmOld = SelectObject (hdcDst, hbm);
889         LPBYTE lpBits = (LPBYTE)(lpBitmap + 1);
890         lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
891         StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
892                          lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS,
893                          SRCCOPY);
894         SelectObject (hdcDst, hbmOld);
895         DeleteDC (hdcDst);
896     }
897     ReleaseDC (NULL, hdcScreen);
898     GlobalFree ((HGLOBAL)lpBitmapInfo);
899     FreeResource (hglb);
900
901     return hbm;
902 }
903
904
905 /***********************************************************************
906  * CreateToolbar [COMCTL32.7] Creates a tool bar control
907  *
908  * PARAMS
909  *     hwnd
910  *     style
911  *     wID
912  *     nBitmaps
913  *     hBMInst
914  *     wBMID
915  *     lpButtons
916  *     iNumButtons
917  *
918  * RETURNS
919  *     Success: handle to the tool bar control
920  *     Failure: 0
921  *
922  * NOTES
923  *     Do not use this functions anymore. Use CreateToolbarEx instead.
924  */
925
926 HWND WINAPI
927 CreateToolbar (HWND hwnd, DWORD style, UINT wID, INT nBitmaps,
928                HINSTANCE hBMInst, UINT wBMID,
929                LPCOLDTBBUTTON lpButtons,INT iNumButtons)
930 {
931     return CreateToolbarEx (hwnd, style | CCS_NODIVIDER, wID, nBitmaps,
932                             hBMInst, wBMID, (LPCTBBUTTON)lpButtons,
933                             iNumButtons, 0, 0, 0, 0, sizeof (OLDTBBUTTON));
934 }
935
936
937 /***********************************************************************
938  * DllGetVersion [COMCTL32.@]
939  *
940  * Retrieves version information of the 'COMCTL32.DLL'
941  *
942  * PARAMS
943  *     pdvi [O] pointer to version information structure.
944  *
945  * RETURNS
946  *     Success: S_OK
947  *     Failure: E_INVALIDARG
948  *
949  * NOTES
950  *     Returns version of a comctl32.dll from IE4.01 SP1.
951  */
952
953 HRESULT WINAPI
954 COMCTL32_DllGetVersion (DLLVERSIONINFO *pdvi)
955 {
956     if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
957         WARN("wrong DLLVERSIONINFO size from app\n");
958         return E_INVALIDARG;
959     }
960
961     pdvi->dwMajorVersion = COMCTL32_VERSION;
962     pdvi->dwMinorVersion = COMCTL32_VERSION_MINOR;
963     pdvi->dwBuildNumber = 2919;
964     pdvi->dwPlatformID = 6304;
965
966     TRACE("%lu.%lu.%lu.%lu\n",
967            pdvi->dwMajorVersion, pdvi->dwMinorVersion,
968            pdvi->dwBuildNumber, pdvi->dwPlatformID);
969
970     return S_OK;
971 }
972
973 /***********************************************************************
974  *              DllInstall (COMCTL32.@)
975  */
976 HRESULT WINAPI COMCTL32_DllInstall(BOOL bInstall, LPCWSTR cmdline)
977 {
978   FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
979         debugstr_w(cmdline));
980
981   return S_OK;
982 }
983
984 /***********************************************************************
985  * _TrackMouseEvent [COMCTL32.@]
986  *
987  * Requests notification of mouse events
988  *
989  * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
990  * to the hwnd specified in the ptme structure.  After the event message
991  * is posted to the hwnd, the entry in the queue is removed.
992  *
993  * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
994  * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
995  * immediately and the TME_LEAVE flag being ignored.
996  *
997  * PARAMS
998  *     ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
999  *
1000  * RETURNS
1001  *     Success: non-zero
1002  *     Failure: zero
1003  *
1004  * IMPLEMENTATION moved to USER32.TrackMouseEvent
1005  *
1006  */
1007
1008 BOOL WINAPI
1009 _TrackMouseEvent (TRACKMOUSEEVENT *ptme)
1010 {
1011     return TrackMouseEvent (ptme);
1012 }
1013
1014 /*************************************************************************
1015  * GetMUILanguage [COMCTL32.@]
1016  *
1017  * FIXME: "Returns the language currently in use by the common controls
1018  * for a particular process." (MSDN)
1019  *
1020  */
1021 LANGID WINAPI GetMUILanguage (VOID)
1022 {
1023     return COMCTL32_uiLang;
1024 }
1025
1026
1027 /*************************************************************************
1028  * InitMUILanguage [COMCTL32.@]
1029  *
1030  * FIXME: "Enables an application to specify a language to be used with
1031  * the common controls that is different than the system language." (MSDN)
1032  *
1033  */
1034
1035 VOID WINAPI InitMUILanguage (LANGID uiLang)
1036 {
1037    COMCTL32_uiLang = uiLang;
1038 }
1039
1040
1041 /***********************************************************************
1042  * SetWindowSubclass [COMCTL32.@]
1043  *
1044  * Starts a window subclass
1045  *
1046  * PARAMS
1047  *     hWnd [in] handle to window subclass.
1048  *     pfnSubclass [in] Pointer to new window procedure.
1049  *     uIDSubclass [in] Unique identifier of sublass together with pfnSubclass.
1050  *     dwRef [in] Reference data to pass to window procedure.
1051  *
1052  * RETURNS
1053  *     Success: non-zero
1054  *     Failure: zero
1055  *
1056  * BUGS
1057  *     If an application manually subclasses a window after subclassing it with
1058  *     this API and then with this API again, then none of the previous 
1059  *     subclasses get called or the origional window procedure.
1060  */
1061
1062 BOOL WINAPI SetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
1063                         UINT_PTR uIDSubclass, DWORD_PTR dwRef)
1064 {
1065    LPSUBCLASS_INFO stack;
1066    int newnum, n;
1067
1068    TRACE ("(%p, %p, %x, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef);
1069
1070    /* Since the window procedure that we set here has two additional arguments,
1071     * we can't simply set it as the new window procedure of the window. So we
1072     * set our own window procedure and then calculate the other two arguments
1073     * from there. */
1074
1075    /* See if we have been called for this window */
1076    stack = (LPSUBCLASS_INFO)GetPropA (hWnd, COMCTL32_aSubclass);
1077    if (!stack) {
1078       /* allocate stack */
1079       stack = (LPSUBCLASS_INFO)HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY,
1080                                          sizeof(SUBCLASS_INFO));
1081       if (!stack) {
1082          ERR ("Failed to allocate our Subclassing stack");
1083          return FALSE;
1084       }
1085       SetPropA (hWnd, COMCTL32_aSubclass, (HANDLE)stack);
1086
1087       /* set window procedure to our own and save the current one */
1088       if (IsWindowUnicode (hWnd))
1089          stack->origproc = (WNDPROC)SetWindowLongW (hWnd, GWL_WNDPROC,
1090                                                    (LONG)DefSubclassProc);
1091       else
1092          stack->origproc = (WNDPROC)SetWindowLongA (hWnd, GWL_WNDPROC,
1093                                                    (LONG)DefSubclassProc);
1094    } else {
1095       WNDPROC current;
1096       if (IsWindowUnicode (hWnd))
1097          current = (WNDPROC)GetWindowLongW (hWnd, GWL_WNDPROC);
1098       else
1099          current = (WNDPROC)GetWindowLongA (hWnd, GWL_WNDPROC);
1100
1101       if (current != DefSubclassProc) {
1102          ERR ("Application has subclassed with our procedure, then manually, then with us again.  The current implementation can't handle this.\n");
1103          return FALSE;
1104       }
1105    }
1106
1107    /* Check to see if we have called this function with the same uIDSubClass
1108     * and pfnSubclass */
1109    for (n = 0; n <= stack->stacknum + stack->stacknew - 1; n++)
1110       if ((stack->SubclassProcs[n].id == uIDSubclass) && 
1111          (stack->SubclassProcs[n].subproc == pfnSubclass)) {
1112          stack->SubclassProcs[n].ref = dwRef;
1113          return TRUE;
1114       }
1115
1116    if ((stack->stacknum + stack->stacknew) >= 32) {
1117       ERR ("We have a Subclass stack overflow, please increment size");
1118       return FALSE;
1119    }
1120
1121    /* we can't simply increment both stackpos and stacknum because there might
1122     * be a window procedure running lower in the stack, we can only get them
1123     * up to date once the last window procedure has run */
1124    if (stack->stacknum == stack->stackpos) {
1125       stack->stacknum++;
1126       stack->stackpos++;
1127    } else
1128       stack->stacknew++;
1129
1130    newnum = stack->stacknew + stack->stacknum - 1;
1131
1132    stack->SubclassProcs[newnum].subproc = pfnSubclass;
1133    stack->SubclassProcs[newnum].ref = dwRef;
1134    stack->SubclassProcs[newnum].id = uIDSubclass;
1135    
1136    return TRUE;
1137 }
1138
1139
1140 /***********************************************************************
1141  * GetWindowSubclass [COMCTL32.@]
1142  *
1143  * Gets the Reference data from a subclass.
1144  *
1145  * PARAMS
1146  *     hWnd [in] Handle to window which were subclassing
1147  *     pfnSubclass [in] Pointer to the subclass procedure
1148  *     uID [in] Unique indentifier of the subclassing procedure
1149  *     pdwRef [out] Pointer to the reference data
1150  *
1151  * RETURNS
1152  *     Success: Non-zero
1153  *     Failure: 0
1154  */
1155
1156 BOOL WINAPI GetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
1157                               UINT_PTR uID, DWORD_PTR *pdwRef)
1158 {
1159    LPSUBCLASS_INFO stack;
1160    int n;
1161
1162    TRACE ("(%p, %p, %x, %p)\n", hWnd, pfnSubclass, uID, pdwRef);
1163
1164    /* See if we have been called for this window */
1165    stack = (LPSUBCLASS_INFO)GetPropA (hWnd, COMCTL32_aSubclass);
1166    if (!stack)
1167       return FALSE;
1168
1169    for (n = 0; n <= stack->stacknum + stack->stacknew - 1; n++)
1170       if ((stack->SubclassProcs[n].id == uID) &&
1171          (stack->SubclassProcs[n].subproc == pfnSubclass)) {
1172          *pdwRef = stack->SubclassProcs[n].ref;
1173          return TRUE;
1174       }
1175
1176    return FALSE;
1177 }
1178
1179
1180 /***********************************************************************
1181  * RemoveWindowSubclass [COMCTL32.@]
1182  *
1183  * Removes a window subclass.
1184  *
1185  * PARAMS
1186  *     hWnd [in] Handle to the window were subclassing
1187  *     pfnSubclass [in] Pointer to the subclass procedure
1188  *     uID [in] Unique identifier of this subclass
1189  *
1190  * RETURNS
1191  *     Success: non-zero
1192  *     Failure: zero
1193  */
1194
1195 BOOL WINAPI RemoveWindowSubclass(HWND hWnd, SUBCLASSPROC pfnSubclass, UINT_PTR uID)
1196 {
1197    LPSUBCLASS_INFO stack;
1198    int n;
1199
1200    TRACE ("(%p, %p, %x)\n", hWnd, pfnSubclass, uID);
1201
1202    /* Find the Subclass to remove */
1203    stack = (LPSUBCLASS_INFO)GetPropA (hWnd, COMCTL32_aSubclass);
1204    if (!stack)
1205       return FALSE;
1206
1207    if ((stack->stacknum == stack->stackpos == 1) && !stack->stacknew) {
1208       TRACE("Last Subclass removed, cleaning up\n");
1209       /* clean up our heap and reset the origional window procedure */
1210       if (IsWindowUnicode (hWnd))
1211          SetWindowLongW (hWnd, GWL_WNDPROC, (LONG)stack->origproc);
1212       else
1213          SetWindowLongA (hWnd, GWL_WNDPROC, (LONG)stack->origproc);
1214       HeapFree (GetProcessHeap (), 0, stack);
1215       RemovePropA( hWnd, COMCTL32_aSubclass );
1216       return TRUE;
1217    }
1218  
1219    for (n = stack->stacknum + stack->stacknew - 1; n >= 0; n--)
1220       if ((stack->SubclassProcs[n].id == uID) &&
1221          (stack->SubclassProcs[n].subproc == pfnSubclass)) {
1222          if (n != (stack->stacknum + stack->stacknew))
1223             /* Fill the hole in the stack */
1224             memmove (&stack->SubclassProcs[n], &stack->SubclassProcs[n + 1],
1225                     sizeof(stack->SubclassProcs[0]) * (stack->stacknew + stack->stacknum - n));
1226          stack->SubclassProcs[n].subproc = NULL;
1227          stack->SubclassProcs[n].ref = 0;
1228          stack->SubclassProcs[n].id = 0;
1229
1230          /* If we are currently running a window procedure we have to manipulate
1231           * the stack position pointers so that we don't corrupt the stack */
1232          if ((n < stack->stackpos) || (stack->stackpos == stack->stacknum)) {
1233             stack->stacknum--;
1234             stack->stackpos--;
1235          } else if (n >= stack->stackpos)
1236             stack->stacknew--;
1237          return TRUE;
1238       }
1239
1240    return FALSE;
1241 }
1242
1243
1244 /***********************************************************************
1245  * DefSubclassProc [COMCTL32.@]
1246  *
1247  * Calls the next window procedure (ie. the one before this subclass)
1248  *
1249  * PARAMS
1250  *     hWnd [in] The window that we're subclassing
1251  *     uMsg [in] Message
1252  *     wParam [in] WPARAM
1253  *     lParam [in] LPARAM
1254  *
1255  * RETURNS
1256  *     Success: non-zero
1257  *     Failure: zero
1258  */
1259
1260 LRESULT WINAPI DefSubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1261 {
1262    LPSUBCLASS_INFO stack;
1263    int stackpos;
1264    LRESULT ret;
1265
1266    /* retrieve our little stack from the Properties */
1267    stack = (LPSUBCLASS_INFO)GetPropA (hWnd, COMCTL32_aSubclass);
1268    if (!stack) {
1269       ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd);
1270       return 0;
1271    }
1272
1273    /* If we are at pos 0 then we have to call the origional window procedure */
1274    if (stack->stackpos == 0) {
1275       if (IsWindowUnicode (hWnd))
1276          return CallWindowProcW (stack->origproc, hWnd, uMsg, wParam, lParam);
1277       else
1278          return CallWindowProcA (stack->origproc, hWnd, uMsg, wParam, lParam);
1279    }
1280
1281    stackpos = --stack->stackpos;
1282    /* call the Subclass procedure from the stack */
1283    ret = stack->SubclassProcs[stackpos].subproc (hWnd, uMsg, wParam, lParam,
1284          stack->SubclassProcs[stackpos].id, stack->SubclassProcs[stackpos].ref);
1285    stack->stackpos++;
1286
1287    if ((stack->stackpos == stack->stacknum) && stack->stacknew) {
1288       stack->stacknum += stack->stacknew;
1289       stack->stackpos += stack->stacknew;
1290       stack->stacknew = 0;
1291    }
1292
1293    /* If we removed the last entry in our stack while a window procedure was
1294     * running then we have to clean up */
1295    if (stack->stackpos == stack->stacknum == 0) {
1296       TRACE("Last Subclass removed, cleaning up\n");
1297       /* clean up our heap and reset the origional window procedure */
1298       if (IsWindowUnicode (hWnd))
1299          SetWindowLongW (hWnd, GWL_WNDPROC, (LONG)stack->origproc);
1300       else
1301          SetWindowLongA (hWnd, GWL_WNDPROC, (LONG)stack->origproc);
1302       HeapFree (GetProcessHeap (), 0, stack);
1303       RemovePropA( hWnd, COMCTL32_aSubclass );
1304       return TRUE;
1305    }
1306
1307    return ret;
1308 }
1309
1310
1311 /***********************************************************************
1312  * COMCTL32_CreateToolTip [NOT AN API]
1313  *
1314  * Creates a tooltip for the control specified in hwnd and does all
1315  * necessary setup and notifications.
1316  *
1317  * PARAMS
1318  *     hwndOwner [I] Handle to the window that will own the tool tip.
1319  *
1320  * RETURNS
1321  *     Success: Handle of tool tip window.
1322  *     Failure: NULL
1323  */
1324
1325 HWND
1326 COMCTL32_CreateToolTip(HWND hwndOwner)
1327 {
1328     HWND hwndToolTip;
1329
1330     hwndToolTip = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0,
1331                                   CW_USEDEFAULT, CW_USEDEFAULT,
1332                                   CW_USEDEFAULT, CW_USEDEFAULT, hwndOwner,
1333                                   0, 0, 0);
1334
1335     /* Send NM_TOOLTIPSCREATED notification */
1336     if (hwndToolTip)
1337     {
1338         NMTOOLTIPSCREATED nmttc;
1339         /* true owner can be different if hwndOwner is a child window */
1340         HWND hwndTrueOwner = GetWindow(hwndToolTip, GW_OWNER);
1341         nmttc.hdr.hwndFrom = hwndTrueOwner;
1342         nmttc.hdr.idFrom = GetWindowLongA(hwndTrueOwner, GWL_ID);
1343         nmttc.hdr.code = NM_TOOLTIPSCREATED;
1344         nmttc.hwndToolTips = hwndToolTip;
1345
1346        SendMessageA(GetParent(hwndTrueOwner), WM_NOTIFY,
1347                     (WPARAM)GetWindowLongA(hwndTrueOwner, GWL_ID),
1348                      (LPARAM)&nmttc);
1349     }
1350
1351     return hwndToolTip;
1352 }
1353
1354
1355 /***********************************************************************
1356  * COMCTL32_RefreshSysColors [NOT AN API]
1357  *
1358  * Invoked on any control recognizing a WM_SYSCOLORCHANGE message to
1359  * refresh the color values in the color structure
1360  *
1361  * PARAMS
1362  *     none
1363  *
1364  * RETURNS
1365  *     none
1366  */
1367
1368 VOID
1369 COMCTL32_RefreshSysColors(void)
1370 {
1371     comctl32_color.clrBtnHighlight = GetSysColor (COLOR_BTNHIGHLIGHT);
1372     comctl32_color.clrBtnShadow = GetSysColor (COLOR_BTNSHADOW);
1373     comctl32_color.clrBtnText = GetSysColor (COLOR_BTNTEXT);
1374     comctl32_color.clrBtnFace = GetSysColor (COLOR_BTNFACE);
1375     comctl32_color.clrHighlight = GetSysColor (COLOR_HIGHLIGHT);
1376     comctl32_color.clrHighlightText = GetSysColor (COLOR_HIGHLIGHTTEXT);
1377     comctl32_color.clr3dHilight = GetSysColor (COLOR_3DHILIGHT);
1378     comctl32_color.clr3dShadow = GetSysColor (COLOR_3DSHADOW);
1379     comctl32_color.clr3dDkShadow = GetSysColor (COLOR_3DDKSHADOW);
1380     comctl32_color.clr3dFace = GetSysColor (COLOR_3DFACE);
1381     comctl32_color.clrWindow = GetSysColor (COLOR_WINDOW);
1382     comctl32_color.clrWindowText = GetSysColor (COLOR_WINDOWTEXT);
1383     comctl32_color.clrGrayText = GetSysColor (COLOR_GRAYTEXT);
1384     comctl32_color.clrActiveCaption = GetSysColor (COLOR_ACTIVECAPTION);
1385     comctl32_color.clrInfoBk = GetSysColor (COLOR_INFOBK);
1386     comctl32_color.clrInfoText = GetSysColor (COLOR_INFOTEXT);
1387 }