| /* |
| * Common controls functions |
| * |
| * Copyright 1997 Dimitrie O. Paun |
| * Copyright 1998,2000 Eric Kohl |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include <string.h> |
| #include <stdlib.h> |
| |
| #include "winbase.h" |
| #include "commctrl.h" |
| #include "winerror.h" |
| #include "winreg.h" |
| #define NO_SHLWAPI_STREAM |
| #include "shlwapi.h" |
| #include "comctl32.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(commctrl); |
| |
| extern void ANIMATE_Register(void); |
| extern void ANIMATE_Unregister(void); |
| extern void COMBOEX_Register(void); |
| extern void COMBOEX_Unregister(void); |
| extern void DATETIME_Register(void); |
| extern void DATETIME_Unregister(void); |
| extern void FLATSB_Register(void); |
| extern void FLATSB_Unregister(void); |
| extern void HEADER_Register(void); |
| extern void HEADER_Unregister(void); |
| extern void HOTKEY_Register(void); |
| extern void HOTKEY_Unregister(void); |
| extern void IPADDRESS_Register(void); |
| extern void IPADDRESS_Unregister(void); |
| extern void LISTVIEW_Register(void); |
| extern void LISTVIEW_Unregister(void); |
| extern void MONTHCAL_Register(void); |
| extern void MONTHCAL_Unregister(void); |
| extern void NATIVEFONT_Register(void); |
| extern void NATIVEFONT_Unregister(void); |
| extern void PAGER_Register(void); |
| extern void PAGER_Unregister(void); |
| extern void PROGRESS_Register(void); |
| extern void PROGRESS_Unregister(void); |
| extern void REBAR_Register(void); |
| extern void REBAR_Unregister(void); |
| extern void STATUS_Register(void); |
| extern void STATUS_Unregister(void); |
| extern void TAB_Register(void); |
| extern void TAB_Unregister(void); |
| extern void TOOLBAR_Register(void); |
| extern void TOOLBAR_Unregister(void); |
| extern void TOOLTIPS_Register(void); |
| extern void TOOLTIPS_Unregister(void); |
| extern void TRACKBAR_Register(void); |
| extern void TRACKBAR_Unregister(void); |
| extern void TREEVIEW_Register(void); |
| extern void TREEVIEW_Unregister(void); |
| extern void UPDOWN_Register(void); |
| extern void UPDOWN_Unregister(void); |
| |
| |
| HANDLE COMCTL32_hHeap = (HANDLE)NULL; |
| LPSTR COMCTL32_aSubclass = (LPSTR)NULL; |
| HMODULE COMCTL32_hModule = 0; |
| LANGID COMCTL32_uiLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL); |
| HBRUSH COMCTL32_hPattern55AABrush = (HANDLE)NULL; |
| COMCTL32_SysColor comctl32_color; |
| |
| static HBITMAP COMCTL32_hPattern55AABitmap = (HANDLE)NULL; |
| |
| static const WORD wPattern55AA[] = |
| { |
| 0x5555, 0xaaaa, 0x5555, 0xaaaa, |
| 0x5555, 0xaaaa, 0x5555, 0xaaaa |
| }; |
| |
| |
| /*********************************************************************** |
| * COMCTL32_LibMain [Internal] Initializes the internal 'COMCTL32.DLL'. |
| * |
| * PARAMS |
| * hinstDLL [I] handle to the 'dlls' instance |
| * fdwReason [I] |
| * lpvReserved [I] reserverd, must be NULL |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| */ |
| |
| BOOL WINAPI |
| COMCTL32_LibMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) |
| { |
| TRACE("%x,%lx,%p\n", hinstDLL, fdwReason, lpvReserved); |
| |
| switch (fdwReason) { |
| case DLL_PROCESS_ATTACH: |
| COMCTL32_hModule = (HMODULE)hinstDLL; |
| |
| /* create private heap */ |
| COMCTL32_hHeap = HeapCreate (0, 0x10000, 0); |
| TRACE("Heap created: 0x%x\n", COMCTL32_hHeap); |
| |
| /* add global subclassing atom (used by 'tooltip' and 'updown') */ |
| COMCTL32_aSubclass = (LPSTR)(DWORD)GlobalAddAtomA ("CC32SubclassInfo"); |
| TRACE("Subclassing atom added: %p\n", COMCTL32_aSubclass); |
| |
| /* create local pattern brush */ |
| COMCTL32_hPattern55AABitmap = CreateBitmap (8, 8, 1, 1, wPattern55AA); |
| COMCTL32_hPattern55AABrush = CreatePatternBrush (COMCTL32_hPattern55AABitmap); |
| |
| /* Get all the colors at DLL load */ |
| COMCTL32_RefreshSysColors(); |
| |
| /* register all Win95 common control classes */ |
| ANIMATE_Register (); |
| FLATSB_Register (); |
| HEADER_Register (); |
| HOTKEY_Register (); |
| LISTVIEW_Register (); |
| PROGRESS_Register (); |
| STATUS_Register (); |
| TAB_Register (); |
| TOOLBAR_Register (); |
| TOOLTIPS_Register (); |
| TRACKBAR_Register (); |
| TREEVIEW_Register (); |
| UPDOWN_Register (); |
| break; |
| |
| case DLL_PROCESS_DETACH: |
| /* unregister all common control classes */ |
| ANIMATE_Unregister (); |
| COMBOEX_Unregister (); |
| DATETIME_Unregister (); |
| FLATSB_Unregister (); |
| HEADER_Unregister (); |
| HOTKEY_Unregister (); |
| IPADDRESS_Unregister (); |
| LISTVIEW_Unregister (); |
| MONTHCAL_Unregister (); |
| NATIVEFONT_Unregister (); |
| PAGER_Unregister (); |
| PROGRESS_Unregister (); |
| REBAR_Unregister (); |
| STATUS_Unregister (); |
| TAB_Unregister (); |
| TOOLBAR_Unregister (); |
| TOOLTIPS_Unregister (); |
| TRACKBAR_Unregister (); |
| TREEVIEW_Unregister (); |
| UPDOWN_Unregister (); |
| |
| /* delete local pattern brush */ |
| DeleteObject (COMCTL32_hPattern55AABrush); |
| COMCTL32_hPattern55AABrush = (HANDLE)NULL; |
| DeleteObject (COMCTL32_hPattern55AABitmap); |
| COMCTL32_hPattern55AABitmap = (HANDLE)NULL; |
| |
| /* delete global subclassing atom */ |
| GlobalDeleteAtom (LOWORD(COMCTL32_aSubclass)); |
| TRACE("Subclassing atom deleted: %p\n", COMCTL32_aSubclass); |
| COMCTL32_aSubclass = (LPSTR)NULL; |
| |
| /* destroy private heap */ |
| HeapDestroy (COMCTL32_hHeap); |
| TRACE("Heap destroyed: 0x%x\n", COMCTL32_hHeap); |
| COMCTL32_hHeap = (HANDLE)NULL; |
| break; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * MenuHelp [COMCTL32.2] |
| * |
| * PARAMS |
| * uMsg [I] message (WM_MENUSELECT) (see NOTES) |
| * wParam [I] wParam of the message uMsg |
| * lParam [I] lParam of the message uMsg |
| * hMainMenu [I] handle to the application's main menu |
| * hInst [I] handle to the module that contains string resources |
| * hwndStatus [I] handle to the status bar window |
| * lpwIDs [I] pointer to an array of integers (see NOTES) |
| * |
| * RETURNS |
| * No return value |
| * |
| * NOTES |
| * The official documentation is incomplete! |
| * This is the correct documentation: |
| * |
| * uMsg: |
| * MenuHelp() does NOT handle WM_COMMAND messages! It only handles |
| * WM_MENUSELECT messages. |
| * |
| * lpwIDs: |
| * (will be written ...) |
| */ |
| |
| VOID WINAPI |
| MenuHelp (UINT uMsg, WPARAM wParam, LPARAM lParam, HMENU hMainMenu, |
| HINSTANCE hInst, HWND hwndStatus, LPUINT lpwIDs) |
| { |
| UINT uMenuID = 0; |
| |
| if (!IsWindow (hwndStatus)) |
| return; |
| |
| switch (uMsg) { |
| case WM_MENUSELECT: |
| TRACE("WM_MENUSELECT wParam=0x%X lParam=0x%lX\n", |
| wParam, lParam); |
| |
| if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) { |
| /* menu was closed */ |
| TRACE("menu was closed!\n"); |
| SendMessageA (hwndStatus, SB_SIMPLE, FALSE, 0); |
| } |
| else { |
| /* menu item was selected */ |
| if (HIWORD(wParam) & MF_POPUP) |
| uMenuID = (UINT)*(lpwIDs+1); |
| else |
| uMenuID = (UINT)LOWORD(wParam); |
| TRACE("uMenuID = %u\n", uMenuID); |
| |
| if (uMenuID) { |
| CHAR szText[256]; |
| |
| if (!LoadStringA (hInst, uMenuID, szText, 256)) |
| szText[0] = '\0'; |
| |
| SendMessageA (hwndStatus, SB_SETTEXTA, |
| 255 | SBT_NOBORDERS, (LPARAM)szText); |
| SendMessageA (hwndStatus, SB_SIMPLE, TRUE, 0); |
| } |
| } |
| break; |
| |
| case WM_COMMAND : |
| TRACE("WM_COMMAND wParam=0x%X lParam=0x%lX\n", |
| wParam, lParam); |
| /* WM_COMMAND is not invalid since it is documented |
| * in the windows api reference. So don't output |
| * any FIXME for WM_COMMAND |
| */ |
| WARN("We don't care about the WM_COMMAND\n"); |
| break; |
| |
| default: |
| FIXME("Invalid Message 0x%x!\n", uMsg); |
| break; |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * ShowHideMenuCtl [COMCTL32.3] |
| * |
| * Shows or hides controls and updates the corresponding menu item. |
| * |
| * PARAMS |
| * hwnd [I] handle to the client window. |
| * uFlags [I] menu command id. |
| * lpInfo [I] pointer to an array of integers. (See NOTES.) |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| * |
| * NOTES |
| * The official documentation is incomplete! |
| * This is the correct documentation: |
| * |
| * hwnd |
| * Handle to the window that contains the menu and controls. |
| * |
| * uFlags |
| * Identifier of the menu item to receive or loose a check mark. |
| * |
| * lpInfo |
| * The array of integers contains pairs of values. BOTH values of |
| * the first pair must be the handles to the application's main menu. |
| * Each subsequent pair consists of a menu id and control id. |
| */ |
| |
| BOOL WINAPI |
| ShowHideMenuCtl (HWND hwnd, UINT uFlags, LPINT lpInfo) |
| { |
| LPINT lpMenuId; |
| |
| TRACE("%x, %x, %p\n", hwnd, uFlags, lpInfo); |
| |
| if (lpInfo == NULL) |
| return FALSE; |
| |
| if (!(lpInfo[0]) || !(lpInfo[1])) |
| return FALSE; |
| |
| /* search for control */ |
| lpMenuId = &lpInfo[2]; |
| while (*lpMenuId != uFlags) |
| lpMenuId += 2; |
| |
| if (GetMenuState (lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) { |
| /* uncheck menu item */ |
| CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED); |
| |
| /* hide control */ |
| lpMenuId++; |
| SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0, |
| SWP_HIDEWINDOW); |
| } |
| else { |
| /* check menu item */ |
| CheckMenuItem (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED); |
| |
| /* show control */ |
| lpMenuId++; |
| SetWindowPos (GetDlgItem (hwnd, *lpMenuId), 0, 0, 0, 0, 0, |
| SWP_SHOWWINDOW); |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * GetEffectiveClientRect [COMCTL32.4] |
| * |
| * PARAMS |
| * hwnd [I] handle to the client window. |
| * lpRect [O] pointer to the rectangle of the client window |
| * lpInfo [I] pointer to an array of integers (see NOTES) |
| * |
| * RETURNS |
| * No return value. |
| * |
| * NOTES |
| * The official documentation is incomplete! |
| * This is the correct documentation: |
| * |
| * lpInfo |
| * (will be written...) |
| */ |
| |
| VOID WINAPI |
| GetEffectiveClientRect (HWND hwnd, LPRECT lpRect, LPINT lpInfo) |
| { |
| RECT rcCtrl; |
| INT *lpRun; |
| HWND hwndCtrl; |
| |
| TRACE("(0x%08lx 0x%08lx 0x%08lx)\n", |
| (DWORD)hwnd, (DWORD)lpRect, (DWORD)lpInfo); |
| |
| GetClientRect (hwnd, lpRect); |
| lpRun = lpInfo; |
| |
| do { |
| lpRun += 2; |
| if (*lpRun == 0) |
| return; |
| lpRun++; |
| hwndCtrl = GetDlgItem (hwnd, *lpRun); |
| if (GetWindowLongA (hwndCtrl, GWL_STYLE) & WS_VISIBLE) { |
| TRACE("control id 0x%x\n", *lpRun); |
| GetWindowRect (hwndCtrl, &rcCtrl); |
| MapWindowPoints ((HWND)0, hwnd, (LPPOINT)&rcCtrl, 2); |
| SubtractRect (lpRect, lpRect, &rcCtrl); |
| } |
| lpRun++; |
| } while (*lpRun); |
| } |
| |
| |
| /*********************************************************************** |
| * DrawStatusTextW [COMCTL32.28] |
| * |
| * Draws text with borders, like in a status bar. |
| * |
| * PARAMS |
| * hdc [I] handle to the window's display context |
| * lprc [I] pointer to a rectangle |
| * text [I] pointer to the text |
| * style [I] drawing style |
| * |
| * RETURNS |
| * No return value. |
| * |
| * NOTES |
| * The style variable can have one of the following values: |
| * (will be written ...) |
| */ |
| |
| void WINAPI DrawStatusTextW (HDC hdc, LPRECT lprc, LPCWSTR text, UINT style) |
| { |
| RECT r = *lprc; |
| UINT border = BDR_SUNKENOUTER; |
| |
| if (style & SBT_POPOUT) |
| border = BDR_RAISEDOUTER; |
| else if (style & SBT_NOBORDERS) |
| border = 0; |
| |
| DrawEdge (hdc, &r, border, BF_RECT|BF_ADJUST); |
| |
| /* now draw text */ |
| if (text) { |
| int oldbkmode = SetBkMode (hdc, TRANSPARENT); |
| UINT align = DT_LEFT; |
| if (*text == L'\t') { |
| text++; |
| align = DT_CENTER; |
| if (*text == L'\t') { |
| text++; |
| align = DT_RIGHT; |
| } |
| } |
| r.left += 3; |
| if (style & SBT_RTLREADING) |
| FIXME("Unsupported RTL style!\n"); |
| DrawTextW (hdc, text, -1, &r, align|DT_VCENTER|DT_SINGLELINE); |
| SetBkMode(hdc, oldbkmode); |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * DrawStatusText [COMCTL32.27] |
| * DrawStatusTextA [COMCTL32.5] |
| * |
| * Draws text with borders, like in a status bar. |
| * |
| * PARAMS |
| * hdc [I] handle to the window's display context |
| * lprc [I] pointer to a rectangle |
| * text [I] pointer to the text |
| * style [I] drawing style |
| * |
| * RETURNS |
| * No return value. |
| */ |
| |
| void WINAPI DrawStatusTextA (HDC hdc, LPRECT lprc, LPCSTR text, UINT style) |
| { |
| INT len; |
| LPWSTR textW = NULL; |
| |
| if ( text ) { |
| if ( (len = MultiByteToWideChar( CP_ACP, 0, text, -1, NULL, 0 )) ) { |
| if ( (textW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )) ) |
| MultiByteToWideChar( CP_ACP, 0, text, -1, textW, len ); |
| } |
| } |
| DrawStatusTextW( hdc, lprc, textW, style ); |
| HeapFree( GetProcessHeap(), 0, textW ); |
| } |
| |
| |
| /*********************************************************************** |
| * CreateStatusWindow [COMCTL32.21] |
| * CreateStatusWindowA [COMCTL32.6] |
| * |
| * Creates a status bar |
| * |
| * PARAMS |
| * style [I] window style |
| * text [I] pointer to the window text |
| * parent [I] handle to the parent window |
| * wid [I] control id of the status bar |
| * |
| * RETURNS |
| * Success: handle to the status window |
| * Failure: 0 |
| */ |
| |
| HWND WINAPI |
| CreateStatusWindowA (INT style, LPCSTR text, HWND parent, UINT wid) |
| { |
| return CreateWindowA(STATUSCLASSNAMEA, text, style, |
| CW_USEDEFAULT, CW_USEDEFAULT, |
| CW_USEDEFAULT, CW_USEDEFAULT, |
| parent, wid, 0, 0); |
| } |
| |
| |
| /*********************************************************************** |
| * CreateStatusWindowW [COMCTL32.22] Creates a status bar control |
| * |
| * PARAMS |
| * style [I] window style |
| * text [I] pointer to the window text |
| * parent [I] handle to the parent window |
| * wid [I] control id of the status bar |
| * |
| * RETURNS |
| * Success: handle to the status window |
| * Failure: 0 |
| */ |
| |
| HWND WINAPI |
| CreateStatusWindowW (INT style, LPCWSTR text, HWND parent, UINT wid) |
| { |
| return CreateWindowW(STATUSCLASSNAMEW, text, style, |
| CW_USEDEFAULT, CW_USEDEFAULT, |
| CW_USEDEFAULT, CW_USEDEFAULT, |
| parent, wid, 0, 0); |
| } |
| |
| |
| /*********************************************************************** |
| * CreateUpDownControl [COMCTL32.16] Creates an up-down control |
| * |
| * PARAMS |
| * style [I] window styles |
| * x [I] horizontal position of the control |
| * y [I] vertical position of the control |
| * cx [I] with of the control |
| * cy [I] height of the control |
| * parent [I] handle to the parent window |
| * id [I] the control's identifier |
| * inst [I] handle to the application's module instance |
| * buddy [I] handle to the buddy window, can be NULL |
| * maxVal [I] upper limit of the control |
| * minVal [I] lower limit of the control |
| * curVal [I] current value of the control |
| * |
| * RETURNS |
| * Success: handle to the updown control |
| * Failure: 0 |
| */ |
| |
| HWND WINAPI |
| CreateUpDownControl (DWORD style, INT x, INT y, INT cx, INT cy, |
| HWND parent, INT id, HINSTANCE inst, |
| HWND buddy, INT maxVal, INT minVal, INT curVal) |
| { |
| HWND hUD = |
| CreateWindowA (UPDOWN_CLASSA, 0, style, x, y, cx, cy, |
| parent, id, inst, 0); |
| if (hUD) { |
| SendMessageA (hUD, UDM_SETBUDDY, buddy, 0); |
| SendMessageA (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal)); |
| SendMessageA (hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0)); |
| } |
| |
| return hUD; |
| } |
| |
| |
| /*********************************************************************** |
| * InitCommonControls [COMCTL32.17] |
| * |
| * Registers the common controls. |
| * |
| * PARAMS |
| * No parameters. |
| * |
| * RETURNS |
| * No return values. |
| * |
| * NOTES |
| * This function is just a dummy. |
| * The Win95 controls are registered at the DLL's initialization. |
| * To register other controls InitCommonControlsEx() must be used. |
| */ |
| |
| VOID WINAPI |
| InitCommonControls (void) |
| { |
| } |
| |
| |
| /*********************************************************************** |
| * InitCommonControlsEx [COMCTL32.84] |
| * |
| * Registers the common controls. |
| * |
| * PARAMS |
| * lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure. |
| * |
| * RETURNS |
| * Success: TRUE |
| * Failure: FALSE |
| * |
| * NOTES |
| * Only the additional common controls are registered by this function. |
| * The Win95 controls are registered at the DLL's initialization. |
| */ |
| |
| BOOL WINAPI |
| InitCommonControlsEx (LPINITCOMMONCONTROLSEX lpInitCtrls) |
| { |
| INT cCount; |
| DWORD dwMask; |
| |
| if (!lpInitCtrls) |
| return FALSE; |
| if (lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX)) |
| return FALSE; |
| |
| TRACE("(0x%08lx)\n", lpInitCtrls->dwICC); |
| |
| for (cCount = 0; cCount < 32; cCount++) { |
| dwMask = 1 << cCount; |
| if (!(lpInitCtrls->dwICC & dwMask)) |
| continue; |
| |
| switch (lpInitCtrls->dwICC & dwMask) { |
| /* dummy initialization */ |
| case ICC_ANIMATE_CLASS: |
| case ICC_BAR_CLASSES: |
| case ICC_LISTVIEW_CLASSES: |
| case ICC_TREEVIEW_CLASSES: |
| case ICC_TAB_CLASSES: |
| case ICC_UPDOWN_CLASS: |
| case ICC_PROGRESS_CLASS: |
| case ICC_HOTKEY_CLASS: |
| break; |
| |
| /* advanced classes - not included in Win95 */ |
| case ICC_DATE_CLASSES: |
| MONTHCAL_Register (); |
| DATETIME_Register (); |
| break; |
| |
| case ICC_USEREX_CLASSES: |
| COMBOEX_Register (); |
| break; |
| |
| case ICC_COOL_CLASSES: |
| REBAR_Register (); |
| break; |
| |
| case ICC_INTERNET_CLASSES: |
| IPADDRESS_Register (); |
| break; |
| |
| case ICC_PAGESCROLLER_CLASS: |
| PAGER_Register (); |
| break; |
| |
| case ICC_NATIVEFNTCTL_CLASS: |
| NATIVEFONT_Register (); |
| break; |
| |
| default: |
| FIXME("Unknown class! dwICC=0x%lX\n", dwMask); |
| break; |
| } |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * CreateToolbarEx [COMCTL32.23] Creates a tool bar window |
| * |
| * PARAMS |
| * hwnd |
| * style |
| * wID |
| * nBitmaps |
| * hBMInst |
| * wBMID |
| * lpButtons |
| * iNumButtons |
| * dxButton |
| * dyButton |
| * dxBitmap |
| * dyBitmap |
| * uStructSize |
| * |
| * RETURNS |
| * Success: handle to the tool bar control |
| * Failure: 0 |
| */ |
| |
| HWND WINAPI |
| CreateToolbarEx (HWND hwnd, DWORD style, UINT wID, INT nBitmaps, |
| HINSTANCE hBMInst, UINT wBMID, LPCTBBUTTON lpButtons, |
| INT iNumButtons, INT dxButton, INT dyButton, |
| INT dxBitmap, INT dyBitmap, UINT uStructSize) |
| { |
| HWND hwndTB; |
| |
| /* If not position is specified then put it at the top */ |
| if ((style & CCS_BOTTOM) == 0) { |
| style|=CCS_TOP; |
| } |
| |
| hwndTB = |
| CreateWindowExA (0, TOOLBARCLASSNAMEA, "", style|WS_CHILD, 0, 0, 0, 0, |
| hwnd, (HMENU)wID, 0, NULL); |
| if(hwndTB) { |
| TBADDBITMAP tbab; |
| |
| SendMessageA (hwndTB, TB_BUTTONSTRUCTSIZE, |
| (WPARAM)uStructSize, 0); |
| |
| /* set bitmap and button size */ |
| /*If CreateToolbarEx receives 0, windows sets default values*/ |
| if (dxBitmap <= 0) |
| dxBitmap = 16; |
| if (dyBitmap <= 0) |
| dyBitmap = 15; |
| SendMessageA (hwndTB, TB_SETBITMAPSIZE, 0, |
| MAKELPARAM((WORD)dxBitmap, (WORD)dyBitmap)); |
| |
| if (dxButton <= 0) |
| dxButton = 24; |
| if (dyButton <= 0) |
| dyButton = 22; |
| SendMessageA (hwndTB, TB_SETBUTTONSIZE, 0, |
| MAKELPARAM((WORD)dxButton, (WORD)dyButton)); |
| |
| |
| /* add bitmaps */ |
| if (nBitmaps > 0) |
| { |
| tbab.hInst = hBMInst; |
| tbab.nID = wBMID; |
| |
| SendMessageA (hwndTB, TB_ADDBITMAP, |
| (WPARAM)nBitmaps, (LPARAM)&tbab); |
| } |
| /* add buttons */ |
| if(iNumButtons > 0) |
| SendMessageA (hwndTB, TB_ADDBUTTONSA, |
| (WPARAM)iNumButtons, (LPARAM)lpButtons); |
| } |
| |
| return hwndTB; |
| } |
| |
| |
| /*********************************************************************** |
| * CreateMappedBitmap [COMCTL32.8] |
| * |
| * PARAMS |
| * hInstance [I] |
| * idBitmap [I] |
| * wFlags [I] |
| * lpColorMap [I] |
| * iNumMaps [I] |
| * |
| * RETURNS |
| * Success: handle to the new bitmap |
| * Failure: 0 |
| */ |
| |
| HBITMAP WINAPI |
| CreateMappedBitmap (HINSTANCE hInstance, INT idBitmap, UINT wFlags, |
| LPCOLORMAP lpColorMap, INT iNumMaps) |
| { |
| HGLOBAL hglb; |
| HRSRC hRsrc; |
| LPBITMAPINFOHEADER lpBitmap, lpBitmapInfo; |
| UINT nSize, nColorTableSize; |
| RGBQUAD *pColorTable; |
| INT iColor, i, iMaps, nWidth, nHeight; |
| HDC hdcScreen; |
| HBITMAP hbm; |
| LPCOLORMAP sysColorMap; |
| COLORREF cRef; |
| COLORMAP internalColorMap[4] = |
| {{0x000000, 0}, {0x808080, 0}, {0xC0C0C0, 0}, {0xFFFFFF, 0}}; |
| |
| /* initialize pointer to colortable and default color table */ |
| if (lpColorMap) { |
| iMaps = iNumMaps; |
| sysColorMap = lpColorMap; |
| } |
| else { |
| internalColorMap[0].to = GetSysColor (COLOR_BTNTEXT); |
| internalColorMap[1].to = GetSysColor (COLOR_BTNSHADOW); |
| internalColorMap[2].to = GetSysColor (COLOR_BTNFACE); |
| internalColorMap[3].to = GetSysColor (COLOR_BTNHIGHLIGHT); |
| iMaps = 4; |
| sysColorMap = (LPCOLORMAP)internalColorMap; |
| } |
| |
| hRsrc = FindResourceA (hInstance, (LPSTR)idBitmap, RT_BITMAPA); |
| if (hRsrc == 0) |
| return 0; |
| hglb = LoadResource (hInstance, hRsrc); |
| if (hglb == 0) |
| return 0; |
| lpBitmap = (LPBITMAPINFOHEADER)LockResource (hglb); |
| if (lpBitmap == NULL) |
| return 0; |
| |
| nColorTableSize = (1 << lpBitmap->biBitCount); |
| nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD); |
| lpBitmapInfo = (LPBITMAPINFOHEADER)GlobalAlloc (GMEM_FIXED, nSize); |
| if (lpBitmapInfo == NULL) |
| return 0; |
| RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize); |
| |
| pColorTable = (RGBQUAD*)(((LPBYTE)lpBitmapInfo)+(UINT)lpBitmapInfo->biSize); |
| |
| for (iColor = 0; iColor < nColorTableSize; iColor++) { |
| for (i = 0; i < iMaps; i++) { |
| cRef = RGB(pColorTable[iColor].rgbRed, |
| pColorTable[iColor].rgbGreen, |
| pColorTable[iColor].rgbBlue); |
| if ( cRef == sysColorMap[i].from) { |
| #if 0 |
| if (wFlags & CBS_MASKED) { |
| if (sysColorMap[i].to != COLOR_BTNTEXT) |
| pColorTable[iColor] = RGB(255, 255, 255); |
| } |
| else |
| #endif |
| pColorTable[iColor].rgbBlue = GetBValue(sysColorMap[i].to); |
| pColorTable[iColor].rgbGreen = GetGValue(sysColorMap[i].to); |
| pColorTable[iColor].rgbRed = GetRValue(sysColorMap[i].to); |
| break; |
| } |
| } |
| } |
| nWidth = (INT)lpBitmapInfo->biWidth; |
| nHeight = (INT)lpBitmapInfo->biHeight; |
| hdcScreen = GetDC ((HWND)0); |
| hbm = CreateCompatibleBitmap (hdcScreen, nWidth, nHeight); |
| if (hbm) { |
| HDC hdcDst = CreateCompatibleDC (hdcScreen); |
| HBITMAP hbmOld = SelectObject (hdcDst, hbm); |
| LPBYTE lpBits = (LPBYTE)(lpBitmap + 1); |
| lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD); |
| StretchDIBits (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight, |
| lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS, |
| SRCCOPY); |
| SelectObject (hdcDst, hbmOld); |
| DeleteDC (hdcDst); |
| } |
| ReleaseDC ((HWND)0, hdcScreen); |
| GlobalFree ((HGLOBAL)lpBitmapInfo); |
| FreeResource (hglb); |
| |
| return hbm; |
| } |
| |
| |
| /*********************************************************************** |
| * CreateToolbar [COMCTL32.7] Creates a tool bar control |
| * |
| * PARAMS |
| * hwnd |
| * style |
| * wID |
| * nBitmaps |
| * hBMInst |
| * wBMID |
| * lpButtons |
| * iNumButtons |
| * |
| * RETURNS |
| * Success: handle to the tool bar control |
| * Failure: 0 |
| * |
| * NOTES |
| * Do not use this functions anymore. Use CreateToolbarEx instead. |
| */ |
| |
| HWND WINAPI |
| CreateToolbar (HWND hwnd, DWORD style, UINT wID, INT nBitmaps, |
| HINSTANCE hBMInst, UINT wBMID, |
| LPCOLDTBBUTTON lpButtons,INT iNumButtons) |
| { |
| return CreateToolbarEx (hwnd, style | CCS_NODIVIDER, wID, nBitmaps, |
| hBMInst, wBMID, (LPCTBBUTTON)lpButtons, |
| iNumButtons, 0, 0, 0, 0, sizeof (OLDTBBUTTON)); |
| } |
| |
| |
| /*********************************************************************** |
| * DllGetVersion [COMCTL32.25] |
| * |
| * Retrieves version information of the 'COMCTL32.DLL' |
| * |
| * PARAMS |
| * pdvi [O] pointer to version information structure. |
| * |
| * RETURNS |
| * Success: S_OK |
| * Failure: E_INVALIDARG |
| * |
| * NOTES |
| * Returns version of a comctl32.dll from IE4.01 SP1. |
| */ |
| |
| HRESULT WINAPI |
| COMCTL32_DllGetVersion (DLLVERSIONINFO *pdvi) |
| { |
| if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) { |
| WARN("wrong DLLVERSIONINFO size from app\n"); |
| return E_INVALIDARG; |
| } |
| |
| pdvi->dwMajorVersion = COMCTL32_VERSION; |
| pdvi->dwMinorVersion = COMCTL32_VERSION_MINOR; |
| pdvi->dwBuildNumber = 2919; |
| pdvi->dwPlatformID = 6304; |
| |
| TRACE("%lu.%lu.%lu.%lu\n", |
| pdvi->dwMajorVersion, pdvi->dwMinorVersion, |
| pdvi->dwBuildNumber, pdvi->dwPlatformID); |
| |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * DllInstall (COMCTL32.26) |
| */ |
| HRESULT WINAPI COMCTL32_DllInstall(BOOL bInstall, LPCWSTR cmdline) |
| { |
| FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE", |
| debugstr_w(cmdline)); |
| |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * _TrackMouseEvent [COMCTL32.91] |
| * |
| * Requests notification of mouse events |
| * |
| * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted |
| * to the hwnd specified in the ptme structure. After the event message |
| * is posted to the hwnd, the entry in the queue is removed. |
| * |
| * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely |
| * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted |
| * immediately and the TME_LEAVE flag being ignored. |
| * |
| * PARAMS |
| * ptme [I,O] pointer to TRACKMOUSEEVENT information structure. |
| * |
| * RETURNS |
| * Success: non-zero |
| * Failure: zero |
| * |
| * IMPLEMENTATION moved to USER32.TrackMouseEvent |
| * |
| */ |
| |
| BOOL WINAPI |
| _TrackMouseEvent (TRACKMOUSEEVENT *ptme) |
| { |
| return TrackMouseEvent (ptme); |
| } |
| |
| /************************************************************************* |
| * GetMUILanguage [COMCTL32.39] |
| * |
| * FIXME: What's this supposed to do? Apparently some i18n thing. |
| * |
| */ |
| LANGID WINAPI GetMUILanguage (VOID) |
| { |
| return COMCTL32_uiLang; |
| } |
| |
| |
| /************************************************************************* |
| * InitMUILanguage [COMCTL32.85] |
| * |
| * FIXME: What's this supposed to do? Apparently some i18n thing. |
| * |
| */ |
| |
| VOID WINAPI InitMUILanguage (LANGID uiLang) |
| { |
| COMCTL32_uiLang = uiLang; |
| } |
| |
| |
| /*********************************************************************** |
| * COMCTL32_CreateToolTip [NOT AN API] |
| * |
| * Creates a tooltip for the control specified in hwnd and does all |
| * necessary setup and notifications. |
| * |
| * PARAMS |
| * hwndOwner [I] Handle to the window that will own the tool tip. |
| * |
| * RETURNS |
| * Success: Handle of tool tip window. |
| * Failure: NULL |
| */ |
| HWND |
| COMCTL32_CreateToolTip(HWND hwndOwner) |
| { |
| HWND hwndToolTip; |
| |
| hwndToolTip = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0, |
| CW_USEDEFAULT, CW_USEDEFAULT, |
| CW_USEDEFAULT, CW_USEDEFAULT, hwndOwner, |
| 0, 0, 0); |
| |
| /* Send NM_TOOLTIPSCREATED notification */ |
| if (hwndToolTip) |
| { |
| NMTOOLTIPSCREATED nmttc; |
| /* true owner can be different if hwndOwner is a child window */ |
| HWND hwndTrueOwner = GetWindow(hwndToolTip, GW_OWNER); |
| nmttc.hdr.hwndFrom = hwndTrueOwner; |
| nmttc.hdr.idFrom = GetWindowLongA(hwndTrueOwner, GWL_ID); |
| nmttc.hdr.code = NM_TOOLTIPSCREATED; |
| nmttc.hwndToolTips = hwndToolTip; |
| |
| SendMessageA(GetParent(hwndTrueOwner), WM_NOTIFY, |
| (WPARAM)GetWindowLongA(hwndTrueOwner, GWL_ID), |
| (LPARAM)&nmttc); |
| } |
| |
| return hwndToolTip; |
| } |
| |
| |
| /*********************************************************************** |
| * COMCTL32_RefreshSysColors [NOT AN API] |
| * |
| * Invoked on any control recognizing a WM_SYSCOLORCHANGE message to |
| * refresh the color values in the color structure |
| * |
| * PARAMS |
| * none |
| * |
| * RETURNS |
| * none |
| */ |
| VOID |
| COMCTL32_RefreshSysColors(void) |
| { |
| comctl32_color.clrBtnHighlight = GetSysColor (COLOR_BTNHIGHLIGHT); |
| comctl32_color.clrBtnShadow = GetSysColor (COLOR_BTNSHADOW); |
| comctl32_color.clrBtnText = GetSysColor (COLOR_BTNTEXT); |
| comctl32_color.clrBtnFace = GetSysColor (COLOR_BTNFACE); |
| comctl32_color.clrHighlight = GetSysColor (COLOR_HIGHLIGHT); |
| comctl32_color.clrHighlightText = GetSysColor (COLOR_HIGHLIGHTTEXT); |
| comctl32_color.clr3dHilight = GetSysColor (COLOR_3DHILIGHT); |
| comctl32_color.clr3dShadow = GetSysColor (COLOR_3DSHADOW); |
| comctl32_color.clr3dDkShadow = GetSysColor (COLOR_3DDKSHADOW); |
| comctl32_color.clr3dFace = GetSysColor (COLOR_3DFACE); |
| comctl32_color.clrWindow = GetSysColor (COLOR_WINDOW); |
| comctl32_color.clrWindowText = GetSysColor (COLOR_WINDOWTEXT); |
| comctl32_color.clrGrayText = GetSysColor (COLOR_GRAYTEXT); |
| comctl32_color.clrActiveCaption = GetSysColor (COLOR_ACTIVECAPTION); |
| comctl32_color.clrInfoBk = GetSysColor (COLOR_INFOBK); |
| comctl32_color.clrInfoText = GetSysColor (COLOR_INFOTEXT); |
| } |