git.oblomov.eu Git - wine/blob - dlls/comctl32/tooltips.c

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