| /* | |
| * Tool tip control | |
| * | |
| * Copyright 1998 Eric Kohl | |
| * | |
| * TODO: | |
| * - Unicode support. | |
| * - Custom draw support. | |
| * | |
| * Testing: | |
| * - Run tests using Waite Group Windows95 API Bible Volume 2. | |
| * The second cdrom (chapter 3) contains executables activate.exe, | |
| * curtool.exe, deltool.exe, enumtools.exe, getinfo.exe, getiptxt.exe, | |
| * hittest.exe, needtext.exe, newrect.exe, updtext.exe and winfrpt.exe. | |
| */ | |
| #include "windows.h" | |
| #include "commctrl.h" | |
| #include "tooltips.h" | |
| #include "win.h" | |
| #include "debug.h" | |
| #define ID_TIMERSHOW 1 /* show delay timer */ | |
| #define ID_TIMERPOP 2 /* auto pop timer */ | |
| #define ID_TIMERLEAVE 3 /* tool leave timer */ | |
| extern LPSTR COMCTL32_aSubclass; /* global subclassing atom */ | |
| /* property name of tooltip window handle */ | |
| /*#define TT_SUBCLASS_PROP "CC32SubclassInfo" */ | |
| #define TOOLTIPS_GetInfoPtr(wndPtr) ((TOOLTIPS_INFO *)wndPtr->wExtra[0]) | |
| LRESULT CALLBACK | |
| TOOLTIPS_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam); | |
| static VOID | |
| TOOLTIPS_Refresh (WND *wndPtr, HDC32 hdc) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| RECT32 rc; | |
| INT32 oldBkMode; | |
| HFONT32 hOldFont; | |
| UINT32 uFlags = DT_EXTERNALLEADING; | |
| if (infoPtr->nMaxTipWidth > -1) | |
| uFlags |= DT_WORDBREAK; | |
| if (wndPtr->dwStyle & TTS_NOPREFIX) | |
| uFlags |= DT_NOPREFIX; | |
| GetClientRect32 (wndPtr->hwndSelf, &rc); | |
| rc.left += (2 + infoPtr->rcMargin.left); | |
| rc.top += (2 + infoPtr->rcMargin.top); | |
| rc.right -= (2 + infoPtr->rcMargin.right); | |
| rc.bottom -= (2 + infoPtr->rcMargin.bottom); | |
| oldBkMode = SetBkMode32 (hdc, TRANSPARENT); | |
| SetTextColor32 (hdc, infoPtr->clrText); | |
| hOldFont = SelectObject32 (hdc, infoPtr->hFont); | |
| DrawText32W (hdc, infoPtr->szTipText, -1, &rc, uFlags); | |
| SelectObject32 (hdc, hOldFont); | |
| if (oldBkMode != TRANSPARENT) | |
| SetBkMode32 (hdc, oldBkMode); | |
| } | |
| static VOID | |
| TOOLTIPS_GetTipText (WND *wndPtr, TOOLTIPS_INFO *infoPtr, INT32 nTool) | |
| { | |
| TTTOOL_INFO *toolPtr = &infoPtr->tools[nTool]; | |
| if ((toolPtr->hinst) && (HIWORD((UINT32)toolPtr->lpszText) == 0)) { | |
| /* load a resource */ | |
| TRACE (tooltips, "load res string %x %x\n", | |
| toolPtr->hinst, (int)toolPtr->lpszText); | |
| LoadString32W (toolPtr->hinst, (UINT32)toolPtr->lpszText, | |
| infoPtr->szTipText, INFOTIPSIZE); | |
| } | |
| else if (toolPtr->lpszText) { | |
| if (toolPtr->lpszText == LPSTR_TEXTCALLBACK32W) { | |
| NMTTDISPINFO32A ttnmdi; | |
| /* fill NMHDR struct */ | |
| ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFO32A)); | |
| ttnmdi.hdr.hwndFrom = wndPtr->hwndSelf; | |
| ttnmdi.hdr.idFrom = toolPtr->uId; | |
| ttnmdi.hdr.code = TTN_GETDISPINFO32A; | |
| ttnmdi.lpszText = (LPSTR)&ttnmdi.szText; | |
| ttnmdi.uFlags = toolPtr->uFlags; | |
| ttnmdi.lParam = toolPtr->lParam; | |
| TRACE (tooltips, "hdr.idFrom = %x\n", ttnmdi.hdr.idFrom); | |
| SendMessage32A (toolPtr->hwnd, WM_NOTIFY, | |
| (WPARAM32)toolPtr->uId, (LPARAM)&ttnmdi); | |
| if ((ttnmdi.hinst) && (HIWORD((UINT32)ttnmdi.szText) == 0)) { | |
| LoadString32W (ttnmdi.hinst, (UINT32)ttnmdi.szText, | |
| infoPtr->szTipText, INFOTIPSIZE); | |
| if (ttnmdi.uFlags & TTF_DI_SETITEM) { | |
| toolPtr->hinst = ttnmdi.hinst; | |
| toolPtr->lpszText = (LPWSTR)ttnmdi.szText; | |
| } | |
| } | |
| else if (ttnmdi.szText[0]) { | |
| lstrcpynAtoW (infoPtr->szTipText, ttnmdi.szText, 80); | |
| if (ttnmdi.uFlags & TTF_DI_SETITEM) { | |
| INT32 len = lstrlen32A (ttnmdi.szText); | |
| toolPtr->hinst = 0; | |
| toolPtr->lpszText = COMCTL32_Alloc ((len+1)* sizeof(WCHAR)); | |
| lstrcpyAtoW (toolPtr->lpszText, ttnmdi.szText); | |
| } | |
| } | |
| else if (ttnmdi.lpszText == 0) { | |
| /* no text available */ | |
| infoPtr->szTipText[0] = L'\0'; | |
| } | |
| else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACK32A) { | |
| lstrcpynAtoW (infoPtr->szTipText, ttnmdi.lpszText, INFOTIPSIZE); | |
| if (ttnmdi.uFlags & TTF_DI_SETITEM) { | |
| INT32 len = lstrlen32A (ttnmdi.lpszText); | |
| toolPtr->hinst = 0; | |
| toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR)); | |
| lstrcpyAtoW (toolPtr->lpszText, ttnmdi.lpszText); | |
| } | |
| } | |
| else { | |
| ERR (tooltips, "recursive text callback!\n"); | |
| infoPtr->szTipText[0] = '\0'; | |
| } | |
| } | |
| else { | |
| /* the item is a usual (unicode) text */ | |
| lstrcpyn32W (infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE); | |
| } | |
| } | |
| else { | |
| /* no text available */ | |
| infoPtr->szTipText[0] = L'\0'; | |
| } | |
| TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText)); | |
| } | |
| static VOID | |
| TOOLTIPS_CalcTipSize (WND *wndPtr, TOOLTIPS_INFO *infoPtr, LPSIZE32 lpSize) | |
| { | |
| HDC32 hdc; | |
| HFONT32 hOldFont; | |
| UINT32 uFlags = DT_EXTERNALLEADING | DT_CALCRECT; | |
| RECT32 rc = {0, 0, 0, 0}; | |
| if (infoPtr->nMaxTipWidth > -1) { | |
| rc.right = infoPtr->nMaxTipWidth; | |
| uFlags |= DT_WORDBREAK; | |
| } | |
| if (wndPtr->dwStyle & TTS_NOPREFIX) | |
| uFlags |= DT_NOPREFIX; | |
| TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText)); | |
| hdc = GetDC32 (wndPtr->hwndSelf); | |
| hOldFont = SelectObject32 (hdc, infoPtr->hFont); | |
| DrawText32W (hdc, infoPtr->szTipText, -1, &rc, uFlags); | |
| SelectObject32 (hdc, hOldFont); | |
| ReleaseDC32 (wndPtr->hwndSelf, hdc); | |
| lpSize->cx = rc.right - rc.left + 4 + | |
| infoPtr->rcMargin.left + infoPtr->rcMargin.right; | |
| lpSize->cy = rc.bottom - rc.top + 4 + | |
| infoPtr->rcMargin.bottom + infoPtr->rcMargin.top; | |
| } | |
| static VOID | |
| TOOLTIPS_Show (WND *wndPtr, TOOLTIPS_INFO *infoPtr) | |
| { | |
| TTTOOL_INFO *toolPtr; | |
| RECT32 rect; | |
| SIZE32 size; | |
| NMHDR hdr; | |
| if (infoPtr->nTool == -1) { | |
| TRACE (tooltips, "invalid tool (-1)!\n"); | |
| return; | |
| } | |
| infoPtr->nCurrentTool = infoPtr->nTool; | |
| TRACE (tooltips, "Show tooltip pre %d!\n", infoPtr->nTool); | |
| TOOLTIPS_GetTipText (wndPtr, infoPtr, infoPtr->nCurrentTool); | |
| if (infoPtr->szTipText[0] == L'\0') { | |
| infoPtr->nCurrentTool = -1; | |
| return; | |
| } | |
| TRACE (tooltips, "Show tooltip %d!\n", infoPtr->nCurrentTool); | |
| toolPtr = &infoPtr->tools[infoPtr->nCurrentTool]; | |
| hdr.hwndFrom = wndPtr->hwndSelf; | |
| hdr.idFrom = toolPtr->uId; | |
| hdr.code = TTN_SHOW; | |
| SendMessage32A (toolPtr->hwnd, WM_NOTIFY, | |
| (WPARAM32)toolPtr->uId, (LPARAM)&hdr); | |
| TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText)); | |
| TOOLTIPS_CalcTipSize (wndPtr, infoPtr, &size); | |
| TRACE (tooltips, "size %d - %d\n", size.cx, size.cy); | |
| if (toolPtr->uFlags & TTF_CENTERTIP) { | |
| RECT32 rc; | |
| if (toolPtr->uFlags & TTF_IDISHWND) | |
| GetWindowRect32 ((HWND32)toolPtr->uId, &rc); | |
| else { | |
| rc = toolPtr->rect; | |
| MapWindowPoints32 (toolPtr->hwnd, (HWND32)0, (LPPOINT32)&rc, 2); | |
| } | |
| rect.left = (rc.left + rc.right - size.cx) / 2; | |
| rect.top = rc.bottom + 2; | |
| } | |
| else { | |
| GetCursorPos32 ((LPPOINT32)&rect); | |
| rect.top += 20; | |
| } | |
| /* FIXME: check position */ | |
| TRACE (tooltips, "pos %d - %d\n", rect.left, rect.top); | |
| rect.right = rect.left + size.cx; | |
| rect.bottom = rect.top + size.cy; | |
| AdjustWindowRectEx32 (&rect, wndPtr->dwStyle, FALSE, wndPtr->dwExStyle); | |
| SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, rect.left, rect.top, | |
| rect.right - rect.left, rect.bottom - rect.top, | |
| SWP_SHOWWINDOW); | |
| SetTimer32 (wndPtr->hwndSelf, ID_TIMERPOP, infoPtr->nAutoPopTime, 0); | |
| } | |
| static VOID | |
| TOOLTIPS_Hide (WND *wndPtr, TOOLTIPS_INFO *infoPtr) | |
| { | |
| TTTOOL_INFO *toolPtr; | |
| NMHDR hdr; | |
| if (infoPtr->nCurrentTool == -1) | |
| return; | |
| toolPtr = &infoPtr->tools[infoPtr->nCurrentTool]; | |
| TRACE (tooltips, "Hide tooltip %d!\n", infoPtr->nCurrentTool); | |
| KillTimer32 (wndPtr->hwndSelf, ID_TIMERPOP); | |
| hdr.hwndFrom = wndPtr->hwndSelf; | |
| hdr.idFrom = toolPtr->uId; | |
| hdr.code = TTN_POP; | |
| SendMessage32A (toolPtr->hwnd, WM_NOTIFY, | |
| (WPARAM32)toolPtr->uId, (LPARAM)&hdr); | |
| infoPtr->nCurrentTool = -1; | |
| SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, 0, 0, 0, 0, | |
| SWP_NOZORDER | SWP_HIDEWINDOW); | |
| } | |
| static VOID | |
| TOOLTIPS_TrackShow (WND *wndPtr, TOOLTIPS_INFO *infoPtr) | |
| { | |
| TTTOOL_INFO *toolPtr; | |
| RECT32 rect; | |
| SIZE32 size; | |
| NMHDR hdr; | |
| if (infoPtr->nTrackTool == -1) { | |
| TRACE (tooltips, "invalid tracking tool (-1)!\n"); | |
| return; | |
| } | |
| TRACE (tooltips, "show tracking tooltip pre %d!\n", infoPtr->nTrackTool); | |
| TOOLTIPS_GetTipText (wndPtr, infoPtr, infoPtr->nTrackTool); | |
| if (infoPtr->szTipText[0] == L'\0') { | |
| infoPtr->nTrackTool = -1; | |
| return; | |
| } | |
| TRACE (tooltips, "show tracking tooltip %d!\n", infoPtr->nTrackTool); | |
| toolPtr = &infoPtr->tools[infoPtr->nTrackTool]; | |
| hdr.hwndFrom = wndPtr->hwndSelf; | |
| hdr.idFrom = toolPtr->uId; | |
| hdr.code = TTN_SHOW; | |
| SendMessage32A (toolPtr->hwnd, WM_NOTIFY, | |
| (WPARAM32)toolPtr->uId, (LPARAM)&hdr); | |
| TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText)); | |
| TOOLTIPS_CalcTipSize (wndPtr, infoPtr, &size); | |
| TRACE (tooltips, "size %d - %d\n", size.cx, size.cy); | |
| if (toolPtr->uFlags & TTF_ABSOLUTE) { | |
| rect.left = infoPtr->xTrackPos; | |
| rect.top = infoPtr->yTrackPos; | |
| if (toolPtr->uFlags & TTF_CENTERTIP) { | |
| rect.left -= (size.cx / 2); | |
| rect.top -= (size.cy / 2); | |
| } | |
| } | |
| else { | |
| RECT32 rcTool; | |
| if (toolPtr->uFlags & TTF_IDISHWND) | |
| GetWindowRect32 ((HWND32)toolPtr->uId, &rcTool); | |
| else { | |
| rcTool = toolPtr->rect; | |
| MapWindowPoints32 (toolPtr->hwnd, (HWND32)0, (LPPOINT32)&rcTool, 2); | |
| } | |
| GetCursorPos32 ((LPPOINT32)&rect); | |
| rect.top += 20; | |
| if (toolPtr->uFlags & TTF_CENTERTIP) { | |
| rect.left -= (size.cx / 2); | |
| rect.top -= (size.cy / 2); | |
| } | |
| /* smart placement */ | |
| if ((rect.left + size.cx > rcTool.left) && (rect.left < rcTool.right) && | |
| (rect.top + size.cy > rcTool.top) && (rect.top < rcTool.bottom)) | |
| rect.left = rcTool.right; | |
| } | |
| TRACE (tooltips, "pos %d - %d\n", rect.left, rect.top); | |
| rect.right = rect.left + size.cx; | |
| rect.bottom = rect.top + size.cy; | |
| AdjustWindowRectEx32 (&rect, wndPtr->dwStyle, FALSE, wndPtr->dwExStyle); | |
| SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, rect.left, rect.top, | |
| rect.right - rect.left, rect.bottom - rect.top, | |
| SWP_SHOWWINDOW); | |
| } | |
| static VOID | |
| TOOLTIPS_TrackHide (WND *wndPtr, TOOLTIPS_INFO *infoPtr) | |
| { | |
| TTTOOL_INFO *toolPtr; | |
| NMHDR hdr; | |
| if (infoPtr->nTrackTool == -1) | |
| return; | |
| toolPtr = &infoPtr->tools[infoPtr->nTrackTool]; | |
| TRACE (tooltips, "hide tracking tooltip %d!\n", infoPtr->nTrackTool); | |
| hdr.hwndFrom = wndPtr->hwndSelf; | |
| hdr.idFrom = toolPtr->uId; | |
| hdr.code = TTN_POP; | |
| SendMessage32A (toolPtr->hwnd, WM_NOTIFY, | |
| (WPARAM32)toolPtr->uId, (LPARAM)&hdr); | |
| SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, 0, 0, 0, 0, | |
| SWP_NOZORDER | SWP_HIDEWINDOW); | |
| } | |
| static INT32 | |
| TOOLTIPS_GetToolFromInfoA (TOOLTIPS_INFO *infoPtr, LPTTTOOLINFO32A lpToolInfo) | |
| { | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if (!(toolPtr->uFlags & TTF_IDISHWND) && | |
| (lpToolInfo->hwnd == toolPtr->hwnd) && | |
| (lpToolInfo->uId == toolPtr->uId)) | |
| return nTool; | |
| } | |
| for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if ((toolPtr->uFlags & TTF_IDISHWND) && | |
| (lpToolInfo->uId == toolPtr->uId)) | |
| return nTool; | |
| } | |
| return -1; | |
| } | |
| static INT32 | |
| TOOLTIPS_GetToolFromInfoW (TOOLTIPS_INFO *infoPtr, LPTTTOOLINFO32W lpToolInfo) | |
| { | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if (!(toolPtr->uFlags & TTF_IDISHWND) && | |
| (lpToolInfo->hwnd == toolPtr->hwnd) && | |
| (lpToolInfo->uId == toolPtr->uId)) | |
| return nTool; | |
| } | |
| for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if ((toolPtr->uFlags & TTF_IDISHWND) && | |
| (lpToolInfo->uId == toolPtr->uId)) | |
| return nTool; | |
| } | |
| return -1; | |
| } | |
| static INT32 | |
| TOOLTIPS_GetToolFromPoint (TOOLTIPS_INFO *infoPtr, HWND32 hwnd, LPPOINT32 lpPt) | |
| { | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if (!(toolPtr->uFlags & TTF_IDISHWND)) { | |
| if (hwnd != toolPtr->hwnd) | |
| continue; | |
| if (!PtInRect32 (&toolPtr->rect, *lpPt)) | |
| continue; | |
| return nTool; | |
| } | |
| } | |
| for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if (toolPtr->uFlags & TTF_IDISHWND) { | |
| if ((HWND32)toolPtr->uId == hwnd) | |
| return nTool; | |
| } | |
| } | |
| return -1; | |
| } | |
| static INT32 | |
| TOOLTIPS_GetToolFromMessage (TOOLTIPS_INFO *infoPtr, HWND32 hwndTool) | |
| { | |
| DWORD dwPos; | |
| POINT32 pt; | |
| dwPos = GetMessagePos (); | |
| pt.x = (INT32)LOWORD(dwPos); | |
| pt.y = (INT32)HIWORD(dwPos); | |
| ScreenToClient32 (hwndTool, &pt); | |
| return TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt); | |
| } | |
| static BOOL32 | |
| TOOLTIPS_IsWindowActive (HWND32 hwnd) | |
| { | |
| HWND32 hwndActive = GetActiveWindow32 (); | |
| if (!hwndActive) | |
| return FALSE; | |
| if (hwndActive == hwnd) | |
| return TRUE; | |
| return IsChild32 (hwndActive, hwnd); | |
| } | |
| static INT32 | |
| TOOLTIPS_CheckTool (WND *wndPtr, BOOL32 bShowTest) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| POINT32 pt; | |
| HWND32 hwndTool; | |
| INT32 nTool; | |
| GetCursorPos32 (&pt); | |
| hwndTool = | |
| SendMessage32A (wndPtr->hwndSelf, TTM_WINDOWFROMPOINT, 0, (LPARAM)&pt); | |
| if (hwndTool == 0) | |
| return -1; | |
| ScreenToClient32 (hwndTool, &pt); | |
| nTool = TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt); | |
| if (nTool == -1) | |
| return -1; | |
| if (!(wndPtr->dwStyle & TTS_ALWAYSTIP) && bShowTest) { | |
| if (!TOOLTIPS_IsWindowActive (wndPtr->owner->hwndSelf)) | |
| return -1; | |
| } | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| return nTool; | |
| } | |
| static LRESULT | |
| TOOLTIPS_Activate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| infoPtr->bActive = (BOOL32)wParam; | |
| if (infoPtr->bActive) | |
| TRACE (tooltips, "activate!\n"); | |
| if (!(infoPtr->bActive) && (infoPtr->nCurrentTool != -1)) | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_AddTool32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return FALSE; | |
| TRACE (tooltips, "add tool (%x) %x %d%s!\n", | |
| wndPtr->hwndSelf, lpToolInfo->hwnd, lpToolInfo->uId, | |
| (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : ""); | |
| if (infoPtr->uNumTools == 0) { | |
| infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO)); | |
| toolPtr = infoPtr->tools; | |
| } | |
| else { | |
| TTTOOL_INFO *oldTools = infoPtr->tools; | |
| infoPtr->tools = | |
| COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1)); | |
| memcpy (infoPtr->tools, oldTools, | |
| infoPtr->uNumTools * sizeof(TTTOOL_INFO)); | |
| COMCTL32_Free (oldTools); | |
| toolPtr = &infoPtr->tools[infoPtr->uNumTools]; | |
| } | |
| infoPtr->uNumTools++; | |
| /* copy tool data */ | |
| toolPtr->uFlags = lpToolInfo->uFlags; | |
| toolPtr->hwnd = lpToolInfo->hwnd; | |
| toolPtr->uId = lpToolInfo->uId; | |
| toolPtr->rect = lpToolInfo->rect; | |
| toolPtr->hinst = lpToolInfo->hinst; | |
| if ((lpToolInfo->hinst) && (HIWORD((INT32)lpToolInfo->lpszText) == 0)) { | |
| TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText); | |
| toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText; | |
| } | |
| else if (lpToolInfo->lpszText) { | |
| if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32A) { | |
| TRACE (tooltips, "add CALLBACK!\n"); | |
| toolPtr->lpszText = LPSTR_TEXTCALLBACK32W; | |
| } | |
| else { | |
| INT32 len = lstrlen32A (lpToolInfo->lpszText); | |
| TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText); | |
| toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR)); | |
| lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText); | |
| } | |
| } | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A)) | |
| toolPtr->lParam = lpToolInfo->lParam; | |
| /* install subclassing hook */ | |
| if (toolPtr->uFlags & TTF_SUBCLASS) { | |
| if (toolPtr->uFlags & TTF_IDISHWND) { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| if (lpttsi == NULL) { | |
| lpttsi = | |
| (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO)); | |
| lpttsi->wpOrigProc = | |
| (WNDPROC32)SetWindowLong32A ((HWND32)toolPtr->uId, | |
| GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc); | |
| lpttsi->hwndToolTip = wndPtr->hwndSelf; | |
| lpttsi->uRefCount++; | |
| SetProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass, | |
| (HANDLE32)lpttsi); | |
| } | |
| else | |
| WARN (tooltips, "A window tool must only be listed once!\n"); | |
| } | |
| else { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, COMCTL32_aSubclass); | |
| if (lpttsi == NULL) { | |
| lpttsi = | |
| (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO)); | |
| lpttsi->wpOrigProc = | |
| (WNDPROC32)SetWindowLong32A (toolPtr->hwnd, | |
| GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc); | |
| lpttsi->hwndToolTip = wndPtr->hwndSelf; | |
| lpttsi->uRefCount++; | |
| SetProp32A (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE32)lpttsi); | |
| } | |
| else | |
| lpttsi->uRefCount++; | |
| } | |
| TRACE (tooltips, "subclassing installed!\n"); | |
| } | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_AddTool32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return FALSE; | |
| TRACE (tooltips, "add tool (%x) %x %d%s!\n", | |
| wndPtr->hwndSelf, lpToolInfo->hwnd, lpToolInfo->uId, | |
| (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : ""); | |
| if (infoPtr->uNumTools == 0) { | |
| infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO)); | |
| toolPtr = infoPtr->tools; | |
| } | |
| else { | |
| TTTOOL_INFO *oldTools = infoPtr->tools; | |
| infoPtr->tools = | |
| COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1)); | |
| memcpy (infoPtr->tools, oldTools, | |
| infoPtr->uNumTools * sizeof(TTTOOL_INFO)); | |
| COMCTL32_Free (oldTools); | |
| toolPtr = &infoPtr->tools[infoPtr->uNumTools]; | |
| } | |
| infoPtr->uNumTools++; | |
| /* copy tool data */ | |
| toolPtr->uFlags = lpToolInfo->uFlags; | |
| toolPtr->hwnd = lpToolInfo->hwnd; | |
| toolPtr->uId = lpToolInfo->uId; | |
| toolPtr->rect = lpToolInfo->rect; | |
| toolPtr->hinst = lpToolInfo->hinst; | |
| if ((lpToolInfo->hinst) && (HIWORD((INT32)lpToolInfo->lpszText) == 0)) { | |
| TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText); | |
| toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText; | |
| } | |
| else if (lpToolInfo->lpszText) { | |
| if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32W) { | |
| TRACE (tooltips, "add CALLBACK!\n"); | |
| toolPtr->lpszText = LPSTR_TEXTCALLBACK32W; | |
| } | |
| else { | |
| INT32 len = lstrlen32W (lpToolInfo->lpszText); | |
| TRACE (tooltips, "add text \"%s\"!\n", | |
| debugstr_w(lpToolInfo->lpszText)); | |
| toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR)); | |
| lstrcpy32W (toolPtr->lpszText, lpToolInfo->lpszText); | |
| } | |
| } | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32W)) | |
| toolPtr->lParam = lpToolInfo->lParam; | |
| /* install subclassing hook */ | |
| if (toolPtr->uFlags & TTF_SUBCLASS) { | |
| if (toolPtr->uFlags & TTF_IDISHWND) { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| if (lpttsi == NULL) { | |
| lpttsi = | |
| (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO)); | |
| lpttsi->wpOrigProc = | |
| (WNDPROC32)SetWindowLong32A ((HWND32)toolPtr->uId, | |
| GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc); | |
| lpttsi->hwndToolTip = wndPtr->hwndSelf; | |
| lpttsi->uRefCount++; | |
| SetProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass, | |
| (HANDLE32)lpttsi); | |
| } | |
| else | |
| WARN (tooltips, "A window tool must only be listed once!\n"); | |
| } | |
| else { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, COMCTL32_aSubclass); | |
| if (lpttsi == NULL) { | |
| lpttsi = | |
| (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO)); | |
| lpttsi->wpOrigProc = | |
| (WNDPROC32)SetWindowLong32A (toolPtr->hwnd, | |
| GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc); | |
| lpttsi->hwndToolTip = wndPtr->hwndSelf; | |
| lpttsi->uRefCount++; | |
| SetProp32A (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE32)lpttsi); | |
| } | |
| else | |
| lpttsi->uRefCount++; | |
| } | |
| TRACE (tooltips, "subclassing installed!\n"); | |
| } | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_DelTool32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return 0; | |
| if (infoPtr->uNumTools == 0) | |
| return 0; | |
| nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo); | |
| if (nTool == -1) return 0; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| /* delete text string */ | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if ((toolPtr->hinst) && (toolPtr->lpszText)) { | |
| if (toolPtr->lpszText != LPSTR_TEXTCALLBACK32W) | |
| COMCTL32_Free (toolPtr->lpszText); | |
| } | |
| /* remove subclassing */ | |
| if (toolPtr->uFlags & TTF_SUBCLASS) { | |
| if (toolPtr->uFlags & TTF_IDISHWND) { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| if (lpttsi) { | |
| SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC, | |
| (LONG)lpttsi->wpOrigProc); | |
| RemoveProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| COMCTL32_Free (&lpttsi); | |
| } | |
| else | |
| ERR (tooltips, "Invalid data handle!\n"); | |
| } | |
| else { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, COMCTL32_aSubclass); | |
| if (lpttsi) { | |
| if (lpttsi->uRefCount == 1) { | |
| SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC, | |
| (LONG)lpttsi->wpOrigProc); | |
| RemoveProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| COMCTL32_Free (&lpttsi); | |
| } | |
| else | |
| lpttsi->uRefCount--; | |
| } | |
| else | |
| ERR (tooltips, "Invalid data handle!\n"); | |
| } | |
| } | |
| /* delete tool from tool list */ | |
| if (infoPtr->uNumTools == 1) { | |
| COMCTL32_Free (infoPtr->tools); | |
| infoPtr->tools = NULL; | |
| } | |
| else { | |
| TTTOOL_INFO *oldTools = infoPtr->tools; | |
| infoPtr->tools = | |
| COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1)); | |
| if (nTool > 0) | |
| memcpy (&infoPtr->tools[0], &oldTools[0], | |
| nTool * sizeof(TTTOOL_INFO)); | |
| if (nTool < infoPtr->uNumTools - 1) | |
| memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1], | |
| (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO)); | |
| COMCTL32_Free (oldTools); | |
| } | |
| infoPtr->uNumTools--; | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_DelTool32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return 0; | |
| if (infoPtr->uNumTools == 0) | |
| return 0; | |
| nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo); | |
| if (nTool == -1) return 0; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| /* delete text string */ | |
| toolPtr = &infoPtr->tools[nTool]; | |
| if ((toolPtr->hinst) && (toolPtr->lpszText)) { | |
| if (toolPtr->lpszText != LPSTR_TEXTCALLBACK32W) | |
| COMCTL32_Free (toolPtr->lpszText); | |
| } | |
| /* remove subclassing */ | |
| if (toolPtr->uFlags & TTF_SUBCLASS) { | |
| if (toolPtr->uFlags & TTF_IDISHWND) { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| if (lpttsi) { | |
| SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC, | |
| (LONG)lpttsi->wpOrigProc); | |
| RemoveProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| COMCTL32_Free (&lpttsi); | |
| } | |
| else | |
| ERR (tooltips, "Invalid data handle!\n"); | |
| } | |
| else { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, COMCTL32_aSubclass); | |
| if (lpttsi) { | |
| if (lpttsi->uRefCount == 1) { | |
| SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC, | |
| (LONG)lpttsi->wpOrigProc); | |
| RemoveProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| COMCTL32_Free (&lpttsi); | |
| } | |
| else | |
| lpttsi->uRefCount--; | |
| } | |
| else | |
| ERR (tooltips, "Invalid data handle!\n"); | |
| } | |
| } | |
| /* delete tool from tool list */ | |
| if (infoPtr->uNumTools == 1) { | |
| COMCTL32_Free (infoPtr->tools); | |
| infoPtr->tools = NULL; | |
| } | |
| else { | |
| TTTOOL_INFO *oldTools = infoPtr->tools; | |
| infoPtr->tools = | |
| COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1)); | |
| if (nTool > 0) | |
| memcpy (&infoPtr->tools[0], &oldTools[0], | |
| nTool * sizeof(TTTOOL_INFO)); | |
| if (nTool < infoPtr->uNumTools - 1) | |
| memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1], | |
| (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO)); | |
| COMCTL32_Free (oldTools); | |
| } | |
| infoPtr->uNumTools--; | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_EnumTools32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| UINT32 uIndex = (UINT32)wParam; | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return FALSE; | |
| if (uIndex >= infoPtr->uNumTools) | |
| return FALSE; | |
| TRACE (tooltips, "index=%u\n", uIndex); | |
| toolPtr = &infoPtr->tools[uIndex]; | |
| /* copy tool data */ | |
| lpToolInfo->uFlags = toolPtr->uFlags; | |
| lpToolInfo->hwnd = toolPtr->hwnd; | |
| lpToolInfo->uId = toolPtr->uId; | |
| lpToolInfo->rect = toolPtr->rect; | |
| lpToolInfo->hinst = toolPtr->hinst; | |
| /* lpToolInfo->lpszText = toolPtr->lpszText; */ | |
| lpToolInfo->lpszText = NULL; /* FIXME */ | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A)) | |
| lpToolInfo->lParam = toolPtr->lParam; | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_EnumTools32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| UINT32 uIndex = (UINT32)wParam; | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return FALSE; | |
| if (uIndex >= infoPtr->uNumTools) | |
| return FALSE; | |
| TRACE (tooltips, "index=%u\n", uIndex); | |
| toolPtr = &infoPtr->tools[uIndex]; | |
| /* copy tool data */ | |
| lpToolInfo->uFlags = toolPtr->uFlags; | |
| lpToolInfo->hwnd = toolPtr->hwnd; | |
| lpToolInfo->uId = toolPtr->uId; | |
| lpToolInfo->rect = toolPtr->rect; | |
| lpToolInfo->hinst = toolPtr->hinst; | |
| /* lpToolInfo->lpszText = toolPtr->lpszText; */ | |
| lpToolInfo->lpszText = NULL; /* FIXME */ | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32W)) | |
| lpToolInfo->lParam = toolPtr->lParam; | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetCurrentTool32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return FALSE; | |
| if (lpToolInfo) { | |
| if (infoPtr->nCurrentTool > -1) { | |
| toolPtr = &infoPtr->tools[infoPtr->nCurrentTool]; | |
| /* copy tool data */ | |
| lpToolInfo->uFlags = toolPtr->uFlags; | |
| lpToolInfo->rect = toolPtr->rect; | |
| lpToolInfo->hinst = toolPtr->hinst; | |
| /* lpToolInfo->lpszText = toolPtr->lpszText; */ | |
| lpToolInfo->lpszText = NULL; /* FIXME */ | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A)) | |
| lpToolInfo->lParam = toolPtr->lParam; | |
| return TRUE; | |
| } | |
| else | |
| return FALSE; | |
| } | |
| else | |
| return (infoPtr->nCurrentTool != -1); | |
| return FALSE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetCurrentTool32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return FALSE; | |
| if (lpToolInfo) { | |
| if (infoPtr->nCurrentTool > -1) { | |
| toolPtr = &infoPtr->tools[infoPtr->nCurrentTool]; | |
| /* copy tool data */ | |
| lpToolInfo->uFlags = toolPtr->uFlags; | |
| lpToolInfo->rect = toolPtr->rect; | |
| lpToolInfo->hinst = toolPtr->hinst; | |
| /* lpToolInfo->lpszText = toolPtr->lpszText; */ | |
| lpToolInfo->lpszText = NULL; /* FIXME */ | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32W)) | |
| lpToolInfo->lParam = toolPtr->lParam; | |
| return TRUE; | |
| } | |
| else | |
| return FALSE; | |
| } | |
| else | |
| return (infoPtr->nCurrentTool != -1); | |
| return FALSE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetDelayTime (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| switch (wParam) { | |
| case TTDT_AUTOMATIC: | |
| return infoPtr->nAutomaticTime; | |
| case TTDT_RESHOW: | |
| return infoPtr->nReshowTime; | |
| case TTDT_AUTOPOP: | |
| return infoPtr->nAutoPopTime; | |
| case TTDT_INITIAL: | |
| return infoPtr->nInitialTime; | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetMargin (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPRECT32 lpRect = (LPRECT32)lParam; | |
| lpRect->left = infoPtr->rcMargin.left; | |
| lpRect->right = infoPtr->rcMargin.right; | |
| lpRect->bottom = infoPtr->rcMargin.bottom; | |
| lpRect->top = infoPtr->rcMargin.top; | |
| return 0; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_GetMaxTipWidth (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| return infoPtr->nMaxTipWidth; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetText32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return 0; | |
| nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo); | |
| if (nTool == -1) return 0; | |
| lstrcpyWtoA (lpToolInfo->lpszText, infoPtr->tools[nTool].lpszText); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetText32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return 0; | |
| nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo); | |
| if (nTool == -1) return 0; | |
| lstrcpy32W (lpToolInfo->lpszText, infoPtr->tools[nTool].lpszText); | |
| return 0; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_GetTipBkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| return infoPtr->clrBk; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_GetTipTextColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| return infoPtr->clrText; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_GetToolCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| return infoPtr->uNumTools; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetToolInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return FALSE; | |
| if (infoPtr->uNumTools == 0) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo); | |
| if (nTool == -1) | |
| return FALSE; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| toolPtr = &infoPtr->tools[nTool]; | |
| /* copy tool data */ | |
| lpToolInfo->uFlags = toolPtr->uFlags; | |
| lpToolInfo->rect = toolPtr->rect; | |
| lpToolInfo->hinst = toolPtr->hinst; | |
| /* lpToolInfo->lpszText = toolPtr->lpszText; */ | |
| lpToolInfo->lpszText = NULL; /* FIXME */ | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A)) | |
| lpToolInfo->lParam = toolPtr->lParam; | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetToolInfo32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return FALSE; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return FALSE; | |
| if (infoPtr->uNumTools == 0) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo); | |
| if (nTool == -1) | |
| return FALSE; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| toolPtr = &infoPtr->tools[nTool]; | |
| /* copy tool data */ | |
| lpToolInfo->uFlags = toolPtr->uFlags; | |
| lpToolInfo->rect = toolPtr->rect; | |
| lpToolInfo->hinst = toolPtr->hinst; | |
| /* lpToolInfo->lpszText = toolPtr->lpszText; */ | |
| lpToolInfo->lpszText = NULL; /* FIXME */ | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32W)) | |
| lpToolInfo->lParam = toolPtr->lParam; | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_HitTest32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTHITTESTINFO32A lptthit = (LPTTHITTESTINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lptthit == 0) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt); | |
| if (nTool == -1) | |
| return FALSE; | |
| TRACE (tooltips, "tool %d!\n", nTool); | |
| /* copy tool data */ | |
| if (lptthit->ti.cbSize >= sizeof(TTTOOLINFO32A)) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| lptthit->ti.uFlags = toolPtr->uFlags; | |
| lptthit->ti.hwnd = toolPtr->hwnd; | |
| lptthit->ti.uId = toolPtr->uId; | |
| lptthit->ti.rect = toolPtr->rect; | |
| lptthit->ti.hinst = toolPtr->hinst; | |
| /* lptthit->ti.lpszText = toolPtr->lpszText; */ | |
| lptthit->ti.lpszText = NULL; /* FIXME */ | |
| lptthit->ti.lParam = toolPtr->lParam; | |
| } | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_HitTest32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTHITTESTINFO32W lptthit = (LPTTHITTESTINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lptthit == 0) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt); | |
| if (nTool == -1) | |
| return FALSE; | |
| TRACE (tooltips, "tool %d!\n", nTool); | |
| /* copy tool data */ | |
| if (lptthit->ti.cbSize >= sizeof(TTTOOLINFO32W)) { | |
| toolPtr = &infoPtr->tools[nTool]; | |
| lptthit->ti.uFlags = toolPtr->uFlags; | |
| lptthit->ti.hwnd = toolPtr->hwnd; | |
| lptthit->ti.uId = toolPtr->uId; | |
| lptthit->ti.rect = toolPtr->rect; | |
| lptthit->ti.hinst = toolPtr->hinst; | |
| /* lptthit->ti.lpszText = toolPtr->lpszText; */ | |
| lptthit->ti.lpszText = NULL; /* FIXME */ | |
| lptthit->ti.lParam = toolPtr->lParam; | |
| } | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_NewToolRect32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpti = (LPTTTOOLINFO32A)lParam; | |
| INT32 nTool; | |
| if (lpti == NULL) | |
| return 0; | |
| if (lpti->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpti); | |
| if (nTool == -1) return 0; | |
| infoPtr->tools[nTool].rect = lpti->rect; | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_NewToolRect32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpti = (LPTTTOOLINFO32W)lParam; | |
| INT32 nTool; | |
| if (lpti == NULL) | |
| return 0; | |
| if (lpti->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpti); | |
| if (nTool == -1) return 0; | |
| infoPtr->tools[nTool].rect = lpti->rect; | |
| return 0; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_Pop (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_RelayEvent (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPMSG32 lpMsg = (LPMSG32)lParam; | |
| POINT32 pt; | |
| if (lParam == 0) { | |
| ERR (tooltips, "lpMsg == NULL!\n"); | |
| return 0; | |
| } | |
| switch (lpMsg->message) { | |
| case WM_LBUTTONDOWN: | |
| case WM_LBUTTONUP: | |
| case WM_MBUTTONDOWN: | |
| case WM_MBUTTONUP: | |
| case WM_RBUTTONDOWN: | |
| case WM_RBUTTONUP: | |
| pt = lpMsg->pt; | |
| ScreenToClient32 (lpMsg->hwnd, &pt); | |
| infoPtr->nOldTool = infoPtr->nTool; | |
| infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt); | |
| TRACE (tooltips, "tool (%x) %d %d\n", | |
| wndPtr->hwndSelf, infoPtr->nOldTool, infoPtr->nTool); | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| break; | |
| case WM_MOUSEMOVE: | |
| pt = lpMsg->pt; | |
| ScreenToClient32 (lpMsg->hwnd, &pt); | |
| infoPtr->nOldTool = infoPtr->nTool; | |
| infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt); | |
| TRACE (tooltips, "tool (%x) %d %d\n", | |
| wndPtr->hwndSelf, infoPtr->nOldTool, infoPtr->nTool); | |
| TRACE (tooltips, "WM_MOUSEMOVE (%04x %d %d)\n", | |
| wndPtr->hwndSelf, pt.x, pt.y); | |
| if ((infoPtr->bActive) && (infoPtr->nTool != infoPtr->nOldTool)) { | |
| if (infoPtr->nOldTool == -1) { | |
| SetTimer32 (wndPtr->hwndSelf, ID_TIMERSHOW, | |
| infoPtr->nInitialTime, 0); | |
| TRACE (tooltips, "timer 1 started!\n"); | |
| } | |
| else { | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| SetTimer32 (wndPtr->hwndSelf, ID_TIMERSHOW, | |
| infoPtr->nReshowTime, 0); | |
| TRACE (tooltips, "timer 2 started!\n"); | |
| } | |
| } | |
| if (infoPtr->nCurrentTool != -1) { | |
| SetTimer32 (wndPtr->hwndSelf, ID_TIMERLEAVE, 100, 0); | |
| TRACE (tooltips, "timer 3 started!\n"); | |
| } | |
| break; | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_SetDelayTime (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| INT32 nTime = (INT32)LOWORD(lParam); | |
| switch (wParam) { | |
| case TTDT_AUTOMATIC: | |
| if (nTime == 0) { | |
| infoPtr->nAutomaticTime = 500; | |
| infoPtr->nReshowTime = 100; | |
| infoPtr->nAutoPopTime = 5000; | |
| infoPtr->nInitialTime = 500; | |
| } | |
| else { | |
| infoPtr->nAutomaticTime = nTime; | |
| infoPtr->nReshowTime = nTime / 5; | |
| infoPtr->nAutoPopTime = nTime * 10; | |
| infoPtr->nInitialTime = nTime; | |
| } | |
| break; | |
| case TTDT_RESHOW: | |
| infoPtr->nReshowTime = nTime; | |
| break; | |
| case TTDT_AUTOPOP: | |
| infoPtr->nAutoPopTime = nTime; | |
| break; | |
| case TTDT_INITIAL: | |
| infoPtr->nInitialTime = nTime; | |
| break; | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_SetMargin (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPRECT32 lpRect = (LPRECT32)lParam; | |
| infoPtr->rcMargin.left = lpRect->left; | |
| infoPtr->rcMargin.right = lpRect->right; | |
| infoPtr->rcMargin.bottom = lpRect->bottom; | |
| infoPtr->rcMargin.top = lpRect->top; | |
| return 0; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_SetMaxTipWidth (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| INT32 nTemp = infoPtr->nMaxTipWidth; | |
| infoPtr->nMaxTipWidth = (INT32)lParam; | |
| return nTemp; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_SetTipBkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| infoPtr->clrBk = (COLORREF)wParam; | |
| return 0; | |
| } | |
| __inline__ static LRESULT | |
| TOOLTIPS_SetTipTextColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| infoPtr->clrText = (COLORREF)wParam; | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_SetToolInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return 0; | |
| nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo); | |
| if (nTool == -1) return 0; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| toolPtr = &infoPtr->tools[nTool]; | |
| /* copy tool data */ | |
| toolPtr->uFlags = lpToolInfo->uFlags; | |
| toolPtr->hwnd = lpToolInfo->hwnd; | |
| toolPtr->uId = lpToolInfo->uId; | |
| toolPtr->rect = lpToolInfo->rect; | |
| toolPtr->hinst = lpToolInfo->hinst; | |
| if ((lpToolInfo->hinst) && (HIWORD((INT32)lpToolInfo->lpszText) == 0)) { | |
| TRACE (tooltips, "set string id %x!\n", (INT32)lpToolInfo->lpszText); | |
| toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText; | |
| } | |
| else if (lpToolInfo->lpszText) { | |
| if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32A) | |
| toolPtr->lpszText = LPSTR_TEXTCALLBACK32W; | |
| else { | |
| if (toolPtr->lpszText) { | |
| COMCTL32_Free (toolPtr->lpszText); | |
| toolPtr->lpszText = NULL; | |
| } | |
| if (lpToolInfo->lpszText) { | |
| INT32 len = lstrlen32A (lpToolInfo->lpszText); | |
| toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR)); | |
| lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText); | |
| } | |
| } | |
| } | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A)) | |
| toolPtr->lParam = lpToolInfo->lParam; | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_SetToolInfo32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return 0; | |
| nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo); | |
| if (nTool == -1) return 0; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| toolPtr = &infoPtr->tools[nTool]; | |
| /* copy tool data */ | |
| toolPtr->uFlags = lpToolInfo->uFlags; | |
| toolPtr->hwnd = lpToolInfo->hwnd; | |
| toolPtr->uId = lpToolInfo->uId; | |
| toolPtr->rect = lpToolInfo->rect; | |
| toolPtr->hinst = lpToolInfo->hinst; | |
| if ((lpToolInfo->hinst) && (HIWORD((INT32)lpToolInfo->lpszText) == 0)) { | |
| TRACE (tooltips, "set string id %x!\n", (INT32)lpToolInfo->lpszText); | |
| toolPtr->lpszText = lpToolInfo->lpszText; | |
| } | |
| else if (lpToolInfo->lpszText) { | |
| if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32W) | |
| toolPtr->lpszText = LPSTR_TEXTCALLBACK32W; | |
| else { | |
| if (toolPtr->lpszText) { | |
| COMCTL32_Free (toolPtr->lpszText); | |
| toolPtr->lpszText = NULL; | |
| } | |
| if (lpToolInfo->lpszText) { | |
| INT32 len = lstrlen32W (lpToolInfo->lpszText); | |
| toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR)); | |
| lstrcpy32W (toolPtr->lpszText, lpToolInfo->lpszText); | |
| } | |
| } | |
| } | |
| if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32W)) | |
| toolPtr->lParam = lpToolInfo->lParam; | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_TrackActivate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return FALSE; | |
| if ((BOOL32)wParam) { | |
| /* activate */ | |
| infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo); | |
| if (infoPtr->nTrackTool != -1) { | |
| TRACE (tooltips, "activated!\n"); | |
| infoPtr->bTrackActive = TRUE; | |
| TOOLTIPS_TrackShow (wndPtr, infoPtr); | |
| } | |
| } | |
| else { | |
| /* deactivate */ | |
| TOOLTIPS_TrackHide (wndPtr, infoPtr); | |
| infoPtr->bTrackActive = FALSE; | |
| infoPtr->nTrackTool = -1; | |
| TRACE (tooltips, "deactivated!\n"); | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_TrackPosition (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| infoPtr->xTrackPos = (INT32)LOWORD(lParam); | |
| infoPtr->yTrackPos = (INT32)HIWORD(lParam); | |
| if (infoPtr->bTrackActive) { | |
| TRACE (tooltips, "[%d %d]\n", | |
| infoPtr->xTrackPos, infoPtr->yTrackPos); | |
| TOOLTIPS_TrackShow (wndPtr, infoPtr); | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_Update (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| if (infoPtr->nCurrentTool != -1) | |
| UpdateWindow32 (wndPtr->hwndSelf); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_UpdateTipText32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32A) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo); | |
| if (nTool == -1) return 0; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| toolPtr = &infoPtr->tools[nTool]; | |
| /* copy tool text */ | |
| toolPtr->hinst = lpToolInfo->hinst; | |
| if ((lpToolInfo->hinst) && (HIWORD((INT32)lpToolInfo->lpszText) == 0)){ | |
| toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText; | |
| } | |
| else if (lpToolInfo->lpszText) { | |
| if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32A) | |
| toolPtr->lpszText = LPSTR_TEXTCALLBACK32W; | |
| else { | |
| if (toolPtr->lpszText) { | |
| COMCTL32_Free (toolPtr->lpszText); | |
| toolPtr->lpszText = NULL; | |
| } | |
| if (lpToolInfo->lpszText) { | |
| INT32 len = lstrlen32A (lpToolInfo->lpszText); | |
| toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR)); | |
| lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText); | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_UpdateTipText32W (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| LPTTTOOLINFO32W lpToolInfo = (LPTTTOOLINFO32W)lParam; | |
| TTTOOL_INFO *toolPtr; | |
| INT32 nTool; | |
| if (lpToolInfo == NULL) | |
| return 0; | |
| if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZE32W) | |
| return FALSE; | |
| nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo); | |
| if (nTool == -1) | |
| return 0; | |
| TRACE (tooltips, "tool %d\n", nTool); | |
| toolPtr = &infoPtr->tools[nTool]; | |
| /* copy tool text */ | |
| toolPtr->hinst = lpToolInfo->hinst; | |
| if ((lpToolInfo->hinst) && (HIWORD((INT32)lpToolInfo->lpszText) == 0)){ | |
| toolPtr->lpszText = lpToolInfo->lpszText; | |
| } | |
| else if (lpToolInfo->lpszText) { | |
| if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32W) | |
| toolPtr->lpszText = LPSTR_TEXTCALLBACK32W; | |
| else { | |
| if (toolPtr->lpszText) { | |
| COMCTL32_Free (toolPtr->lpszText); | |
| toolPtr->lpszText = NULL; | |
| } | |
| if (lpToolInfo->lpszText) { | |
| INT32 len = lstrlen32W (lpToolInfo->lpszText); | |
| toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR)); | |
| lstrcpy32W (toolPtr->lpszText, lpToolInfo->lpszText); | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_WindowFromPoint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| return WindowFromPoint32 (*((LPPOINT32)lParam)); | |
| } | |
| static LRESULT | |
| TOOLTIPS_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr; | |
| NONCLIENTMETRICS32A nclm; | |
| INT32 nResult; | |
| /* allocate memory for info structure */ | |
| infoPtr = (TOOLTIPS_INFO *)COMCTL32_Alloc (sizeof(TOOLTIPS_INFO)); | |
| wndPtr->wExtra[0] = (DWORD)infoPtr; | |
| if (infoPtr == NULL) { | |
| ERR (tooltips, "could not allocate info memory!\n"); | |
| return 0; | |
| } | |
| /* initialize info structure */ | |
| infoPtr->bActive = TRUE; | |
| infoPtr->bTrackActive = FALSE; | |
| infoPtr->clrBk = GetSysColor32 (COLOR_INFOBK); | |
| infoPtr->clrText = GetSysColor32 (COLOR_INFOTEXT); | |
| nclm.cbSize = sizeof(NONCLIENTMETRICS32A); | |
| SystemParametersInfo32A (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0); | |
| infoPtr->hFont = CreateFontIndirect32A (&nclm.lfStatusFont); | |
| infoPtr->nMaxTipWidth = -1; | |
| infoPtr->nTool = -1; | |
| infoPtr->nOldTool = -1; | |
| infoPtr->nCurrentTool = -1; | |
| infoPtr->nTrackTool = -1; | |
| infoPtr->nAutomaticTime = 500; | |
| infoPtr->nReshowTime = 100; | |
| infoPtr->nAutoPopTime = 5000; | |
| infoPtr->nInitialTime = 500; | |
| nResult = | |
| (INT32) SendMessage32A (wndPtr->parent->hwndSelf, WM_NOTIFYFORMAT, | |
| (WPARAM32)wndPtr->hwndSelf, (LPARAM)NF_QUERY); | |
| if (nResult == NFR_ANSI) | |
| FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: NFR_ANSI\n"); | |
| else if (nResult == NFR_UNICODE) | |
| FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: NFR_UNICODE\n"); | |
| else | |
| FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: error!\n"); | |
| SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, 0, 0, 0, 0, | |
| SWP_NOZORDER | SWP_HIDEWINDOW); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| TTTOOL_INFO *toolPtr; | |
| INT32 i; | |
| /* free tools */ | |
| if (infoPtr->tools) { | |
| for (i = 0; i < infoPtr->uNumTools; i++) { | |
| toolPtr = &infoPtr->tools[i]; | |
| if ((toolPtr->hinst) && (toolPtr->lpszText)) { | |
| if (toolPtr->lpszText != LPSTR_TEXTCALLBACK32W) | |
| COMCTL32_Free (toolPtr->lpszText); | |
| } | |
| /* remove subclassing */ | |
| if (toolPtr->uFlags & TTF_SUBCLASS) { | |
| LPTT_SUBCLASS_INFO lpttsi; | |
| if (toolPtr->uFlags & TTF_IDISHWND) | |
| lpttsi = (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| else | |
| lpttsi = (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, COMCTL32_aSubclass); | |
| if (lpttsi) { | |
| SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC, | |
| (LONG)lpttsi->wpOrigProc); | |
| RemoveProp32A ((HWND32)toolPtr->uId, COMCTL32_aSubclass); | |
| COMCTL32_Free (&lpttsi); | |
| } | |
| } | |
| } | |
| COMCTL32_Free (infoPtr->tools); | |
| } | |
| /* delete font */ | |
| DeleteObject32 (infoPtr->hFont); | |
| /* free tool tips info data */ | |
| COMCTL32_Free (infoPtr); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_EraseBackground (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| RECT32 rect; | |
| HBRUSH32 hBrush; | |
| hBrush = CreateSolidBrush32 (infoPtr->clrBk); | |
| GetClientRect32 (wndPtr->hwndSelf, &rect); | |
| FillRect32 ((HDC32)wParam, &rect, hBrush); | |
| DeleteObject32 (hBrush); | |
| return FALSE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_GetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| return infoPtr->hFont; | |
| } | |
| static LRESULT | |
| TOOLTIPS_MouseMessage (WND *wndPtr, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_NCCreate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| wndPtr->dwStyle &= 0x0000FFFF; | |
| wndPtr->dwStyle |= (WS_POPUP | WS_BORDER | WS_CLIPSIBLINGS); | |
| return TRUE; | |
| } | |
| static LRESULT | |
| TOOLTIPS_NCHitTest (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| INT32 nTool = (infoPtr->bTrackActive) ? infoPtr->nTrackTool : infoPtr->nTool; | |
| TRACE (tooltips, " nTool=%d\n", nTool); | |
| if ((nTool > -1) && (nTool < infoPtr->uNumTools)) { | |
| if (infoPtr->tools[nTool].uFlags & TTF_TRANSPARENT) { | |
| TRACE (tooltips, "-- in transparent mode!\n"); | |
| return HTTRANSPARENT; | |
| } | |
| } | |
| return DefWindowProc32A (wndPtr->hwndSelf, WM_NCHITTEST, wParam, lParam); | |
| } | |
| static LRESULT | |
| TOOLTIPS_Paint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| HDC32 hdc; | |
| PAINTSTRUCT32 ps; | |
| hdc = (wParam == 0) ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam; | |
| TOOLTIPS_Refresh (wndPtr, hdc); | |
| if (!wParam) | |
| EndPaint32 (wndPtr->hwndSelf, &ps); | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_SetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| infoPtr->hFont = (HFONT32)wParam; | |
| if ((LOWORD(lParam)) & (infoPtr->nCurrentTool != -1)) { | |
| FIXME (tooltips, "full redraw needed!\n"); | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_Timer (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| TRACE (tooltips, "timer %d (%x) expired!\n", wParam, wndPtr->hwndSelf); | |
| switch (wParam) | |
| { | |
| case ID_TIMERSHOW: | |
| KillTimer32 (wndPtr->hwndSelf, ID_TIMERSHOW); | |
| if (TOOLTIPS_CheckTool (wndPtr, TRUE) == infoPtr->nTool) | |
| TOOLTIPS_Show (wndPtr, infoPtr); | |
| break; | |
| case ID_TIMERPOP: | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| break; | |
| case ID_TIMERLEAVE: | |
| KillTimer32 (wndPtr->hwndSelf, ID_TIMERLEAVE); | |
| if (TOOLTIPS_CheckTool (wndPtr, FALSE) == -1) { | |
| infoPtr->nTool = -1; | |
| infoPtr->nOldTool = -1; | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| } | |
| break; | |
| } | |
| return 0; | |
| } | |
| static LRESULT | |
| TOOLTIPS_WinIniChange (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| NONCLIENTMETRICS32A nclm; | |
| infoPtr->clrBk = GetSysColor32 (COLOR_INFOBK); | |
| infoPtr->clrText = GetSysColor32 (COLOR_INFOTEXT); | |
| DeleteObject32 (infoPtr->hFont); | |
| nclm.cbSize = sizeof(NONCLIENTMETRICS32A); | |
| SystemParametersInfo32A (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0); | |
| infoPtr->hFont = CreateFontIndirect32A (&nclm.lfStatusFont); | |
| return 0; | |
| } | |
| LRESULT CALLBACK | |
| TOOLTIPS_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| LPTT_SUBCLASS_INFO lpttsi = | |
| (LPTT_SUBCLASS_INFO)GetProp32A (hwnd, COMCTL32_aSubclass); | |
| WND *wndPtr; | |
| TOOLTIPS_INFO *infoPtr; | |
| UINT32 nTool; | |
| switch (uMsg) { | |
| case WM_LBUTTONDOWN: | |
| case WM_LBUTTONUP: | |
| case WM_MBUTTONDOWN: | |
| case WM_MBUTTONUP: | |
| case WM_RBUTTONDOWN: | |
| case WM_RBUTTONUP: | |
| { | |
| wndPtr = WIN_FindWndPtr(lpttsi->hwndToolTip); | |
| infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd); | |
| TRACE (tooltips, "subclassed mouse message %04x\n", uMsg); | |
| infoPtr->nOldTool = infoPtr->nTool; | |
| infoPtr->nTool = nTool; | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| } | |
| break; | |
| case WM_MOUSEMOVE: | |
| { | |
| wndPtr = WIN_FindWndPtr(lpttsi->hwndToolTip); | |
| infoPtr = TOOLTIPS_GetInfoPtr(wndPtr); | |
| nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd); | |
| TRACE (tooltips, "subclassed WM_MOUSEMOVE\n"); | |
| infoPtr->nOldTool = infoPtr->nTool; | |
| infoPtr->nTool = nTool; | |
| if ((infoPtr->bActive) && | |
| (infoPtr->nTool != infoPtr->nOldTool)) { | |
| if (infoPtr->nOldTool == -1) { | |
| SetTimer32 (wndPtr->hwndSelf, ID_TIMERSHOW, | |
| infoPtr->nInitialTime, 0); | |
| TRACE (tooltips, "timer 1 started!\n"); | |
| } | |
| else { | |
| TOOLTIPS_Hide (wndPtr, infoPtr); | |
| SetTimer32 (wndPtr->hwndSelf, ID_TIMERSHOW, | |
| infoPtr->nReshowTime, 0); | |
| TRACE (tooltips, "timer 2 started!\n"); | |
| } | |
| } | |
| if (infoPtr->nCurrentTool != -1) { | |
| SetTimer32 (wndPtr->hwndSelf, ID_TIMERLEAVE, 100, 0); | |
| TRACE (tooltips, "timer 3 started!\n"); | |
| } | |
| } | |
| break; | |
| } | |
| return CallWindowProc32A (lpttsi->wpOrigProc, hwnd, uMsg, wParam, lParam); | |
| } | |
| LRESULT CALLBACK | |
| TOOLTIPS_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam) | |
| { | |
| WND *wndPtr = WIN_FindWndPtr(hwnd); | |
| switch (uMsg) | |
| { | |
| case TTM_ACTIVATE: | |
| return TOOLTIPS_Activate (wndPtr, wParam, lParam); | |
| case TTM_ADDTOOL32A: | |
| return TOOLTIPS_AddTool32A (wndPtr, wParam, lParam); | |
| case TTM_ADDTOOL32W: | |
| return TOOLTIPS_AddTool32W (wndPtr, wParam, lParam); | |
| case TTM_DELTOOL32A: | |
| return TOOLTIPS_DelTool32A (wndPtr, wParam, lParam); | |
| case TTM_DELTOOL32W: | |
| return TOOLTIPS_DelTool32W (wndPtr, wParam, lParam); | |
| case TTM_ENUMTOOLS32A: | |
| return TOOLTIPS_EnumTools32A (wndPtr, wParam, lParam); | |
| case TTM_ENUMTOOLS32W: | |
| return TOOLTIPS_EnumTools32W (wndPtr, wParam, lParam); | |
| case TTM_GETCURRENTTOOL32A: | |
| return TOOLTIPS_GetCurrentTool32A (wndPtr, wParam, lParam); | |
| case TTM_GETCURRENTTOOL32W: | |
| return TOOLTIPS_GetCurrentTool32W (wndPtr, wParam, lParam); | |
| case TTM_GETDELAYTIME: | |
| return TOOLTIPS_GetDelayTime (wndPtr, wParam, lParam); | |
| case TTM_GETMARGIN: | |
| return TOOLTIPS_GetMargin (wndPtr, wParam, lParam); | |
| case TTM_GETMAXTIPWIDTH: | |
| return TOOLTIPS_GetMaxTipWidth (wndPtr, wParam, lParam); | |
| case TTM_GETTEXT32A: | |
| return TOOLTIPS_GetText32A (wndPtr, wParam, lParam); | |
| case TTM_GETTEXT32W: | |
| return TOOLTIPS_GetText32W (wndPtr, wParam, lParam); | |
| case TTM_GETTIPBKCOLOR: | |
| return TOOLTIPS_GetTipBkColor (wndPtr, wParam, lParam); | |
| case TTM_GETTIPTEXTCOLOR: | |
| return TOOLTIPS_GetTipTextColor (wndPtr, wParam, lParam); | |
| case TTM_GETTOOLCOUNT: | |
| return TOOLTIPS_GetToolCount (wndPtr, wParam, lParam); | |
| case TTM_GETTOOLINFO32A: | |
| return TOOLTIPS_GetToolInfo32A (wndPtr, wParam, lParam); | |
| case TTM_GETTOOLINFO32W: | |
| return TOOLTIPS_GetToolInfo32W (wndPtr, wParam, lParam); | |
| case TTM_HITTEST32A: | |
| return TOOLTIPS_HitTest32A (wndPtr, wParam, lParam); | |
| case TTM_HITTEST32W: | |
| return TOOLTIPS_HitTest32W (wndPtr, wParam, lParam); | |
| case TTM_NEWTOOLRECT32A: | |
| return TOOLTIPS_NewToolRect32A (wndPtr, wParam, lParam); | |
| case TTM_NEWTOOLRECT32W: | |
| return TOOLTIPS_NewToolRect32W (wndPtr, wParam, lParam); | |
| case TTM_POP: | |
| return TOOLTIPS_Pop (wndPtr, wParam, lParam); | |
| case TTM_RELAYEVENT: | |
| return TOOLTIPS_RelayEvent (wndPtr, wParam, lParam); | |
| case TTM_SETDELAYTIME: | |
| return TOOLTIPS_SetDelayTime (wndPtr, wParam, lParam); | |
| case TTM_SETMARGIN: | |
| return TOOLTIPS_SetMargin (wndPtr, wParam, lParam); | |
| case TTM_SETMAXTIPWIDTH: | |
| return TOOLTIPS_SetMaxTipWidth (wndPtr, wParam, lParam); | |
| case TTM_SETTIPBKCOLOR: | |
| return TOOLTIPS_SetTipBkColor (wndPtr, wParam, lParam); | |
| case TTM_SETTIPTEXTCOLOR: | |
| return TOOLTIPS_SetTipTextColor (wndPtr, wParam, lParam); | |
| case TTM_SETTOOLINFO32A: | |
| return TOOLTIPS_SetToolInfo32A (wndPtr, wParam, lParam); | |
| case TTM_SETTOOLINFO32W: | |
| return TOOLTIPS_SetToolInfo32W (wndPtr, wParam, lParam); | |
| case TTM_TRACKACTIVATE: | |
| return TOOLTIPS_TrackActivate (wndPtr, wParam, lParam); | |
| case TTM_TRACKPOSITION: | |
| return TOOLTIPS_TrackPosition (wndPtr, wParam, lParam); | |
| case TTM_UPDATE: | |
| return TOOLTIPS_Update (wndPtr, wParam, lParam); | |
| case TTM_UPDATETIPTEXT32A: | |
| return TOOLTIPS_UpdateTipText32A (wndPtr, wParam, lParam); | |
| case TTM_UPDATETIPTEXT32W: | |
| return TOOLTIPS_UpdateTipText32W (wndPtr, wParam, lParam); | |
| case TTM_WINDOWFROMPOINT: | |
| return TOOLTIPS_WindowFromPoint (wndPtr, wParam, lParam); | |
| case WM_CREATE: | |
| return TOOLTIPS_Create (wndPtr, wParam, lParam); | |
| case WM_DESTROY: | |
| return TOOLTIPS_Destroy (wndPtr, wParam, lParam); | |
| case WM_ERASEBKGND: | |
| return TOOLTIPS_EraseBackground (wndPtr, wParam, lParam); | |
| case WM_GETFONT: | |
| return TOOLTIPS_GetFont (wndPtr, wParam, lParam); | |
| case WM_LBUTTONDOWN: | |
| case WM_LBUTTONUP: | |
| case WM_MBUTTONDOWN: | |
| case WM_MBUTTONUP: | |
| case WM_RBUTTONDOWN: | |
| case WM_RBUTTONUP: | |
| case WM_MOUSEMOVE: | |
| return TOOLTIPS_MouseMessage (wndPtr, uMsg, wParam, lParam); | |
| case WM_NCCREATE: | |
| return TOOLTIPS_NCCreate (wndPtr, wParam, lParam); | |
| case WM_NCHITTEST: | |
| return TOOLTIPS_NCHitTest (wndPtr, wParam, lParam); | |
| /* case WM_NOTIFYFORMAT: */ | |
| /* return TOOLTIPS_NotifyFormat (wndPtr, wParam, lParam); */ | |
| case WM_PAINT: | |
| return TOOLTIPS_Paint (wndPtr, wParam, lParam); | |
| case WM_SETFONT: | |
| return TOOLTIPS_SetFont (wndPtr, wParam, lParam); | |
| case WM_TIMER: | |
| return TOOLTIPS_Timer (wndPtr, wParam, lParam); | |
| case WM_WININICHANGE: | |
| return TOOLTIPS_WinIniChange (wndPtr, wParam, lParam); | |
| default: | |
| if (uMsg >= WM_USER) | |
| ERR (tooltips, "unknown msg %04x wp=%08x lp=%08lx\n", | |
| uMsg, wParam, lParam); | |
| return DefWindowProc32A (hwnd, uMsg, wParam, lParam); | |
| } | |
| return 0; | |
| } | |
| VOID | |
| TOOLTIPS_Register (VOID) | |
| { | |
| WNDCLASS32A wndClass; | |
| if (GlobalFindAtom32A (TOOLTIPS_CLASS32A)) return; | |
| ZeroMemory (&wndClass, sizeof(WNDCLASS32A)); | |
| wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS | CS_SAVEBITS; | |
| wndClass.lpfnWndProc = (WNDPROC32)TOOLTIPS_WindowProc; | |
| wndClass.cbClsExtra = 0; | |
| wndClass.cbWndExtra = sizeof(TOOLTIPS_INFO *); | |
| wndClass.hCursor = LoadCursor32A (0, IDC_ARROW32A); | |
| wndClass.hbrBackground = 0; | |
| wndClass.lpszClassName = TOOLTIPS_CLASS32A; | |
| RegisterClass32A (&wndClass); | |
| } | |
| VOID | |
| TOOLTIPS_Unregister (VOID) | |
| { | |
| if (GlobalFindAtom32A (TOOLTIPS_CLASS32A)) | |
| UnregisterClass32A (TOOLTIPS_CLASS32A, (HINSTANCE32)NULL); | |
| } | |