/* * Common controls functions * * Copyright 1997 Dimitrie O. Paun * Copyright 1998 Eric Kohl * */ #include "win.h" #include "heap.h" #include "commctrl.h" #include "animate.h" #include "comboex.h" #include "datetime.h" #include "flatsb.h" #include "header.h" #include "hotkey.h" #include "ipaddress.h" #include "listview.h" #include "monthcal.h" #include "nativefont.h" #include "pager.h" #include "progress.h" #include "propsheet.h" #include "rebar.h" #include "status.h" #include "tab.h" #include "toolbar.h" #include "tooltips.h" #include "trackbar.h" #include "treeview.h" #include "updown.h" #include "debug.h" #include "winerror.h" HANDLE32 COMCTL32_hHeap = (HANDLE32)NULL; DWORD COMCTL32_dwProcessesAttached = 0; LPSTR COMCTL32_aSubclass = (LPSTR)NULL; /*********************************************************************** * 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 */ BOOL32 WINAPI COMCTL32_LibMain (HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { TRACE (commctrl, "%x,%lx,%p\n", hinstDLL, fdwReason, lpvReserved); switch (fdwReason) { case DLL_PROCESS_ATTACH: if (COMCTL32_dwProcessesAttached == 0) { /* create private heap */ COMCTL32_hHeap = HeapCreate (0, 0x10000, 0); TRACE (commctrl, "Heap created: 0x%x\n", COMCTL32_hHeap); /* add global subclassing atom (used by 'tooltip' and 'updown') */ COMCTL32_aSubclass = (LPSTR)(DWORD)GlobalAddAtom32A ("CC32SubclassInfo"); TRACE (commctrl, "Subclassing atom added: %p\n", COMCTL32_aSubclass); /* register all Win95 common control classes */ ANIMATE_Register (); FLATSB_Register (); HEADER_Register (); HOTKEY_Register (); LISTVIEW_Register (); PROGRESS_Register (); PROPSHEET_Register (); STATUS_Register (); TAB_Register (); TOOLBAR_Register (); TOOLTIPS_Register (); TRACKBAR_Register (); TREEVIEW_Register (); UPDOWN_Register (); } COMCTL32_dwProcessesAttached++; break; case DLL_PROCESS_DETACH: COMCTL32_dwProcessesAttached--; if (COMCTL32_dwProcessesAttached == 0) { /* 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 (); PROPSHEET_UnRegister (); REBAR_Unregister (); STATUS_Unregister (); TAB_Unregister (); TOOLBAR_Unregister (); TOOLTIPS_Unregister (); TRACKBAR_Unregister (); TREEVIEW_Unregister (); UPDOWN_Unregister (); /* delete global subclassing atom */ GlobalDeleteAtom (LOWORD(COMCTL32_aSubclass)); TRACE (commctrl, "Subclassing atom deleted: %p\n", COMCTL32_aSubclass); COMCTL32_aSubclass = (LPSTR)NULL; /* destroy private heap */ HeapDestroy (COMCTL32_hHeap); TRACE (commctrl, "Heap destroyed: 0x%x\n", COMCTL32_hHeap); COMCTL32_hHeap = (HANDLE32)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 intergers (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 handes * WM_MENUSELECT messages. * * lpwIDs: * (will be written ...) */ VOID WINAPI MenuHelp (UINT32 uMsg, WPARAM32 wParam, LPARAM lParam, HMENU32 hMainMenu, HINSTANCE32 hInst, HWND32 hwndStatus, LPUINT32 lpwIDs) { UINT32 uMenuID = 0; if (!IsWindow32 (hwndStatus)) return; switch (uMsg) { case WM_MENUSELECT: TRACE (commctrl, "WM_MENUSELECT wParam=0x%X lParam=0x%lX\n", wParam, lParam); if ((HIWORD(wParam) == 0xFFFF) && (lParam == 0)) { /* menu was closed */ TRACE (commctrl, "menu was closed!\n"); SendMessage32A (hwndStatus, SB_SIMPLE, FALSE, 0); } else { /* menu item was selected */ if (HIWORD(wParam) & MF_POPUP) uMenuID = (UINT32)*(lpwIDs+1); else uMenuID = (UINT32)LOWORD(wParam); TRACE (commctrl, "uMenuID = %u\n", uMenuID); if (uMenuID) { CHAR szText[256]; if (!LoadString32A (hInst, uMenuID, szText, 256)) szText[0] = '\0'; SendMessage32A (hwndStatus, SB_SETTEXT32A, 255 | SBT_NOBORDERS, (LPARAM)szText); SendMessage32A (hwndStatus, SB_SIMPLE, TRUE, 0); } } break; default: FIXME (commctrl, "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. */ BOOL32 WINAPI ShowHideMenuCtl (HWND32 hwnd, UINT32 uFlags, LPINT32 lpInfo) { LPINT32 lpMenuId; TRACE (commctrl, "%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 (GetMenuState32 (lpInfo[1], uFlags, MF_BYCOMMAND) & MFS_CHECKED) { /* uncheck menu item */ CheckMenuItem32 (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_UNCHECKED); /* hide control */ lpMenuId++; SetWindowPos32 (GetDlgItem32 (hwnd, *lpMenuId), 0, 0, 0, 0, 0, SWP_HIDEWINDOW); } else { /* check menu item */ CheckMenuItem32 (lpInfo[0], *lpMenuId, MF_BYCOMMAND | MF_CHECKED); /* show control */ lpMenuId++; SetWindowPos32 (GetDlgItem32 (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 (HWND32 hwnd, LPRECT32 lpRect, LPINT32 lpInfo) { RECT32 rcCtrl; INT32 *lpRun; HWND32 hwndCtrl; TRACE (commctrl, "(0x%08lx 0x%08lx 0x%08lx)\n", (DWORD)hwnd, (DWORD)lpRect, (DWORD)lpInfo); GetClientRect32 (hwnd, lpRect); lpRun = lpInfo; do { lpRun += 2; if (*lpRun == 0) return; lpRun++; hwndCtrl = GetDlgItem32 (hwnd, *lpRun); if (GetWindowLong32A (hwndCtrl, GWL_STYLE) & WS_VISIBLE) { TRACE (commctrl, "control id 0x%x\n", *lpRun); GetWindowRect32 (hwndCtrl, &rcCtrl); MapWindowPoints32 ((HWND32)0, hwnd, (LPPOINT32)&rcCtrl, 2); SubtractRect32 (lpRect, lpRect, &rcCtrl); } lpRun++; } while (*lpRun); } /*********************************************************************** * DrawStatusText32A [COMCTL32.5][COMCTL32.27] * * 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 DrawStatusText32A (HDC32 hdc, LPRECT32 lprc, LPCSTR text, UINT32 style) { RECT32 r = *lprc; UINT32 border = BDR_SUNKENOUTER; if (style == SBT_POPOUT) border = BDR_RAISEDOUTER; else if (style == SBT_NOBORDERS) border = 0; DrawEdge32 (hdc, &r, border, BF_RECT|BF_ADJUST|BF_MIDDLE); /* now draw text */ if (text) { int oldbkmode = SetBkMode32 (hdc, TRANSPARENT); r.left += 3; DrawText32A (hdc, text, lstrlen32A(text), &r, DT_LEFT|DT_VCENTER|DT_SINGLELINE); if (oldbkmode != TRANSPARENT) SetBkMode32(hdc, oldbkmode); } } /*********************************************************************** * DrawStatusText32W [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. */ VOID WINAPI DrawStatusText32W (HDC32 hdc, LPRECT32 lprc, LPCWSTR text, UINT32 style) { LPSTR p = HEAP_strdupWtoA (GetProcessHeap (), 0, text); DrawStatusText32A (hdc, lprc, p, style); HeapFree (GetProcessHeap (), 0, p ); } /*********************************************************************** * CreateStatusWindow32A [COMCTL32.6][COMCTL32.21] * * 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 */ HWND32 WINAPI CreateStatusWindow32A (INT32 style, LPCSTR text, HWND32 parent, UINT32 wid) { return CreateWindow32A(STATUSCLASSNAME32A, text, style, CW_USEDEFAULT32, CW_USEDEFAULT32, CW_USEDEFAULT32, CW_USEDEFAULT32, parent, wid, 0, 0); } /*********************************************************************** * CreateStatusWindow32W [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 */ HWND32 WINAPI CreateStatusWindow32W (INT32 style, LPCWSTR text, HWND32 parent, UINT32 wid) { return CreateWindow32W(STATUSCLASSNAME32W, text, style, CW_USEDEFAULT32, CW_USEDEFAULT32, CW_USEDEFAULT32, CW_USEDEFAULT32, 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 */ HWND32 WINAPI CreateUpDownControl (DWORD style, INT32 x, INT32 y, INT32 cx, INT32 cy, HWND32 parent, INT32 id, HINSTANCE32 inst, HWND32 buddy, INT32 maxVal, INT32 minVal, INT32 curVal) { HWND32 hUD = CreateWindow32A (UPDOWN_CLASS32A, 0, style, x, y, cx, cy, parent, id, inst, 0); if (hUD) { SendMessage32A (hUD, UDM_SETBUDDY, buddy, 0); SendMessage32A (hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal)); SendMessage32A (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.81] * * Registers the common controls. * * PARAMS * lpInitCtrls [I] pointer to an INITCOMMONCONTROLS structure. * * RETURNS * Success: TRUE * Failure: FALSE * * NOTES * Only the additinal common controls are registered by this function. * The Win95 controls are registered at the DLL's initialization. */ BOOL32 WINAPI InitCommonControlsEx (LPINITCOMMONCONTROLSEX lpInitCtrls) { INT32 cCount; DWORD dwMask; if (!lpInitCtrls) return FALSE; if (lpInitCtrls->dwSize != sizeof(INITCOMMONCONTROLSEX)) return FALSE; TRACE(commctrl,"(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 (commctrl, "Unknown class! dwICC=0x%lX\n", dwMask); break; } } return TRUE; } /*********************************************************************** * CreateToolbarEx [COMCTL32.32] 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 */ HWND32 WINAPI CreateToolbarEx (HWND32 hwnd, DWORD style, UINT32 wID, INT32 nBitmaps, HINSTANCE32 hBMInst, UINT32 wBMID, LPCTBBUTTON lpButtons, INT32 iNumButtons, INT32 dxButton, INT32 dyButton, INT32 dxBitmap, INT32 dyBitmap, UINT32 uStructSize) { HWND32 hwndTB = CreateWindowEx32A (0, TOOLBARCLASSNAME32A, "", style, 0, 0, 0, 0, hwnd, (HMENU32)wID, 0, NULL); if(hwndTB) { TBADDBITMAP tbab; SendMessage32A (hwndTB, TB_BUTTONSTRUCTSIZE, (WPARAM32)uStructSize, 0); /* set bitmap and button size */ if (hBMInst == HINST_COMMCTRL) { if (wBMID & 1) { SendMessage32A (hwndTB, TB_SETBITMAPSIZE, 0, MAKELPARAM(26, 25)); SendMessage32A (hwndTB, TB_SETBUTTONSIZE, 0, MAKELPARAM(33, 32)); } else { SendMessage32A (hwndTB, TB_SETBITMAPSIZE, 0, MAKELPARAM(16, 15)); SendMessage32A (hwndTB, TB_SETBUTTONSIZE, 0, MAKELPARAM(23, 22)); } } else { SendMessage32A (hwndTB, TB_SETBITMAPSIZE, 0, MAKELPARAM((WORD)dyBitmap, (WORD)dxBitmap)); SendMessage32A (hwndTB, TB_SETBUTTONSIZE, 0, MAKELPARAM((WORD)dyButton, (WORD)dxButton)); } /* add bitmaps */ tbab.hInst = hBMInst; tbab.nID = wBMID; SendMessage32A (hwndTB, TB_ADDBITMAP, (WPARAM32)nBitmaps, (LPARAM)&tbab); /* add buttons */ SendMessage32A (hwndTB, TB_ADDBUTTONS32A, (WPARAM32)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 */ HBITMAP32 WINAPI CreateMappedBitmap (HINSTANCE32 hInstance, INT32 idBitmap, UINT32 wFlags, LPCOLORMAP lpColorMap, INT32 iNumMaps) { HGLOBAL32 hglb; HRSRC32 hRsrc; LPBITMAPINFOHEADER lpBitmap, lpBitmapInfo; UINT32 nSize, nColorTableSize; DWORD *pColorTable; INT32 iColor, i, iMaps, nWidth, nHeight; HDC32 hdcScreen; HBITMAP32 hbm; LPCOLORMAP sysColorMap; 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 = GetSysColor32 (COLOR_BTNTEXT); internalColorMap[1].to = GetSysColor32 (COLOR_BTNSHADOW); internalColorMap[2].to = GetSysColor32 (COLOR_BTNFACE); internalColorMap[3].to = GetSysColor32 (COLOR_BTNHIGHLIGHT); iMaps = 4; sysColorMap = (LPCOLORMAP)internalColorMap; } hRsrc = FindResource32A (hInstance, (LPSTR)idBitmap, RT_BITMAP32A); if (hRsrc == 0) return 0; hglb = LoadResource32 (hInstance, hRsrc); if (hglb == 0) return 0; lpBitmap = (LPBITMAPINFOHEADER)LockResource32 (hglb); if (lpBitmap == NULL) return 0; nColorTableSize = (1 << lpBitmap->biBitCount); nSize = lpBitmap->biSize + nColorTableSize * sizeof(RGBQUAD); lpBitmapInfo = (LPBITMAPINFOHEADER)GlobalAlloc32 (GMEM_FIXED, nSize); if (lpBitmapInfo == NULL) return 0; RtlMoveMemory (lpBitmapInfo, lpBitmap, nSize); pColorTable = (DWORD*)(((LPBYTE)lpBitmapInfo)+(UINT32)lpBitmapInfo->biSize); for (iColor = 0; iColor < nColorTableSize; iColor++) { for (i = 0; i < iMaps; i++) { if (pColorTable[iColor] == 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] = sysColorMap[i].to; break; } } } nWidth = (INT32)lpBitmapInfo->biWidth; nHeight = (INT32)lpBitmapInfo->biHeight; hdcScreen = GetDC32 ((HWND32)0); hbm = CreateCompatibleBitmap32 (hdcScreen, nWidth, nHeight); if (hbm) { HDC32 hdcDst = CreateCompatibleDC32 (hdcScreen); HBITMAP32 hbmOld = SelectObject32 (hdcDst, hbm); LPBYTE lpBits = (LPBYTE)(lpBitmap + 1); lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD); StretchDIBits32 (hdcDst, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight, lpBits, (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS, SRCCOPY); SelectObject32 (hdcDst, hbmOld); DeleteDC32 (hdcDst); } ReleaseDC32 ((HWND32)0, hdcScreen); GlobalFree32 ((HGLOBAL32)lpBitmapInfo); FreeResource32 (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. */ HWND32 WINAPI CreateToolbar (HWND32 hwnd, DWORD style, UINT32 wID, INT32 nBitmaps, HINSTANCE32 hBMInst, UINT32 wBMID, LPCOLDTBBUTTON lpButtons,INT32 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 (commctrl, "wrong DLLVERSIONINFO size from app"); return E_INVALIDARG; } pdvi->dwMajorVersion = 4; pdvi->dwMinorVersion = 72; pdvi->dwBuildNumber = 3110; pdvi->dwPlatformID = 1; TRACE (commctrl, "%lu.%lu.%lu.%lu\n", pdvi->dwMajorVersion, pdvi->dwMinorVersion, pdvi->dwBuildNumber, pdvi->dwPlatformID); return S_OK; }