?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comctl32: Add support for retrieving lpszText in TOOLINFO structure.
[wine/multimedia.git] / dlls / comctl32 / tooltips.c
blob1d758b4e4981008f8c43288faaded831b3a7ee6f
1 /*
2 * Tool tip control
3 *
4 * Copyright 1998, 1999 Eric Kohl
5 * Copyright 2004 Robert Shearman
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * NOTES
22 *
23 * This code was audited for completeness against the documented features
24 * of Comctl32.dll version 6.0 on Sep. 08, 2004, by Robert Shearman.
25 *
26 * Unless otherwise noted, we believe this code to be complete, as per
27 * the specification mentioned above.
28 * If you discover missing features or bugs please note them below.
29 *
30 * TODO:
31 * - Custom draw support.
32 * - Animation.
33 * - Links.
34 * - Messages:
35 * o TTM_ADJUSTRECT
36 * o TTM_GETTITLEA
37 * o TTM_GETTTILEW
38 * o TTM_POPUP
39 * - Styles:
40 * o TTS_NOANIMATE
41 * o TTS_NOFADE
42 * o TTS_CLOSE
43 *
44 * Testing:
45 * - Run tests using Waite Group Windows95 API Bible Volume 2.
46 * The second cdrom (chapter 3) contains executables activate.exe,
47 * curtool.exe, deltool.exe, enumtools.exe, getinfo.exe, getiptxt.exe,
48 * hittest.exe, needtext.exe, newrect.exe, updtext.exe and winfrpt.exe.
49 *
50 * Timer logic.
51 *
52 * One important point to remember is that tools don't necessarily get
53 * a WM_MOUSEMOVE once the cursor leaves the tool, an example is when
54 * a tool sets TTF_IDISHWND (i.e. an entire window is a tool) because
55 * here WM_MOUSEMOVEs only get sent when the cursor is inside the
56 * client area. Therefore the only reliable way to know that the
57 * cursor has left a tool is to keep a timer running and check the
58 * position every time it expires. This is the role of timer
59 * ID_TIMERLEAVE.
60 *
61 *
62 * On entering a tool (detected in a relayed WM_MOUSEMOVE) we start
63 * ID_TIMERSHOW, if this times out and we're still in the tool we show
64 * the tip. On showing a tip we start both ID_TIMERPOP and
65 * ID_TIMERLEAVE. On hiding a tooltip we kill ID_TIMERPOP.
66 * ID_TIMERPOP is restarted on every relayed WM_MOUSEMOVE. If
67 * ID_TIMERPOP expires the tool is hidden and ID_TIMERPOP is killed.
68 * ID_TIMERLEAVE remains running - this is important as we need to
69 * determine when the cursor leaves the tool.
70 *
71 * When ID_TIMERLEAVE expires or on a relayed WM_MOUSEMOVE if we're
72 * still in the tool do nothing (apart from restart ID_TIMERPOP if
73 * this is a WM_MOUSEMOVE) (ID_TIMERLEAVE remains running). If we've
74 * left the tool and entered another one then hide the tip and start
75 * ID_TIMERSHOW with time ReshowTime and kill ID_TIMERLEAVE. If we're
76 * outside all tools hide the tip and kill ID_TIMERLEAVE. On Relayed
77 * mouse button messages hide the tip but leave ID_TIMERLEAVE running,
78 * this again will let us keep track of when the cursor leaves the
79 * tool.
80 *
81 *
82 * infoPtr->nTool is the tool the mouse was on on the last relayed MM
83 * or timer expiry or -1 if the mouse was not on a tool.
84 *
85 * infoPtr->nCurrentTool is the tool for which the tip is currently
86 * displaying text for or -1 if the tip is not shown. Actually this
87 * will only ever be infoPtr-nTool or -1, so it could be changed to a
88 * BOOL.
89 *
90 */
91
92
93
94 #include <stdarg.h>
95 #include <string.h>
96
97 #include "windef.h"
98 #include "winbase.h"
99 #include "wine/unicode.h"
100 #include "wingdi.h"
101 #include "winuser.h"
102 #include "winnls.h"
103 #include "commctrl.h"
104 #include "comctl32.h"
105 #include "wine/debug.h"
106
107 WINE_DEFAULT_DEBUG_CHANNEL(tooltips);
108
109 static HICON hTooltipIcons[TTI_ERROR+1];
110
111 typedef struct
112 {
113 UINT uFlags;
114 HWND hwnd;
115 BOOL bNotifyUnicode;
116 UINT_PTR uId;
117 RECT rect;
118 HINSTANCE hinst;
119 LPWSTR lpszText;
120 LPARAM lParam;
121 } TTTOOL_INFO;
122
123
124 typedef struct
125 {
126 HWND hwndSelf;
127 WCHAR szTipText[INFOTIPSIZE];
128 BOOL bActive;
129 BOOL bTrackActive;
130 UINT uNumTools;
131 COLORREF clrBk;
132 COLORREF clrText;
133 HFONT hFont;
134 HFONT hTitleFont;
135 INT xTrackPos;
136 INT yTrackPos;
137 INT nMaxTipWidth;
138 INT nTool; /* tool that mouse was on on last relayed mouse move */
139 INT nCurrentTool;
140 INT nTrackTool;
141 INT nReshowTime;
142 INT nAutoPopTime;
143 INT nInitialTime;
144 RECT rcMargin;
145 BOOL bToolBelow;
146 LPWSTR pszTitle;
147 HICON hTitleIcon;
148
149 TTTOOL_INFO *tools;
150 } TOOLTIPS_INFO;
151
152 #define ID_TIMERSHOW 1 /* show delay timer */
153 #define ID_TIMERPOP 2 /* auto pop timer */
154 #define ID_TIMERLEAVE 3 /* tool leave timer */
155
156
157 #define TOOLTIPS_GetInfoPtr(hWindow) ((TOOLTIPS_INFO *)GetWindowLongPtrW (hWindow, 0))
158
159 /* offsets from window edge to start of text */
160 #define NORMAL_TEXT_MARGIN 2
161 #define BALLOON_TEXT_MARGIN (NORMAL_TEXT_MARGIN+8)
162 /* value used for CreateRoundRectRgn that specifies how much
163 * each corner is curved */
164 #define BALLOON_ROUNDEDNESS 20
165 #define BALLOON_STEMHEIGHT 13
166 #define BALLOON_STEMWIDTH 10
167 #define BALLOON_STEMINDENT 20
168
169 #define BALLOON_ICON_TITLE_SPACING 8 /* horizontal spacing between icon and title */
170 #define BALLOON_TITLE_TEXT_SPACING 8 /* vertical spacing between icon/title and main text */
171 #define ICON_HEIGHT 16
172 #define ICON_WIDTH 16
173
174 static LRESULT CALLBACK
175 TOOLTIPS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uId, DWORD_PTR dwRef);
176
177
178 static inline BOOL TOOLTIPS_IsCallbackString(LPCWSTR str, BOOL isW)
179 {
180 if (isW)
181 return str == LPSTR_TEXTCALLBACKW;
182 else
183 return (LPCSTR)str == LPSTR_TEXTCALLBACKA;
184 }
185
186 static inline UINT_PTR
187 TOOLTIPS_GetTitleIconIndex(HICON hIcon)
188 {
189 UINT i;
190 for (i = 0; i <= TTI_ERROR; i++)
191 if (hTooltipIcons[i] == hIcon)
192 return i;
193 return (UINT_PTR)hIcon;
194 }
195
196 static void
197 TOOLTIPS_InitSystemSettings (TOOLTIPS_INFO *infoPtr)
198 {
199 NONCLIENTMETRICSW nclm;
200
201 infoPtr->clrBk = comctl32_color.clrInfoBk;
202 infoPtr->clrText = comctl32_color.clrInfoText;
203
204 DeleteObject (infoPtr->hFont);
205 nclm.cbSize = sizeof(nclm);
206 SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, sizeof(nclm), &nclm, 0);
207 infoPtr->hFont = CreateFontIndirectW (&nclm.lfStatusFont);
208
209 DeleteObject (infoPtr->hTitleFont);
210 nclm.lfStatusFont.lfWeight = FW_BOLD;
211 infoPtr->hTitleFont = CreateFontIndirectW (&nclm.lfStatusFont);
212 }
213
214 /* Custom draw routines */
215 static void
216 TOOLTIPS_customdraw_fill(const TOOLTIPS_INFO *infoPtr, NMTTCUSTOMDRAW *lpnmttcd,
217 HDC hdc, const RECT *rcBounds, UINT uFlags)
218 {
219 ZeroMemory(lpnmttcd, sizeof(NMTTCUSTOMDRAW));
220 lpnmttcd->uDrawFlags = uFlags;
221 lpnmttcd->nmcd.hdr.hwndFrom = infoPtr->hwndSelf;
222 lpnmttcd->nmcd.hdr.code = NM_CUSTOMDRAW;
223 if (infoPtr->nCurrentTool != -1) {
224 TTTOOL_INFO *toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
225 lpnmttcd->nmcd.hdr.idFrom = toolPtr->uId;
226 }
227 lpnmttcd->nmcd.hdc = hdc;
228 lpnmttcd->nmcd.rc = *rcBounds;
229 /* FIXME - dwItemSpec, uItemState, lItemlParam */
230 }
231
232 static inline DWORD
233 TOOLTIPS_notify_customdraw (DWORD dwDrawStage, NMTTCUSTOMDRAW *lpnmttcd)
234 {
235 LRESULT result = CDRF_DODEFAULT;
236 lpnmttcd->nmcd.dwDrawStage = dwDrawStage;
237
238 TRACE("Notifying stage %d, flags %x, id %x\n", lpnmttcd->nmcd.dwDrawStage,
239 lpnmttcd->uDrawFlags, lpnmttcd->nmcd.hdr.code);
240
241 result = SendMessageW(GetParent(lpnmttcd->nmcd.hdr.hwndFrom), WM_NOTIFY,
242 0, (LPARAM)lpnmttcd);
243
244 TRACE("Notify result %x\n", (unsigned int)result);
245
246 return result;
247 }
248
249 static void
250 TOOLTIPS_Refresh (const TOOLTIPS_INFO *infoPtr, HDC hdc)
251 {
252 RECT rc;
253 INT oldBkMode;
254 HFONT hOldFont;
255 HBRUSH hBrush;
256 UINT uFlags = DT_EXTERNALLEADING;
257 HRGN hRgn = NULL;
258 DWORD dwStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
259 NMTTCUSTOMDRAW nmttcd;
260 DWORD cdmode;
261
262 if (infoPtr->nMaxTipWidth > -1)
263 uFlags |= DT_WORDBREAK;
264 if (GetWindowLongW (infoPtr->hwndSelf, GWL_STYLE) & TTS_NOPREFIX)
265 uFlags |= DT_NOPREFIX;
266 GetClientRect (infoPtr->hwndSelf, &rc);
267
268 hBrush = CreateSolidBrush(infoPtr->clrBk);
269
270 oldBkMode = SetBkMode (hdc, TRANSPARENT);
271 SetTextColor (hdc, infoPtr->clrText);
272 hOldFont = SelectObject (hdc, infoPtr->hFont);
273
274 /* Custom draw - Call PrePaint once initial properties set up */
275 /* Note: Contrary to MSDN, CDRF_SKIPDEFAULT still draws a tooltip */
276 TOOLTIPS_customdraw_fill(infoPtr, &nmttcd, hdc, &rc, uFlags);
277 cdmode = TOOLTIPS_notify_customdraw(CDDS_PREPAINT, &nmttcd);
278 uFlags = nmttcd.uDrawFlags;
279
280 if (dwStyle & TTS_BALLOON)
281 {
282 /* create a region to store result into */
283 hRgn = CreateRectRgn(0, 0, 0, 0);
284
285 GetWindowRgn(infoPtr->hwndSelf, hRgn);
286
287 /* fill the background */
288 FillRgn(hdc, hRgn, hBrush);
289 DeleteObject(hBrush);
290 hBrush = NULL;
291 }
292 else
293 {
294 /* fill the background */
295 FillRect(hdc, &rc, hBrush);
296 DeleteObject(hBrush);
297 hBrush = NULL;
298 }
299
300 if ((dwStyle & TTS_BALLOON) || infoPtr->pszTitle)
301 {
302 /* calculate text rectangle */
303 rc.left += (BALLOON_TEXT_MARGIN + infoPtr->rcMargin.left);
304 rc.top += (BALLOON_TEXT_MARGIN + infoPtr->rcMargin.top);
305 rc.right -= (BALLOON_TEXT_MARGIN + infoPtr->rcMargin.right);
306 rc.bottom -= (BALLOON_TEXT_MARGIN + infoPtr->rcMargin.bottom);
307 if(infoPtr->bToolBelow) rc.top += BALLOON_STEMHEIGHT;
308
309 if (infoPtr->pszTitle)
310 {
311 RECT rcTitle = {rc.left, rc.top, rc.right, rc.bottom};
312 int height;
313 BOOL icon_present;
314 HFONT prevFont;
315
316 /* draw icon */
317 icon_present = infoPtr->hTitleIcon &&
318 DrawIconEx(hdc, rc.left, rc.top, infoPtr->hTitleIcon,
319 ICON_WIDTH, ICON_HEIGHT, 0, NULL, DI_NORMAL);
320 if (icon_present)
321 rcTitle.left += ICON_WIDTH + BALLOON_ICON_TITLE_SPACING;
322
323 rcTitle.bottom = rc.top + ICON_HEIGHT;
324
325 /* draw title text */
326 prevFont = SelectObject (hdc, infoPtr->hTitleFont);
327 height = DrawTextW(hdc, infoPtr->pszTitle, -1, &rcTitle, DT_BOTTOM | DT_SINGLELINE | DT_NOPREFIX);
328 SelectObject (hdc, prevFont);
329 rc.top += height + BALLOON_TITLE_TEXT_SPACING;
330 }
331 }
332 else
333 {
334 /* calculate text rectangle */
335 rc.left += (NORMAL_TEXT_MARGIN + infoPtr->rcMargin.left);
336 rc.top += (NORMAL_TEXT_MARGIN + infoPtr->rcMargin.top);
337 rc.right -= (NORMAL_TEXT_MARGIN + infoPtr->rcMargin.right);
338 rc.bottom -= (NORMAL_TEXT_MARGIN + infoPtr->rcMargin.bottom);
339 }
340
341 /* draw text */
342 DrawTextW (hdc, infoPtr->szTipText, -1, &rc, uFlags);
343
344 /* Custom draw - Call PostPaint after drawing */
345 if (cdmode & CDRF_NOTIFYPOSTPAINT) {
346 TOOLTIPS_notify_customdraw(CDDS_POSTPAINT, &nmttcd);
347 }
348
349 /* be polite and reset the things we changed in the dc */
350 SelectObject (hdc, hOldFont);
351 SetBkMode (hdc, oldBkMode);
352
353 if (dwStyle & TTS_BALLOON)
354 {
355 /* frame region because default window proc doesn't do it */
356 INT width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
357 INT height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
358
359 hBrush = GetSysColorBrush(COLOR_WINDOWFRAME);
360 FrameRgn(hdc, hRgn, hBrush, width, height);
361 }
362
363 if (hRgn)
364 DeleteObject(hRgn);
365 }
366
367 static void TOOLTIPS_GetDispInfoA(const TOOLTIPS_INFO *infoPtr, TTTOOL_INFO *toolPtr, WCHAR *buffer)
368 {
369 NMTTDISPINFOA ttnmdi;
370
371 /* fill NMHDR struct */
372 ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFOA));
373 ttnmdi.hdr.hwndFrom = infoPtr->hwndSelf;
374 ttnmdi.hdr.idFrom = toolPtr->uId;
375 ttnmdi.hdr.code = TTN_GETDISPINFOA; /* == TTN_NEEDTEXTA */
376 ttnmdi.lpszText = ttnmdi.szText;
377 ttnmdi.uFlags = toolPtr->uFlags;
378 ttnmdi.lParam = toolPtr->lParam;
379
380 TRACE("hdr.idFrom = %lx\n", ttnmdi.hdr.idFrom);
381 SendMessageW(toolPtr->hwnd, WM_NOTIFY, toolPtr->uId, (LPARAM)&ttnmdi);
382
383 if (IS_INTRESOURCE(ttnmdi.lpszText)) {
384 LoadStringW(ttnmdi.hinst, LOWORD(ttnmdi.lpszText),
385 buffer, INFOTIPSIZE);
386 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
387 toolPtr->hinst = ttnmdi.hinst;
388 toolPtr->lpszText = (LPWSTR)ttnmdi.lpszText;
389 }
390 }
391 else if (ttnmdi.lpszText == 0) {
392 buffer[0] = '\0';
393 }
394 else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA) {
395 Str_GetPtrAtoW(ttnmdi.lpszText, buffer, INFOTIPSIZE);
396 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
397 toolPtr->hinst = 0;
398 toolPtr->lpszText = NULL;
399 Str_SetPtrW(&toolPtr->lpszText, buffer);
400 }
401 }
402 else {
403 ERR("recursive text callback!\n");
404 buffer[0] = '\0';
405 }
406
407 /* no text available - try calling parent instead as per native */
408 /* FIXME: Unsure if SETITEM should save the value or not */
409 if (buffer[0] == 0x00) {
410
411 SendMessageW(GetParent(toolPtr->hwnd), WM_NOTIFY, toolPtr->uId, (LPARAM)&ttnmdi);
412
413 if (IS_INTRESOURCE(ttnmdi.lpszText)) {
414 LoadStringW(ttnmdi.hinst, LOWORD(ttnmdi.lpszText),
415 buffer, INFOTIPSIZE);
416 } else if (ttnmdi.lpszText &&
417 ttnmdi.lpszText != LPSTR_TEXTCALLBACKA) {
418 Str_GetPtrAtoW(ttnmdi.lpszText, buffer, INFOTIPSIZE);
419 }
420 }
421 }
422
423 static void TOOLTIPS_GetDispInfoW(const TOOLTIPS_INFO *infoPtr, TTTOOL_INFO *toolPtr, WCHAR *buffer)
424 {
425 NMTTDISPINFOW ttnmdi;
426
427 /* fill NMHDR struct */
428 ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFOW));
429 ttnmdi.hdr.hwndFrom = infoPtr->hwndSelf;
430 ttnmdi.hdr.idFrom = toolPtr->uId;
431 ttnmdi.hdr.code = TTN_GETDISPINFOW; /* == TTN_NEEDTEXTW */
432 ttnmdi.lpszText = ttnmdi.szText;
433 ttnmdi.uFlags = toolPtr->uFlags;
434 ttnmdi.lParam = toolPtr->lParam;
435
436 TRACE("hdr.idFrom = %lx\n", ttnmdi.hdr.idFrom);
437 SendMessageW(toolPtr->hwnd, WM_NOTIFY, toolPtr->uId, (LPARAM)&ttnmdi);
438
439 if (IS_INTRESOURCE(ttnmdi.lpszText)) {
440 LoadStringW(ttnmdi.hinst, LOWORD(ttnmdi.lpszText),
441 buffer, INFOTIPSIZE);
442 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
443 toolPtr->hinst = ttnmdi.hinst;
444 toolPtr->lpszText = ttnmdi.lpszText;
445 }
446 }
447 else if (ttnmdi.lpszText == 0) {
448 buffer[0] = '\0';
449 }
450 else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKW) {
451 Str_GetPtrW(ttnmdi.lpszText, buffer, INFOTIPSIZE);
452 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
453 toolPtr->hinst = 0;
454 toolPtr->lpszText = NULL;
455 Str_SetPtrW(&toolPtr->lpszText, buffer);
456 }
457 }
458 else {
459 ERR("recursive text callback!\n");
460 buffer[0] = '\0';
461 }
462
463 /* no text available - try calling parent instead as per native */
464 /* FIXME: Unsure if SETITEM should save the value or not */
465 if (buffer[0] == 0x00) {
466
467 SendMessageW(GetParent(toolPtr->hwnd), WM_NOTIFY, toolPtr->uId, (LPARAM)&ttnmdi);
468
469 if (IS_INTRESOURCE(ttnmdi.lpszText)) {
470 LoadStringW(ttnmdi.hinst, LOWORD(ttnmdi.lpszText),
471 buffer, INFOTIPSIZE);
472 } else if (ttnmdi.lpszText &&
473 ttnmdi.lpszText != LPSTR_TEXTCALLBACKW) {
474 Str_GetPtrW(ttnmdi.lpszText, buffer, INFOTIPSIZE);
475 }
476 }
477
478 }
479
480 static void
481 TOOLTIPS_GetTipText (const TOOLTIPS_INFO *infoPtr, INT nTool, WCHAR *buffer)
482 {
483 TTTOOL_INFO *toolPtr = &infoPtr->tools[nTool];
484
485 if (IS_INTRESOURCE(toolPtr->lpszText) && toolPtr->hinst) {
486 /* load a resource */
487 TRACE("load res string %p %x\n",
488 toolPtr->hinst, LOWORD(toolPtr->lpszText));
489 LoadStringW (toolPtr->hinst, LOWORD(toolPtr->lpszText),
490 buffer, INFOTIPSIZE);
491 }
492 else if (toolPtr->lpszText) {
493 if (toolPtr->lpszText == LPSTR_TEXTCALLBACKW) {
494 if (toolPtr->bNotifyUnicode)
495 TOOLTIPS_GetDispInfoW(infoPtr, toolPtr, buffer);
496 else
497 TOOLTIPS_GetDispInfoA(infoPtr, toolPtr, buffer);
498 }
499 else {
500 /* the item is a usual (unicode) text */
501 lstrcpynW (buffer, toolPtr->lpszText, INFOTIPSIZE);
502 }
503 }
504 else {
505 /* no text available */
506 buffer[0] = '\0';
507 }
508
509 TRACE("%s\n", debugstr_w(buffer));
510 }
511
512
513 static void
514 TOOLTIPS_CalcTipSize (const TOOLTIPS_INFO *infoPtr, LPSIZE lpSize)
515 {
516 HDC hdc;
517 HFONT hOldFont;
518 DWORD style = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
519 UINT uFlags = DT_EXTERNALLEADING | DT_CALCRECT;
520 RECT rc = {0, 0, 0, 0};
521 SIZE title = {0, 0};
522
523 if (infoPtr->nMaxTipWidth > -1) {
524 rc.right = infoPtr->nMaxTipWidth;
525 uFlags |= DT_WORDBREAK;
526 }
527 if (style & TTS_NOPREFIX)
528 uFlags |= DT_NOPREFIX;
529 TRACE("%s\n", debugstr_w(infoPtr->szTipText));
530
531 hdc = GetDC (infoPtr->hwndSelf);
532 if (infoPtr->pszTitle)
533 {
534 RECT rcTitle = {0, 0, 0, 0};
535 TRACE("title %s\n", debugstr_w(infoPtr->pszTitle));
536 if (infoPtr->hTitleIcon)
537 {
538 title.cx = ICON_WIDTH;
539 title.cy = ICON_HEIGHT;
540 }
541 if (title.cx != 0) title.cx += BALLOON_ICON_TITLE_SPACING;
542 hOldFont = SelectObject (hdc, infoPtr->hTitleFont);
543 DrawTextW(hdc, infoPtr->pszTitle, -1, &rcTitle, DT_SINGLELINE | DT_NOPREFIX | DT_CALCRECT);
544 SelectObject (hdc, hOldFont);
545 title.cy = max(title.cy, rcTitle.bottom - rcTitle.top) + BALLOON_TITLE_TEXT_SPACING;
546 title.cx += (rcTitle.right - rcTitle.left);
547 }
548 hOldFont = SelectObject (hdc, infoPtr->hFont);
549 DrawTextW (hdc, infoPtr->szTipText, -1, &rc, uFlags);
550 SelectObject (hdc, hOldFont);
551 ReleaseDC (infoPtr->hwndSelf, hdc);
552
553 if ((style & TTS_BALLOON) || infoPtr->pszTitle)
554 {
555 lpSize->cx = max(rc.right - rc.left, title.cx) + 2*BALLOON_TEXT_MARGIN +
556 infoPtr->rcMargin.left + infoPtr->rcMargin.right;
557 lpSize->cy = title.cy + rc.bottom - rc.top + 2*BALLOON_TEXT_MARGIN +
558 infoPtr->rcMargin.bottom + infoPtr->rcMargin.top +
559 BALLOON_STEMHEIGHT;
560 }
561 else
562 {
563 lpSize->cx = rc.right - rc.left + 2*NORMAL_TEXT_MARGIN +
564 infoPtr->rcMargin.left + infoPtr->rcMargin.right;
565 lpSize->cy = rc.bottom - rc.top + 2*NORMAL_TEXT_MARGIN +
566 infoPtr->rcMargin.bottom + infoPtr->rcMargin.top;
567 }
568 }
569
570
571 static void
572 TOOLTIPS_Show (TOOLTIPS_INFO *infoPtr, BOOL track_activate)
573 {
574 TTTOOL_INFO *toolPtr;
575 HMONITOR monitor;
576 MONITORINFO mon_info;
577 RECT rect;
578 SIZE size;
579 NMHDR hdr;
580 int ptfx = 0;
581 DWORD style = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
582 INT nTool;
583
584 if (track_activate)
585 {
586 if (infoPtr->nTrackTool == -1)
587 {
588 TRACE("invalid tracking tool (-1)!\n");
589 return;
590 }
591 nTool = infoPtr->nTrackTool;
592 }
593 else
594 {
595 if (infoPtr->nTool == -1)
596 {
597 TRACE("invalid tool (-1)!\n");
598 return;
599 }
600 nTool = infoPtr->nTool;
601 }
602
603 TRACE("Show tooltip pre %d! (%p)\n", nTool, infoPtr->hwndSelf);
604
605 TOOLTIPS_GetTipText (infoPtr, nTool, infoPtr->szTipText);
606
607 if (infoPtr->szTipText[0] == '\0')
608 return;
609
610 toolPtr = &infoPtr->tools[nTool];
611
612 if (!track_activate)
613 infoPtr->nCurrentTool = infoPtr->nTool;
614
615 TRACE("Show tooltip %d!\n", nTool);
616
617 hdr.hwndFrom = infoPtr->hwndSelf;
618 hdr.idFrom = toolPtr->uId;
619 hdr.code = TTN_SHOW;
620 SendMessageW (toolPtr->hwnd, WM_NOTIFY, toolPtr->uId, (LPARAM)&hdr);
621
622 TRACE("%s\n", debugstr_w(infoPtr->szTipText));
623
624 TOOLTIPS_CalcTipSize (infoPtr, &size);
625 TRACE("size %d x %d\n", size.cx, size.cy);
626
627 if (track_activate)
628 {
629 rect.left = infoPtr->xTrackPos;
630 rect.top = infoPtr->yTrackPos;
631 ptfx = rect.left;
632
633 if (toolPtr->uFlags & TTF_CENTERTIP)
634 {
635 rect.left -= (size.cx / 2);
636 if (!(style & TTS_BALLOON))
637 rect.top -= (size.cy / 2);
638 }
639 if (!(infoPtr->bToolBelow = (infoPtr->yTrackPos + size.cy <= GetSystemMetrics(SM_CYSCREEN))))
640 rect.top -= size.cy;
641
642 if (!(toolPtr->uFlags & TTF_ABSOLUTE))
643 {
644 if (style & TTS_BALLOON)
645 rect.left -= BALLOON_STEMINDENT;
646 else
647 {
648 RECT rcTool;
649
650 if (toolPtr->uFlags & TTF_IDISHWND)
651 GetWindowRect ((HWND)toolPtr->uId, &rcTool);
652 else
653 {
654 rcTool = toolPtr->rect;
655 MapWindowPoints (toolPtr->hwnd, NULL, (LPPOINT)&rcTool, 2);
656 }
657
658 /* smart placement */
659 if ((rect.left + size.cx > rcTool.left) && (rect.left < rcTool.right) &&
660 (rect.top + size.cy > rcTool.top) && (rect.top < rcTool.bottom))
661 rect.left = rcTool.right;
662 }
663 }
664 }
665 else
666 {
667 if (toolPtr->uFlags & TTF_CENTERTIP)
668 {
669 RECT rc;
670
671 if (toolPtr->uFlags & TTF_IDISHWND)
672 GetWindowRect ((HWND)toolPtr->uId, &rc);
673 else {
674 rc = toolPtr->rect;
675 MapWindowPoints (toolPtr->hwnd, NULL, (LPPOINT)&rc, 2);
676 }
677 rect.left = (rc.left + rc.right - size.cx) / 2;
678 if (style & TTS_BALLOON)
679 {
680 ptfx = rc.left + ((rc.right - rc.left) / 2);
681
682 /* CENTERTIP ballon tooltips default to below the field
683 * if they fit on the screen */
684 if (rc.bottom + size.cy > GetSystemMetrics(SM_CYSCREEN))
685 {
686 rect.top = rc.top - size.cy;
687 infoPtr->bToolBelow = FALSE;
688 }
689 else
690 {
691 infoPtr->bToolBelow = TRUE;
692 rect.top = rc.bottom;
693 }
694 rect.left = max(0, rect.left - BALLOON_STEMINDENT);
695 }
696 else
697 {
698 rect.top = rc.bottom + 2;
699 infoPtr->bToolBelow = TRUE;
700 }
701 }
702 else
703 {
704 GetCursorPos ((LPPOINT)&rect);
705 if (style & TTS_BALLOON)
706 {
707 ptfx = rect.left;
708 if(rect.top - size.cy >= 0)
709 {
710 rect.top -= size.cy;
711 infoPtr->bToolBelow = FALSE;
712 }
713 else
714 {
715 infoPtr->bToolBelow = TRUE;
716 rect.top += 20;
717 }
718 rect.left = max(0, rect.left - BALLOON_STEMINDENT);
719 }
720 else
721 {
722 rect.top += 20;
723 infoPtr->bToolBelow = TRUE;
724 }
725 }
726 }
727
728 TRACE("pos %d - %d\n", rect.left, rect.top);
729
730 rect.right = rect.left + size.cx;
731 rect.bottom = rect.top + size.cy;
732
733 /* check position */
734
735 monitor = MonitorFromRect( &rect, MONITOR_DEFAULTTOPRIMARY );
736 mon_info.cbSize = sizeof(mon_info);
737 GetMonitorInfoW( monitor, &mon_info );
738
739 if( rect.right > mon_info.rcWork.right ) {
740 rect.left -= rect.right - mon_info.rcWork.right + 2;
741 rect.right = mon_info.rcWork.right - 2;
742 }
743 if (rect.left < mon_info.rcWork.left) rect.left = mon_info.rcWork.left;
744
745 if( rect.bottom > mon_info.rcWork.bottom ) {
746 RECT rc;
747
748 if (toolPtr->uFlags & TTF_IDISHWND)
749 GetWindowRect ((HWND)toolPtr->uId, &rc);
750 else {
751 rc = toolPtr->rect;
752 MapWindowPoints (toolPtr->hwnd, NULL, (LPPOINT)&rc, 2);
753 }
754 rect.bottom = rc.top - 2;
755 rect.top = rect.bottom - size.cy;
756 }
757
758 AdjustWindowRectEx (&rect, GetWindowLongW (infoPtr->hwndSelf, GWL_STYLE),
759 FALSE, GetWindowLongW (infoPtr->hwndSelf, GWL_EXSTYLE));
760
761 if (style & TTS_BALLOON)
762 {
763 HRGN hRgn;
764 HRGN hrStem;
765 POINT pts[3];
766
767 ptfx -= rect.left;
768
769 if(infoPtr->bToolBelow)
770 {
771 pts[0].x = ptfx;
772 pts[0].y = 0;
773 pts[1].x = max(BALLOON_STEMINDENT, ptfx - (BALLOON_STEMWIDTH / 2));
774 pts[1].y = BALLOON_STEMHEIGHT;
775 pts[2].x = pts[1].x + BALLOON_STEMWIDTH;
776 pts[2].y = pts[1].y;
777 if(pts[2].x > (rect.right - rect.left) - BALLOON_STEMINDENT)
778 {
779 pts[2].x = (rect.right - rect.left) - BALLOON_STEMINDENT;
780 pts[1].x = pts[2].x - BALLOON_STEMWIDTH;
781 }
782 }
783 else
784 {
785 pts[0].x = max(BALLOON_STEMINDENT, ptfx - (BALLOON_STEMWIDTH / 2));
786 pts[0].y = (rect.bottom - rect.top) - BALLOON_STEMHEIGHT;
787 pts[1].x = pts[0].x + BALLOON_STEMWIDTH;
788 pts[1].y = pts[0].y;
789 pts[2].x = ptfx;
790 pts[2].y = (rect.bottom - rect.top);
791 if(pts[1].x > (rect.right - rect.left) - BALLOON_STEMINDENT)
792 {
793 pts[1].x = (rect.right - rect.left) - BALLOON_STEMINDENT;
794 pts[0].x = pts[1].x - BALLOON_STEMWIDTH;
795 }
796 }
797
798 hrStem = CreatePolygonRgn(pts, sizeof(pts) / sizeof(pts[0]), ALTERNATE);
799
800 hRgn = CreateRoundRectRgn(0,
801 (infoPtr->bToolBelow ? BALLOON_STEMHEIGHT : 0),
802 rect.right - rect.left,
803 (infoPtr->bToolBelow ? rect.bottom - rect.top : rect.bottom - rect.top - BALLOON_STEMHEIGHT),
804 BALLOON_ROUNDEDNESS, BALLOON_ROUNDEDNESS);
805
806 CombineRgn(hRgn, hRgn, hrStem, RGN_OR);
807 DeleteObject(hrStem);
808
809 SetWindowRgn(infoPtr->hwndSelf, hRgn, FALSE);
810 /* we don't free the region handle as the system deletes it when
811 * it is no longer needed */
812 }
813
814 SetWindowPos (infoPtr->hwndSelf, HWND_TOPMOST, rect.left, rect.top,
815 rect.right - rect.left, rect.bottom - rect.top,
816 SWP_SHOWWINDOW | SWP_NOACTIVATE);
817
818 /* repaint the tooltip */
819 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
820 UpdateWindow(infoPtr->hwndSelf);
821
822 if (!track_activate)
823 {
824 SetTimer (infoPtr->hwndSelf, ID_TIMERPOP, infoPtr->nAutoPopTime, 0);
825 TRACE("timer 2 started!\n");
826 SetTimer (infoPtr->hwndSelf, ID_TIMERLEAVE, infoPtr->nReshowTime, 0);
827 TRACE("timer 3 started!\n");
828 }
829 }
830
831
832 static void
833 TOOLTIPS_Hide (TOOLTIPS_INFO *infoPtr)
834 {
835 TTTOOL_INFO *toolPtr;
836 NMHDR hdr;
837
838 TRACE("Hide tooltip %d! (%p)\n", infoPtr->nCurrentTool, infoPtr->hwndSelf);
839
840 if (infoPtr->nCurrentTool == -1)
841 return;
842
843 toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
844 KillTimer (infoPtr->hwndSelf, ID_TIMERPOP);
845
846 hdr.hwndFrom = infoPtr->hwndSelf;
847 hdr.idFrom = toolPtr->uId;
848 hdr.code = TTN_POP;
849 SendMessageW (toolPtr->hwnd, WM_NOTIFY, toolPtr->uId, (LPARAM)&hdr);
850
851 infoPtr->nCurrentTool = -1;
852
853 SetWindowPos (infoPtr->hwndSelf, HWND_TOP, 0, 0, 0, 0,
854 SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
855 }
856
857
858 static void
859 TOOLTIPS_TrackShow (TOOLTIPS_INFO *infoPtr)
860 {
861 TOOLTIPS_Show(infoPtr, TRUE);
862 }
863
864
865 static void
866 TOOLTIPS_TrackHide (const TOOLTIPS_INFO *infoPtr)
867 {
868 TTTOOL_INFO *toolPtr;
869 NMHDR hdr;
870
871 TRACE("hide tracking tooltip %d\n", infoPtr->nTrackTool);
872
873 if (infoPtr->nTrackTool == -1)
874 return;
875
876 toolPtr = &infoPtr->tools[infoPtr->nTrackTool];
877
878 hdr.hwndFrom = infoPtr->hwndSelf;
879 hdr.idFrom = toolPtr->uId;
880 hdr.code = TTN_POP;
881 SendMessageW (toolPtr->hwnd, WM_NOTIFY, toolPtr->uId, (LPARAM)&hdr);
882
883 SetWindowPos (infoPtr->hwndSelf, HWND_TOP, 0, 0, 0, 0,
884 SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
885 }
886
887 /* Structure layout is the same for TTTOOLINFOW and TTTOOLINFOA,
888 this helper is used in both cases. */
889 static INT
890 TOOLTIPS_GetToolFromInfoT (const TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *lpToolInfo)
891 {
892 TTTOOL_INFO *toolPtr;
893 UINT nTool;
894
895 for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
896 toolPtr = &infoPtr->tools[nTool];
897
898 if (!(toolPtr->uFlags & TTF_IDISHWND) &&
899 (lpToolInfo->hwnd == toolPtr->hwnd) &&
900 (lpToolInfo->uId == toolPtr->uId))
901 return nTool;
902 }
903
904 for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
905 toolPtr = &infoPtr->tools[nTool];
906
907 if ((toolPtr->uFlags & TTF_IDISHWND) &&
908 (lpToolInfo->uId == toolPtr->uId))
909 return nTool;
910 }
911
912 return -1;
913 }
914
915
916 static INT
917 TOOLTIPS_GetToolFromPoint (const TOOLTIPS_INFO *infoPtr, HWND hwnd, const POINT *lpPt)
918 {
919 TTTOOL_INFO *toolPtr;
920 UINT nTool;
921
922 for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
923 toolPtr = &infoPtr->tools[nTool];
924
925 if (!(toolPtr->uFlags & TTF_IDISHWND)) {
926 if (hwnd != toolPtr->hwnd)
927 continue;
928 if (!PtInRect (&toolPtr->rect, *lpPt))
929 continue;
930 return nTool;
931 }
932 }
933
934 for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
935 toolPtr = &infoPtr->tools[nTool];
936
937 if (toolPtr->uFlags & TTF_IDISHWND) {
938 if ((HWND)toolPtr->uId == hwnd)
939 return nTool;
940 }
941 }
942
943 return -1;
944 }
945
946 static inline void
947 TOOLTIPS_CopyInfoT (const TTTOOL_INFO *toolPtr, TTTOOLINFOW *ti, BOOL isW)
948 {
949 if (ti->lpszText) {
950 if (toolPtr->lpszText == NULL ||
951 IS_INTRESOURCE(toolPtr->lpszText) ||
952 toolPtr->lpszText == LPSTR_TEXTCALLBACKW)
953 ti->lpszText = toolPtr->lpszText;
954 else if (isW)
955 strcpyW (ti->lpszText, toolPtr->lpszText);
956 else
957 WideCharToMultiByte(CP_ACP, 0, toolPtr->lpszText, -1,
958 (LPSTR)ti->lpszText, INFOTIPSIZE, NULL, NULL);
959 }
960 }
961
962 static BOOL
963 TOOLTIPS_IsWindowActive (HWND hwnd)
964 {
965 HWND hwndActive = GetActiveWindow ();
966 if (!hwndActive)
967 return FALSE;
968 if (hwndActive == hwnd)
969 return TRUE;
970 return IsChild (hwndActive, hwnd);
971 }
972
973
974 static INT
975 TOOLTIPS_CheckTool (const TOOLTIPS_INFO *infoPtr, BOOL bShowTest)
976 {
977 POINT pt;
978 HWND hwndTool;
979 INT nTool;
980
981 GetCursorPos (&pt);
982 hwndTool = (HWND)SendMessageW (infoPtr->hwndSelf, TTM_WINDOWFROMPOINT, 0, (LPARAM)&pt);
983 if (hwndTool == 0)
984 return -1;
985
986 ScreenToClient (hwndTool, &pt);
987 nTool = TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt);
988 if (nTool == -1)
989 return -1;
990
991 if (!(GetWindowLongW (infoPtr->hwndSelf, GWL_STYLE) & TTS_ALWAYSTIP) && bShowTest) {
992 if (!TOOLTIPS_IsWindowActive (GetWindow (infoPtr->hwndSelf, GW_OWNER)))
993 return -1;
994 }
995
996 TRACE("tool %d\n", nTool);
997
998 return nTool;
999 }
1000
1001
1002 static LRESULT
1003 TOOLTIPS_Activate (TOOLTIPS_INFO *infoPtr, BOOL activate)
1004 {
1005 infoPtr->bActive = activate;
1006
1007 if (infoPtr->bActive)
1008 TRACE("activate!\n");
1009
1010 if (!(infoPtr->bActive) && (infoPtr->nCurrentTool != -1))
1011 TOOLTIPS_Hide (infoPtr);
1012
1013 return 0;
1014 }
1015
1016
1017 static LRESULT
1018 TOOLTIPS_AddToolT (TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *ti, BOOL isW)
1019 {
1020 TTTOOL_INFO *toolPtr;
1021 INT nResult;
1022
1023 if (!ti) return FALSE;
1024
1025 TRACE("add tool (%p) %p %ld%s!\n",
1026 infoPtr->hwndSelf, ti->hwnd, ti->uId,
1027 (ti->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
1028
1029 if (infoPtr->uNumTools == 0) {
1030 infoPtr->tools = Alloc (sizeof(TTTOOL_INFO));
1031 toolPtr = infoPtr->tools;
1032 }
1033 else {
1034 TTTOOL_INFO *oldTools = infoPtr->tools;
1035 infoPtr->tools =
1036 Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
1037 memcpy (infoPtr->tools, oldTools,
1038 infoPtr->uNumTools * sizeof(TTTOOL_INFO));
1039 Free (oldTools);
1040 toolPtr = &infoPtr->tools[infoPtr->uNumTools];
1041 }
1042
1043 infoPtr->uNumTools++;
1044
1045 /* copy tool data */
1046 toolPtr->uFlags = ti->uFlags;
1047 toolPtr->hwnd = ti->hwnd;
1048 toolPtr->uId = ti->uId;
1049 toolPtr->rect = ti->rect;
1050 toolPtr->hinst = ti->hinst;
1051
1052 if (IS_INTRESOURCE(ti->lpszText)) {
1053 TRACE("add string id %x\n", LOWORD(ti->lpszText));
1054 toolPtr->lpszText = ti->lpszText;
1055 }
1056 else if (ti->lpszText) {
1057 if (TOOLTIPS_IsCallbackString(ti->lpszText, isW)) {
1058 TRACE("add CALLBACK!\n");
1059 toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
1060 }
1061 else if (isW) {
1062 INT len = lstrlenW (ti->lpszText);
1063 TRACE("add text %s!\n", debugstr_w(ti->lpszText));
1064 toolPtr->lpszText = Alloc ((len + 1)*sizeof(WCHAR));
1065 strcpyW (toolPtr->lpszText, ti->lpszText);
1066 }
1067 else {
1068 INT len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ti->lpszText, -1, NULL, 0);
1069 TRACE("add text \"%s\"!\n", (LPSTR)ti->lpszText);
1070 toolPtr->lpszText = Alloc (len * sizeof(WCHAR));
1071 MultiByteToWideChar(CP_ACP, 0, (LPSTR)ti->lpszText, -1, toolPtr->lpszText, len);
1072 }
1073 }
1074
1075 if (ti->cbSize >= TTTOOLINFOW_V2_SIZE)
1076 toolPtr->lParam = ti->lParam;
1077
1078 /* install subclassing hook */
1079 if (toolPtr->uFlags & TTF_SUBCLASS) {
1080 if (toolPtr->uFlags & TTF_IDISHWND) {
1081 SetWindowSubclass((HWND)toolPtr->uId, TOOLTIPS_SubclassProc, 1,
1082 (DWORD_PTR)infoPtr->hwndSelf);
1083 }
1084 else {
1085 SetWindowSubclass(toolPtr->hwnd, TOOLTIPS_SubclassProc, 1,
1086 (DWORD_PTR)infoPtr->hwndSelf);
1087 }
1088 TRACE("subclassing installed!\n");
1089 }
1090
1091 nResult = SendMessageW (toolPtr->hwnd, WM_NOTIFYFORMAT,
1092 (WPARAM)infoPtr->hwndSelf, NF_QUERY);
1093 if (nResult == NFR_ANSI) {
1094 toolPtr->bNotifyUnicode = FALSE;
1095 TRACE(" -- WM_NOTIFYFORMAT returns: NFR_ANSI\n");
1096 } else if (nResult == NFR_UNICODE) {
1097 toolPtr->bNotifyUnicode = TRUE;
1098 TRACE(" -- WM_NOTIFYFORMAT returns: NFR_UNICODE\n");
1099 } else {
1100 TRACE (" -- WM_NOTIFYFORMAT returns: error!\n");
1101 }
1102
1103 return TRUE;
1104 }
1105
1106
1107 static LRESULT
1108 TOOLTIPS_DelToolT (TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *ti, BOOL isW)
1109 {
1110 TTTOOL_INFO *toolPtr;
1111 INT nTool;
1112
1113 if (!ti) return 0;
1114 if (isW && ti->cbSize > TTTOOLINFOW_V2_SIZE &&
1115 ti->cbSize != TTTOOLINFOW_V3_SIZE)
1116 return 0;
1117 if (infoPtr->uNumTools == 0)
1118 return 0;
1119
1120 nTool = TOOLTIPS_GetToolFromInfoT (infoPtr, ti);
1121
1122 TRACE("tool %d\n", nTool);
1123
1124 if (nTool == -1)
1125 return 0;
1126
1127 /* make sure the tooltip has disappeared before deleting it */
1128 TOOLTIPS_Hide(infoPtr);
1129
1130 /* delete text string */
1131 toolPtr = &infoPtr->tools[nTool];
1132 if (toolPtr->lpszText) {
1133 if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
1134 !IS_INTRESOURCE(toolPtr->lpszText) )
1135 Free (toolPtr->lpszText);
1136 }
1137
1138 /* remove subclassing */
1139 if (toolPtr->uFlags & TTF_SUBCLASS) {
1140 if (toolPtr->uFlags & TTF_IDISHWND) {
1141 RemoveWindowSubclass((HWND)toolPtr->uId, TOOLTIPS_SubclassProc, 1);
1142 }
1143 else {
1144 RemoveWindowSubclass(toolPtr->hwnd, TOOLTIPS_SubclassProc, 1);
1145 }
1146 }
1147
1148 /* delete tool from tool list */
1149 if (infoPtr->uNumTools == 1) {
1150 Free (infoPtr->tools);
1151 infoPtr->tools = NULL;
1152 }
1153 else {
1154 TTTOOL_INFO *oldTools = infoPtr->tools;
1155 infoPtr->tools =
1156 Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
1157
1158 if (nTool > 0)
1159 memcpy (&infoPtr->tools[0], &oldTools[0],
1160 nTool * sizeof(TTTOOL_INFO));
1161
1162 if (nTool < infoPtr->uNumTools - 1)
1163 memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
1164 (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
1165
1166 Free (oldTools);
1167 }
1168
1169 /* update any indices affected by delete */
1170
1171 /* destroying tool that mouse was on on last relayed mouse move */
1172 if (infoPtr->nTool == nTool)
1173 /* -1 means no current tool (0 means first tool) */
1174 infoPtr->nTool = -1;
1175 else if (infoPtr->nTool > nTool)
1176 infoPtr->nTool--;
1177
1178 if (infoPtr->nTrackTool == nTool)
1179 /* -1 means no current tool (0 means first tool) */
1180 infoPtr->nTrackTool = -1;
1181 else if (infoPtr->nTrackTool > nTool)
1182 infoPtr->nTrackTool--;
1183
1184 if (infoPtr->nCurrentTool == nTool)
1185 /* -1 means no current tool (0 means first tool) */
1186 infoPtr->nCurrentTool = -1;
1187 else if (infoPtr->nCurrentTool > nTool)
1188 infoPtr->nCurrentTool--;
1189
1190 infoPtr->uNumTools--;
1191
1192 return 0;
1193 }
1194
1195 static LRESULT
1196 TOOLTIPS_EnumToolsT (const TOOLTIPS_INFO *infoPtr, UINT uIndex, TTTOOLINFOW *ti,
1197 BOOL isW)
1198 {
1199 TTTOOL_INFO *toolPtr;
1200
1201 if (!ti) return FALSE;
1202 if (ti->cbSize < TTTOOLINFOW_V1_SIZE)
1203 return FALSE;
1204 if (uIndex >= infoPtr->uNumTools)
1205 return FALSE;
1206
1207 TRACE("index=%u\n", uIndex);
1208
1209 toolPtr = &infoPtr->tools[uIndex];
1210
1211 /* copy tool data */
1212 ti->uFlags = toolPtr->uFlags;
1213 ti->hwnd = toolPtr->hwnd;
1214 ti->uId = toolPtr->uId;
1215 ti->rect = toolPtr->rect;
1216 ti->hinst = toolPtr->hinst;
1217 TOOLTIPS_CopyInfoT (toolPtr, ti, isW);
1218
1219 if (ti->cbSize >= TTTOOLINFOA_V2_SIZE)
1220 ti->lParam = toolPtr->lParam;
1221
1222 return TRUE;
1223 }
1224
1225 static LRESULT
1226 TOOLTIPS_GetBubbleSize (const TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *lpToolInfo)
1227 {
1228 INT nTool;
1229 SIZE size;
1230
1231 if (lpToolInfo == NULL)
1232 return FALSE;
1233 if (lpToolInfo->cbSize < TTTOOLINFOW_V1_SIZE)
1234 return FALSE;
1235
1236 nTool = TOOLTIPS_GetToolFromInfoT (infoPtr, lpToolInfo);
1237 if (nTool == -1) return 0;
1238
1239 TRACE("tool %d\n", nTool);
1240
1241 TOOLTIPS_CalcTipSize (infoPtr, &size);
1242 TRACE("size %d x %d\n", size.cx, size.cy);
1243
1244 return MAKELRESULT(size.cx, size.cy);
1245 }
1246
1247 static LRESULT
1248 TOOLTIPS_GetCurrentToolT (const TOOLTIPS_INFO *infoPtr, TTTOOLINFOW *ti, BOOL isW)
1249 {
1250 TTTOOL_INFO *toolPtr;
1251
1252 if (ti) {
1253 if (ti->cbSize < TTTOOLINFOW_V1_SIZE)
1254 return FALSE;
1255
1256 if (infoPtr->nCurrentTool > -1) {
1257 toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
1258
1259 /* copy tool data */
1260 ti->uFlags = toolPtr->uFlags;
1261 ti->rect = toolPtr->rect;
1262 ti->hinst = toolPtr->hinst;
1263 TOOLTIPS_CopyInfoT (toolPtr, ti, isW);
1264
1265 if (ti->cbSize >= TTTOOLINFOW_V2_SIZE)
1266 ti->lParam = toolPtr->lParam;
1267
1268 return TRUE;
1269 }
1270 else
1271 return FALSE;
1272 }
1273 else
1274 return (infoPtr->nCurrentTool != -1);
1275 }
1276
1277
1278 static LRESULT
1279 TOOLTIPS_GetDelayTime (const TOOLTIPS_INFO *infoPtr, DWORD duration)
1280 {
1281 switch (duration) {
1282 case TTDT_RESHOW:
1283 return infoPtr->nReshowTime;
1284
1285 case TTDT_AUTOPOP:
1286 return infoPtr->nAutoPopTime;
1287
1288 case TTDT_INITIAL:
1289 case TTDT_AUTOMATIC: /* Apparently TTDT_AUTOMATIC returns TTDT_INITIAL */
1290 return infoPtr->nInitialTime;
1291
1292 default:
1293 WARN("Invalid duration flag %x\n", duration);
1294 break;
1295 }
1296
1297 return -1;
1298 }
1299
1300
1301 static LRESULT
1302 TOOLTIPS_GetMargin (const TOOLTIPS_INFO *infoPtr, LPRECT lpRect)
1303 {
1304 lpRect->left = infoPtr->rcMargin.left;
1305 lpRect->right = infoPtr->rcMargin.right;
1306 lpRect->bottom = infoPtr->rcMargin.bottom;
1307 lpRect->top = infoPtr->rcMargin.top;
1308
1309 return 0;
1310 }
1311
1312
1313 static inline LRESULT
1314 TOOLTIPS_GetMaxTipWidth (const TOOLTIPS_INFO *infoPtr)
1315 {
1316 return infoPtr->nMaxTipWidth;
1317 }
1318
1319
1320 static LRESULT
1321 TOOLTIPS_GetTextT (const TOOLTIPS_INFO *infoPtr, TTTOOLINFOW *ti, BOOL isW)
1322 {
1323 INT nTool;
1324
1325 if (!ti) return 0;
1326 if (ti->cbSize < TTTOOLINFOW_V1_SIZE)
1327 return 0;
1328
1329 nTool = TOOLTIPS_GetToolFromInfoT (infoPtr, ti);
1330 if (nTool == -1) return 0;
1331
1332 if (infoPtr->tools[nTool].lpszText == NULL)
1333 return 0;
1334
1335 if (isW) {
1336 ti->lpszText[0] = '\0';
1337 TOOLTIPS_GetTipText(infoPtr, nTool, ti->lpszText);
1338 }
1339 else {
1340 WCHAR buffer[INFOTIPSIZE];
1341
1342 /* NB this API is broken, there is no way for the app to determine
1343 what size buffer it requires nor a way to specify how long the
1344 one it supplies is. We'll assume it's up to INFOTIPSIZE */
1345
1346 buffer[0] = '\0';
1347 TOOLTIPS_GetTipText(infoPtr, nTool, buffer);
1348 WideCharToMultiByte(CP_ACP, 0, buffer, -1, (LPSTR)ti->lpszText,
1349 INFOTIPSIZE, NULL, NULL);
1350 }
1351
1352 return 0;
1353 }
1354
1355
1356 static inline LRESULT
1357 TOOLTIPS_GetTipBkColor (const TOOLTIPS_INFO *infoPtr)
1358 {
1359 return infoPtr->clrBk;
1360 }
1361
1362
1363 static inline LRESULT
1364 TOOLTIPS_GetTipTextColor (const TOOLTIPS_INFO *infoPtr)
1365 {
1366 return infoPtr->clrText;
1367 }
1368
1369
1370 static inline LRESULT
1371 TOOLTIPS_GetToolCount (const TOOLTIPS_INFO *infoPtr)
1372 {
1373 return infoPtr->uNumTools;
1374 }
1375
1376
1377 static LRESULT
1378 TOOLTIPS_GetToolInfoT (const TOOLTIPS_INFO *infoPtr, TTTOOLINFOW *ti, BOOL isW)
1379 {
1380 TTTOOL_INFO *toolPtr;
1381 INT nTool;
1382
1383 if (!ti) return FALSE;
1384 if (ti->cbSize < TTTOOLINFOW_V1_SIZE)
1385 return FALSE;
1386 if (infoPtr->uNumTools == 0)
1387 return FALSE;
1388
1389 nTool = TOOLTIPS_GetToolFromInfoT (infoPtr, ti);
1390 if (nTool == -1)
1391 return FALSE;
1392
1393 TRACE("tool %d\n", nTool);
1394
1395 toolPtr = &infoPtr->tools[nTool];
1396
1397 /* copy tool data */
1398 ti->uFlags = toolPtr->uFlags;
1399 ti->rect = toolPtr->rect;
1400 ti->hinst = toolPtr->hinst;
1401 TOOLTIPS_CopyInfoT (toolPtr, ti, isW);
1402
1403 if (ti->cbSize >= TTTOOLINFOW_V2_SIZE)
1404 ti->lParam = toolPtr->lParam;
1405
1406 return TRUE;
1407 }
1408
1409
1410 static LRESULT
1411 TOOLTIPS_HitTestT (const TOOLTIPS_INFO *infoPtr, LPTTHITTESTINFOW lptthit,
1412 BOOL isW)
1413 {
1414 TTTOOL_INFO *toolPtr;
1415 INT nTool;
1416
1417 if (lptthit == 0)
1418 return FALSE;
1419
1420 nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt);
1421 if (nTool == -1)
1422 return FALSE;
1423
1424 TRACE("tool %d!\n", nTool);
1425
1426 /* copy tool data */
1427 if (lptthit->ti.cbSize >= TTTOOLINFOW_V1_SIZE) {
1428 toolPtr = &infoPtr->tools[nTool];
1429
1430 lptthit->ti.uFlags = toolPtr->uFlags;
1431 lptthit->ti.hwnd = toolPtr->hwnd;
1432 lptthit->ti.uId = toolPtr->uId;
1433 lptthit->ti.rect = toolPtr->rect;
1434 lptthit->ti.hinst = toolPtr->hinst;
1435 TOOLTIPS_CopyInfoT (toolPtr, &lptthit->ti, isW);
1436 if (lptthit->ti.cbSize >= TTTOOLINFOW_V2_SIZE)
1437 lptthit->ti.lParam = toolPtr->lParam;
1438 }
1439
1440 return TRUE;
1441 }
1442
1443
1444 static LRESULT
1445 TOOLTIPS_NewToolRectT (TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *ti)
1446 {
1447 INT nTool;
1448
1449 if (!ti) return 0;
1450 if (ti->cbSize < TTTOOLINFOW_V1_SIZE)
1451 return FALSE;
1452
1453 nTool = TOOLTIPS_GetToolFromInfoT (infoPtr, ti);
1454
1455 TRACE("nTool = %d, rect = %s\n", nTool, wine_dbgstr_rect(&ti->rect));
1456
1457 if (nTool == -1) return 0;
1458
1459 infoPtr->tools[nTool].rect = ti->rect;
1460
1461 return 0;
1462 }
1463
1464
1465 static inline LRESULT
1466 TOOLTIPS_Pop (TOOLTIPS_INFO *infoPtr)
1467 {
1468 TOOLTIPS_Hide (infoPtr);
1469
1470 return 0;
1471 }
1472
1473
1474 static LRESULT
1475 TOOLTIPS_RelayEvent (TOOLTIPS_INFO *infoPtr, LPMSG lpMsg)
1476 {
1477 POINT pt;
1478 INT nOldTool;
1479
1480 if (!lpMsg) {
1481 ERR("lpMsg == NULL!\n");
1482 return 0;
1483 }
1484
1485 switch (lpMsg->message) {
1486 case WM_LBUTTONDOWN:
1487 case WM_LBUTTONUP:
1488 case WM_MBUTTONDOWN:
1489 case WM_MBUTTONUP:
1490 case WM_RBUTTONDOWN:
1491 case WM_RBUTTONUP:
1492 TOOLTIPS_Hide (infoPtr);
1493 break;
1494
1495 case WM_MOUSEMOVE:
1496 pt.x = (short)LOWORD(lpMsg->lParam);
1497 pt.y = (short)HIWORD(lpMsg->lParam);
1498 nOldTool = infoPtr->nTool;
1499 infoPtr->nTool = TOOLTIPS_GetToolFromPoint(infoPtr, lpMsg->hwnd,
1500 &pt);
1501 TRACE("tool (%p) %d %d %d\n", infoPtr->hwndSelf, nOldTool,
1502 infoPtr->nTool, infoPtr->nCurrentTool);
1503 TRACE("WM_MOUSEMOVE (%p %d %d)\n", infoPtr->hwndSelf, pt.x, pt.y);
1504
1505 if (infoPtr->nTool != nOldTool) {
1506 if(infoPtr->nTool == -1) { /* Moved out of all tools */
1507 TOOLTIPS_Hide(infoPtr);
1508 KillTimer(infoPtr->hwndSelf, ID_TIMERLEAVE);
1509 } else if (nOldTool == -1) { /* Moved from outside */
1510 if(infoPtr->bActive) {
1511 SetTimer(infoPtr->hwndSelf, ID_TIMERSHOW, infoPtr->nInitialTime, 0);
1512 TRACE("timer 1 started!\n");
1513 }
1514 } else { /* Moved from one to another */
1515 TOOLTIPS_Hide (infoPtr);
1516 KillTimer(infoPtr->hwndSelf, ID_TIMERLEAVE);
1517 if(infoPtr->bActive) {
1518 SetTimer (infoPtr->hwndSelf, ID_TIMERSHOW, infoPtr->nReshowTime, 0);
1519 TRACE("timer 1 started!\n");
1520 }
1521 }
1522 } else if(infoPtr->nCurrentTool != -1) { /* restart autopop */
1523 KillTimer(infoPtr->hwndSelf, ID_TIMERPOP);
1524 SetTimer(infoPtr->hwndSelf, ID_TIMERPOP, infoPtr->nAutoPopTime, 0);
1525 TRACE("timer 2 restarted\n");
1526 } else if(infoPtr->nTool != -1 && infoPtr->bActive) {
1527 /* previous show attempt didn't result in tooltip so try again */
1528 SetTimer(infoPtr->hwndSelf, ID_TIMERSHOW, infoPtr->nInitialTime, 0);
1529 TRACE("timer 1 started!\n");
1530 }
1531 break;
1532 }
1533
1534 return 0;
1535 }
1536
1537
1538 static LRESULT
1539 TOOLTIPS_SetDelayTime (TOOLTIPS_INFO *infoPtr, DWORD duration, INT nTime)
1540 {
1541 switch (duration) {
1542 case TTDT_AUTOMATIC:
1543 if (nTime <= 0)
1544 nTime = GetDoubleClickTime();
1545 infoPtr->nReshowTime = nTime / 5;
1546 infoPtr->nAutoPopTime = nTime * 10;
1547 infoPtr->nInitialTime = nTime;
1548 break;
1549
1550 case TTDT_RESHOW:
1551 if(nTime < 0)
1552 nTime = GetDoubleClickTime() / 5;
1553 infoPtr->nReshowTime = nTime;
1554 break;
1555
1556 case TTDT_AUTOPOP:
1557 if(nTime < 0)
1558 nTime = GetDoubleClickTime() * 10;
1559 infoPtr->nAutoPopTime = nTime;
1560 break;
1561
1562 case TTDT_INITIAL:
1563 if(nTime < 0)
1564 nTime = GetDoubleClickTime();
1565 infoPtr->nInitialTime = nTime;
1566 break;
1567
1568 default:
1569 WARN("Invalid duration flag %x\n", duration);
1570 break;
1571 }
1572
1573 return 0;
1574 }
1575
1576
1577 static LRESULT
1578 TOOLTIPS_SetMargin (TOOLTIPS_INFO *infoPtr, const RECT *lpRect)
1579 {
1580 infoPtr->rcMargin.left = lpRect->left;
1581 infoPtr->rcMargin.right = lpRect->right;
1582 infoPtr->rcMargin.bottom = lpRect->bottom;
1583 infoPtr->rcMargin.top = lpRect->top;
1584
1585 return 0;
1586 }
1587
1588
1589 static inline LRESULT
1590 TOOLTIPS_SetMaxTipWidth (TOOLTIPS_INFO *infoPtr, INT MaxWidth)
1591 {
1592 INT nTemp = infoPtr->nMaxTipWidth;
1593
1594 infoPtr->nMaxTipWidth = MaxWidth;
1595
1596 return nTemp;
1597 }
1598
1599
1600 static inline LRESULT
1601 TOOLTIPS_SetTipBkColor (TOOLTIPS_INFO *infoPtr, COLORREF clrBk)
1602 {
1603 infoPtr->clrBk = clrBk;
1604
1605 return 0;
1606 }
1607
1608
1609 static inline LRESULT
1610 TOOLTIPS_SetTipTextColor (TOOLTIPS_INFO *infoPtr, COLORREF clrText)
1611 {
1612 infoPtr->clrText = clrText;
1613
1614 return 0;
1615 }
1616
1617
1618 static LRESULT
1619 TOOLTIPS_SetTitleT (TOOLTIPS_INFO *infoPtr, UINT_PTR uTitleIcon, LPCWSTR pszTitle,
1620 BOOL isW)
1621 {
1622 UINT size;
1623
1624 TRACE("hwnd = %p, title = %s, icon = %p\n", infoPtr->hwndSelf, debugstr_w(pszTitle),
1625 (void*)uTitleIcon);
1626
1627 Free(infoPtr->pszTitle);
1628
1629 if (pszTitle)
1630 {
1631 if (isW)
1632 {
1633 size = (strlenW(pszTitle)+1)*sizeof(WCHAR);
1634 infoPtr->pszTitle = Alloc(size);
1635 if (!infoPtr->pszTitle)
1636 return FALSE;
1637 memcpy(infoPtr->pszTitle, pszTitle, size);
1638 }
1639 else
1640 {
1641 size = sizeof(WCHAR)*MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pszTitle, -1, NULL, 0);
1642 infoPtr->pszTitle = Alloc(size);
1643 if (!infoPtr->pszTitle)
1644 return FALSE;
1645 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pszTitle, -1, infoPtr->pszTitle, size/sizeof(WCHAR));
1646 }
1647 }
1648 else
1649 infoPtr->pszTitle = NULL;
1650
1651 if (uTitleIcon <= TTI_ERROR)
1652 infoPtr->hTitleIcon = hTooltipIcons[uTitleIcon];
1653 else
1654 infoPtr->hTitleIcon = CopyIcon((HICON)uTitleIcon);
1655
1656 TRACE("icon = %p\n", infoPtr->hTitleIcon);
1657
1658 return TRUE;
1659 }
1660
1661
1662 static LRESULT
1663 TOOLTIPS_SetToolInfoT (TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *ti, BOOL isW)
1664 {
1665 TTTOOL_INFO *toolPtr;
1666 INT nTool;
1667
1668 if (!ti) return 0;
1669 if (ti->cbSize < TTTOOLINFOW_V1_SIZE)
1670 return 0;
1671
1672 nTool = TOOLTIPS_GetToolFromInfoT (infoPtr, ti);
1673 if (nTool == -1) return 0;
1674
1675 TRACE("tool %d\n", nTool);
1676
1677 toolPtr = &infoPtr->tools[nTool];
1678
1679 /* copy tool data */
1680 toolPtr->uFlags = ti->uFlags;
1681 toolPtr->hwnd = ti->hwnd;
1682 toolPtr->uId = ti->uId;
1683 toolPtr->rect = ti->rect;
1684 toolPtr->hinst = ti->hinst;
1685
1686 if (IS_INTRESOURCE(ti->lpszText)) {
1687 TRACE("set string id %x!\n", LOWORD(ti->lpszText));
1688 toolPtr->lpszText = ti->lpszText;
1689 }
1690 else {
1691 if (TOOLTIPS_IsCallbackString(ti->lpszText, isW))
1692 toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
1693 else {
1694 if ( (toolPtr->lpszText) &&
1695 !IS_INTRESOURCE(toolPtr->lpszText) ) {
1696 if( toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
1697 Free (toolPtr->lpszText);
1698 toolPtr->lpszText = NULL;
1699 }
1700 if (ti->lpszText) {
1701 if (isW) {
1702 INT len = lstrlenW (ti->lpszText);
1703 toolPtr->lpszText = Alloc ((len+1)*sizeof(WCHAR));
1704 strcpyW (toolPtr->lpszText, ti->lpszText);
1705 }
1706 else {
1707 INT len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ti->lpszText,
1708 -1, NULL, 0);
1709 toolPtr->lpszText = Alloc (len * sizeof(WCHAR));
1710 MultiByteToWideChar(CP_ACP, 0, (LPSTR)ti->lpszText, -1,
1711 toolPtr->lpszText, len);
1712 }
1713 }
1714 }
1715 }
1716
1717 if (ti->cbSize >= TTTOOLINFOW_V2_SIZE)
1718 toolPtr->lParam = ti->lParam;
1719
1720 if (infoPtr->nCurrentTool == nTool)
1721 {
1722 TOOLTIPS_GetTipText (infoPtr, infoPtr->nCurrentTool, infoPtr->szTipText);
1723
1724 if (infoPtr->szTipText[0] == 0)
1725 TOOLTIPS_Hide(infoPtr);
1726 else
1727 TOOLTIPS_Show (infoPtr, FALSE);
1728 }
1729
1730 return 0;
1731 }
1732
1733
1734 static LRESULT
1735 TOOLTIPS_TrackActivate (TOOLTIPS_INFO *infoPtr, BOOL track_activate, const TTTOOLINFOA *ti)
1736 {
1737 if (track_activate) {
1738
1739 if (!ti) return 0;
1740 if (ti->cbSize < TTTOOLINFOA_V1_SIZE)
1741 return FALSE;
1742
1743 /* activate */
1744 infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoT (infoPtr, (const TTTOOLINFOW*)ti);
1745 if (infoPtr->nTrackTool != -1) {
1746 TRACE("activated!\n");
1747 infoPtr->bTrackActive = TRUE;
1748 TOOLTIPS_TrackShow (infoPtr);
1749 }
1750 }
1751 else {
1752 /* deactivate */
1753 TOOLTIPS_TrackHide (infoPtr);
1754
1755 infoPtr->bTrackActive = FALSE;
1756 infoPtr->nTrackTool = -1;
1757
1758 TRACE("deactivated!\n");
1759 }
1760
1761 return 0;
1762 }
1763
1764
1765 static LRESULT
1766 TOOLTIPS_TrackPosition (TOOLTIPS_INFO *infoPtr, LPARAM coord)
1767 {
1768 infoPtr->xTrackPos = (INT)LOWORD(coord);
1769 infoPtr->yTrackPos = (INT)HIWORD(coord);
1770
1771 if (infoPtr->bTrackActive) {
1772 TRACE("[%d %d]\n",
1773 infoPtr->xTrackPos, infoPtr->yTrackPos);
1774
1775 TOOLTIPS_TrackShow (infoPtr);
1776 }
1777
1778 return 0;
1779 }
1780
1781
1782 static LRESULT
1783 TOOLTIPS_Update (TOOLTIPS_INFO *infoPtr)
1784 {
1785 if (infoPtr->nCurrentTool != -1)
1786 UpdateWindow (infoPtr->hwndSelf);
1787
1788 return 0;
1789 }
1790
1791
1792 static LRESULT
1793 TOOLTIPS_UpdateTipTextT (TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *ti, BOOL isW)
1794 {
1795 TTTOOL_INFO *toolPtr;
1796 INT nTool;
1797
1798 if (!ti) return 0;
1799 if (ti->cbSize < TTTOOLINFOW_V1_SIZE)
1800 return FALSE;
1801
1802 nTool = TOOLTIPS_GetToolFromInfoT (infoPtr, ti);
1803 if (nTool == -1)
1804 return 0;
1805
1806 TRACE("tool %d\n", nTool);
1807
1808 toolPtr = &infoPtr->tools[nTool];
1809
1810 /* copy tool text */
1811 toolPtr->hinst = ti->hinst;
1812
1813 if (IS_INTRESOURCE(ti->lpszText)){
1814 toolPtr->lpszText = ti->lpszText;
1815 }
1816 else if (ti->lpszText) {
1817 if (TOOLTIPS_IsCallbackString(ti->lpszText, isW))
1818 toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
1819 else {
1820 if ( (toolPtr->lpszText) &&
1821 !IS_INTRESOURCE(toolPtr->lpszText) ) {
1822 if( toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
1823 Free (toolPtr->lpszText);
1824 toolPtr->lpszText = NULL;
1825 }
1826 if (ti->lpszText) {
1827 if (isW) {
1828 INT len = lstrlenW (ti->lpszText);
1829 toolPtr->lpszText = Alloc ((len+1)*sizeof(WCHAR));
1830 strcpyW (toolPtr->lpszText, ti->lpszText);
1831 }
1832 else {
1833 INT len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ti->lpszText,
1834 -1, NULL, 0);
1835 toolPtr->lpszText = Alloc (len * sizeof(WCHAR));
1836 MultiByteToWideChar(CP_ACP, 0, (LPSTR)ti->lpszText, -1,
1837 toolPtr->lpszText, len);
1838 }
1839 }
1840 }
1841 }
1842
1843 if(infoPtr->nCurrentTool == -1) return 0;
1844 /* force repaint */
1845 if (infoPtr->bActive)
1846 TOOLTIPS_Show (infoPtr, FALSE);
1847 else if (infoPtr->bTrackActive)
1848 TOOLTIPS_Show (infoPtr, TRUE);
1849
1850 return 0;
1851 }
1852
1853
1854 static LRESULT
1855 TOOLTIPS_Create (HWND hwnd)
1856 {
1857 TOOLTIPS_INFO *infoPtr;
1858
1859 /* allocate memory for info structure */
1860 infoPtr = Alloc (sizeof(TOOLTIPS_INFO));
1861 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
1862
1863 /* initialize info structure */
1864 infoPtr->bActive = TRUE;
1865 infoPtr->bTrackActive = FALSE;
1866
1867 infoPtr->nMaxTipWidth = -1;
1868 infoPtr->nTool = -1;
1869 infoPtr->nCurrentTool = -1;
1870 infoPtr->nTrackTool = -1;
1871 infoPtr->hwndSelf = hwnd;
1872
1873 /* initialize colours and fonts */
1874 TOOLTIPS_InitSystemSettings(infoPtr);
1875
1876 TOOLTIPS_SetDelayTime(infoPtr, TTDT_AUTOMATIC, 0);
1877
1878 SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
1879
1880 return 0;
1881 }
1882
1883
1884 static LRESULT
1885 TOOLTIPS_Destroy (TOOLTIPS_INFO *infoPtr)
1886 {
1887 TTTOOL_INFO *toolPtr;
1888 UINT i;
1889
1890 /* free tools */
1891 if (infoPtr->tools) {
1892 for (i = 0; i < infoPtr->uNumTools; i++) {
1893 toolPtr = &infoPtr->tools[i];
1894 if (toolPtr->lpszText) {
1895 if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
1896 !IS_INTRESOURCE(toolPtr->lpszText) )
1897 {
1898 Free (toolPtr->lpszText);
1899 toolPtr->lpszText = NULL;
1900 }
1901 }
1902
1903 /* remove subclassing */
1904 if (toolPtr->uFlags & TTF_SUBCLASS) {
1905 if (toolPtr->uFlags & TTF_IDISHWND) {
1906 RemoveWindowSubclass((HWND)toolPtr->uId, TOOLTIPS_SubclassProc, 1);
1907 }
1908 else {
1909 RemoveWindowSubclass(toolPtr->hwnd, TOOLTIPS_SubclassProc, 1);
1910 }
1911 }
1912 }
1913 Free (infoPtr->tools);
1914 }
1915
1916 /* free title string */
1917 Free (infoPtr->pszTitle);
1918 /* free title icon if not a standard one */
1919 if (TOOLTIPS_GetTitleIconIndex(infoPtr->hTitleIcon) > TTI_ERROR)
1920 DeleteObject(infoPtr->hTitleIcon);
1921
1922 /* delete fonts */
1923 DeleteObject (infoPtr->hFont);
1924 DeleteObject (infoPtr->hTitleFont);
1925
1926 /* free tool tips info data */
1927 SetWindowLongPtrW(infoPtr->hwndSelf, 0, 0);
1928 Free (infoPtr);
1929
1930 return 0;
1931 }
1932
1933
1934 static inline LRESULT
1935 TOOLTIPS_GetFont (const TOOLTIPS_INFO *infoPtr)
1936 {
1937 return (LRESULT)infoPtr->hFont;
1938 }
1939
1940
1941 static LRESULT
1942 TOOLTIPS_MouseMessage (TOOLTIPS_INFO *infoPtr)
1943 {
1944 TOOLTIPS_Hide (infoPtr);
1945
1946 return 0;
1947 }
1948
1949
1950 static LRESULT
1951 TOOLTIPS_NCCreate (HWND hwnd)
1952 {
1953 DWORD dwStyle = GetWindowLongW (hwnd, GWL_STYLE);
1954 DWORD dwExStyle = GetWindowLongW (hwnd, GWL_EXSTYLE);
1955
1956 dwStyle &= ~(WS_CHILD | /*WS_MAXIMIZE |*/ WS_BORDER | WS_DLGFRAME);
1957 dwStyle |= (WS_POPUP | WS_BORDER | WS_CLIPSIBLINGS);
1958
1959 /* WS_BORDER only draws a border round the window rect, not the
1960 * window region, therefore it is useless to us in balloon mode */
1961 if (dwStyle & TTS_BALLOON) dwStyle &= ~WS_BORDER;
1962
1963 SetWindowLongW (hwnd, GWL_STYLE, dwStyle);
1964
1965 dwExStyle |= WS_EX_TOOLWINDOW;
1966 SetWindowLongW (hwnd, GWL_EXSTYLE, dwExStyle);
1967
1968 return TRUE;
1969 }
1970
1971
1972 static LRESULT
1973 TOOLTIPS_NCHitTest (const TOOLTIPS_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1974 {
1975 INT nTool = (infoPtr->bTrackActive) ? infoPtr->nTrackTool : infoPtr->nTool;
1976
1977 TRACE(" nTool=%d\n", nTool);
1978
1979 if ((nTool > -1) && (nTool < infoPtr->uNumTools)) {
1980 if (infoPtr->tools[nTool].uFlags & TTF_TRANSPARENT) {
1981 TRACE("-- in transparent mode!\n");
1982 return HTTRANSPARENT;
1983 }
1984 }
1985
1986 return DefWindowProcW (infoPtr->hwndSelf, WM_NCHITTEST, wParam, lParam);
1987 }
1988
1989
1990 static LRESULT
1991 TOOLTIPS_NotifyFormat (TOOLTIPS_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1992 {
1993 FIXME ("hwnd=%p wParam=%lx lParam=%lx\n", infoPtr->hwndSelf, wParam, lParam);
1994
1995 return 0;
1996 }
1997
1998
1999 static LRESULT
2000 TOOLTIPS_Paint (const TOOLTIPS_INFO *infoPtr, HDC hDC)
2001 {
2002 HDC hdc;
2003 PAINTSTRUCT ps;
2004
2005 hdc = (hDC == NULL) ? BeginPaint (infoPtr->hwndSelf, &ps) : hDC;
2006 TOOLTIPS_Refresh (infoPtr, hdc);
2007 if (!hDC)
2008 EndPaint (infoPtr->hwndSelf, &ps);
2009 return 0;
2010 }
2011
2012
2013 static LRESULT
2014 TOOLTIPS_SetFont (TOOLTIPS_INFO *infoPtr, HFONT hFont, BOOL redraw)
2015 {
2016 LOGFONTW lf;
2017
2018 if(!GetObjectW(hFont, sizeof(lf), &lf))
2019 return 0;
2020
2021 DeleteObject (infoPtr->hFont);
2022 infoPtr->hFont = CreateFontIndirectW(&lf);
2023
2024 DeleteObject (infoPtr->hTitleFont);
2025 lf.lfWeight = FW_BOLD;
2026 infoPtr->hTitleFont = CreateFontIndirectW(&lf);
2027
2028 if (redraw && infoPtr->nCurrentTool != -1) {
2029 FIXME("full redraw needed!\n");
2030 }
2031
2032 return 0;
2033 }
2034
2035 /******************************************************************
2036 * TOOLTIPS_GetTextLength
2037 *
2038 * This function is called when the tooltip receive a
2039 * WM_GETTEXTLENGTH message.
2040 *
2041 * returns the length, in characters, of the tip text
2042 */
2043 static inline LRESULT
2044 TOOLTIPS_GetTextLength(const TOOLTIPS_INFO *infoPtr)
2045 {
2046 return strlenW(infoPtr->szTipText);
2047 }
2048
2049 /******************************************************************
2050 * TOOLTIPS_OnWMGetText
2051 *
2052 * This function is called when the tooltip receive a
2053 * WM_GETTEXT message.
2054 * wParam : specifies the maximum number of characters to be copied
2055 * lParam : is the pointer to the buffer that will receive
2056 * the tip text
2057 *
2058 * returns the number of characters copied
2059 */
2060 static LRESULT
2061 TOOLTIPS_OnWMGetText (const TOOLTIPS_INFO *infoPtr, WPARAM size, LPWSTR pszText)
2062 {
2063 LRESULT res;
2064
2065 if(!size)
2066 return 0;
2067
2068 res = min(strlenW(infoPtr->szTipText)+1, size);
2069 memcpy(pszText, infoPtr->szTipText, res*sizeof(WCHAR));
2070 pszText[res-1] = '\0';
2071 return res-1;
2072 }
2073
2074 static LRESULT
2075 TOOLTIPS_Timer (TOOLTIPS_INFO *infoPtr, INT iTimer)
2076 {
2077 INT nOldTool;
2078
2079 TRACE("timer %d (%p) expired!\n", iTimer, infoPtr->hwndSelf);
2080
2081 switch (iTimer) {
2082 case ID_TIMERSHOW:
2083 KillTimer (infoPtr->hwndSelf, ID_TIMERSHOW);
2084 nOldTool = infoPtr->nTool;
2085 if ((infoPtr->nTool = TOOLTIPS_CheckTool (infoPtr, TRUE)) == nOldTool)
2086 TOOLTIPS_Show (infoPtr, FALSE);
2087 break;
2088
2089 case ID_TIMERPOP:
2090 TOOLTIPS_Hide (infoPtr);
2091 break;
2092
2093 case ID_TIMERLEAVE:
2094 nOldTool = infoPtr->nTool;
2095 infoPtr->nTool = TOOLTIPS_CheckTool (infoPtr, FALSE);
2096 TRACE("tool (%p) %d %d %d\n", infoPtr->hwndSelf, nOldTool,
2097 infoPtr->nTool, infoPtr->nCurrentTool);
2098 if (infoPtr->nTool != nOldTool) {
2099 if(infoPtr->nTool == -1) { /* Moved out of all tools */
2100 TOOLTIPS_Hide(infoPtr);
2101 KillTimer(infoPtr->hwndSelf, ID_TIMERLEAVE);
2102 } else if (nOldTool == -1) { /* Moved from outside */
2103 ERR("How did this happen?\n");
2104 } else { /* Moved from one to another */
2105 TOOLTIPS_Hide (infoPtr);
2106 KillTimer(infoPtr->hwndSelf, ID_TIMERLEAVE);
2107 if(infoPtr->bActive) {
2108 SetTimer (infoPtr->hwndSelf, ID_TIMERSHOW, infoPtr->nReshowTime, 0);
2109 TRACE("timer 1 started!\n");
2110 }
2111 }
2112 }
2113 break;
2114
2115 default:
2116 ERR("Unknown timer id %d\n", iTimer);
2117 break;
2118 }
2119 return 0;
2120 }
2121
2122
2123 static LRESULT
2124 TOOLTIPS_WinIniChange (TOOLTIPS_INFO *infoPtr)
2125 {
2126 TOOLTIPS_InitSystemSettings (infoPtr);
2127
2128 return 0;
2129 }
2130
2131
2132 static LRESULT CALLBACK
2133 TOOLTIPS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uID, DWORD_PTR dwRef)
2134 {
2135 TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr ((HWND)dwRef);
2136 MSG msg;
2137
2138 switch(uMsg) {
2139 case WM_MOUSEMOVE:
2140 case WM_LBUTTONDOWN:
2141 case WM_LBUTTONUP:
2142 case WM_MBUTTONDOWN:
2143 case WM_MBUTTONUP:
2144 case WM_RBUTTONDOWN:
2145 case WM_RBUTTONUP:
2146 msg.hwnd = hwnd;
2147 msg.message = uMsg;
2148 msg.wParam = wParam;
2149 msg.lParam = lParam;
2150 TOOLTIPS_RelayEvent(infoPtr, &msg);
2151 break;
2152
2153 default:
2154 break;
2155 }
2156 return DefSubclassProc(hwnd, uMsg, wParam, lParam);
2157 }
2158
2159
2160 static LRESULT CALLBACK
2161 TOOLTIPS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2162 {
2163 TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
2164
2165 TRACE("hwnd=%p msg=%x wparam=%lx lParam=%lx\n", hwnd, uMsg, wParam, lParam);
2166 if (!infoPtr && (uMsg != WM_CREATE) && (uMsg != WM_NCCREATE))
2167 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
2168 switch (uMsg)
2169 {
2170 case TTM_ACTIVATE:
2171 return TOOLTIPS_Activate (infoPtr, (BOOL)wParam);
2172
2173 case TTM_ADDTOOLA:
2174 case TTM_ADDTOOLW:
2175 return TOOLTIPS_AddToolT (infoPtr, (LPTTTOOLINFOW)lParam, uMsg == TTM_ADDTOOLW);
2176
2177 case TTM_DELTOOLA:
2178 case TTM_DELTOOLW:
2179 return TOOLTIPS_DelToolT (infoPtr, (LPTOOLINFOW)lParam,
2180 uMsg == TTM_DELTOOLW);
2181 case TTM_ENUMTOOLSA:
2182 case TTM_ENUMTOOLSW:
2183 return TOOLTIPS_EnumToolsT (infoPtr, (UINT)wParam, (LPTTTOOLINFOW)lParam,
2184 uMsg == TTM_ENUMTOOLSW);
2185 case TTM_GETBUBBLESIZE:
2186 return TOOLTIPS_GetBubbleSize (infoPtr, (LPTTTOOLINFOW)lParam);
2187
2188 case TTM_GETCURRENTTOOLA:
2189 case TTM_GETCURRENTTOOLW:
2190 return TOOLTIPS_GetCurrentToolT (infoPtr, (LPTTTOOLINFOW)lParam,
2191 uMsg == TTM_GETCURRENTTOOLW);
2192
2193 case TTM_GETDELAYTIME:
2194 return TOOLTIPS_GetDelayTime (infoPtr, (DWORD)wParam);
2195
2196 case TTM_GETMARGIN:
2197 return TOOLTIPS_GetMargin (infoPtr, (LPRECT)lParam);
2198
2199 case TTM_GETMAXTIPWIDTH:
2200 return TOOLTIPS_GetMaxTipWidth (infoPtr);
2201
2202 case TTM_GETTEXTA:
2203 case TTM_GETTEXTW:
2204 return TOOLTIPS_GetTextT (infoPtr, (LPTTTOOLINFOW)lParam,
2205 uMsg == TTM_GETTEXTW);
2206
2207 case TTM_GETTIPBKCOLOR:
2208 return TOOLTIPS_GetTipBkColor (infoPtr);
2209
2210 case TTM_GETTIPTEXTCOLOR:
2211 return TOOLTIPS_GetTipTextColor (infoPtr);
2212
2213 case TTM_GETTOOLCOUNT:
2214 return TOOLTIPS_GetToolCount (infoPtr);
2215
2216 case TTM_GETTOOLINFOA:
2217 case TTM_GETTOOLINFOW:
2218 return TOOLTIPS_GetToolInfoT (infoPtr, (LPTTTOOLINFOW)lParam,
2219 uMsg == TTM_GETTOOLINFOW);
2220
2221 case TTM_HITTESTA:
2222 case TTM_HITTESTW:
2223 return TOOLTIPS_HitTestT (infoPtr, (LPTTHITTESTINFOW)lParam,
2224 uMsg == TTM_HITTESTW);
2225 case TTM_NEWTOOLRECTA:
2226 case TTM_NEWTOOLRECTW:
2227 return TOOLTIPS_NewToolRectT (infoPtr, (LPTTTOOLINFOW)lParam);
2228
2229 case TTM_POP:
2230 return TOOLTIPS_Pop (infoPtr);
2231
2232 case TTM_RELAYEVENT:
2233 return TOOLTIPS_RelayEvent (infoPtr, (LPMSG)lParam);
2234
2235 case TTM_SETDELAYTIME:
2236 return TOOLTIPS_SetDelayTime (infoPtr, (DWORD)wParam, (INT)LOWORD(lParam));
2237
2238 case TTM_SETMARGIN:
2239 return TOOLTIPS_SetMargin (infoPtr, (LPRECT)lParam);
2240
2241 case TTM_SETMAXTIPWIDTH:
2242 return TOOLTIPS_SetMaxTipWidth (infoPtr, (INT)lParam);
2243
2244 case TTM_SETTIPBKCOLOR:
2245 return TOOLTIPS_SetTipBkColor (infoPtr, (COLORREF)wParam);
2246
2247 case TTM_SETTIPTEXTCOLOR:
2248 return TOOLTIPS_SetTipTextColor (infoPtr, (COLORREF)wParam);
2249
2250 case TTM_SETTITLEA:
2251 case TTM_SETTITLEW:
2252 return TOOLTIPS_SetTitleT (infoPtr, (UINT_PTR)wParam, (LPCWSTR)lParam,
2253 uMsg == TTM_SETTITLEW);
2254
2255 case TTM_SETTOOLINFOA:
2256 case TTM_SETTOOLINFOW:
2257 return TOOLTIPS_SetToolInfoT (infoPtr, (LPTTTOOLINFOW)lParam,
2258 uMsg == TTM_SETTOOLINFOW);
2259
2260 case TTM_TRACKACTIVATE:
2261 return TOOLTIPS_TrackActivate (infoPtr, (BOOL)wParam, (LPTTTOOLINFOA)lParam);
2262
2263 case TTM_TRACKPOSITION:
2264 return TOOLTIPS_TrackPosition (infoPtr, lParam);
2265
2266 case TTM_UPDATE:
2267 return TOOLTIPS_Update (infoPtr);
2268
2269 case TTM_UPDATETIPTEXTA:
2270 case TTM_UPDATETIPTEXTW:
2271 return TOOLTIPS_UpdateTipTextT (infoPtr, (LPTTTOOLINFOW)lParam,
2272 uMsg == TTM_UPDATETIPTEXTW);
2273
2274 case TTM_WINDOWFROMPOINT:
2275 return (LRESULT)WindowFromPoint (*((LPPOINT)lParam));
2276
2277 case WM_CREATE:
2278 return TOOLTIPS_Create (hwnd);
2279
2280 case WM_DESTROY:
2281 return TOOLTIPS_Destroy (infoPtr);
2282
2283 case WM_ERASEBKGND:
2284 /* we draw the background in WM_PAINT */
2285 return 0;
2286
2287 case WM_GETFONT:
2288 return TOOLTIPS_GetFont (infoPtr);
2289
2290 case WM_GETTEXT:
2291 return TOOLTIPS_OnWMGetText (infoPtr, wParam, (LPWSTR)lParam);
2292
2293 case WM_GETTEXTLENGTH:
2294 return TOOLTIPS_GetTextLength (infoPtr);
2295
2296 case WM_LBUTTONDOWN:
2297 case WM_LBUTTONUP:
2298 case WM_MBUTTONDOWN:
2299 case WM_MBUTTONUP:
2300 case WM_RBUTTONDOWN:
2301 case WM_RBUTTONUP:
2302 case WM_MOUSEMOVE:
2303 return TOOLTIPS_MouseMessage (infoPtr);
2304
2305 case WM_NCCREATE:
2306 return TOOLTIPS_NCCreate (hwnd);
2307
2308 case WM_NCHITTEST:
2309 return TOOLTIPS_NCHitTest (infoPtr, wParam, lParam);
2310
2311 case WM_NOTIFYFORMAT:
2312 return TOOLTIPS_NotifyFormat (infoPtr, wParam, lParam);
2313
2314 case WM_PRINTCLIENT:
2315 case WM_PAINT:
2316 return TOOLTIPS_Paint (infoPtr, (HDC)wParam);
2317
2318 case WM_SETFONT:
2319 return TOOLTIPS_SetFont (infoPtr, (HFONT)wParam, LOWORD(lParam));
2320
2321 case WM_SYSCOLORCHANGE:
2322 COMCTL32_RefreshSysColors();
2323 return 0;
2324
2325 case WM_TIMER:
2326 return TOOLTIPS_Timer (infoPtr, (INT)wParam);
2327
2328 case WM_WININICHANGE:
2329 return TOOLTIPS_WinIniChange (infoPtr);
2330
2331 default:
2332 if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
2333 ERR("unknown msg %04x wp=%08lx lp=%08lx\n",
2334 uMsg, wParam, lParam);
2335 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
2336 }
2337 }
2338
2339
2340 VOID
2341 TOOLTIPS_Register (void)
2342 {
2343 WNDCLASSW wndClass;
2344
2345 ZeroMemory (&wndClass, sizeof(WNDCLASSW));
2346 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS | CS_SAVEBITS;
2347 wndClass.lpfnWndProc = TOOLTIPS_WindowProc;
2348 wndClass.cbClsExtra = 0;
2349 wndClass.cbWndExtra = sizeof(TOOLTIPS_INFO *);
2350 wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW);
2351 wndClass.hbrBackground = 0;
2352 wndClass.lpszClassName = TOOLTIPS_CLASSW;
2353
2354 RegisterClassW (&wndClass);
2355
2356 hTooltipIcons[TTI_NONE] = NULL;
2357 hTooltipIcons[TTI_INFO] = LoadImageW(COMCTL32_hModule,
2358 (LPCWSTR)MAKEINTRESOURCE(IDI_TT_INFO_SM), IMAGE_ICON, 0, 0, 0);
2359 hTooltipIcons[TTI_WARNING] = LoadImageW(COMCTL32_hModule,
2360 (LPCWSTR)MAKEINTRESOURCE(IDI_TT_WARN_SM), IMAGE_ICON, 0, 0, 0);
2361 hTooltipIcons[TTI_ERROR] = LoadImageW(COMCTL32_hModule,
2362 (LPCWSTR)MAKEINTRESOURCE(IDI_TT_ERROR_SM), IMAGE_ICON, 0, 0, 0);
2363 }
2364
2365
2366 VOID
2367 TOOLTIPS_Unregister (void)
2368 {
2369 int i;
2370 for (i = TTI_INFO; i <= TTI_ERROR; i++)
2371 DestroyIcon(hTooltipIcons[i]);
2372 UnregisterClassW (TOOLTIPS_CLASSW, NULL);
2373 }
Maarten's multimedia branch