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