controls/tooltips.c

   1 /*
   2  * Tool tip control
   3  *
   4  * Copyright 1998 Eric Kohl
   5  *
   6  * TODO:
   7  *   - Tracking tooltips (under construction).
   8  *   - TTS_ALWAYSTIP (undefined).
   9  *   - Unicode support.
  10  *   - Custom draw support.
  11  *   - The "lParam" variable from NMTTDISPINFO32A is not handled
  12  *     in TOOLTIPS_GetTipText.
  13  *
  14  * Testing:
  15  *   - Run tests using Waite Group Windows95 API Bible Volume 2.
  16  *     The second cdrom (chapter 3) contains executables activate.exe,
  17  *     curtool.exe, deltool.exe, enumtools.exe, getinfo.exe, getiptxt.exe,
  18  *     hittest.exe, needtext.exe, newrect.exe, updtext.exe and winfrpt.exe.
  19  */
  20
  21 #include "windows.h"
  22 #include "commctrl.h"
  23 #include "tooltips.h"
  24 #include "heap.h"
  25 #include "win.h"
  26 #include "debug.h"
  27
  28
  29 #define ID_TIMER1  1    /* show delay timer */
  30 #define ID_TIMER2  2    /* auto pop timer */
  31 #define ID_TIMER3  3    /* tool leave timer */
  32 #define TT_SUBCLASS_PROP "CC32SubclassInfo"   /* property name of tooltip window handle */
  33
  34 #define TOOLTIPS_GetInfoPtr(wndPtr) ((TOOLTIPS_INFO *)wndPtr->wExtra[0])
  35
  36
  37 LRESULT CALLBACK
  38 TOOLTIPS_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam);
  39
  40
  41 static VOID
  42 TOOLTIPS_Refresh (WND *wndPtr, HDC32 hdc)
  43 {
  44     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
  45     RECT32 rc;
  46     INT32 oldBkMode;
  47     HFONT32 hOldFont;
  48     UINT32 uFlags = DT_EXTERNALLEADING;
  49
  50     if (infoPtr->nMaxTipWidth > -1)
  51         uFlags |= DT_WORDBREAK;
  52     if (wndPtr->dwStyle & TTS_NOPREFIX)
  53         uFlags |= DT_NOPREFIX;
  54     GetClientRect32 (wndPtr->hwndSelf, &rc);
  55     rc.left   += (2 + infoPtr->rcMargin.left);
  56     rc.top    += (2 + infoPtr->rcMargin.top);
  57     rc.right  -= (2 + infoPtr->rcMargin.right);
  58     rc.bottom -= (2 + infoPtr->rcMargin.bottom);
  59     oldBkMode = SetBkMode32 (hdc, TRANSPARENT);
  60     SetTextColor32 (hdc, infoPtr->clrText);
  61     hOldFont = SelectObject32 (hdc, infoPtr->hFont);
  62     DrawText32A (hdc, infoPtr->szTipText, -1, &rc, uFlags);
  63     SelectObject32 (hdc, hOldFont);
  64     if (oldBkMode != TRANSPARENT)
  65         SetBkMode32 (hdc, oldBkMode);
  66 }
  67
  68
  69 static VOID
  70 TOOLTIPS_GetTipText (WND *wndPtr, TOOLTIPS_INFO *infoPtr)
  71 {
  72     TTTOOL_INFO *toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
  73
  74     if (toolPtr->hinst) {
  75         TRACE (tooltips, "get res string %x %x\n",
  76                toolPtr->hinst, (int)toolPtr->lpszText);
  77         LoadString32A (toolPtr->hinst, (UINT32)toolPtr->lpszText,
  78                        infoPtr->szTipText, INFOTIPSIZE);
  79     }
  80     else if (toolPtr->lpszText) {
  81         if (toolPtr->lpszText == LPSTR_TEXTCALLBACK32A) {
  82             NMTTDISPINFO32A ttnmdi;
  83
  84             /* fill NMHDR struct */
  85             ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFO32A));
  86             ttnmdi.hdr.hwndFrom = wndPtr->hwndSelf;
  87             ttnmdi.hdr.idFrom = toolPtr->uId;
  88             ttnmdi.hdr.code = TTN_GETDISPINFO32A;
  89             ttnmdi.uFlags = toolPtr->uFlags;
  90             ttnmdi.lpszText = infoPtr->szTipText;
  91
  92             TRACE (tooltips, "hdr.idFrom = %x\n", ttnmdi.hdr.idFrom);
  93             SendMessage32A (toolPtr->hwnd, WM_NOTIFY,
  94                             (WPARAM32)toolPtr->uId, (LPARAM)&ttnmdi);
  95
  96             if (ttnmdi.hinst) {
  97                 LoadString32A (ttnmdi.hinst, (UINT32)ttnmdi.szText,
  98                                infoPtr->szTipText, INFOTIPSIZE);
  99                 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
 100                     toolPtr->hinst = ttnmdi.hinst;
 101                     toolPtr->lpszText = ttnmdi.szText;
 102                 }
 103             }
 104             else if (ttnmdi.szText[0]) {
 105                 lstrcpyn32A (infoPtr->szTipText, ttnmdi.szText, 80);
 106                 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
 107                     INT32 len = lstrlen32A (ttnmdi.szText) + 1;
 108                     toolPtr->hinst = 0;
 109                     toolPtr->lpszText =
 110                         HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len);
 111                     lstrcpy32A (toolPtr->lpszText, ttnmdi.szText);
 112                 }
 113             }
 114             else if (ttnmdi.lpszText == 0) {
 115                 /* no text available */
 116                 infoPtr->szTipText[0] = '\0';
 117             }
 118             else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACK32A) {
 119                 if (ttnmdi.lpszText != infoPtr->szTipText)
 120                     lstrcpyn32A (infoPtr->szTipText, ttnmdi.lpszText,
 121                                  INFOTIPSIZE);
 122                 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
 123                     INT32 len = lstrlen32A (ttnmdi.lpszText) + 1;
 124                     toolPtr->hinst = 0;
 125                     toolPtr->lpszText =
 126                         HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len);
 127                     lstrcpy32A (toolPtr->lpszText, ttnmdi.lpszText);
 128                 }
 129             }
 130             else
 131                 ERR (tooltips, "recursive text callback!\n");
 132         }
 133         else
 134             lstrcpyn32A (infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
 135     }
 136     else
 137         /* no text available */
 138         infoPtr->szTipText[0] = '\0';
 139
 140     TRACE (tooltips, "\"%s\"\n", infoPtr->szTipText);
 141 }
 142
 143
 144 static VOID
 145 TOOLTIPS_CalcTipSize (WND *wndPtr, TOOLTIPS_INFO *infoPtr, LPSIZE32 lpSize)
 146 {
 147     HDC32 hdc;
 148     HFONT32 hOldFont;
 149     UINT32 uFlags = DT_EXTERNALLEADING | DT_CALCRECT;
 150     RECT32 rc = {0, 0, 0, 0};
 151
 152     if (infoPtr->nMaxTipWidth > -1) {
 153         rc.right = infoPtr->nMaxTipWidth;
 154         uFlags |= DT_WORDBREAK;
 155     }
 156     if (wndPtr->dwStyle & TTS_NOPREFIX)
 157         uFlags |= DT_NOPREFIX;
 158     TRACE (tooltips, "\"%s\"\n", infoPtr->szTipText);
 159
 160     hdc = GetDC32 (wndPtr->hwndSelf);
 161     hOldFont = SelectObject32 (hdc, infoPtr->hFont);
 162     DrawText32A (hdc, infoPtr->szTipText, -1, &rc, uFlags);
 163     SelectObject32 (hdc, hOldFont);
 164     ReleaseDC32 (wndPtr->hwndSelf, hdc);
 165
 166     lpSize->cx = rc.right - rc.left + 4 +
 167                  infoPtr->rcMargin.left + infoPtr->rcMargin.right;
 168     lpSize->cy = rc.bottom - rc.top + 4 +
 169                  infoPtr->rcMargin.bottom + infoPtr->rcMargin.top;
 170 }
 171
 172
 173 static VOID
 174 TOOLTIPS_Show (WND *wndPtr, TOOLTIPS_INFO *infoPtr)
 175 {
 176     TTTOOL_INFO *toolPtr;
 177     POINT32 pt;
 178     SIZE32 size;
 179     NMHDR hdr;
 180
 181     if (infoPtr->nTool == -1) {
 182         TRACE (tooltips, "invalid tool (-1)!\n");
 183         return;
 184     }
 185
 186     infoPtr->nCurrentTool = infoPtr->nTool;
 187
 188     TRACE (tooltips, "Show tooltip pre %d!\n", infoPtr->nTool);
 189
 190     TOOLTIPS_GetTipText (wndPtr, infoPtr);
 191
 192     if (infoPtr->szTipText[0] == '\0') {
 193         infoPtr->nCurrentTool = -1;
 194         return;
 195     }
 196
 197     TRACE (tooltips, "Show tooltip %d!\n", infoPtr->nCurrentTool);
 198     toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
 199
 200     hdr.hwndFrom = wndPtr->hwndSelf;
 201     hdr.idFrom = toolPtr->uId;
 202     hdr.code = TTN_SHOW;
 203     SendMessage32A (toolPtr->hwnd, WM_NOTIFY,
 204                     (WPARAM32)toolPtr->uId, (LPARAM)&hdr);
 205
 206     TRACE (tooltips, "\"%s\"\n", infoPtr->szTipText);
 207
 208     TOOLTIPS_CalcTipSize (wndPtr, infoPtr, &size);
 209     TRACE (tooltips, "size %d - %d\n", size.cx, size.cy);
 210
 211     if ((toolPtr->uFlags & TTF_TRACK) && (toolPtr->uFlags & TTF_ABSOLUTE)) {
 212         pt.x = infoPtr->xTrackPos;
 213         pt.y = infoPtr->yTrackPos;
 214     }
 215     else if (toolPtr->uFlags & TTF_CENTERTIP) {
 216         RECT32 rect;
 217
 218         if (toolPtr->uFlags & TTF_IDISHWND)
 219             GetWindowRect32 ((HWND32)toolPtr->uId, &rect);
 220         else {
 221             rect = toolPtr->rect;
 222             MapWindowPoints32 (toolPtr->hwnd, (HWND32)0, (LPPOINT32)&rect, 2);
 223         }
 224         pt.x = (rect.left + rect.right - size.cx) / 2;
 225         pt.y = rect.bottom + 2;
 226     }
 227     else {
 228         GetCursorPos32 (&pt);
 229         pt.y += 20;
 230     }
 231
 232     TRACE (tooltips, "pos %d - %d\n", pt.x, pt.y);
 233
 234 //    SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, 1, 1,
 235     SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, pt.x, pt.y,
 236                     size.cx, size.cy, SWP_SHOWWINDOW);
 237
 238     SetTimer32 (wndPtr->hwndSelf, ID_TIMER2, infoPtr->nAutoPopTime, 0);
 239 }
 240
 241
 242 static VOID
 243 TOOLTIPS_Hide (WND *wndPtr, TOOLTIPS_INFO *infoPtr)
 244 {
 245     TTTOOL_INFO *toolPtr;
 246     NMHDR hdr;
 247
 248     if (infoPtr->nCurrentTool == -1)
 249         return;
 250
 251     toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
 252     TRACE (tooltips, "Hide tooltip %d!\n", infoPtr->nCurrentTool);
 253     KillTimer32 (wndPtr->hwndSelf, ID_TIMER2);
 254
 255     hdr.hwndFrom = wndPtr->hwndSelf;
 256     hdr.idFrom = toolPtr->uId;
 257     hdr.code = TTN_POP;
 258     SendMessage32A (toolPtr->hwnd, WM_NOTIFY,
 259                     (WPARAM32)toolPtr->uId, (LPARAM)&hdr);
 260
 261     infoPtr->nCurrentTool = -1;
 262
 263     SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, 0, 0, 0, 0, SWP_HIDEWINDOW);
 264 }
 265
 266
 267 static INT32
 268 TOOLTIPS_GetToolFromInfoA (TOOLTIPS_INFO *infoPtr, LPTTTOOLINFO32A lpToolInfo)
 269 {
 270     TTTOOL_INFO *toolPtr;
 271     INT32 nTool;
 272
 273     for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
 274         toolPtr = &infoPtr->tools[nTool];
 275
 276         if (!(toolPtr->uFlags & TTF_IDISHWND) &&
 277             (lpToolInfo->hwnd == toolPtr->hwnd) &&
 278             (lpToolInfo->uId == toolPtr->uId))
 279             return nTool;
 280     }
 281
 282     for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
 283         toolPtr = &infoPtr->tools[nTool];
 284
 285         if ((toolPtr->uFlags & TTF_IDISHWND) &&
 286             (lpToolInfo->uId == toolPtr->uId))
 287             return nTool;
 288     }
 289
 290     return -1;
 291 }
 292
 293
 294 static INT32
 295 TOOLTIPS_GetToolFromPoint (TOOLTIPS_INFO *infoPtr, HWND32 hwnd, LPPOINT32 lpPt)
 296 {
 297     TTTOOL_INFO *toolPtr;
 298     INT32  nTool;
 299
 300     for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
 301         toolPtr = &infoPtr->tools[nTool];
 302
 303         if (!(toolPtr->uFlags & TTF_IDISHWND)) {
 304             if (hwnd != toolPtr->hwnd)
 305                 continue;
 306             if (!PtInRect32 (&toolPtr->rect, *lpPt))
 307                 continue;
 308             return nTool;
 309         }
 310     }
 311
 312     for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
 313         toolPtr = &infoPtr->tools[nTool];
 314
 315         if (toolPtr->uFlags & TTF_IDISHWND) {
 316             if ((HWND32)toolPtr->uId == hwnd)
 317                 return nTool;
 318         }
 319     }
 320
 321     return -1;
 322 }
 323
 324
 325 static INT32
 326 TOOLTIPS_GetToolFromMessage (TOOLTIPS_INFO *infoPtr, HWND32 hwndTool)
 327 {
 328     DWORD   dwPos;
 329     POINT32 pt;
 330
 331     dwPos = GetMessagePos ();
 332     pt.x = (INT32)LOWORD(dwPos);
 333     pt.y = (INT32)HIWORD(dwPos);
 334     ScreenToClient32 (hwndTool, &pt);
 335
 336     return TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt);
 337 }
 338
 339
 340 static BOOL32
 341 TOOLTIPS_CheckTool (WND *wndPtr)
 342 {
 343     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 344     POINT32 pt;
 345     HWND32 hwndTool;
 346     INT32 nTool;
 347
 348     GetCursorPos32 (&pt);
 349     hwndTool =
 350         SendMessage32A (wndPtr->hwndSelf, TTM_WINDOWFROMPOINT, 0, (LPARAM)&pt);
 351     if (hwndTool == 0)
 352         return FALSE;
 353
 354     ScreenToClient32 (hwndTool, &pt);
 355     nTool = TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt);
 356     TRACE (tooltips, "tool %d\n", nTool);
 357
 358     return (nTool != -1);
 359 }
 360
 361
 362 static LRESULT
 363 TOOLTIPS_Activate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 364 {
 365     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 366
 367     infoPtr->bActive = (BOOL32)wParam;
 368
 369     if (infoPtr->bActive)
 370         TRACE (tooltips, "activate!\n");
 371
 372     if (!(infoPtr->bActive) && (infoPtr->nCurrentTool != -1))
 373             TOOLTIPS_Hide (wndPtr, infoPtr);
 374
 375     return 0;
 376 }
 377
 378
 379 static LRESULT
 380 TOOLTIPS_AddTool32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 381 {
 382     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 383     LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam;
 384     TTTOOL_INFO *toolPtr;
 385
 386     if (lpToolInfo == NULL) return FALSE;
 387
 388     TRACE (tooltips, "add tool (%x) %x %d%s!\n",
 389            wndPtr->hwndSelf, lpToolInfo->hwnd, lpToolInfo->uId,
 390            (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
 391
 392     if (infoPtr->uNumTools == 0) {
 393         infoPtr->tools =
 394             HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 395                        sizeof(TTTOOL_INFO));
 396         toolPtr = infoPtr->tools;
 397     }
 398     else {
 399         TTTOOL_INFO *oldTools = infoPtr->tools;
 400         infoPtr->tools =
 401             HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 402                        sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
 403         memcpy (infoPtr->tools, oldTools,
 404                 infoPtr->uNumTools * sizeof(TTTOOL_INFO));
 405         HeapFree (GetProcessHeap (), 0, oldTools);
 406         toolPtr = &infoPtr->tools[infoPtr->uNumTools];
 407     }
 408
 409     infoPtr->uNumTools++;
 410
 411     /* copy tool data */
 412     toolPtr->uFlags = lpToolInfo->uFlags;
 413     toolPtr->hwnd   = lpToolInfo->hwnd;
 414     toolPtr->uId    = lpToolInfo->uId;
 415     toolPtr->rect   = lpToolInfo->rect;
 416     toolPtr->hinst  = lpToolInfo->hinst;
 417
 418     if (lpToolInfo->hinst) {
 419         TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
 420         toolPtr->lpszText = lpToolInfo->lpszText;
 421     }
 422     else if (lpToolInfo->lpszText) {
 423         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32A) {
 424             TRACE (tooltips, "add CALLBACK!\n");
 425             toolPtr->lpszText = lpToolInfo->lpszText;
 426         }
 427         else {
 428             INT32 len = lstrlen32A (lpToolInfo->lpszText);
 429             TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
 430             toolPtr->lpszText =
 431                 HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len + 1);
 432             lstrcpy32A (toolPtr->lpszText, lpToolInfo->lpszText);
 433         }
 434     }
 435
 436     if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A))
 437         toolPtr->lParam = lpToolInfo->lParam;
 438
 439     /* install subclassing */
 440     if (toolPtr->uFlags & TTF_SUBCLASS) {
 441         if (toolPtr->uFlags & TTF_IDISHWND) {
 442             LPTT_SUBCLASS_INFO lpttsi =
 443                 (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, TT_SUBCLASS_PROP);
 444             if (lpttsi == NULL) {
 445                 lpttsi = (LPTT_SUBCLASS_INFO)HeapAlloc (GetProcessHeap(),
 446                     HEAP_ZERO_MEMORY, sizeof(TT_SUBCLASS_INFO));
 447                 lpttsi->wpOrigProc =
 448                     (WNDPROC32)SetWindowLong32A ((HWND32)toolPtr->uId,
 449                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
 450                 lpttsi->hwndToolTip = wndPtr->hwndSelf;
 451                 lpttsi->uRefCount++;
 452                 SetProp32A ((HWND32)toolPtr->uId, TT_SUBCLASS_PROP,
 453                             (HANDLE32)lpttsi);
 454             }
 455             else
 456                 ERR (tooltips, "A window tool must only be listed once!\n");
 457         }
 458         else {
 459             LPTT_SUBCLASS_INFO lpttsi =
 460                 (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, TT_SUBCLASS_PROP);
 461             if (lpttsi == NULL) {
 462                 lpttsi = (LPTT_SUBCLASS_INFO)HeapAlloc (GetProcessHeap(),
 463                     HEAP_ZERO_MEMORY, sizeof(TT_SUBCLASS_INFO));
 464                 lpttsi->wpOrigProc =
 465                     (WNDPROC32)SetWindowLong32A (toolPtr->hwnd,
 466                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
 467                 lpttsi->hwndToolTip = wndPtr->hwndSelf;
 468                 lpttsi->uRefCount++;
 469                 SetProp32A (toolPtr->hwnd, TT_SUBCLASS_PROP, (HANDLE32)lpttsi);
 470             }
 471             else
 472                 lpttsi->uRefCount++;
 473         }
 474         TRACE (tooltips, "subclassing installed!\n");
 475     }
 476
 477     return TRUE;
 478 }
 479
 480
 481 // << TOOLTIPS_AddTool32W >>
 482
 483
 484 static LRESULT
 485 TOOLTIPS_DelTool32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 486 {
 487     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 488     LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam;
 489     TTTOOL_INFO *toolPtr;
 490     INT32 nTool;
 491
 492     if (lpToolInfo == NULL) return 0;
 493     if (infoPtr->uNumTools == 0) return 0;
 494
 495     nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
 496     if (nTool == -1) return 0;
 497
 498     TRACE (tooltips, "tool %d\n", nTool);
 499
 500     /* delete text string */
 501     toolPtr = &infoPtr->tools[nTool];
 502     if ((toolPtr->hinst) && (toolPtr->lpszText)) {
 503         if (toolPtr->lpszText != LPSTR_TEXTCALLBACK32A)
 504             HeapFree (GetProcessHeap (), 0, toolPtr->lpszText);
 505     }
 506
 507     /* remove subclassing */
 508     if (toolPtr->uFlags & TTF_SUBCLASS) {
 509         if (toolPtr->uFlags & TTF_IDISHWND) {
 510             LPTT_SUBCLASS_INFO lpttsi =
 511                 (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, TT_SUBCLASS_PROP);
 512             if (lpttsi) {
 513                 SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC,
 514                                   (LONG)lpttsi->wpOrigProc);
 515                 RemoveProp32A ((HWND32)toolPtr->uId, TT_SUBCLASS_PROP);
 516                 HeapFree (GetProcessHeap(), 0, &lpttsi);
 517             }
 518             else
 519                 ERR (tooltips, "Invalid data handle!\n");
 520         }
 521         else {
 522             LPTT_SUBCLASS_INFO lpttsi =
 523                 (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, TT_SUBCLASS_PROP);
 524             if (lpttsi) {
 525                 if (lpttsi->uRefCount == 1) {
 526                     SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC,
 527                                       (LONG)lpttsi->wpOrigProc);
 528                     RemoveProp32A ((HWND32)toolPtr->uId, TT_SUBCLASS_PROP);
 529                     HeapFree (GetProcessHeap(), 0, &lpttsi);
 530                 }
 531                 else
 532                     lpttsi->uRefCount--;
 533             }
 534             else
 535                 ERR (tooltips, "Invalid data handle!\n");
 536         }
 537     }
 538
 539     /* delete tool from tool list */
 540     if (infoPtr->uNumTools == 1) {
 541         HeapFree (GetProcessHeap (), 0, infoPtr->tools);
 542         infoPtr->tools = NULL;
 543     }
 544     else {
 545         TTTOOL_INFO *oldTools = infoPtr->tools;
 546         infoPtr->tools =
 547             HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 548                        sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
 549
 550         if (nTool > 0)
 551             memcpy (&infoPtr->tools[0], &oldTools[0],
 552                     nTool * sizeof(TTTOOL_INFO));
 553
 554         if (nTool < infoPtr->uNumTools - 1)
 555             memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
 556                     (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
 557
 558         HeapFree (GetProcessHeap (), 0, oldTools);
 559     }
 560
 561     infoPtr->uNumTools--;
 562
 563     return 0;
 564 }
 565
 566
 567 // << TOOLTIPS_DelTool32W >>
 568
 569
 570 static LRESULT
 571 TOOLTIPS_EnumTools32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 572 {
 573     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 574     UINT32 uIndex = (UINT32)wParam;
 575     LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam;
 576     TTTOOL_INFO *toolPtr;
 577
 578     if (uIndex >= infoPtr->uNumTools) return FALSE;
 579     if (lpToolInfo == NULL) return FALSE;
 580
 581     TRACE (tooltips, "index=%u\n", uIndex);
 582
 583     toolPtr = &infoPtr->tools[uIndex];
 584
 585     /* copy tool data */
 586     lpToolInfo->uFlags   = toolPtr->uFlags;
 587     lpToolInfo->hwnd     = toolPtr->hwnd;
 588     lpToolInfo->uId      = toolPtr->uId;
 589     lpToolInfo->rect     = toolPtr->rect;
 590     lpToolInfo->hinst    = toolPtr->hinst;
 591     lpToolInfo->lpszText = toolPtr->lpszText;
 592
 593     if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A))
 594         lpToolInfo->lParam = toolPtr->lParam;
 595
 596     return TRUE;
 597 }
 598
 599
 600 // << TOOLTIPS_EnumTools32W >>
 601
 602
 603 static LRESULT
 604 TOOLTIPS_GetCurrentTool32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 605 {
 606     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 607     LPTTTOOLINFO32A lpti = (LPTTTOOLINFO32A)lParam;
 608     TTTOOL_INFO *toolPtr;
 609
 610     if (lpti) {
 611         if (infoPtr->nCurrentTool > -1) {
 612             toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
 613
 614             /* copy tool data */
 615             lpti->uFlags   = toolPtr->uFlags;
 616             lpti->rect     = toolPtr->rect;
 617             lpti->hinst    = toolPtr->hinst;
 618             lpti->lpszText = toolPtr->lpszText;
 619
 620             if (lpti->cbSize >= sizeof(TTTOOLINFO32A))
 621                 lpti->lParam = toolPtr->lParam;
 622
 623             return TRUE;
 624         }
 625         else
 626             return FALSE;
 627     }
 628     else
 629         return (infoPtr->nCurrentTool != -1);
 630
 631     return FALSE;
 632 }
 633
 634
 635 // << TOOLTIPS_GetCurrentTool32W >>
 636
 637
 638 static LRESULT
 639 TOOLTIPS_GetDelayTime (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 640 {
 641     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 642
 643     switch (wParam) {
 644         case TTDT_AUTOMATIC:
 645             return infoPtr->nAutomaticTime;
 646
 647         case TTDT_RESHOW:
 648             return infoPtr->nReshowTime;
 649
 650         case TTDT_AUTOPOP:
 651             return infoPtr->nAutoPopTime;
 652
 653         case TTDT_INITIAL:
 654             return infoPtr->nInitialTime;
 655     }
 656
 657     return 0;
 658 }
 659
 660
 661 static LRESULT
 662 TOOLTIPS_GetMargin (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 663 {
 664     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 665     LPRECT32 lpRect = (LPRECT32)lParam;
 666
 667     lpRect->left   = infoPtr->rcMargin.left;
 668     lpRect->right  = infoPtr->rcMargin.right;
 669     lpRect->bottom = infoPtr->rcMargin.bottom;
 670     lpRect->top    = infoPtr->rcMargin.top;
 671
 672     return 0;
 673 }
 674
 675
 676 static LRESULT
 677 TOOLTIPS_GetMaxTipWidth (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 678 {
 679     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 680
 681     return infoPtr->nMaxTipWidth;
 682 }
 683
 684
 685 static LRESULT
 686 TOOLTIPS_GetText32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 687 {
 688     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 689     LPTTTOOLINFO32A lpti = (LPTTTOOLINFO32A)lParam;
 690     INT32 nTool;
 691
 692     if (!(lpti)) return 0;
 693     if (lpti->cbSize < sizeof(TTTOOLINFO32A)) return 0;
 694
 695     nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpti);
 696     if (nTool == -1) return 0;
 697
 698     lstrcpy32A (lpti->lpszText, infoPtr->tools[nTool].lpszText);
 699
 700     return 0;
 701 }
 702
 703
 704 // << TOOLTIPS_GetText32W >>
 705
 706
 707 static LRESULT
 708 TOOLTIPS_GetTipBkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 709 {
 710     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 711     return infoPtr->clrBk;
 712 }
 713
 714
 715 static LRESULT
 716 TOOLTIPS_GetTipTextColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 717 {
 718     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 719     return infoPtr->clrText;
 720 }
 721
 722
 723 static LRESULT
 724 TOOLTIPS_GetToolCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 725 {
 726     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 727     return infoPtr->uNumTools;
 728 }
 729
 730
 731 static LRESULT
 732 TOOLTIPS_GetToolInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 733 {
 734     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 735     LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam;
 736     TTTOOL_INFO *toolPtr;
 737     INT32 nTool;
 738
 739     if (lpToolInfo == NULL) return FALSE;
 740     if (infoPtr->uNumTools == 0) return FALSE;
 741
 742     nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
 743     if (nTool == -1) return FALSE;
 744
 745     TRACE (tooltips, "tool %d\n", nTool);
 746
 747     toolPtr = &infoPtr->tools[nTool];
 748
 749     /* copy tool data */
 750     lpToolInfo->uFlags   = toolPtr->uFlags;
 751     lpToolInfo->rect     = toolPtr->rect;
 752     lpToolInfo->hinst    = toolPtr->hinst;
 753     lpToolInfo->lpszText = toolPtr->lpszText;
 754
 755     if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A))
 756         lpToolInfo->lParam = toolPtr->lParam;
 757
 758     return TRUE;
 759 }
 760
 761
 762 // << TOOLTIPS_GetToolInfo32W >>
 763
 764
 765 static LRESULT
 766 TOOLTIPS_HitTest32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 767 {
 768     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 769     LPTTHITTESTINFO32A lptthit = (LPTTHITTESTINFO32A)lParam;
 770     TTTOOL_INFO *toolPtr;
 771     INT32 nTool;
 772
 773     if (lptthit == 0)
 774         return FALSE;
 775
 776     nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt);
 777     if (nTool == -1)
 778         return FALSE;
 779
 780     TRACE (tooltips, "tool %d!\n", nTool);
 781
 782     /* copy tool data */
 783     toolPtr = &infoPtr->tools[nTool];
 784     lptthit->ti.cbSize   = sizeof(TTTOOLINFO32A);
 785     lptthit->ti.uFlags   = toolPtr->uFlags;
 786     lptthit->ti.hwnd     = toolPtr->hwnd;
 787     lptthit->ti.uId      = toolPtr->uId;
 788     lptthit->ti.rect     = toolPtr->rect;
 789     lptthit->ti.hinst    = toolPtr->hinst;
 790     lptthit->ti.lpszText = toolPtr->lpszText;
 791     lptthit->ti.lParam   = toolPtr->lParam;
 792
 793     return TRUE;
 794 }
 795
 796
 797 // << TOOLTIPS_HitTest32W >>
 798
 799
 800 static LRESULT
 801 TOOLTIPS_NewToolRect32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 802 {
 803     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 804     LPTTTOOLINFO32A lpti = (LPTTTOOLINFO32A)lParam;
 805     INT32 nTool;
 806
 807     if (!(lpti)) return 0;
 808 #if 0
 809     if (lpti->cbSize < sizeof(TTTOOLINFO32A)) return 0;
 810 #endif
 811
 812     nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpti);
 813     if (nTool == -1) return 0;
 814
 815     infoPtr->tools[nTool].rect = lpti->rect;
 816
 817     return 0;
 818 }
 819
 820
 821 // << TOOLTIPS_NewToolRect32W >>
 822
 823
 824 static LRESULT
 825 TOOLTIPS_Pop (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 826 {
 827     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 828
 829     TOOLTIPS_Hide (wndPtr, infoPtr);
 830
 831     return 0;
 832 }
 833
 834
 835 static LRESULT
 836 TOOLTIPS_RelayEvent (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 837 {
 838     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 839     LPMSG32 lpMsg = (LPMSG32)lParam;
 840     POINT32 pt;
 841
 842     if (lParam == NULL) {
 843         ERR (tooltips, "lpMsg == NULL!\n");
 844         return 0;
 845     }
 846
 847     switch (lpMsg->message) {
 848         case WM_LBUTTONDOWN:
 849         case WM_LBUTTONUP:
 850         case WM_MBUTTONDOWN:
 851         case WM_MBUTTONUP:
 852         case WM_RBUTTONDOWN:
 853         case WM_RBUTTONUP:
 854             pt = lpMsg->pt;
 855             ScreenToClient32 (lpMsg->hwnd, &pt);
 856             infoPtr->nOldTool = infoPtr->nTool;
 857             infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
 858             TRACE (tooltips, "tool (%x) %d %d\n",
 859                    wndPtr->hwndSelf, infoPtr->nOldTool, infoPtr->nTool);
 860             TOOLTIPS_Hide (wndPtr, infoPtr);
 861             break;
 862
 863         case WM_MOUSEMOVE:
 864             pt = lpMsg->pt;
 865             ScreenToClient32 (lpMsg->hwnd, &pt);
 866             infoPtr->nOldTool = infoPtr->nTool;
 867             infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
 868             TRACE (tooltips, "tool (%x) %d %d\n",
 869                    wndPtr->hwndSelf, infoPtr->nOldTool, infoPtr->nTool);
 870             TRACE (tooltips, "WM_MOUSEMOVE (%04x %d %d)\n",
 871                    wndPtr->hwndSelf, pt.x, pt.y);
 872             if ((infoPtr->bActive) && (infoPtr->nTool != infoPtr->nOldTool)) {
 873                 if (infoPtr->nOldTool == -1) {
 874                     SetTimer32 (wndPtr->hwndSelf, ID_TIMER1,
 875                                 infoPtr->nInitialTime, 0);
 876                     TRACE (tooltips, "timer 1 started!\n");
 877                 }
 878                 else {
 879                     TOOLTIPS_Hide (wndPtr, infoPtr);
 880                     SetTimer32 (wndPtr->hwndSelf, ID_TIMER1,
 881                                 infoPtr->nReshowTime, 0);
 882                     TRACE (tooltips, "timer 2 started!\n");
 883                 }
 884             }
 885             if (infoPtr->nCurrentTool != -1) {
 886                 SetTimer32 (wndPtr->hwndSelf, ID_TIMER3, 100, 0);
 887                 TRACE (tooltips, "timer 3 started!\n");
 888             }
 889             break;
 890     }
 891
 892     return 0;
 893 }
 894
 895
 896 static LRESULT
 897 TOOLTIPS_SetDelayTime (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 898 {
 899     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 900     INT32 nTime = (INT32)LOWORD(lParam);
 901
 902     switch (wParam) {
 903         case TTDT_AUTOMATIC:
 904             if (nTime == 0) {
 905                 infoPtr->nAutomaticTime = 500;
 906                 infoPtr->nReshowTime    = 100;
 907                 infoPtr->nAutoPopTime   = 5000;
 908                 infoPtr->nInitialTime   = 500;
 909             }
 910             else {
 911                 infoPtr->nAutomaticTime = nTime;
 912                 infoPtr->nReshowTime    = nTime / 5;
 913                 infoPtr->nAutoPopTime   = nTime * 10;
 914                 infoPtr->nInitialTime   = nTime;
 915             }
 916             break;
 917
 918         case TTDT_RESHOW:
 919             infoPtr->nReshowTime = nTime;
 920             break;
 921
 922         case TTDT_AUTOPOP:
 923             infoPtr->nAutoPopTime = nTime;
 924             break;
 925
 926         case TTDT_INITIAL:
 927             infoPtr->nInitialTime = nTime;
 928             break;
 929     }
 930
 931     return 0;
 932 }
 933
 934
 935 static LRESULT
 936 TOOLTIPS_SetMargin (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 937 {
 938     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 939     LPRECT32 lpRect = (LPRECT32)lParam;
 940
 941     infoPtr->rcMargin.left   = lpRect->left;
 942     infoPtr->rcMargin.right  = lpRect->right;
 943     infoPtr->rcMargin.bottom = lpRect->bottom;
 944     infoPtr->rcMargin.top    = lpRect->top;
 945
 946     return 0;
 947 }
 948
 949
 950 static LRESULT
 951 TOOLTIPS_SetMaxTipWidth (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 952 {
 953     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 954     INT32 nTemp = infoPtr->nMaxTipWidth;
 955
 956     infoPtr->nMaxTipWidth = (INT32)lParam;
 957
 958     return nTemp;
 959 }
 960
 961
 962 static LRESULT
 963 TOOLTIPS_SetTipBkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 964 {
 965     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 966
 967     infoPtr->clrBk = (COLORREF)wParam;
 968
 969     return 0;
 970 }
 971
 972
 973 static LRESULT
 974 TOOLTIPS_SetTipTextColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 975 {
 976     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 977
 978     infoPtr->clrText = (COLORREF)wParam;
 979
 980     return 0;
 981 }
 982
 983
 984 static LRESULT
 985 TOOLTIPS_SetToolInfo32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 986 {
 987     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
 988     LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam;
 989     TTTOOL_INFO *toolPtr;
 990     INT32 nTool;
 991
 992     if (lpToolInfo == NULL) return 0;
 993
 994     nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
 995     if (nTool == -1) return 0;
 996
 997     TRACE (tooltips, "tool %d\n", nTool);
 998
 999     toolPtr = &infoPtr->tools[nTool];
1000
1001     /* copy tool data */
1002     toolPtr->uFlags = lpToolInfo->uFlags;
1003     toolPtr->hwnd   = lpToolInfo->hwnd;
1004     toolPtr->uId    = lpToolInfo->uId;
1005     toolPtr->rect   = lpToolInfo->rect;
1006     toolPtr->hinst  = lpToolInfo->hinst;
1007
1008     if (lpToolInfo->hinst) {
1009         toolPtr->lpszText = lpToolInfo->lpszText;
1010     }
1011     else if (lpToolInfo->lpszText) {
1012         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32A)
1013             toolPtr->lpszText = lpToolInfo->lpszText;
1014         else {
1015             INT32 len = lstrlen32A (lpToolInfo->lpszText);
1016             HeapFree (GetProcessHeap (), 0, toolPtr->lpszText);
1017             toolPtr->lpszText =
1018                 HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len + 1);
1019             lstrcpy32A (toolPtr->lpszText, lpToolInfo->lpszText);
1020         }
1021     }
1022
1023     if (lpToolInfo->cbSize >= sizeof(TTTOOLINFO32A))
1024         toolPtr->lParam = lpToolInfo->lParam;
1025
1026     return 0;
1027 }
1028
1029
1030 // << TOOLTIPS_SetToolInfo32W >>
1031
1032
1033 static LRESULT
1034 TOOLTIPS_TrackActivate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1035 {
1036     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1037     LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam;
1038
1039     if ((BOOL32)wParam) {
1040         /* activate */
1041         infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
1042         if (infoPtr->nTrackTool != -1) {
1043             infoPtr->bTrackActive = TRUE;
1044
1045             /* FIXME : show tool tip */
1046         }
1047     }
1048     else {
1049         /* deactivate */
1050         /* FIXME : hide tool tip */
1051
1052         infoPtr->bTrackActive = FALSE;
1053         infoPtr->nTrackTool = -1;
1054     }
1055
1056     return 0;
1057 }
1058
1059
1060 static LRESULT
1061 TOOLTIPS_TrackPosition (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1062 {
1063     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1064
1065     infoPtr->xTrackPos = (INT32)LOWORD(lParam);
1066     infoPtr->yTrackPos = (INT32)HIWORD(lParam);
1067
1068     if (infoPtr->bTrackActive) {
1069
1070         FIXME (tooltips, "set position!\n");
1071     }
1072
1073     return 0;
1074 }
1075
1076
1077 static LRESULT
1078 TOOLTIPS_Update (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1079 {
1080     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1081
1082     if (infoPtr->nCurrentTool != -1)
1083         UpdateWindow32 (wndPtr->hwndSelf);
1084
1085     return 0;
1086 }
1087
1088
1089 static LRESULT
1090 TOOLTIPS_UpdateTipText32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1091 {
1092     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1093     LPTTTOOLINFO32A lpToolInfo = (LPTTTOOLINFO32A)lParam;
1094     TTTOOL_INFO *toolPtr;
1095     INT32 nTool;
1096
1097     if (lpToolInfo == NULL) return 0;
1098
1099     nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
1100     if (nTool == -1) return 0;
1101
1102     TRACE (tooltips, "tool %d\n", nTool);
1103
1104     toolPtr = &infoPtr->tools[nTool];
1105
1106     /* copy tool text */
1107     toolPtr->hinst  = lpToolInfo->hinst;
1108
1109     if (lpToolInfo->hinst) {
1110         toolPtr->lpszText = lpToolInfo->lpszText;
1111     }
1112     else if (lpToolInfo->lpszText) {
1113         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK32A)
1114             toolPtr->lpszText = lpToolInfo->lpszText;
1115         else {
1116             INT32 len = lstrlen32A (lpToolInfo->lpszText);
1117             HeapFree (GetProcessHeap (), 0, toolPtr->lpszText);
1118             toolPtr->lpszText =
1119                 HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, len + 1);
1120             lstrcpy32A (toolPtr->lpszText, lpToolInfo->lpszText);
1121         }
1122     }
1123
1124     return 0;
1125 }
1126
1127
1128 // << TOOLTIPS_UpdateTipText32W >>
1129
1130
1131 static LRESULT
1132 TOOLTIPS_WindowFromPoint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1133 {
1134     return WindowFromPoint32 (*((LPPOINT32)lParam));
1135 }
1136
1137
1138
1139 static LRESULT
1140 TOOLTIPS_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1141 {
1142     TOOLTIPS_INFO *infoPtr;
1143     LOGFONT32A logFont;
1144
1145     /* allocate memory for info structure */
1146     infoPtr = (TOOLTIPS_INFO *)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
1147                                           sizeof(TOOLTIPS_INFO));
1148     wndPtr->wExtra[0] = (DWORD)infoPtr;
1149
1150     if (infoPtr == NULL) {
1151         ERR (tooltips, "could not allocate info memory!\n");
1152         return 0;
1153     }
1154
1155     /* initialize info structure */
1156     infoPtr->bActive = TRUE;
1157     infoPtr->bTrackActive = FALSE;
1158     infoPtr->clrBk   = GetSysColor32 (COLOR_INFOBK);
1159     infoPtr->clrText = GetSysColor32 (COLOR_INFOTEXT);
1160
1161     SystemParametersInfo32A( SPI_GETICONTITLELOGFONT, 0, &logFont, 0 );
1162     infoPtr->hFont = CreateFontIndirect32A( &logFont );
1163
1164     infoPtr->nMaxTipWidth = -1;
1165     infoPtr->nTool = -1;
1166     infoPtr->nOldTool = -1;
1167     infoPtr->nCurrentTool = -1;
1168     infoPtr->nTrackTool = -1;
1169
1170     infoPtr->nAutomaticTime = 500;
1171     infoPtr->nReshowTime    = 100;
1172     infoPtr->nAutoPopTime   = 5000;
1173     infoPtr->nInitialTime   = 500;
1174
1175     SetWindowPos32 (wndPtr->hwndSelf, HWND_TOP, 0, 0, 0, 0, SWP_HIDEWINDOW);
1176
1177     return 0;
1178 }
1179
1180
1181 static LRESULT
1182 TOOLTIPS_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1183 {
1184     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1185     TTTOOL_INFO *toolPtr;
1186
1187     /* free tools */
1188     if (infoPtr->tools) {
1189         INT32 i;
1190         for (i = 0; i < infoPtr->uNumTools; i++) {
1191             toolPtr = &infoPtr->tools[i];
1192             if ((toolPtr->hinst) && (toolPtr->lpszText)) {
1193                 if (toolPtr->lpszText != LPSTR_TEXTCALLBACK32A)
1194                     HeapFree (GetProcessHeap (), 0, toolPtr->lpszText);
1195             }
1196
1197             /* remove subclassing */
1198             if (toolPtr->uFlags & TTF_SUBCLASS) {
1199                 LPTT_SUBCLASS_INFO lpttsi;
1200
1201                 if (toolPtr->uFlags & TTF_IDISHWND)
1202                     lpttsi = (LPTT_SUBCLASS_INFO)GetProp32A ((HWND32)toolPtr->uId, TT_SUBCLASS_PROP);
1203                 else
1204                     lpttsi = (LPTT_SUBCLASS_INFO)GetProp32A (toolPtr->hwnd, TT_SUBCLASS_PROP);
1205
1206                 if (lpttsi) {
1207                     SetWindowLong32A ((HWND32)toolPtr->uId, GWL_WNDPROC,
1208                                       (LONG)lpttsi->wpOrigProc);
1209                     RemoveProp32A ((HWND32)toolPtr->uId, TT_SUBCLASS_PROP);
1210                     HeapFree (GetProcessHeap(), 0, &lpttsi);
1211                 }
1212             }
1213         }
1214         HeapFree (GetProcessHeap (), 0, infoPtr->tools);
1215     }
1216
1217     /* delete font */
1218     DeleteObject32 (infoPtr->hFont);
1219
1220     /* free tool tips info data */
1221     HeapFree (GetProcessHeap (), 0, infoPtr);
1222
1223     return 0;
1224 }
1225
1226
1227 static LRESULT
1228 TOOLTIPS_EraseBackground (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1229 {
1230     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1231     RECT32 rect;
1232     HBRUSH32 hBrush;
1233
1234     hBrush = CreateSolidBrush32 (infoPtr->clrBk);
1235     GetClientRect32 (wndPtr->hwndSelf, &rect);
1236     FillRect32 ((HDC32)wParam, &rect, hBrush);
1237     DeleteObject32 (hBrush);
1238
1239     return FALSE;
1240 }
1241
1242
1243 static LRESULT
1244 TOOLTIPS_GetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1245 {
1246     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1247
1248     return infoPtr->hFont;
1249 }
1250
1251
1252 static LRESULT
1253 TOOLTIPS_MouseMove (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1254 {
1255     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1256
1257     TOOLTIPS_Hide (wndPtr, infoPtr);
1258
1259     return 0;
1260 }
1261
1262
1263 static LRESULT
1264 TOOLTIPS_NcCreate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1265 {
1266     wndPtr->dwStyle &= 0x0000FFFF;
1267     wndPtr->dwStyle |= (WS_POPUP | WS_BORDER);
1268
1269     return TRUE;
1270 }
1271
1272
1273 static LRESULT
1274 TOOLTIPS_Paint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1275 {
1276     HDC32 hdc;
1277     PAINTSTRUCT32 ps;
1278
1279     hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam;
1280     TOOLTIPS_Refresh (wndPtr, hdc);
1281     if (!wParam)
1282         EndPaint32 (wndPtr->hwndSelf, &ps);
1283     return 0;
1284 }
1285
1286
1287 static LRESULT
1288 TOOLTIPS_SetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1289 {
1290     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1291
1292     infoPtr->hFont = (HFONT32)wParam;
1293
1294     if ((LOWORD(lParam)) & (infoPtr->nCurrentTool != -1)) {
1295         FIXME (tooltips, "full redraw needed!\n");
1296     }
1297
1298     return 0;
1299 }
1300
1301
1302 static LRESULT
1303 TOOLTIPS_Timer (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1304 {
1305     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1306
1307     TRACE (tooltips, "timer %d (%x) expired!\n", wParam, wndPtr->hwndSelf);
1308
1309     switch (wParam)
1310     {
1311         case ID_TIMER1:
1312             KillTimer32 (wndPtr->hwndSelf, ID_TIMER1);
1313             TOOLTIPS_Show (wndPtr, infoPtr);
1314             break;
1315
1316         case ID_TIMER2:
1317             TOOLTIPS_Hide (wndPtr, infoPtr);
1318             break;
1319
1320         case ID_TIMER3:
1321             KillTimer32 (wndPtr->hwndSelf, ID_TIMER3);
1322             if (TOOLTIPS_CheckTool (wndPtr) == FALSE) {
1323                 infoPtr->nTool = -1;
1324                 infoPtr->nOldTool = -1;
1325                 TOOLTIPS_Hide (wndPtr, infoPtr);
1326             }
1327             break;
1328     }
1329     return 0;
1330 }
1331
1332
1333 static LRESULT
1334 TOOLTIPS_WinIniChange (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1335 {
1336     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1337     LOGFONT32A logFont;
1338
1339     infoPtr->clrBk   = GetSysColor32 (COLOR_INFOBK);
1340     infoPtr->clrText = GetSysColor32 (COLOR_INFOTEXT);
1341
1342     DeleteObject32 (infoPtr->hFont);
1343     SystemParametersInfo32A( SPI_GETICONTITLELOGFONT, 0, &logFont, 0 );
1344     infoPtr->hFont = CreateFontIndirect32A( &logFont );
1345
1346     return 0;
1347 }
1348
1349
1350 LRESULT CALLBACK
1351 TOOLTIPS_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
1352 {
1353     LPTT_SUBCLASS_INFO lpttsi =
1354         (LPTT_SUBCLASS_INFO)GetProp32A (hwnd, TT_SUBCLASS_PROP);
1355     WND *wndPtr;
1356     TOOLTIPS_INFO *infoPtr;
1357     UINT32 nTool;
1358
1359     switch (uMsg) {
1360         case WM_LBUTTONDOWN:
1361         case WM_LBUTTONUP:
1362         case WM_MBUTTONDOWN:
1363         case WM_MBUTTONUP:
1364         case WM_RBUTTONDOWN:
1365         case WM_RBUTTONUP:
1366             {
1367                 wndPtr = WIN_FindWndPtr(lpttsi->hwndToolTip);
1368                 infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1369                 nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
1370
1371                 TRACE (tooltips, "subclassed mouse message %04x\n", uMsg);
1372                 infoPtr->nOldTool = infoPtr->nTool;
1373                 infoPtr->nTool = nTool;
1374                 TOOLTIPS_Hide (wndPtr, infoPtr);
1375             }
1376             break;
1377
1378         case WM_MOUSEMOVE:
1379             {
1380                 wndPtr = WIN_FindWndPtr(lpttsi->hwndToolTip);
1381                 infoPtr = TOOLTIPS_GetInfoPtr(wndPtr);
1382                 nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
1383
1384                 TRACE (tooltips, "subclassed WM_MOUSEMOVE\n");
1385                 infoPtr->nOldTool = infoPtr->nTool;
1386                 infoPtr->nTool = nTool;
1387
1388                 if ((infoPtr->bActive) &&
1389                     (infoPtr->nTool != infoPtr->nOldTool)) {
1390                     if (infoPtr->nOldTool == -1) {
1391                         SetTimer32 (wndPtr->hwndSelf, ID_TIMER1,
1392                                     infoPtr->nInitialTime, 0);
1393                         TRACE (tooltips, "timer 1 started!\n");
1394                     }
1395                     else {
1396                         TOOLTIPS_Hide (wndPtr, infoPtr);
1397                         SetTimer32 (wndPtr->hwndSelf, ID_TIMER1,
1398                                 infoPtr->nReshowTime, 0);
1399                         TRACE (tooltips, "timer 2 started!\n");
1400                     }
1401                 }
1402                 if (infoPtr->nCurrentTool != -1) {
1403                     SetTimer32 (wndPtr->hwndSelf, ID_TIMER3, 100, 0);
1404                     TRACE (tooltips, "timer 3 started!\n");
1405                 }
1406             }
1407             break;
1408     }
1409
1410     return CallWindowProc32A (lpttsi->wpOrigProc, hwnd, uMsg, wParam, lParam);
1411 }
1412
1413
1414 LRESULT CALLBACK
1415 TOOLTIPS_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
1416 {
1417     WND *wndPtr = WIN_FindWndPtr(hwnd);
1418
1419     switch (uMsg)
1420     {
1421         case TTM_ACTIVATE:
1422             return TOOLTIPS_Activate (wndPtr, wParam, lParam);
1423
1424         case TTM_ADDTOOL32A:
1425             return TOOLTIPS_AddTool32A (wndPtr, wParam, lParam);
1426
1427 //      case TTM_ADDTOOL32W:
1428
1429         case TTM_DELTOOL32A:
1430             return TOOLTIPS_DelTool32A (wndPtr, wParam, lParam);
1431
1432 //      case TTM_DELTOOL32W:
1433
1434         case TTM_ENUMTOOLS32A:
1435             return TOOLTIPS_EnumTools32A (wndPtr, wParam, lParam);
1436
1437 //      case TTM_ENUMTOOLS32W:
1438
1439         case TTM_GETCURRENTTOOL32A:
1440             return TOOLTIPS_GetCurrentTool32A (wndPtr, wParam, lParam);
1441
1442 //      case TTM_GETCURRENTTOOL32W:
1443
1444         case TTM_GETDELAYTIME:
1445             return TOOLTIPS_GetDelayTime (wndPtr, wParam, lParam);
1446
1447         case TTM_GETMARGIN:
1448             return TOOLTIPS_GetMargin (wndPtr, wParam, lParam);
1449
1450         case TTM_GETMAXTIPWIDTH:
1451             return TOOLTIPS_GetMaxTipWidth (wndPtr, wParam, lParam);
1452
1453         case TTM_GETTEXT32A:
1454             return TOOLTIPS_GetText32A (wndPtr, wParam, lParam);
1455
1456 //      case TTM_GETTEXT32W:
1457
1458         case TTM_GETTIPBKCOLOR:
1459             return TOOLTIPS_GetTipBkColor (wndPtr, wParam, lParam);
1460
1461         case TTM_GETTIPTEXTCOLOR:
1462             return TOOLTIPS_GetTipTextColor (wndPtr, wParam, lParam);
1463
1464         case TTM_GETTOOLCOUNT:
1465             return TOOLTIPS_GetToolCount (wndPtr, wParam, lParam);
1466
1467         case TTM_GETTOOLINFO32A:
1468             return TOOLTIPS_GetToolInfo32A (wndPtr, wParam, lParam);
1469
1470 //      case TTM_GETTOOLINFO32W:
1471
1472         case TTM_HITTEST32A:
1473             return TOOLTIPS_HitTest32A (wndPtr, wParam, lParam);
1474
1475 //      case TTM_HITTEST32W:
1476
1477         case TTM_NEWTOOLRECT32A:
1478             return TOOLTIPS_NewToolRect32A (wndPtr, wParam, lParam);
1479
1480 //      case TTM_NEWTOOLRECT32W:
1481
1482         case TTM_POP:
1483             return TOOLTIPS_Pop (wndPtr, wParam, lParam);
1484
1485         case TTM_RELAYEVENT:
1486             return TOOLTIPS_RelayEvent (wndPtr, wParam, lParam);
1487
1488         case TTM_SETDELAYTIME:
1489             return TOOLTIPS_SetDelayTime (wndPtr, wParam, lParam);
1490
1491         case TTM_SETMARGIN:
1492             return TOOLTIPS_SetMargin (wndPtr, wParam, lParam);
1493
1494         case TTM_SETMAXTIPWIDTH:
1495             return TOOLTIPS_SetMaxTipWidth (wndPtr, wParam, lParam);
1496
1497         case TTM_SETTIPBKCOLOR:
1498             return TOOLTIPS_SetTipBkColor (wndPtr, wParam, lParam);
1499
1500         case TTM_SETTIPTEXTCOLOR:
1501             return TOOLTIPS_SetTipTextColor (wndPtr, wParam, lParam);
1502
1503         case TTM_SETTOOLINFO32A:
1504             return TOOLTIPS_SetToolInfo32A (wndPtr, wParam, lParam);
1505
1506 //      case TTM_SETTOOLINFO32W:
1507
1508         case TTM_TRACKACTIVATE:
1509             return TOOLTIPS_TrackActivate (wndPtr, wParam, lParam);
1510
1511         case TTM_TRACKPOSITION:
1512             return TOOLTIPS_TrackPosition (wndPtr, wParam, lParam);
1513
1514         case TTM_UPDATE:
1515             return TOOLTIPS_Update (wndPtr, wParam, lParam);
1516
1517         case TTM_UPDATETIPTEXT32A:
1518             return TOOLTIPS_UpdateTipText32A (wndPtr, wParam, lParam);
1519
1520 //      case TTM_UPDATETIPTEXT32W:
1521
1522         case TTM_WINDOWFROMPOINT:
1523             return TOOLTIPS_WindowFromPoint (wndPtr, wParam, lParam);
1524
1525
1526         case WM_CREATE:
1527             return TOOLTIPS_Create (wndPtr, wParam, lParam);
1528
1529         case WM_DESTROY:
1530             return TOOLTIPS_Destroy (wndPtr, wParam, lParam);
1531
1532         case WM_ERASEBKGND:
1533             return TOOLTIPS_EraseBackground (wndPtr, wParam, lParam);
1534
1535         case WM_GETFONT:
1536             return TOOLTIPS_GetFont (wndPtr, wParam, lParam);
1537
1538 //      case WM_GETTEXT:
1539 //      case WM_GETTEXTLENGTH:
1540 //      case WM_LBUTTONDOWN:
1541 //      case WM_MBUTTONDOWN:
1542
1543         case WM_MOUSEMOVE:
1544             return TOOLTIPS_MouseMove (wndPtr, wParam, lParam);
1545
1546         case WM_NCCREATE:
1547             return TOOLTIPS_NcCreate (wndPtr, wParam, lParam);
1548
1549 //      case WM_NCHITTEST:
1550 //      case WM_NOTIFYFORMAT:
1551
1552         case WM_PAINT:
1553             return TOOLTIPS_Paint (wndPtr, wParam, lParam);
1554
1555 //      case WM_PRINTCLIENT:
1556 //      case WM_RBUTTONDOWN:
1557
1558         case WM_SETFONT:
1559             return TOOLTIPS_SetFont (wndPtr, wParam, lParam);
1560
1561 //      case WM_STYLECHANGED:
1562
1563         case WM_TIMER:
1564             return TOOLTIPS_Timer (wndPtr, wParam, lParam);
1565
1566         case WM_WININICHANGE:
1567             return TOOLTIPS_WinIniChange (wndPtr, wParam, lParam);
1568
1569         default:
1570             if (uMsg >= WM_USER)
1571                 ERR (tooltips, "unknown msg %04x wp=%08x lp=%08lx\n",
1572                      uMsg, wParam, lParam);
1573             return DefWindowProc32A (hwnd, uMsg, wParam, lParam);
1574     }
1575     return 0;
1576 }
1577
1578
1579 void
1580 TOOLTIPS_Register (void)
1581 {
1582     WNDCLASS32A wndClass;
1583
1584     if (GlobalFindAtom32A (TOOLTIPS_CLASS32A)) return;
1585
1586     ZeroMemory (&wndClass, sizeof(WNDCLASS32A));
1587     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_SAVEBITS;
1588     wndClass.lpfnWndProc   = (WNDPROC32)TOOLTIPS_WindowProc;
1589     wndClass.cbClsExtra    = 0;
1590     wndClass.cbWndExtra    = sizeof(TOOLTIPS_INFO *);
1591     wndClass.hCursor       = LoadCursor32A (0, IDC_ARROW32A);
1592     wndClass.hbrBackground = 0;
1593     wndClass.lpszClassName = TOOLTIPS_CLASS32A;
1594
1595     RegisterClass32A (&wndClass);
1596 }