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