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