2 * Common controls functions
4 * Copyright 1997 Dimitrie O. Paun
5 * Copyright 1998,2000 Eric Kohl
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.
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.
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
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.
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.
31 * -- implement GetMUILanguage + InitMUILanguage
32 * -- finish NOTES for MenuHelp, GetEffectiveClientRect and GetStatusTextW
33 * -- FIXMEs + BUGS (search for them)
36 * -- ICC_ANIMATE_CLASS
41 * -- ICC_INTERNET_CLASSES
43 * -- ICC_LISTVIEW_CLASSES
44 * -- ICC_NATIVEFNTCTL_CLASS
45 * -- ICC_PAGESCROLLER_CLASS
46 * -- ICC_PROGRESS_CLASS
47 * -- ICC_STANDARD_CLASSES (not yet implemented)
49 * -- ICC_TREEVIEW_CLASSES
51 * -- ICC_USEREX_CLASSES
52 * -- ICC_WIN95_CLASSES
67 #define NO_SHLWAPI_STREAM
70 #include "wine/debug.h"
72 WINE_DEFAULT_DEBUG_CHANNEL(commctrl
);
74 LRESULT WINAPI
COMCTL32_SubclassProc (HWND hWnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
);
76 LPWSTR COMCTL32_wSubclass
= NULL
;
77 HMODULE COMCTL32_hModule
= 0;
78 LANGID COMCTL32_uiLang
= MAKELANGID(LANG_NEUTRAL
, SUBLANG_NEUTRAL
);
79 HBRUSH COMCTL32_hPattern55AABrush
= NULL
;
80 COMCTL32_SysColor comctl32_color
;
82 static HBITMAP COMCTL32_hPattern55AABitmap
= NULL
;
84 static const WORD wPattern55AA
[] =
86 0x5555, 0xaaaa, 0x5555, 0xaaaa,
87 0x5555, 0xaaaa, 0x5555, 0xaaaa
90 static const WCHAR strCC32SubclassInfo
[] = {
91 'C','C','3','2','S','u','b','c','l','a','s','s','I','n','f','o',0
94 /***********************************************************************
97 * Initializes the internal 'COMCTL32.DLL'.
100 * hinstDLL [I] handle to the 'dlls' instance
102 * lpvReserved [I] reserverd, must be NULL
109 BOOL WINAPI
DllMain(HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
111 TRACE("%p,%x,%p\n", hinstDLL
, fdwReason
, lpvReserved
);
114 case DLL_PROCESS_ATTACH
:
115 DisableThreadLibraryCalls(hinstDLL
);
117 COMCTL32_hModule
= (HMODULE
)hinstDLL
;
119 /* add global subclassing atom (used by 'tooltip' and 'updown') */
120 COMCTL32_wSubclass
= (LPWSTR
)(DWORD_PTR
)GlobalAddAtomW (strCC32SubclassInfo
);
121 TRACE("Subclassing atom added: %p\n", COMCTL32_wSubclass
);
123 /* create local pattern brush */
124 COMCTL32_hPattern55AABitmap
= CreateBitmap (8, 8, 1, 1, wPattern55AA
);
125 COMCTL32_hPattern55AABrush
= CreatePatternBrush (COMCTL32_hPattern55AABitmap
);
127 /* Get all the colors at DLL load */
128 COMCTL32_RefreshSysColors();
130 /* like comctl32 5.82+ register all the common control classes */
133 DATETIME_Register ();
137 IPADDRESS_Register ();
138 LISTVIEW_Register ();
139 MONTHCAL_Register ();
140 NATIVEFONT_Register ();
142 PROGRESS_Register ();
148 TOOLTIPS_Register ();
149 TRACKBAR_Register ();
150 TREEVIEW_Register ();
153 /* subclass user32 controls */
154 THEMING_Initialize ();
157 case DLL_PROCESS_DETACH
:
158 /* clean up subclassing */
159 THEMING_Uninitialize();
161 /* unregister all common control classes */
162 ANIMATE_Unregister ();
163 COMBOEX_Unregister ();
164 DATETIME_Unregister ();
165 FLATSB_Unregister ();
166 HEADER_Unregister ();
167 HOTKEY_Unregister ();
168 IPADDRESS_Unregister ();
169 LISTVIEW_Unregister ();
170 MONTHCAL_Unregister ();
171 NATIVEFONT_Unregister ();
173 PROGRESS_Unregister ();
175 STATUS_Unregister ();
176 SYSLINK_Unregister ();
178 TOOLBAR_Unregister ();
179 TOOLTIPS_Unregister ();
180 TRACKBAR_Unregister ();
181 TREEVIEW_Unregister ();
182 UPDOWN_Unregister ();
184 /* delete local pattern brush */
185 DeleteObject (COMCTL32_hPattern55AABrush
);
186 COMCTL32_hPattern55AABrush
= NULL
;
187 DeleteObject (COMCTL32_hPattern55AABitmap
);
188 COMCTL32_hPattern55AABitmap
= NULL
;
190 /* delete global subclassing atom */
191 GlobalDeleteAtom (LOWORD(COMCTL32_wSubclass
));
192 TRACE("Subclassing atom deleted: %p\n", COMCTL32_wSubclass
);
193 COMCTL32_wSubclass
= NULL
;
201 /***********************************************************************
202 * MenuHelp [COMCTL32.2]
204 * Handles the setting of status bar help messages when the user
205 * selects menu items.
208 * uMsg [I] message (WM_MENUSELECT) (see NOTES)
209 * wParam [I] wParam of the message uMsg
210 * lParam [I] lParam of the message uMsg
211 * hMainMenu [I] handle to the application's main menu
212 * hInst [I] handle to the module that contains string resources
213 * hwndStatus [I] handle to the status bar window
214 * lpwIDs [I] pointer to an array of integers (see NOTES)
220 * The official documentation is incomplete!
221 * This is the correct documentation:
224 * MenuHelp() does NOT handle WM_COMMAND messages! It only handles
225 * WM_MENUSELECT messages.
228 * (will be written ...)
232 MenuHelp (UINT uMsg
, WPARAM wParam
, LPARAM lParam
, HMENU hMainMenu
,
233 HINSTANCE hInst
, HWND hwndStatus
, UINT
* lpwIDs
)
237 if (!IsWindow (hwndStatus
))
242 TRACE("WM_MENUSELECT wParam=0x%X lParam=0x%lX\n",
245 if ((HIWORD(wParam
) == 0xFFFF) && (lParam
== 0)) {
246 /* menu was closed */
247 TRACE("menu was closed!\n");
248 SendMessageW (hwndStatus
, SB_SIMPLE
, FALSE
, 0);
251 /* menu item was selected */
252 if (HIWORD(wParam
) & MF_POPUP
)
253 uMenuID
= (UINT
)*(lpwIDs
+1);
255 uMenuID
= (UINT
)LOWORD(wParam
);
256 TRACE("uMenuID = %u\n", uMenuID
);
261 if (!LoadStringW (hInst
, uMenuID
, szText
, sizeof(szText
)/sizeof(szText
[0])))
264 SendMessageW (hwndStatus
, SB_SETTEXTW
,
265 255 | SBT_NOBORDERS
, (LPARAM
)szText
);
266 SendMessageW (hwndStatus
, SB_SIMPLE
, TRUE
, 0);
272 TRACE("WM_COMMAND wParam=0x%X lParam=0x%lX\n",
274 /* WM_COMMAND is not invalid since it is documented
275 * in the windows api reference. So don't output
276 * any FIXME for WM_COMMAND
278 WARN("We don't care about the WM_COMMAND\n");
282 FIXME("Invalid Message 0x%x!\n", uMsg
);
288 /***********************************************************************
289 * ShowHideMenuCtl [COMCTL32.3]
291 * Shows or hides controls and updates the corresponding menu item.
294 * hwnd [I] handle to the client window.
295 * uFlags [I] menu command id.
296 * lpInfo [I] pointer to an array of integers. (See NOTES.)
303 * The official documentation is incomplete!
304 * This is the correct documentation:
307 * Handle to the window that contains the menu and controls.
310 * Identifier of the menu item to receive or lose a check mark.
313 * The array of integers contains pairs of values. BOTH values of
314 * the first pair must be the handles to the application's main menu.
315 * Each subsequent pair consists of a menu id and control id.
319 ShowHideMenuCtl (HWND hwnd
, UINT_PTR uFlags
, LPINT lpInfo
)
323 TRACE("%p, %x, %p\n", hwnd
, uFlags
, lpInfo
);
328 if (!(lpInfo
[0]) || !(lpInfo
[1]))
331 /* search for control */
332 lpMenuId
= &lpInfo
[2];
333 while (*lpMenuId
!= uFlags
)
336 if (GetMenuState ((HMENU
)(DWORD_PTR
)lpInfo
[1], uFlags
, MF_BYCOMMAND
) & MFS_CHECKED
) {
337 /* uncheck menu item */
338 CheckMenuItem ((HMENU
)(DWORD_PTR
)lpInfo
[0], *lpMenuId
, MF_BYCOMMAND
| MF_UNCHECKED
);
342 SetWindowPos (GetDlgItem (hwnd
, *lpMenuId
), 0, 0, 0, 0, 0,
346 /* check menu item */
347 CheckMenuItem ((HMENU
)(DWORD_PTR
)lpInfo
[0], *lpMenuId
, MF_BYCOMMAND
| MF_CHECKED
);
351 SetWindowPos (GetDlgItem (hwnd
, *lpMenuId
), 0, 0, 0, 0, 0,
359 /***********************************************************************
360 * GetEffectiveClientRect [COMCTL32.4]
362 * Calculates the coordinates of a rectangle in the client area.
365 * hwnd [I] handle to the client window.
366 * lpRect [O] pointer to the rectangle of the client window
367 * lpInfo [I] pointer to an array of integers (see NOTES)
373 * The official documentation is incomplete!
374 * This is the correct documentation:
377 * (will be written ...)
381 GetEffectiveClientRect (HWND hwnd
, LPRECT lpRect
, LPINT lpInfo
)
387 TRACE("(%p %p %p)\n",
388 hwnd
, lpRect
, lpInfo
);
390 GetClientRect (hwnd
, lpRect
);
398 hwndCtrl
= GetDlgItem (hwnd
, *lpRun
);
399 if (GetWindowLongW (hwndCtrl
, GWL_STYLE
) & WS_VISIBLE
) {
400 TRACE("control id 0x%x\n", *lpRun
);
401 GetWindowRect (hwndCtrl
, &rcCtrl
);
402 MapWindowPoints (NULL
, hwnd
, (LPPOINT
)&rcCtrl
, 2);
403 SubtractRect (lpRect
, lpRect
, &rcCtrl
);
410 /***********************************************************************
411 * DrawStatusTextW [COMCTL32.@]
413 * Draws text with borders, like in a status bar.
416 * hdc [I] handle to the window's display context
417 * lprc [I] pointer to a rectangle
418 * text [I] pointer to the text
419 * style [I] drawing style
425 * The style variable can have one of the following values:
426 * (will be written ...)
429 void WINAPI
DrawStatusTextW (HDC hdc
, LPRECT lprc
, LPCWSTR text
, UINT style
)
432 UINT border
= BDR_SUNKENOUTER
;
434 if (style
& SBT_POPOUT
)
435 border
= BDR_RAISEDOUTER
;
436 else if (style
& SBT_NOBORDERS
)
439 DrawEdge (hdc
, &r
, border
, BF_RECT
|BF_ADJUST
);
443 int oldbkmode
= SetBkMode (hdc
, TRANSPARENT
);
444 UINT align
= DT_LEFT
;
445 if (*text
== L
'\t') {
448 if (*text
== L
'\t') {
454 if (style
& SBT_RTLREADING
)
455 FIXME("Unsupported RTL style!\n");
456 DrawTextW (hdc
, text
, -1, &r
, align
|DT_VCENTER
|DT_SINGLELINE
|DT_NOPREFIX
);
457 SetBkMode(hdc
, oldbkmode
);
462 /***********************************************************************
463 * DrawStatusText [COMCTL32.@]
464 * DrawStatusTextA [COMCTL32.5]
466 * Draws text with borders, like in a status bar.
469 * hdc [I] handle to the window's display context
470 * lprc [I] pointer to a rectangle
471 * text [I] pointer to the text
472 * style [I] drawing style
478 void WINAPI
DrawStatusTextA (HDC hdc
, LPRECT lprc
, LPCSTR text
, UINT style
)
484 if ( (len
= MultiByteToWideChar( CP_ACP
, 0, text
, -1, NULL
, 0 )) ) {
485 if ( (textW
= Alloc( len
* sizeof(WCHAR
) )) )
486 MultiByteToWideChar( CP_ACP
, 0, text
, -1, textW
, len
);
489 DrawStatusTextW( hdc
, lprc
, textW
, style
);
494 /***********************************************************************
495 * CreateStatusWindow [COMCTL32.@]
496 * CreateStatusWindowA [COMCTL32.6]
498 * Creates a status bar
501 * style [I] window style
502 * text [I] pointer to the window text
503 * parent [I] handle to the parent window
504 * wid [I] control id of the status bar
507 * Success: handle to the status window
512 CreateStatusWindowA (LONG style
, LPCSTR text
, HWND parent
, UINT wid
)
514 return CreateWindowA(STATUSCLASSNAMEA
, text
, style
,
515 CW_USEDEFAULT
, CW_USEDEFAULT
,
516 CW_USEDEFAULT
, CW_USEDEFAULT
,
517 parent
, (HMENU
)(DWORD_PTR
)wid
, 0, 0);
521 /***********************************************************************
522 * CreateStatusWindowW [COMCTL32.@]
524 * Creates a status bar control
527 * style [I] window style
528 * text [I] pointer to the window text
529 * parent [I] handle to the parent window
530 * wid [I] control id of the status bar
533 * Success: handle to the status window
538 CreateStatusWindowW (LONG style
, LPCWSTR text
, HWND parent
, UINT wid
)
540 return CreateWindowW(STATUSCLASSNAMEW
, text
, style
,
541 CW_USEDEFAULT
, CW_USEDEFAULT
,
542 CW_USEDEFAULT
, CW_USEDEFAULT
,
543 parent
, (HMENU
)(DWORD_PTR
)wid
, 0, 0);
547 /***********************************************************************
548 * CreateUpDownControl [COMCTL32.16]
550 * Creates an up-down control
553 * style [I] window styles
554 * x [I] horizontal position of the control
555 * y [I] vertical position of the control
556 * cx [I] with of the control
557 * cy [I] height of the control
558 * parent [I] handle to the parent window
559 * id [I] the control's identifier
560 * inst [I] handle to the application's module instance
561 * buddy [I] handle to the buddy window, can be NULL
562 * maxVal [I] upper limit of the control
563 * minVal [I] lower limit of the control
564 * curVal [I] current value of the control
567 * Success: handle to the updown control
572 CreateUpDownControl (DWORD style
, INT x
, INT y
, INT cx
, INT cy
,
573 HWND parent
, INT id
, HINSTANCE inst
,
574 HWND buddy
, INT maxVal
, INT minVal
, INT curVal
)
577 CreateWindowW (UPDOWN_CLASSW
, 0, style
, x
, y
, cx
, cy
,
578 parent
, (HMENU
)(DWORD_PTR
)id
, inst
, 0);
580 SendMessageW (hUD
, UDM_SETBUDDY
, (WPARAM
)buddy
, 0);
581 SendMessageW (hUD
, UDM_SETRANGE
, 0, MAKELONG(maxVal
, minVal
));
582 SendMessageW (hUD
, UDM_SETPOS
, 0, MAKELONG(curVal
, 0));
589 /***********************************************************************
590 * InitCommonControls [COMCTL32.17]
592 * Registers the common controls.
601 * This function is just a dummy - all the controls are registered at
602 * the DLL's initialization. See InitCommonContolsEx for details.
606 InitCommonControls (void)
611 /***********************************************************************
612 * InitCommonControlsEx [COMCTL32.@]
614 * Registers the common controls.
617 * lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure.
624 * Probaly all versions of comctl32 initializes the Win95 controls in DllMain
625 * during DLL initializaiton. Starting from comctl32 v5.82 all the controls
626 * are initialized there. We follow this behaviour and this function is just
629 * Note: when writing programs under Windows, if you don't call any function
630 * from comctl32 the linker may not link this DLL. If InitCommonControlsEx
631 * was the only comctl32 function you were calling and you remove it you may
632 * have a false impression that InitCommonControlsEx actually did something.
636 InitCommonControlsEx (const INITCOMMONCONTROLSEX
*lpInitCtrls
)
638 if (!lpInitCtrls
|| lpInitCtrls
->dwSize
!= sizeof(INITCOMMONCONTROLSEX
))
641 TRACE("(0x%08x)\n", lpInitCtrls
->dwICC
);
646 /***********************************************************************
647 * CreateToolbarEx [COMCTL32.@]
649 * Creates a toolbar window.
667 * Success: handle to the tool bar control
672 CreateToolbarEx (HWND hwnd
, DWORD style
, UINT wID
, INT nBitmaps
,
673 HINSTANCE hBMInst
, UINT wBMID
, LPCTBBUTTON lpButtons
,
674 INT iNumButtons
, INT dxButton
, INT dyButton
,
675 INT dxBitmap
, INT dyBitmap
, UINT uStructSize
)
680 CreateWindowExW(0, TOOLBARCLASSNAMEW
, NULL
, style
|WS_CHILD
, 0,0,100,30,
681 hwnd
, (HMENU
)(DWORD_PTR
)wID
, COMCTL32_hModule
, NULL
);
685 SendMessageW (hwndTB
, TB_BUTTONSTRUCTSIZE
, (WPARAM
)uStructSize
, 0);
687 /* set bitmap and button size */
688 /*If CreateToolbarEx receives 0, windows sets default values*/
693 SendMessageW (hwndTB
, TB_SETBITMAPSIZE
, 0,
694 MAKELPARAM((WORD
)dxBitmap
, (WORD
)dyBitmap
));
700 SendMessageW (hwndTB
, TB_SETBUTTONSIZE
, 0,
701 MAKELPARAM((WORD
)dxButton
, (WORD
)dyButton
));
707 tbab
.hInst
= hBMInst
;
710 SendMessageW (hwndTB
, TB_ADDBITMAP
, (WPARAM
)nBitmaps
, (LPARAM
)&tbab
);
714 SendMessageW (hwndTB
, TB_ADDBUTTONSW
,
715 (WPARAM
)iNumButtons
, (LPARAM
)lpButtons
);
722 /***********************************************************************
723 * CreateMappedBitmap [COMCTL32.8]
725 * Loads a bitmap resource using a colour map.
728 * hInstance [I] Handle to the module containing the bitmap.
729 * idBitmap [I] The bitmap resource ID.
730 * wFlags [I] CMB_MASKED for using bitmap as a mask or 0 for normal.
731 * lpColorMap [I] Colour information needed for the bitmap or NULL (uses system colours).
732 * iNumMaps [I] Number of COLORMAP's pointed to by lpColorMap.
735 * Success: handle to the new bitmap
740 CreateMappedBitmap (HINSTANCE hInstance
, INT_PTR idBitmap
, UINT wFlags
,
741 LPCOLORMAP lpColorMap
, INT iNumMaps
)
745 LPBITMAPINFOHEADER lpBitmap
, lpBitmapInfo
;
746 UINT nSize
, nColorTableSize
, iColor
;
747 RGBQUAD
*pColorTable
;
748 INT i
, iMaps
, nWidth
, nHeight
;
751 LPCOLORMAP sysColorMap
;
753 COLORMAP internalColorMap
[4] =
754 {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}};
756 /* initialize pointer to colortable and default color table */
759 sysColorMap
= lpColorMap
;
762 internalColorMap
[0].to
= GetSysColor (COLOR_BTNTEXT
);
763 internalColorMap
[1].to
= GetSysColor (COLOR_BTNSHADOW
);
764 internalColorMap
[2].to
= GetSysColor (COLOR_BTNFACE
);
765 internalColorMap
[3].to
= GetSysColor (COLOR_BTNHIGHLIGHT
);
767 sysColorMap
= (LPCOLORMAP
)internalColorMap
;
770 hRsrc
= FindResourceW (hInstance
, (LPWSTR
)idBitmap
, (LPWSTR
)RT_BITMAP
);
773 hglb
= LoadResource (hInstance
, hRsrc
);
776 lpBitmap
= (LPBITMAPINFOHEADER
)LockResource (hglb
);
777 if (lpBitmap
== NULL
)
780 if (lpBitmap
->biSize
>= sizeof(BITMAPINFOHEADER
) && lpBitmap
->biClrUsed
)
781 nColorTableSize
= lpBitmap
->biClrUsed
;
782 else if (lpBitmap
->biBitCount
<= 8)
783 nColorTableSize
= (1 << lpBitmap
->biBitCount
);
786 nSize
= lpBitmap
->biSize
+ nColorTableSize
* sizeof(RGBQUAD
);
787 lpBitmapInfo
= (LPBITMAPINFOHEADER
)GlobalAlloc (GMEM_FIXED
, nSize
);
788 if (lpBitmapInfo
== NULL
)
790 RtlMoveMemory (lpBitmapInfo
, lpBitmap
, nSize
);
792 pColorTable
= (RGBQUAD
*)(((LPBYTE
)lpBitmapInfo
)+(UINT
)lpBitmapInfo
->biSize
);
794 for (iColor
= 0; iColor
< nColorTableSize
; iColor
++) {
795 for (i
= 0; i
< iMaps
; i
++) {
796 cRef
= RGB(pColorTable
[iColor
].rgbRed
,
797 pColorTable
[iColor
].rgbGreen
,
798 pColorTable
[iColor
].rgbBlue
);
799 if ( cRef
== sysColorMap
[i
].from
) {
801 if (wFlags
& CBS_MASKED
) {
802 if (sysColorMap
[i
].to
!= COLOR_BTNTEXT
)
803 pColorTable
[iColor
] = RGB(255, 255, 255);
807 pColorTable
[iColor
].rgbBlue
= GetBValue(sysColorMap
[i
].to
);
808 pColorTable
[iColor
].rgbGreen
= GetGValue(sysColorMap
[i
].to
);
809 pColorTable
[iColor
].rgbRed
= GetRValue(sysColorMap
[i
].to
);
814 nWidth
= (INT
)lpBitmapInfo
->biWidth
;
815 nHeight
= (INT
)lpBitmapInfo
->biHeight
;
816 hdcScreen
= GetDC (NULL
);
817 hbm
= CreateCompatibleBitmap (hdcScreen
, nWidth
, nHeight
);
819 HDC hdcDst
= CreateCompatibleDC (hdcScreen
);
820 HBITMAP hbmOld
= SelectObject (hdcDst
, hbm
);
821 LPBYTE lpBits
= (LPBYTE
)(lpBitmap
+ 1);
822 lpBits
+= nColorTableSize
* sizeof(RGBQUAD
);
823 StretchDIBits (hdcDst
, 0, 0, nWidth
, nHeight
, 0, 0, nWidth
, nHeight
,
824 lpBits
, (LPBITMAPINFO
)lpBitmapInfo
, DIB_RGB_COLORS
,
826 SelectObject (hdcDst
, hbmOld
);
829 ReleaseDC (NULL
, hdcScreen
);
830 GlobalFree ((HGLOBAL
)lpBitmapInfo
);
837 /***********************************************************************
838 * CreateToolbar [COMCTL32.7]
840 * Creates a toolbar control.
853 * Success: handle to the tool bar control
857 * Do not use this functions anymore. Use CreateToolbarEx instead.
861 CreateToolbar (HWND hwnd
, DWORD style
, UINT wID
, INT nBitmaps
,
862 HINSTANCE hBMInst
, UINT wBMID
,
863 LPCTBBUTTON lpButtons
,INT iNumButtons
)
865 return CreateToolbarEx (hwnd
, style
| CCS_NODIVIDER
, wID
, nBitmaps
,
866 hBMInst
, wBMID
, lpButtons
,
867 iNumButtons
, 0, 0, 0, 0, CCSIZEOF_STRUCT(TBBUTTON
, dwData
));
871 /***********************************************************************
872 * DllGetVersion [COMCTL32.@]
874 * Retrieves version information of the 'COMCTL32.DLL'
877 * pdvi [O] pointer to version information structure.
881 * Failure: E_INVALIDARG
884 * Returns version of a comctl32.dll from IE4.01 SP1.
887 HRESULT WINAPI
DllGetVersion (DLLVERSIONINFO
*pdvi
)
889 if (pdvi
->cbSize
!= sizeof(DLLVERSIONINFO
)) {
890 WARN("wrong DLLVERSIONINFO size from app\n");
894 pdvi
->dwMajorVersion
= COMCTL32_VERSION
;
895 pdvi
->dwMinorVersion
= COMCTL32_VERSION_MINOR
;
896 pdvi
->dwBuildNumber
= 2919;
897 pdvi
->dwPlatformID
= 6304;
899 TRACE("%u.%u.%u.%u\n",
900 pdvi
->dwMajorVersion
, pdvi
->dwMinorVersion
,
901 pdvi
->dwBuildNumber
, pdvi
->dwPlatformID
);
906 /***********************************************************************
907 * DllInstall (COMCTL32.@)
909 * Installs the ComCtl32 DLL.
913 * Failure: A HRESULT error
915 HRESULT WINAPI
DllInstall(BOOL bInstall
, LPCWSTR cmdline
)
917 FIXME("(%s, %s): stub\n", bInstall
?"TRUE":"FALSE",
918 debugstr_w(cmdline
));
923 /***********************************************************************
924 * _TrackMouseEvent [COMCTL32.@]
926 * Requests notification of mouse events
928 * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
929 * to the hwnd specified in the ptme structure. After the event message
930 * is posted to the hwnd, the entry in the queue is removed.
932 * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
933 * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
934 * immediately and the TME_LEAVE flag being ignored.
937 * ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
943 * IMPLEMENTATION moved to USER32.TrackMouseEvent
948 _TrackMouseEvent (TRACKMOUSEEVENT
*ptme
)
950 return TrackMouseEvent (ptme
);
953 /*************************************************************************
954 * GetMUILanguage [COMCTL32.@]
956 * Returns the user interface language in use by the current process.
959 * Language ID in use by the current process.
961 LANGID WINAPI
GetMUILanguage (VOID
)
963 return COMCTL32_uiLang
;
967 /*************************************************************************
968 * InitMUILanguage [COMCTL32.@]
970 * Sets the user interface language to be used by the current process.
975 VOID WINAPI
InitMUILanguage (LANGID uiLang
)
977 COMCTL32_uiLang
= uiLang
;
981 /***********************************************************************
982 * SetWindowSubclass [COMCTL32.410]
984 * Starts a window subclass
987 * hWnd [in] handle to window subclass.
988 * pfnSubclass [in] Pointer to new window procedure.
989 * uIDSubclass [in] Unique identifier of sublass together with pfnSubclass.
990 * dwRef [in] Reference data to pass to window procedure.
997 * If an application manually subclasses a window after subclassing it with
998 * this API and then with this API again, then none of the previous
999 * subclasses get called or the origional window procedure.
1002 BOOL WINAPI
SetWindowSubclass (HWND hWnd
, SUBCLASSPROC pfnSubclass
,
1003 UINT_PTR uIDSubclass
, DWORD_PTR dwRef
)
1005 LPSUBCLASS_INFO stack
;
1006 LPSUBCLASSPROCS proc
;
1008 TRACE ("(%p, %p, %x, %lx)\n", hWnd
, pfnSubclass
, uIDSubclass
, dwRef
);
1010 /* Since the window procedure that we set here has two additional arguments,
1011 * we can't simply set it as the new window procedure of the window. So we
1012 * set our own window procedure and then calculate the other two arguments
1015 /* See if we have been called for this window */
1016 stack
= (LPSUBCLASS_INFO
)GetPropW (hWnd
, COMCTL32_wSubclass
);
1018 /* allocate stack */
1019 stack
= Alloc (sizeof(SUBCLASS_INFO
));
1021 ERR ("Failed to allocate our Subclassing stack\n");
1024 SetPropW (hWnd
, COMCTL32_wSubclass
, (HANDLE
)stack
);
1026 /* set window procedure to our own and save the current one */
1027 if (IsWindowUnicode (hWnd
))
1028 stack
->origproc
= (WNDPROC
)SetWindowLongPtrW (hWnd
, GWLP_WNDPROC
,
1029 (DWORD_PTR
)COMCTL32_SubclassProc
);
1031 stack
->origproc
= (WNDPROC
)SetWindowLongPtrA (hWnd
, GWLP_WNDPROC
,
1032 (DWORD_PTR
)COMCTL32_SubclassProc
);
1035 /* Check to see if we have called this function with the same uIDSubClass
1036 * and pfnSubclass */
1037 proc
= stack
->SubclassProcs
;
1039 if ((proc
->id
== uIDSubclass
) &&
1040 (proc
->subproc
== pfnSubclass
)) {
1048 proc
= Alloc(sizeof(SUBCLASSPROCS
));
1050 ERR ("Failed to allocate subclass entry in stack\n");
1051 if (IsWindowUnicode (hWnd
))
1052 SetWindowLongPtrW (hWnd
, GWLP_WNDPROC
, (DWORD_PTR
)stack
->origproc
);
1054 SetWindowLongPtrA (hWnd
, GWLP_WNDPROC
, (DWORD_PTR
)stack
->origproc
);
1056 RemovePropW( hWnd
, COMCTL32_wSubclass
);
1060 proc
->subproc
= pfnSubclass
;
1062 proc
->id
= uIDSubclass
;
1063 proc
->next
= stack
->SubclassProcs
;
1064 stack
->SubclassProcs
= proc
;
1070 /***********************************************************************
1071 * GetWindowSubclass [COMCTL32.411]
1073 * Gets the Reference data from a subclass.
1076 * hWnd [in] Handle to window which were subclassing
1077 * pfnSubclass [in] Pointer to the subclass procedure
1078 * uID [in] Unique indentifier of the subclassing procedure
1079 * pdwRef [out] Pointer to the reference data
1086 BOOL WINAPI
GetWindowSubclass (HWND hWnd
, SUBCLASSPROC pfnSubclass
,
1087 UINT_PTR uID
, DWORD_PTR
*pdwRef
)
1089 LPSUBCLASS_INFO stack
;
1090 LPSUBCLASSPROCS proc
;
1092 TRACE ("(%p, %p, %x, %p)\n", hWnd
, pfnSubclass
, uID
, pdwRef
);
1094 /* See if we have been called for this window */
1095 stack
= (LPSUBCLASS_INFO
)GetPropW (hWnd
, COMCTL32_wSubclass
);
1099 proc
= stack
->SubclassProcs
;
1101 if ((proc
->id
== uID
) &&
1102 (proc
->subproc
== pfnSubclass
)) {
1103 *pdwRef
= proc
->ref
;
1113 /***********************************************************************
1114 * RemoveWindowSubclass [COMCTL32.412]
1116 * Removes a window subclass.
1119 * hWnd [in] Handle to the window were subclassing
1120 * pfnSubclass [in] Pointer to the subclass procedure
1121 * uID [in] Unique identifier of this subclass
1128 BOOL WINAPI
RemoveWindowSubclass(HWND hWnd
, SUBCLASSPROC pfnSubclass
, UINT_PTR uID
)
1130 LPSUBCLASS_INFO stack
;
1131 LPSUBCLASSPROCS prevproc
= NULL
;
1132 LPSUBCLASSPROCS proc
;
1135 TRACE ("(%p, %p, %x)\n", hWnd
, pfnSubclass
, uID
);
1137 /* Find the Subclass to remove */
1138 stack
= (LPSUBCLASS_INFO
)GetPropW (hWnd
, COMCTL32_wSubclass
);
1142 proc
= stack
->SubclassProcs
;
1144 if ((proc
->id
== uID
) &&
1145 (proc
->subproc
== pfnSubclass
)) {
1148 stack
->SubclassProcs
= proc
->next
;
1150 prevproc
->next
= proc
->next
;
1152 if (stack
->stackpos
== proc
)
1153 stack
->stackpos
= stack
->stackpos
->next
;
1163 if (!stack
->SubclassProcs
&& !stack
->running
) {
1164 TRACE("Last Subclass removed, cleaning up\n");
1165 /* clean up our heap and reset the origional window procedure */
1166 if (IsWindowUnicode (hWnd
))
1167 SetWindowLongPtrW (hWnd
, GWLP_WNDPROC
, (DWORD_PTR
)stack
->origproc
);
1169 SetWindowLongPtrA (hWnd
, GWLP_WNDPROC
, (DWORD_PTR
)stack
->origproc
);
1171 RemovePropW( hWnd
, COMCTL32_wSubclass
);
1177 /***********************************************************************
1178 * COMCTL32_SubclassProc (internal)
1180 * Window procedure for all subclassed windows.
1181 * Saves the current subclassing stack position to support nested messages
1183 LRESULT WINAPI
COMCTL32_SubclassProc (HWND hWnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
1185 LPSUBCLASS_INFO stack
;
1186 LPSUBCLASSPROCS proc
;
1189 TRACE ("(%p, 0x%08x, 0x%08x, 0x%08lx)\n", hWnd
, uMsg
, wParam
, lParam
);
1191 stack
= (LPSUBCLASS_INFO
)GetPropW (hWnd
, COMCTL32_wSubclass
);
1193 ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd
);
1197 /* Save our old stackpos to properly handle nested messages */
1198 proc
= stack
->stackpos
;
1199 stack
->stackpos
= stack
->SubclassProcs
;
1201 ret
= DefSubclassProc(hWnd
, uMsg
, wParam
, lParam
);
1203 stack
->stackpos
= proc
;
1205 if (!stack
->SubclassProcs
&& !stack
->running
) {
1206 TRACE("Last Subclass removed, cleaning up\n");
1207 /* clean up our heap and reset the origional window procedure */
1208 if (IsWindowUnicode (hWnd
))
1209 SetWindowLongPtrW (hWnd
, GWLP_WNDPROC
, (DWORD_PTR
)stack
->origproc
);
1211 SetWindowLongPtrA (hWnd
, GWLP_WNDPROC
, (DWORD_PTR
)stack
->origproc
);
1213 RemovePropW( hWnd
, COMCTL32_wSubclass
);
1218 /***********************************************************************
1219 * DefSubclassProc [COMCTL32.413]
1221 * Calls the next window procedure (ie. the one before this subclass)
1224 * hWnd [in] The window that we're subclassing
1226 * wParam [in] WPARAM
1227 * lParam [in] LPARAM
1234 LRESULT WINAPI
DefSubclassProc (HWND hWnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
1236 LPSUBCLASS_INFO stack
;
1239 TRACE ("(%p, 0x%08x, 0x%08x, 0x%08lx)\n", hWnd
, uMsg
, wParam
, lParam
);
1241 /* retrieve our little stack from the Properties */
1242 stack
= (LPSUBCLASS_INFO
)GetPropW (hWnd
, COMCTL32_wSubclass
);
1244 ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd
);
1248 /* If we are at the end of stack then we have to call the original
1249 * window procedure */
1250 if (!stack
->stackpos
) {
1251 if (IsWindowUnicode (hWnd
))
1252 ret
= CallWindowProcW (stack
->origproc
, hWnd
, uMsg
, wParam
, lParam
);
1254 ret
= CallWindowProcA (stack
->origproc
, hWnd
, uMsg
, wParam
, lParam
);
1256 LPSUBCLASSPROCS proc
= stack
->stackpos
;
1257 stack
->stackpos
= stack
->stackpos
->next
;
1258 /* call the Subclass procedure from the stack */
1259 ret
= proc
->subproc (hWnd
, uMsg
, wParam
, lParam
,
1260 proc
->id
, proc
->ref
);
1267 /***********************************************************************
1268 * COMCTL32_CreateToolTip [NOT AN API]
1270 * Creates a tooltip for the control specified in hwnd and does all
1271 * necessary setup and notifications.
1274 * hwndOwner [I] Handle to the window that will own the tool tip.
1277 * Success: Handle of tool tip window.
1282 COMCTL32_CreateToolTip(HWND hwndOwner
)
1286 hwndToolTip
= CreateWindowExW(0, TOOLTIPS_CLASSW
, NULL
, WS_POPUP
,
1287 CW_USEDEFAULT
, CW_USEDEFAULT
,
1288 CW_USEDEFAULT
, CW_USEDEFAULT
, hwndOwner
,
1291 /* Send NM_TOOLTIPSCREATED notification */
1294 NMTOOLTIPSCREATED nmttc
;
1295 /* true owner can be different if hwndOwner is a child window */
1296 HWND hwndTrueOwner
= GetWindow(hwndToolTip
, GW_OWNER
);
1297 nmttc
.hdr
.hwndFrom
= hwndTrueOwner
;
1298 nmttc
.hdr
.idFrom
= GetWindowLongPtrW(hwndTrueOwner
, GWLP_ID
);
1299 nmttc
.hdr
.code
= NM_TOOLTIPSCREATED
;
1300 nmttc
.hwndToolTips
= hwndToolTip
;
1302 SendMessageW(GetParent(hwndTrueOwner
), WM_NOTIFY
,
1303 (WPARAM
)GetWindowLongPtrW(hwndTrueOwner
, GWLP_ID
),
1311 /***********************************************************************
1312 * COMCTL32_RefreshSysColors [NOT AN API]
1314 * Invoked on any control recognizing a WM_SYSCOLORCHANGE message to
1315 * refresh the color values in the color structure
1325 COMCTL32_RefreshSysColors(void)
1327 comctl32_color
.clrBtnHighlight
= GetSysColor (COLOR_BTNHIGHLIGHT
);
1328 comctl32_color
.clrBtnShadow
= GetSysColor (COLOR_BTNSHADOW
);
1329 comctl32_color
.clrBtnText
= GetSysColor (COLOR_BTNTEXT
);
1330 comctl32_color
.clrBtnFace
= GetSysColor (COLOR_BTNFACE
);
1331 comctl32_color
.clrHighlight
= GetSysColor (COLOR_HIGHLIGHT
);
1332 comctl32_color
.clrHighlightText
= GetSysColor (COLOR_HIGHLIGHTTEXT
);
1333 comctl32_color
.clr3dHilight
= GetSysColor (COLOR_3DHILIGHT
);
1334 comctl32_color
.clr3dShadow
= GetSysColor (COLOR_3DSHADOW
);
1335 comctl32_color
.clr3dDkShadow
= GetSysColor (COLOR_3DDKSHADOW
);
1336 comctl32_color
.clr3dFace
= GetSysColor (COLOR_3DFACE
);
1337 comctl32_color
.clrWindow
= GetSysColor (COLOR_WINDOW
);
1338 comctl32_color
.clrWindowText
= GetSysColor (COLOR_WINDOWTEXT
);
1339 comctl32_color
.clrGrayText
= GetSysColor (COLOR_GRAYTEXT
);
1340 comctl32_color
.clrActiveCaption
= GetSysColor (COLOR_ACTIVECAPTION
);
1341 comctl32_color
.clrInfoBk
= GetSysColor (COLOR_INFOBK
);
1342 comctl32_color
.clrInfoText
= GetSysColor (COLOR_INFOTEXT
);
1345 /***********************************************************************
1346 * COMCTL32_DrawInsertMark [NOT AN API]
1348 * Draws an insertion mark (which looks similar to an 'I').
1351 * hDC [I] Device context to draw onto.
1352 * lpRect [I] Co-ordinates of insertion mark.
1353 * clrInsertMark [I] Colour of the insertion mark.
1354 * bHorizontal [I] True if insert mark should be drawn horizontally,
1355 * vertical otherwise.
1361 * Draws up to but not including the bottom co-ordinate when drawing
1362 * vertically or the right co-ordinate when horizontal.
1364 void COMCTL32_DrawInsertMark(HDC hDC
, const RECT
*lpRect
, COLORREF clrInsertMark
, BOOL bHorizontal
)
1366 HPEN hPen
= CreatePen(PS_SOLID
, 1, clrInsertMark
);
1368 static const DWORD adwPolyPoints
[] = {4,4,4};
1369 LONG lCentre
= (bHorizontal
?
1370 lpRect
->top
+ (lpRect
->bottom
- lpRect
->top
)/2 :
1371 lpRect
->left
+ (lpRect
->right
- lpRect
->left
)/2);
1372 LONG l1
= (bHorizontal
? lpRect
->left
: lpRect
->top
);
1373 LONG l2
= (bHorizontal
? lpRect
->right
: lpRect
->bottom
);
1374 const POINT aptInsertMark
[] =
1376 /* top (V) or left (H) arrow */
1380 {lCentre
+ 1, l1
+ 2},
1384 {lCentre
+ 1, l1
- 1},
1385 {lCentre
+ 1, l2
- 2},
1386 /* bottom (V) or right (H) arrow */
1388 {lCentre
- 2, l2
- 1},
1389 {lCentre
+ 3, l2
- 1},
1390 {lCentre
+ 1, l2
- 3},
1392 hOldPen
= SelectObject(hDC
, hPen
);
1393 PolyPolyline(hDC
, aptInsertMark
, adwPolyPoints
, sizeof(adwPolyPoints
)/sizeof(adwPolyPoints
[0]));
1394 SelectObject(hDC
, hOldPen
);
1398 /***********************************************************************
1399 * COMCTL32_EnsureBitmapSize [internal]
1401 * If needed enlarge the bitmap so that the width is at least cxMinWidth
1402 * the height is at least cyMinHeight. If the bitmap already have these
1403 * dimensions nothing changes.
1406 * hBitmap [I/O] Bitmap to modify. The handle may change
1407 * cxMinWidth [I] If the width of the bitmap is smaller then it will
1408 * be enlarged to this value
1409 * cyMinHeight [I] If the height of the bitmap is smaller then it will
1410 * be enlarged to this value
1411 * cyBackground [I] The color with which the new area will be filled
1416 void COMCTL32_EnsureBitmapSize(HBITMAP
*pBitmap
, int cxMinWidth
, int cyMinHeight
, COLORREF crBackground
)
1421 HBITMAP hNewDCBitmap
, hOldDCBitmap
;
1425 if (!GetObjectW(*pBitmap
, sizeof(BITMAP
), &bmp
))
1427 cxNew
= (cxMinWidth
> bmp
.bmWidth
? cxMinWidth
: bmp
.bmWidth
);
1428 cyNew
= (cyMinHeight
> bmp
.bmHeight
? cyMinHeight
: bmp
.bmHeight
);
1429 if (cxNew
== bmp
.bmWidth
&& cyNew
== bmp
.bmHeight
)
1432 hdcNew
= CreateCompatibleDC(NULL
);
1433 hNewBitmap
= CreateBitmap(cxNew
, cyNew
, bmp
.bmPlanes
, bmp
.bmBitsPixel
, NULL
);
1434 hNewDCBitmap
= SelectObject(hdcNew
, hNewBitmap
);
1435 hNewDCBrush
= SelectObject(hdcNew
, CreateSolidBrush(crBackground
));
1437 hdcOld
= CreateCompatibleDC(NULL
);
1438 hOldDCBitmap
= SelectObject(hdcOld
, *pBitmap
);
1440 BitBlt(hdcNew
, 0, 0, bmp
.bmWidth
, bmp
.bmHeight
, hdcOld
, 0, 0, SRCCOPY
);
1441 if (bmp
.bmWidth
< cxMinWidth
)
1442 PatBlt(hdcNew
, bmp
.bmWidth
, 0, cxNew
, bmp
.bmHeight
, PATCOPY
);
1443 if (bmp
.bmHeight
< cyMinHeight
)
1444 PatBlt(hdcNew
, 0, bmp
.bmHeight
, bmp
.bmWidth
, cyNew
, PATCOPY
);
1445 if (bmp
.bmWidth
< cxMinWidth
&& bmp
.bmHeight
< cyMinHeight
)
1446 PatBlt(hdcNew
, bmp
.bmWidth
, bmp
.bmHeight
, cxNew
, cyNew
, PATCOPY
);
1448 SelectObject(hdcNew
, hNewDCBitmap
);
1449 DeleteObject(SelectObject(hdcNew
, hNewDCBrush
));
1451 SelectObject(hdcOld
, hOldDCBitmap
);
1454 DeleteObject(*pBitmap
);
1455 *pBitmap
= hNewBitmap
;
1459 /***********************************************************************
1460 * MirrorIcon [COMCTL32.414]
1462 * Mirrors an icon so that it will appear correctly on a mirrored DC.
1465 * phicon1 [I/O] Icon.
1466 * phicon2 [I/O] Icon.
1472 BOOL WINAPI
MirrorIcon(HICON
*phicon1
, HICON
*phicon2
)
1474 FIXME("(%p, %p): stub\n", phicon1
, phicon2
);
1478 static inline int IsDelimiter(WCHAR c
)
1491 static int CALLBACK
PathWordBreakProc(LPWSTR lpch
, int ichCurrent
, int cch
, int code
)
1493 if (code
== WB_ISDELIMITER
)
1494 return IsDelimiter(lpch
[ichCurrent
]);
1497 int dir
= (code
== WB_LEFT
) ? -1 : 1;
1498 for(; 0 <= ichCurrent
&& ichCurrent
< cch
; ichCurrent
+= dir
)
1499 if (IsDelimiter(lpch
[ichCurrent
])) return ichCurrent
;
1504 /***********************************************************************
1505 * SetPathWordBreakProc [COMCTL32.384]
1507 * Sets the word break procedure for an edit control to one that understands
1508 * paths so that the user can jump over directories.
1511 * hwnd [I] Handle to edit control.
1512 * bSet [I] If this is TRUE then the word break proc is set, otherwise it is removed.
1515 * Result from EM_SETWORDBREAKPROC message.
1517 LRESULT WINAPI
SetPathWordBreakProc(HWND hwnd
, BOOL bSet
)
1519 return SendMessageW(hwnd
, EM_SETWORDBREAKPROC
, 0,
1520 (LPARAM
)(bSet
? PathWordBreakProc
: NULL
));