Changeset 3962 for trunk/src


Ignore:
Timestamp:
Aug 6, 2000, 4:40:18 PM (25 years ago)
Author:
sandervl
Message:

PD: update to wine20000801 (toolbar+tooltips)

Location:
trunk/src/comctl32
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/toolbar.cpp

    r3956 r3962  
     1/* $Id: toolbar.cpp,v 1.8 2000-08-06 14:40:17 sandervl Exp $ */
    12/*
    23 * Toolbar control

  • trunk/src/comctl32/tooltips.cpp

    r3585 r3962  
    1 /* $Id: tooltips.cpp,v 1.8 2000-05-22 17:25:12 cbratschi Exp $ */
     1/* $Id: tooltips.cpp,v 1.9 2000-08-06 14:40:18 sandervl Exp $ */
    22/*
    33 * Tool tip control
    … …  
    88 *
    99 * TODO:
     10 *   - Unicode support (started).
    1011 *   - Custom draw support.
    1112 *
    … …  
    1516 *     curtool.exe, deltool.exe, enumtools.exe, getinfo.exe, getiptxt.exe,
    1617 *     hittest.exe, needtext.exe, newrect.exe, updtext.exe and winfrpt.exe.
     18 *
     19 *   Timer logic.
     20 *
     21 * One important point to remember is that tools don't necessarily get
     22 * a WM_MOUSEMOVE once the cursor leaves the tool, an example is when
     23 * a tool sets TTF_IDISHWND (i.e. an entire window is a tool) because
     24 * here WM_MOUSEMOVEs only get sent when the cursor is inside the
     25 * client area.  Therefore the only reliable way to know that the
     26 * cursor has left a tool is to keep a timer running and check the
     27 * position every time it expires.  This is the role of timer
     28 * ID_TIMERLEAVE.
     29 *
     30 *
     31 * On entering a tool (detected in a relayed WM_MOUSEMOVE) we start
     32 * ID_TIMERSHOW, if this times out and we're still in the tool we show
     33 * the tip.  On showing a tip we start both ID_TIMERPOP and
     34 * ID_TIMERLEAVE.  On hiding a tooltip we kill ID_TIMERPOP.
     35 * ID_TIMERPOP is restarted on every relayed WM_MOUSEMOVE.  If
     36 * ID_TIMERPOP expires the tool is hidden and ID_TIMERPOP is killed.
     37 * ID_TIMERLEAVE remains running - this is important as we need to
     38 * determine when the cursor leaves the tool.
     39 *
     40 * When ID_TIMERLEAVE expires or on a relayed WM_MOUSEMOVE if we're
     41 * still in the tool do nothing (apart from restart ID_TIMERPOP if
     42 * this is a WM_MOUSEMOVE) (ID_TIMERLEAVE remains running).  If we've
     43 * left the tool and entered another one then hide the tip and start
     44 * ID_TIMERSHOW with time ReshowTime and kill ID_TIMERLEAVE.  If we're
     45 * outside all tools hide the tip and kill ID_TIMERLEAVE.  On Relayed
     46 * mouse button messages hide the tip but leave ID_TIMERLEAVE running,
     47 * this again will let us keep track of when the cursor leaves the
     48 * tool.
     49 *
     50 *
     51 * infoPtr->nTool is the tool the mouse was on on the last relayed MM
     52 * or timer expiry or -1 if the mouse was not on a tool.
     53 *
     54 * infoPtr->nCurrentTool is the tool for which the tip is currently
     55 * displaying text for or -1 if the tip is not shown.  Actually this
     56 * will only ever be infoPtr-nTool or -1, so it could be changed to a
     57 * BOOL.
     58 *
    1759 */
    1860
    1961/*
    20  - Corel WINE 20000513 level
    21  - (WINE 20000130 level)
     62 - (WINE 20000801 level)
    2263*/
    2364
    2465#include <string.h>
    2566
     67#include "winnls.h"
    2668#include "winbase.h"
    2769#include "commctrl.h"
    … …  
    3476#define ID_TIMERLEAVE  3    /* tool leave timer */
    3577
     78#ifdef __WIN32OS2__
     79  #define FIXME
     80  #define TRACE
     81  #define WARN
     82  #define ERR
     83  #define debugstr_w
     84#endif
    3685
    3786extern LPSTR COMCTL32_aSubclass; /* global subclassing atom */
    … …  
    4594TOOLTIPS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
    4695
    47 
    48 static VOID TOOLTIPS_Draw (HWND hwnd, HDC hdc)
     96static VOID
     97TOOLTIPS_Refresh (HWND hwnd, HDC hdc)
    4998{
    5099    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
    … …  
    55104    UINT uFlags = DT_EXTERNALLEADING;
    56105
    57     if (infoPtr->nMaxTipWidth > -1) uFlags |= DT_WORDBREAK;
    58     if (GetWindowLongA(hwnd,GWL_STYLE) & TTS_NOPREFIX) uFlags |= DT_NOPREFIX;
    59     GetClientRect(hwnd,&rc);
     106    if (infoPtr->nMaxTipWidth > -1)
     107        uFlags |= DT_WORDBREAK;
     108    if (GetWindowLongA (hwnd, GWL_STYLE) & TTS_NOPREFIX)
     109        uFlags |= DT_NOPREFIX;
     110    GetClientRect (hwnd, &rc);
    60111
    61112    /* fill the background */
    62     hBrush = CreateSolidBrush(infoPtr->clrBk);
    63     FillRect(hdc,&rc,hBrush);
    64     DeleteObject(hBrush);
     113    hBrush = CreateSolidBrush (infoPtr->clrBk);
     114    FillRect (hdc, &rc, hBrush);
     115    DeleteObject (hBrush);
    65116
    66117    /* calculate text rectangle */
    67     rc.left   += (2+infoPtr->rcMargin.left);
    68     rc.top    += (2+infoPtr->rcMargin.top);
    69     rc.right  -= (2+infoPtr->rcMargin.right);
    70     rc.bottom -= (2+infoPtr->rcMargin.bottom);
     118    rc.left   += (2 + infoPtr->rcMargin.left);
     119    rc.top    += (2 + infoPtr->rcMargin.top);
     120    rc.right  -= (2 + infoPtr->rcMargin.right);
     121    rc.bottom -= (2 + infoPtr->rcMargin.bottom);
    71122
    72123    /* draw text */
    73     oldBkMode = SetBkMode(hdc,TRANSPARENT);
    74     SetTextColor(hdc,infoPtr->clrText);
    75     hOldFont = SelectObject(hdc,infoPtr->hFont);
    76     DrawTextW(hdc,infoPtr->szTipText,-1,&rc,uFlags);
    77     SelectObject(hdc,hOldFont);
    78     if (oldBkMode != TRANSPARENT) SetBkMode(hdc,oldBkMode);
    79 }
    80 
    81 static VOID TOOLTIPS_GetCallbackText(HWND hwnd,TOOLTIPS_INFO *infoPtr,TTTOOL_INFO *toolPtr)
    82 {
    83   if (isUnicodeNotify(&infoPtr->header))
    84   {
    85     NMTTDISPINFOW ttnmdi;
    86 
    87     /* fill NMHDR struct */
    88     ZeroMemory (&ttnmdi,sizeof(NMTTDISPINFOW));
    89     ttnmdi.hdr.hwndFrom = hwnd;
    90     ttnmdi.hdr.idFrom = toolPtr->uId;
    91     ttnmdi.hdr.code = TTN_GETDISPINFOW;
    92     ttnmdi.lpszText = (WCHAR*)&ttnmdi.szText;
    93     ttnmdi.uFlags = toolPtr->uFlags;
    94     ttnmdi.lParam = toolPtr->lParam;
    95     SendMessageA(toolPtr->hwnd,WM_NOTIFY,(WPARAM)toolPtr->uId,(LPARAM)&ttnmdi);
    96 
    97     if ((ttnmdi.hinst) && (HIWORD((UINT)ttnmdi.lpszText) == 0))
    98     {
    99       LoadStringW(ttnmdi.hinst,(UINT)ttnmdi.lpszText,infoPtr->szTipText,INFOTIPSIZE);
    100       if (ttnmdi.uFlags & TTF_DI_SETITEM)
    101       {
    102         toolPtr->hinst = ttnmdi.hinst;
    103         toolPtr->lpszText = (LPWSTR)ttnmdi.lpszText;
    104       }
    105     } else
    106     {
    107       if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKW)
    108       {
    109         if (!HIWORD(ttnmdi.lpszText) && (ttnmdi.lpszText != NULL))
    110         {
    111           //error
    112           infoPtr->szTipText[0] = '\0';
    113           return;
    114         }
    115         lstrcpynW(infoPtr->szTipText,ttnmdi.lpszText,INFOTIPSIZE);
    116         if (ttnmdi.uFlags & TTF_DI_SETITEM)
    117         {
    118           INT len = lstrlenW(ttnmdi.lpszText);
    119           toolPtr->hinst = 0;
    120           toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    121           lstrcpyW(toolPtr->lpszText,ttnmdi.lpszText);
    122         }
    123       } else
    124       {
    125         //ERR (tooltips, "recursive text callback!\n");
    126         infoPtr->szTipText[0] = '\0';
    127       }
    128     }
    129   } else
    130   {
    131     NMTTDISPINFOA ttnmdi;
    132 
    133     /* fill NMHDR struct */
    134     ZeroMemory (&ttnmdi,sizeof(NMTTDISPINFOA));
    135     ttnmdi.hdr.hwndFrom = hwnd;
    136     ttnmdi.hdr.idFrom = toolPtr->uId;
    137     ttnmdi.hdr.code = TTN_GETDISPINFOA;
    138     ttnmdi.lpszText = (CHAR*)&ttnmdi.szText;
    139     ttnmdi.uFlags = toolPtr->uFlags;
    140     ttnmdi.lParam = toolPtr->lParam;
    141     SendMessageA(toolPtr->hwnd,WM_NOTIFY,(WPARAM)toolPtr->uId,(LPARAM)&ttnmdi);
    142 
    143     if ((ttnmdi.hinst) && (HIWORD((UINT)ttnmdi.lpszText) == 0))
    144     {
    145       LoadStringW(ttnmdi.hinst,(UINT)ttnmdi.lpszText,infoPtr->szTipText,INFOTIPSIZE);
    146       if (ttnmdi.uFlags & TTF_DI_SETITEM)
    147       {
    148         toolPtr->hinst = ttnmdi.hinst;
    149         toolPtr->lpszText = (LPWSTR)ttnmdi.lpszText;
    150       }
    151     } else
    152     {
    153       if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA)
    154       {
    155         if (!HIWORD(ttnmdi.lpszText) && (ttnmdi.lpszText != NULL))
    156         {
    157           //error
    158           infoPtr->szTipText[0] = '\0';
    159           return;
    160         }
    161         lstrcpynAtoW(infoPtr->szTipText,ttnmdi.lpszText,INFOTIPSIZE);
    162         if (ttnmdi.uFlags & TTF_DI_SETITEM)
    163         {
    164           INT len = lstrlenA(ttnmdi.lpszText);
    165           toolPtr->hinst = 0;
    166           toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    167           lstrcpyAtoW(toolPtr->lpszText,ttnmdi.lpszText);
    168         }
    169       } else
    170       {
    171         //ERR (tooltips, "recursive text callback!\n");
    172         infoPtr->szTipText[0] = '\0';
    173       }
    174     }
    175   }
    176 }
    177 
    178 static VOID TOOLTIPS_GetTipText(HWND hwnd,TOOLTIPS_INFO *infoPtr,INT nTool)
     124    oldBkMode = SetBkMode (hdc, TRANSPARENT);
     125    SetTextColor (hdc, infoPtr->clrText);
     126    hOldFont = SelectObject (hdc, infoPtr->hFont);
     127    DrawTextW (hdc, infoPtr->szTipText, -1, &rc, uFlags);
     128    SelectObject (hdc, hOldFont);
     129    if (oldBkMode != TRANSPARENT)
     130        SetBkMode (hdc, oldBkMode);
     131}
     132
     133
     134static VOID
     135TOOLTIPS_GetTipText (HWND hwnd, TOOLTIPS_INFO *infoPtr, INT nTool)
    179136{
    180137    TTTOOL_INFO *toolPtr = &infoPtr->tools[nTool];
    181138
    182     if ((toolPtr->hinst) && (HIWORD((UINT)toolPtr->lpszText) == 0))
    183     {
    184       /* load a resource */
    185 
    186       LoadStringW(toolPtr->hinst,(UINT)toolPtr->lpszText,infoPtr->szTipText,INFOTIPSIZE);
    187     } else if (toolPtr->lpszText)
    188     {
    189       if (toolPtr->lpszText == LPSTR_TEXTCALLBACKW)
    190         TOOLTIPS_GetCallbackText(hwnd,infoPtr,toolPtr);
    191       else
    192       {
    193         /* the item is a usual (unicode) text */
    194         lstrcpynW(infoPtr->szTipText,toolPtr->lpszText,INFOTIPSIZE);
    195       }
    196     } else
    197     {
    198       /* no text available */
    199       infoPtr->szTipText[0] = '\0';
    200     }
    201 }
    202 
    203 static VOID
    204 TOOLTIPS_CalcTipRect (HWND hwnd,TOOLTIPS_INFO *infoPtr,TTTOOL_INFO *toolPtr,LPRECT lpRect)
    205 {
    206     HDC hdc;
    207     HFONT hOldFont;
    208     UINT uFlags = DT_EXTERNALLEADING | DT_CALCRECT;
    209     RECT rc = {0,0,0,0};
    210     SIZE size;
    211 
    212     if (infoPtr->nMaxTipWidth > -1)
    213     {
    214       rc.right = infoPtr->nMaxTipWidth;
    215       uFlags |= DT_WORDBREAK;
    216     }
    217     if (GetWindowLongA(hwnd,GWL_STYLE) & TTS_NOPREFIX) uFlags |= DT_NOPREFIX;
    218     //TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
    219 
    220     hdc = GetDC(hwnd);
    221     hOldFont = SelectObject(hdc,infoPtr->hFont);
    222     DrawTextW(hdc,infoPtr->szTipText,-1,&rc,uFlags);
    223     SelectObject(hdc,hOldFont);
    224     ReleaseDC(hwnd,hdc);
    225 
    226     size.cx = rc.right-rc.left+4+infoPtr->rcMargin.left+infoPtr->rcMargin.right;
    227     size.cy = rc.bottom-rc.top+4+infoPtr->rcMargin.bottom+infoPtr->rcMargin.top;
    228 
    229     if (toolPtr->uFlags & TTF_ABSOLUTE)
    230     {
    231       rc.left = infoPtr->xTrackPos;
    232       rc.top  = infoPtr->yTrackPos;
    233 
    234       if (toolPtr->uFlags & TTF_ALIGNMASK)
    235       {
    236         //CB: Odin only (Win32 does something similar but with an undocumented mechanism)
    237 
    238         if (toolPtr->uFlags & TTF_ALIGNLEFT)
    239           rc.left -= size.cx;
    240         else if (toolPtr->uFlags & TTF_HCENTER)
    241           rc.left -= size.cx/2;
    242 
    243         if (toolPtr->uFlags & TTF_ALIGNTOP)
    244           rc.top -= size.cy;
    245         else if (toolPtr->uFlags & TTF_VCENTER)
    246           rc.top -= size.cy/2;
    247 
    248       } else
    249       {
    250         if (toolPtr->uFlags & TTF_CENTERTIP)
    251         {
    252           rc.left -= (size.cx/2);
    253           rc.top  -= (size.cy/2);
    254         }
    255       }
    256     } else
    257     {
    258       RECT rcTool;
    259 
    260       if (toolPtr->uFlags & TTF_IDISHWND)
    261       {
    262         GetWindowRect((HWND)toolPtr->uId,&rcTool); //screen coordinates
    263       } else
    264       {
    265         rcTool = toolPtr->rect;
    266         MapWindowPoints(toolPtr->hwnd,(HWND)0,(LPPOINT)&rcTool,2);
    267       }
    268 
    269       if (toolPtr->uFlags & TTF_CENTERTIP)
    270       {
    271         if (infoPtr->bTrackActive)
    272         {
    273           GetCursorPos((LPPOINT)&rc);
    274           rc.top += 20;
    275           rc.left -= (size.cx / 2);
    276           rc.top  -= (size.cy / 2);
    277         } else
    278         {
    279           rc.left = (rcTool.left + rcTool.right-size.cx)/ 2;
    280           rc.top  = rcTool.bottom+2;
    281         }
    282 
    283       } else
    284       {
    285         GetCursorPos((LPPOINT)&rc);
    286         rc.top += 20;
    287       }
    288 
    289       /* smart placement */
    290       if (infoPtr->bTrackActive)
    291       {
    292         if ((rc.left + size.cx > rcTool.left) && (rc.left < rcTool.right) &&
    293             (rc.top + size.cy > rcTool.top) && (rc.top < rcTool.bottom))
    294             rc.left = rcTool.right;
    295       }
    296     }
    297 
    298     //TRACE (tooltips, "pos %d - %d\n", rect.left, rect.top);
    299 
    300     rc.right = rc.left+size.cx;
    301     rc.bottom = rc.top+size.cy;
    302 
    303     AdjustWindowRectEx (&rc,GetWindowLongA(hwnd,GWL_STYLE),
    304                         FALSE,GetWindowLongA(hwnd,GWL_EXSTYLE));
    305 
    306     *lpRect = rc;
    307 }
     139    if ((toolPtr->hinst) && (HIWORD((UINT)toolPtr->lpszText) == 0)) {
     140        /* load a resource */
     141        TRACE("load res string %x %x\n",
     142               toolPtr->hinst, (int)toolPtr->lpszText);
     143        LoadStringW (toolPtr->hinst, (UINT)toolPtr->lpszText,
     144                       infoPtr->szTipText, INFOTIPSIZE);
     145    }
     146    else if (toolPtr->lpszText) {
     147        if (toolPtr->lpszText == LPSTR_TEXTCALLBACKW) {
     148            NMTTDISPINFOA ttnmdi;
     149
     150            /* fill NMHDR struct */
     151            ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFOA));
     152            ttnmdi.hdr.hwndFrom = hwnd;
     153            ttnmdi.hdr.idFrom = toolPtr->uId;
     154            ttnmdi.hdr.code = TTN_GETDISPINFOA;
     155            ttnmdi.lpszText = (LPSTR)&ttnmdi.szText;
     156            ttnmdi.uFlags = toolPtr->uFlags;
     157            ttnmdi.lParam = toolPtr->lParam;
     158
     159            TRACE("hdr.idFrom = %x\n", ttnmdi.hdr.idFrom);
     160            SendMessageA (toolPtr->hwnd, WM_NOTIFY,
     161                            (WPARAM)toolPtr->uId, (LPARAM)&ttnmdi);
     162
     163            if ((ttnmdi.hinst) && (HIWORD((UINT)ttnmdi.lpszText) == 0)) {
     164                LoadStringW (ttnmdi.hinst, (UINT)ttnmdi.lpszText,
     165                               infoPtr->szTipText, INFOTIPSIZE);
     166                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
     167                    toolPtr->hinst = ttnmdi.hinst;
     168                    toolPtr->lpszText = (LPWSTR)ttnmdi.lpszText;
     169                }
     170            }
     171            else if (ttnmdi.szText[0]) {
     172                MultiByteToWideChar(CP_ACP, 0, ttnmdi.szText, 80,
     173                                    infoPtr->szTipText, INFOTIPSIZE);
     174                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
     175                    INT len = MultiByteToWideChar(CP_ACP, 0, ttnmdi.szText,
     176                                                  80, NULL, 0);
     177                    toolPtr->hinst = 0;
     178                    toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc (len * sizeof(WCHAR));
     179                    MultiByteToWideChar(CP_ACP, 0, ttnmdi.szText, 80,
     180                                        toolPtr->lpszText, len);
     181                }
     182            }
     183            else if (ttnmdi.lpszText == 0) {
     184                /* no text available */
     185                infoPtr->szTipText[0] = L'\0';
     186            }
     187            else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA) {
     188                MultiByteToWideChar(CP_ACP, 0, ttnmdi.lpszText, -1,
     189                                    infoPtr->szTipText, INFOTIPSIZE);
     190                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
     191                    INT len = MultiByteToWideChar(CP_ACP, 0, ttnmdi.lpszText,
     192                                                  -1, NULL, 0);
     193                    toolPtr->hinst = 0;
     194                    toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc (len * sizeof(WCHAR));
     195                    MultiByteToWideChar(CP_ACP, 0, ttnmdi.lpszText, -1,
     196                                        toolPtr->lpszText, len);
     197                }
     198            }
     199            else {
     200                ERR("recursive text callback!\n");
     201                infoPtr->szTipText[0] = '\0';
     202            }
     203        }
     204        else {
     205            /* the item is a usual (unicode) text */
     206            lstrcpynW (infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
     207        }
     208    }
     209    else {
     210        /* no text available */
     211        infoPtr->szTipText[0] = L'\0';
     212    }
     213
     214    // TRACE("%s\n", debugstr_w(infoPtr->szTipText));
     215}
     216
    308217
    309218static VOID
    … …  
    316225
    317226    if (infoPtr->nMaxTipWidth > -1) {
    318         rc.right = infoPtr->nMaxTipWidth;
    319         uFlags |= DT_WORDBREAK;
     227        rc.right = infoPtr->nMaxTipWidth;
     228        uFlags |= DT_WORDBREAK;
    320229    }
    321230    if (GetWindowLongA (hwnd, GWL_STYLE) & TTS_NOPREFIX)
    322         uFlags |= DT_NOPREFIX;
    323     //TRACE("\"%s\"\n", debugstr_w(infoPtr->szTipText));
     231        uFlags |= DT_NOPREFIX;
     232    TRACE("%s\n", debugstr_w(infoPtr->szTipText));
    324233
    325234    hdc = GetDC (hwnd);
    … …  
    329238    ReleaseDC (hwnd, hdc);
    330239
    331     lpSize->cx = rc.right - rc.left + 4 +
    332                 infoPtr->rcMargin.left + infoPtr->rcMargin.right;
     240    lpSize->cx = rc.right - rc.left + 4 + 
     241                infoPtr->rcMargin.left + infoPtr->rcMargin.right;
    333242    lpSize->cy = rc.bottom - rc.top + 4 +
    334                  infoPtr->rcMargin.bottom + infoPtr->rcMargin.top;
    335 }
     243                 infoPtr->rcMargin.bottom + infoPtr->rcMargin.top;
     244}
     245
    336246
    337247static VOID
    … …  
    341251    RECT rect, wndrect;
    342252    SIZE size;
    343     HDC  hdc;
    344253    NMHDR  hdr;
    345254
    346255    if (infoPtr->nTool == -1) {
    347 //      TRACE("invalid tool (-1)!\n");
    348         return;
     256        TRACE("invalid tool (-1)!\n");
     257        return;
    349258    }
    350259
    351260    infoPtr->nCurrentTool = infoPtr->nTool;
    352261
    353 //    TRACE("Show tooltip pre %d!\n", infoPtr->nTool);
     262    TRACE("Show tooltip pre %d! (%04x)\n", infoPtr->nTool, hwnd);
    354263
    355264    TOOLTIPS_GetTipText (hwnd, infoPtr, infoPtr->nCurrentTool);
    356265
    357266    if (infoPtr->szTipText[0] == L'\0') {
    358         infoPtr->nCurrentTool = -1;
    359         return;
    360     }
    361 
    362 //    TRACE("Show tooltip %d!\n", infoPtr->nCurrentTool);
     267        infoPtr->nCurrentTool = -1;
     268        return;
     269    }
     270
     271    TRACE("Show tooltip %d!\n", infoPtr->nCurrentTool);
    363272    toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
    364273
    … …  
    367276    hdr.code = TTN_SHOW;
    368277    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    369                     (WPARAM)toolPtr->uId, (LPARAM)&hdr);
    370 
    371 //    TRACE("\"%s\"\n", debugstr_w(infoPtr->szTipText));
     278                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     279
     280    TRACE("%s\n", debugstr_w(infoPtr->szTipText));
    372281
    373282    TOOLTIPS_CalcTipSize (hwnd, infoPtr, &size);
    374 //    TRACE("size %d - %d\n", size.cx, size.cy);
     283    TRACE("size %d - %d\n", size.cx, size.cy);
    375284
    376285    if (toolPtr->uFlags & TTF_CENTERTIP) {
    377         RECT rc;
    378 
    379         if (toolPtr->uFlags & TTF_IDISHWND)
    380             GetWindowRect ((HWND)toolPtr->uId, &rc);
    381         else {
    382             rc = toolPtr->rect;
    383             MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rc, 2);
    384         }
    385         rect.left = (rc.left + rc.right - size.cx) / 2;
    386         rect.top  = rc.bottom + 2;
     286        RECT rc;
     287
     288        if (toolPtr->uFlags & TTF_IDISHWND)
     289            GetWindowRect ((HWND)toolPtr->uId, &rc);
     290        else {
     291            rc = toolPtr->rect;
     292            MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rc, 2);
     293        }
     294        rect.left = (rc.left + rc.right - size.cx) / 2;
     295        rect.top  = rc.bottom + 2;
    387296    }
    388297    else {
    389         GetCursorPos ((LPPOINT)&rect);
    390         rect.top += 20;
    391     }
    392 
    393 //    TRACE("pos %d - %d\n", rect.left, rect.top);
     298        GetCursorPos ((LPPOINT)&rect);
     299        rect.top += 20;
     300    }
     301
     302    TRACE("pos %d - %d\n", rect.left, rect.top);
    394303
    395304    rect.right = rect.left + size.cx;
    … …  
    399308    wndrect.right = GetSystemMetrics( SM_CXSCREEN );
    400309    if( rect.right > wndrect.right ) {
    401            rect.left -= rect.right - wndrect.right + 2;
    402            rect.right = wndrect.right - 2;
     310           rect.left -= rect.right - wndrect.right + 2;
     311           rect.right = wndrect.right - 2;
    403312    }
    404313    wndrect.bottom = GetSystemMetrics( SM_CYSCREEN );
    … …  
    406315        RECT rc;
    407316
    408         if (toolPtr->uFlags & TTF_IDISHWND)
    409             GetWindowRect ((HWND)toolPtr->uId, &rc);
    410         else {
    411             rc = toolPtr->rect;
    412             MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rc, 2);
    413         }
    414         rect.bottom = rc.top - 2;
    415         rect.top = rect.bottom - size.cy;
     317        if (toolPtr->uFlags & TTF_IDISHWND)
     318            GetWindowRect ((HWND)toolPtr->uId, &rc);
     319        else {
     320            rc = toolPtr->rect;
     321            MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rc, 2);
     322        }   
     323        rect.bottom = rc.top - 2;
     324        rect.top = rect.bottom - size.cy;
    416325    }
    417326
    418327    AdjustWindowRectEx (&rect, GetWindowLongA (hwnd, GWL_STYLE),
    419                         FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
     328                        FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
    420329
    421330    SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
    422                     rect.right - rect.left, rect.bottom - rect.top,
    423                     SWP_SHOWWINDOW | SWP_NOACTIVATE);
     331                    rect.right - rect.left, rect.bottom - rect.top,
     332                    SWP_SHOWWINDOW | SWP_NOACTIVATE);
    424333
    425334    /* repaint the tooltip */
    426     hdc = GetDC (hwnd);
    427     TOOLTIPS_Draw(hwnd, hdc);
    428     ReleaseDC (hwnd, hdc);
     335    InvalidateRect(hwnd, NULL, TRUE);
     336    UpdateWindow(hwnd);
    429337
    430338    SetTimer (hwnd, ID_TIMERPOP, infoPtr->nAutoPopTime, 0);
     339    TRACE("timer 2 started!\n");
     340    SetTimer (hwnd, ID_TIMERLEAVE, infoPtr->nReshowTime, 0);
     341    TRACE("timer 3 started!\n");
    431342}
    432343
    … …  
    438349    NMHDR hdr;
    439350
     351    TRACE("Hide tooltip %d! (%04x)\n", infoPtr->nCurrentTool, hwnd);
     352
    440353    if (infoPtr->nCurrentTool == -1)
    441         return;
     354        return;
    442355
    443356    toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
    444     //TRACE (tooltips, "Hide tooltip %d!\n", infoPtr->nCurrentTool);
    445357    KillTimer (hwnd, ID_TIMERPOP);
    446358
    … …  
    449361    hdr.code = TTN_POP;
    450362    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    451                     (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     363                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
    452364
    453365    infoPtr->nCurrentTool = -1;
    454366
    455367    SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0,
    456                     SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
     368                    SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
    457369}
    458370
    … …  
    463375    TTTOOL_INFO *toolPtr;
    464376    RECT rect;
    465     HDC  hdc;
     377    SIZE size;
    466378    NMHDR hdr;
    467379
    468     if (infoPtr->nTrackTool == -1)
    469     {
    470       //TRACE (tooltips, "invalid tracking tool (-1)!\n");
    471       return;
    472     }
    473 
    474     //TRACE (tooltips, "show tracking tooltip pre %d!\n", infoPtr->nTrackTool);
    475 
    476     TOOLTIPS_GetTipText(hwnd,infoPtr,infoPtr->nTrackTool);
    477 
    478     if (infoPtr->szTipText[0] == '\0')
    479     {
    480       infoPtr->nTrackTool = -1;
    481       return;
    482     }
    483 
    484     //TRACE (tooltips, "show tracking tooltip %d!\n", infoPtr->nTrackTool);
     380    if (infoPtr->nTrackTool == -1) {
     381        TRACE("invalid tracking tool (-1)!\n");
     382        return;
     383    }
     384
     385    TRACE("show tracking tooltip pre %d!\n", infoPtr->nTrackTool);
     386
     387    TOOLTIPS_GetTipText (hwnd, infoPtr, infoPtr->nTrackTool);
     388
     389    if (infoPtr->szTipText[0] == L'\0') {
     390        infoPtr->nTrackTool = -1;
     391        return;
     392    }
     393
     394    TRACE("show tracking tooltip %d!\n", infoPtr->nTrackTool);
    485395    toolPtr = &infoPtr->tools[infoPtr->nTrackTool];
    486396
    … …  
    488398    hdr.idFrom = toolPtr->uId;
    489399    hdr.code = TTN_SHOW;
    490     SendMessageA(toolPtr->hwnd,WM_NOTIFY,(WPARAM)toolPtr->uId,(LPARAM)&hdr);
    491 
    492     //TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
    493 
    494     TOOLTIPS_CalcTipRect(hwnd,infoPtr,toolPtr,&rect);
    495 
    496     SetWindowPos (hwnd,HWND_TOP,rect.left,rect.top,
    497                     rect.right-rect.left,rect.bottom-rect.top,
    498                     SWP_SHOWWINDOW | SWP_NOACTIVATE );
    499 
    500     hdc = GetDC (hwnd);
    501     TOOLTIPS_Draw(hwnd, hdc);
    502     ReleaseDC (hwnd, hdc);
     400    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
     401                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     402
     403    TRACE("%s\n", debugstr_w(infoPtr->szTipText));
     404
     405    TOOLTIPS_CalcTipSize (hwnd, infoPtr, &size);
     406    TRACE("size %d - %d\n", size.cx, size.cy);
     407
     408    if (toolPtr->uFlags & TTF_ABSOLUTE) {
     409        rect.left = infoPtr->xTrackPos;
     410        rect.top  = infoPtr->yTrackPos;
     411
     412        if (toolPtr->uFlags & TTF_CENTERTIP) {
     413            rect.left -= (size.cx / 2);
     414            rect.top  -= (size.cy / 2);
     415        }
     416    }
     417    else {
     418        RECT rcTool;
     419
     420        if (toolPtr->uFlags & TTF_IDISHWND)
     421            GetWindowRect ((HWND)toolPtr->uId, &rcTool);
     422        else {
     423            rcTool = toolPtr->rect;
     424            MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rcTool, 2);
     425        }
     426
     427        GetCursorPos ((LPPOINT)&rect);
     428        rect.top += 20;
     429
     430        if (toolPtr->uFlags & TTF_CENTERTIP) {
     431            rect.left -= (size.cx / 2);
     432            rect.top  -= (size.cy / 2);
     433        }
     434
     435        /* smart placement */
     436        if ((rect.left + size.cx > rcTool.left) && (rect.left < rcTool.right) &&
     437            (rect.top + size.cy > rcTool.top) && (rect.top < rcTool.bottom))
     438            rect.left = rcTool.right;
     439    }
     440
     441    TRACE("pos %d - %d\n", rect.left, rect.top);
     442
     443    rect.right = rect.left + size.cx;
     444    rect.bottom = rect.top + size.cy;
     445
     446    AdjustWindowRectEx (&rect, GetWindowLongA (hwnd, GWL_STYLE),
     447                        FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
     448
     449    SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
     450                    rect.right - rect.left, rect.bottom - rect.top,
     451                    SWP_SHOWWINDOW | SWP_NOACTIVATE );
     452
     453    InvalidateRect(hwnd, NULL, TRUE);
     454    UpdateWindow(hwnd);
    503455}
    504456
    … …  
    511463
    512464    if (infoPtr->nTrackTool == -1)
    513         return;
     465        return;
    514466
    515467    toolPtr = &infoPtr->tools[infoPtr->nTrackTool];
    516 //    TRACE (tooltips, "hide tracking tooltip %d!\n", infoPtr->nTrackTool);
     468    TRACE("hide tracking tooltip %d!\n", infoPtr->nTrackTool);
    517469
    518470    hdr.hwndFrom = hwnd;
    … …  
    520472    hdr.code = TTN_POP;
    521473    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    522                     (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     474                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
    523475
    524476    SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0,
    525                     SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
     477                    SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
    526478}
    527479
    … …  
    534486
    535487    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    536         toolPtr = &infoPtr->tools[nTool];
    537 
    538         if (!(toolPtr->uFlags & TTF_IDISHWND) &&
    539             (lpToolInfo->hwnd == toolPtr->hwnd) &&
    540             (lpToolInfo->uId == toolPtr->uId))
    541             return nTool;
     488        toolPtr = &infoPtr->tools[nTool];
     489
     490        if (!(toolPtr->uFlags & TTF_IDISHWND) &&
     491            (lpToolInfo->hwnd == toolPtr->hwnd) &&
     492            (lpToolInfo->uId == toolPtr->uId))
     493            return nTool;
    542494    }
    543495
    544496    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    545         toolPtr = &infoPtr->tools[nTool];
    546 
    547         if ((toolPtr->uFlags & TTF_IDISHWND) &&
    548             (lpToolInfo->uId == toolPtr->uId))
    549             return nTool;
     497        toolPtr = &infoPtr->tools[nTool];
     498
     499        if ((toolPtr->uFlags & TTF_IDISHWND) &&
     500            (lpToolInfo->uId == toolPtr->uId))
     501            return nTool;
    550502    }
    551503
    … …  
    561513
    562514    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    563         toolPtr = &infoPtr->tools[nTool];
    564 
    565         if (!(toolPtr->uFlags & TTF_IDISHWND) &&
    566             (lpToolInfo->hwnd == toolPtr->hwnd) &&
    567             (lpToolInfo->uId == toolPtr->uId))
    568             return nTool;
     515        toolPtr = &infoPtr->tools[nTool];
     516
     517        if (!(toolPtr->uFlags & TTF_IDISHWND) &&
     518            (lpToolInfo->hwnd == toolPtr->hwnd) &&
     519            (lpToolInfo->uId == toolPtr->uId))
     520            return nTool;
    569521    }
    570522
    571523    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    572         toolPtr = &infoPtr->tools[nTool];
    573 
    574         if ((toolPtr->uFlags & TTF_IDISHWND) &&
    575             (lpToolInfo->uId == toolPtr->uId))
    576             return nTool;
     524        toolPtr = &infoPtr->tools[nTool];
     525
     526        if ((toolPtr->uFlags & TTF_IDISHWND) &&
     527            (lpToolInfo->uId == toolPtr->uId))
     528            return nTool;
    577529    }
    578530
    … …  
    587539    INT  nTool;
    588540
    589     //@@@AH 2000/02/25 make sure we don't get garbage in
    590     if (!infoPtr)
    591     {
    592       dprintf(("Tooltips:GetToolFromPoint: infoPtr == NULL!!!\n"));
    593       return 0;
    594     }
    595 
    596541    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    597         toolPtr = &infoPtr->tools[nTool];
    598 
    599         if (!(toolPtr->uFlags & TTF_IDISHWND)) {
    600             if (hwnd != toolPtr->hwnd)
    601                 continue;
    602             if (!PtInRect (&toolPtr->rect, *lpPt))
    603                 continue;
    604             return nTool;
    605         }
     542        toolPtr = &infoPtr->tools[nTool];
     543
     544        if (!(toolPtr->uFlags & TTF_IDISHWND)) {
     545            if (hwnd != toolPtr->hwnd)
     546                continue;
     547            if (!PtInRect (&toolPtr->rect, *lpPt))
     548                continue;
     549            return nTool;
     550        }
    606551    }
    607552
    608553    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    609         toolPtr = &infoPtr->tools[nTool];
    610 
    611         if (toolPtr->uFlags & TTF_IDISHWND) {
    612             if ((HWND)toolPtr->uId == hwnd)
    613                 return nTool;
    614         }
     554        toolPtr = &infoPtr->tools[nTool];
     555
     556        if (toolPtr->uFlags & TTF_IDISHWND) {
     557            if ((HWND)toolPtr->uId == hwnd)
     558                return nTool;
     559        }
    615560    }
    616561
    617562    return -1;
    618 }
    619 
    620 
    621 static INT
    622 TOOLTIPS_GetToolFromMessage (TOOLTIPS_INFO *infoPtr, HWND hwndTool)
    623 {
    624     DWORD   dwPos;
    625     POINT pt;
    626 
    627     dwPos = GetMessagePos ();
    628     pt.x = (INT)LOWORD(dwPos);
    629     pt.y = (INT)HIWORD(dwPos);
    630     ScreenToClient (hwndTool, &pt);
    631 
    632     return TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt);
    633563}
    634564
    … …  
    639569    HWND hwndActive = GetActiveWindow ();
    640570    if (!hwndActive)
    641         return FALSE;
     571        return FALSE;
    642572    if (hwndActive == hwnd)
    643         return TRUE;
     573        return TRUE;
    644574    return IsChild (hwndActive, hwnd);
    645575}
    … …  
    657587    hwndTool = SendMessageA (hwnd, TTM_WINDOWFROMPOINT, 0, (LPARAM)&pt);
    658588    if (hwndTool == 0)
    659         return -1;
     589        return -1;
    660590
    661591    ScreenToClient (hwndTool, &pt);
    662592    nTool = TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt);
    663593    if (nTool == -1)
    664         return -1;
     594        return -1;
    665595
    666596    if (!(GetWindowLongA (hwnd, GWL_STYLE) & TTS_ALWAYSTIP) && bShowTest) {
    667         if (!TOOLTIPS_IsWindowActive (GetWindow (hwnd, GW_OWNER)))
    668             return -1;
    669     }
     597        if (!TOOLTIPS_IsWindowActive (GetWindow (hwnd, GW_OWNER)))
     598            return -1;
     599    }
     600
     601    TRACE("tool %d\n", nTool);
    670602
    671603    return nTool;
    … …  
    676608TOOLTIPS_Activate (HWND hwnd, WPARAM wParam, LPARAM lParam)
    677609{
    678     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
     610    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    679611
    680612    infoPtr->bActive = (BOOL)wParam;
    681613
     614    if (infoPtr->bActive)
     615        TRACE("activate!\n");
     616
    682617    if (!(infoPtr->bActive) && (infoPtr->nCurrentTool != -1))
    683         TOOLTIPS_Hide (hwnd, infoPtr);
    684 
    685     return 0;
    686 }
    687 
    688 
    689 static VOID TOOLTIPS_Subclass(HWND hwnd,TTTOOL_INFO *toolPtr)
    690 {
    691     if (toolPtr->uFlags & TTF_SUBCLASS)
    692     {
    693       if (toolPtr->uFlags & TTF_IDISHWND)
    694       {
    695         LPTT_SUBCLASS_INFO lpttsi =
    696             (LPTT_SUBCLASS_INFO)GetPropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
    697         if (lpttsi == NULL)
    698         {
    699           lpttsi = (LPTT_SUBCLASS_INFO)COMCTL32_Alloc(sizeof(TT_SUBCLASS_INFO));
    700           lpttsi->wpOrigProc =
    701               (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
    702               GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    703           lpttsi->hwndToolTip = hwnd;
    704           lpttsi->uRefCount++;
    705           SetPropA ((HWND)toolPtr->uId,COMCTL32_aSubclass,(HANDLE)lpttsi);
    706         }
    707 //          else
    708 //              WARN (tooltips, "A window tool must only be listed once!\n");
    709       } else
    710       {
    711         LPTT_SUBCLASS_INFO lpttsi =
    712            (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    713         if (lpttsi == NULL)
    714         {
    715           lpttsi = (LPTT_SUBCLASS_INFO)COMCTL32_Alloc(sizeof(TT_SUBCLASS_INFO));
    716           lpttsi->wpOrigProc =
    717               (WNDPROC)SetWindowLongA (toolPtr->hwnd,
    718               GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    719           lpttsi->hwndToolTip = hwnd;
    720           lpttsi->uRefCount++;
    721           SetPropA(toolPtr->hwnd,COMCTL32_aSubclass,(HANDLE)lpttsi);
    722         } else lpttsi->uRefCount++;
    723       }
    724 //      TRACE (tooltips, "subclassing installed!\n");
    725     }
    726 }
    727 
    728 static VOID TOOLTIPS_Desubclass(TTTOOL_INFO *toolPtr)
    729 {
    730     if (toolPtr->uFlags & TTF_SUBCLASS)
    731     {
    732       if (toolPtr->uFlags & TTF_IDISHWND)
    733       {
    734         LPTT_SUBCLASS_INFO lpttsi =
    735             (LPTT_SUBCLASS_INFO)GetPropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
    736         if (lpttsi)
    737         {
    738           SetWindowLongA ((HWND)toolPtr->uId,GWL_WNDPROC,(LONG)lpttsi->wpOrigProc);
    739           RemovePropA ((HWND)toolPtr->uId,COMCTL32_aSubclass);
    740           COMCTL32_Free(&lpttsi);
    741         }
    742 //          else
    743 //              ERR (tooltips, "Invalid data handle!\n");
    744       } else
    745       {
    746         LPTT_SUBCLASS_INFO lpttsi =
    747             (LPTT_SUBCLASS_INFO)GetPropA(toolPtr->hwnd,COMCTL32_aSubclass);
    748         if (lpttsi)
    749         {
    750           if (lpttsi->uRefCount == 1)
    751           {
    752             SetWindowLongA((HWND)toolPtr->uId,GWL_WNDPROC,(LONG)lpttsi->wpOrigProc);
    753             RemovePropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
    754             COMCTL32_Free(&lpttsi);
    755           } else lpttsi->uRefCount--;
    756         }
    757 //          else
    758 //              ERR (tooltips, "Invalid data handle!\n");
    759       }
    760     }
    761 }
    762 
    763 static LRESULT
    764 TOOLTIPS_AddToolA(HWND hwnd,WPARAM wParam,LPARAM lParam)
    765 {
    766     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
     618        TOOLTIPS_Hide (hwnd, infoPtr);
     619
     620    return 0;
     621}
     622
     623
     624static LRESULT
     625TOOLTIPS_AddToolA (HWND hwnd, WPARAM wParam, LPARAM lParam)
     626{
     627    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    767628    LPTTTOOLINFOA lpToolInfo = (LPTTTOOLINFOA)lParam;
    768629    TTTOOL_INFO *toolPtr;
    769630
    770     if (lpToolInfo == NULL) return FALSE;
    771     if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA) return FALSE;
    772 
    773 //    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
    774 //         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
    775 //         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
    776 
    777     if (infoPtr->uNumTools == 0)
    778     {
    779       infoPtr->tools = (TTTOOL_INFO*)COMCTL32_Alloc(sizeof(TTTOOL_INFO));
    780       toolPtr = infoPtr->tools;
    781     } else
    782     {
    783       TTTOOL_INFO *oldTools = infoPtr->tools;
    784       INT x;
    785 
    786       toolPtr = NULL;
    787 
    788       //check if toolinfo already exists
    789       for (x = 0;x < infoPtr->uNumTools;x++)
    790       {
    791         if (lpToolInfo->hwnd == infoPtr->tools[x].hwnd && lpToolInfo->uId == infoPtr->tools[x].uId)
    792         {
    793           //return toolPtr
    794           toolPtr = &infoPtr->tools[x];
    795           //free allocated memory
    796           TOOLTIPS_Desubclass(toolPtr);
    797           if ((toolPtr->hinst) && (toolPtr->lpszText))
    798           {
    799             if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(toolPtr->lpszText);
    800           }
    801 
    802           break;
    803         }
    804       }
    805 
    806       if (toolPtr == NULL)
    807       {
    808         infoPtr->tools = (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO)*(infoPtr->uNumTools+1));
    809         memcpy(infoPtr->tools,oldTools,infoPtr->uNumTools*sizeof(TTTOOL_INFO));
    810         COMCTL32_Free(oldTools);
    811         toolPtr = &infoPtr->tools[infoPtr->uNumTools];
    812       }
     631    if (lpToolInfo == NULL)
     632        return FALSE;
     633    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
     634        return FALSE;
     635
     636    TRACE("add tool (%x) %x %d%s!\n",
     637           hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
     638           (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
     639
     640    if (infoPtr->uNumTools == 0) {
     641        infoPtr->tools = (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO));
     642        toolPtr = infoPtr->tools;
     643    }
     644    else {
     645        TTTOOL_INFO *oldTools = infoPtr->tools;
     646        infoPtr->tools =
     647            (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
     648        memcpy (infoPtr->tools, oldTools,
     649                infoPtr->uNumTools * sizeof(TTTOOL_INFO));
     650        COMCTL32_Free (oldTools);
     651        toolPtr = &infoPtr->tools[infoPtr->uNumTools];
    813652    }
    814653
    … …  
    822661    toolPtr->hinst  = lpToolInfo->hinst;
    823662
    824     if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0))
    825     {
    826 //    TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
    827       toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    828     } else if (lpToolInfo->lpszText)
    829     {
    830       if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
    831       {
    832 //      TRACE (tooltips, "add CALLBACK!\n");
    833         toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    834       } else
    835       {
    836         INT len = lstrlenA (lpToolInfo->lpszText);
    837 //          TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
    838         toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    839         lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
    840       }
    841     } else toolPtr->lpszText = NULL;
     663    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
     664        TRACE("add string id %x!\n", (int)lpToolInfo->lpszText);
     665        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     666    }
     667    else if (lpToolInfo->lpszText) {
     668        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA) {
     669            TRACE("add CALLBACK!\n");
     670            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     671        }
     672        else {
     673            INT len = MultiByteToWideChar(CP_ACP, 0, lpToolInfo->lpszText, -1,
     674                                          NULL, 0);
     675            TRACE("add text \"%s\"!\n", lpToolInfo->lpszText);
     676            toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc (len * sizeof(WCHAR));
     677            MultiByteToWideChar(CP_ACP, 0, lpToolInfo->lpszText, -1,
     678                                toolPtr->lpszText, len);
     679        }
     680    }
    842681
    843682    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    844         toolPtr->lParam = lpToolInfo->lParam;
     683        toolPtr->lParam = lpToolInfo->lParam;
    845684
    846685    /* install subclassing hook */
    847     TOOLTIPS_Subclass(hwnd,toolPtr);
     686    if (toolPtr->uFlags & TTF_SUBCLASS) {
     687        if (toolPtr->uFlags & TTF_IDISHWND) {
     688            LPTT_SUBCLASS_INFO lpttsi =
     689                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     690            if (lpttsi == NULL) {
     691                lpttsi =
     692                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     693                lpttsi->wpOrigProc =
     694                    (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
     695                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     696                lpttsi->hwndToolTip = hwnd;
     697                lpttsi->uRefCount++;
     698                SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
     699                            (HANDLE)lpttsi);
     700            }
     701            else
     702                WARN("A window tool must only be listed once!\n");
     703        }
     704        else {
     705            LPTT_SUBCLASS_INFO lpttsi =
     706                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     707            if (lpttsi == NULL) {
     708                lpttsi =
     709                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     710                lpttsi->wpOrigProc =
     711                    (WNDPROC)SetWindowLongA (toolPtr->hwnd,
     712                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     713                lpttsi->hwndToolTip = hwnd;
     714                lpttsi->uRefCount++;
     715                SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
     716            }
     717            else
     718                lpttsi->uRefCount++;
     719        }
     720        TRACE("subclassing installed!\n");
     721    }
    848722
    849723    return TRUE;
    … …  
    859733
    860734    if (lpToolInfo == NULL)
    861         return FALSE;
     735        return FALSE;
    862736    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    863         return FALSE;
    864 
    865 //    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
    866 //         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
    867 //         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
    868 
    869     if (infoPtr->uNumTools == 0)
    870     {
    871       infoPtr->tools = (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO));
    872       toolPtr = infoPtr->tools;
    873     } else
    874     {
    875       TTTOOL_INFO *oldTools = infoPtr->tools;
    876       INT x;
    877 
    878       toolPtr = NULL;
    879 
    880       //check if toolinfo already exists
    881       for (x = 0;x < infoPtr->uNumTools;x++)
    882       {
    883         if (lpToolInfo->hwnd == infoPtr->tools[x].hwnd && lpToolInfo->uId == infoPtr->tools[x].uId)
    884         {
    885           //return toolPtr
    886           toolPtr = &infoPtr->tools[x];
    887           //free allocated memory
    888           TOOLTIPS_Desubclass(toolPtr);
    889           if ((toolPtr->hinst) && (toolPtr->lpszText))
    890           {
    891             if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(toolPtr->lpszText);
    892           }
    893 
    894           break;
    895         }
    896       }
    897 
    898       if (toolPtr == NULL)
    899       {
    900         infoPtr->tools = (TTTOOL_INFO*)COMCTL32_Alloc(sizeof(TTTOOL_INFO)*(infoPtr->uNumTools+1));
    901         memcpy (infoPtr->tools,oldTools,infoPtr->uNumTools*sizeof(TTTOOL_INFO));
    902         COMCTL32_Free(oldTools);
    903         toolPtr = &infoPtr->tools[infoPtr->uNumTools];
    904       }
     737        return FALSE;
     738
     739    TRACE("add tool (%x) %x %d%s!\n",
     740           hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
     741           (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
     742
     743    if (infoPtr->uNumTools == 0) {
     744        infoPtr->tools = (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO));
     745        toolPtr = infoPtr->tools;
     746    }
     747    else {
     748        TTTOOL_INFO *oldTools = infoPtr->tools;
     749        infoPtr->tools =
     750            (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
     751        memcpy (infoPtr->tools, oldTools,
     752                infoPtr->uNumTools * sizeof(TTTOOL_INFO));
     753        COMCTL32_Free (oldTools);
     754        toolPtr = &infoPtr->tools[infoPtr->uNumTools];
    905755    }
    906756
    … …  
    915765
    916766    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
    917 //      TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
    918         toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     767        TRACE("add string id %x!\n", (int)lpToolInfo->lpszText);
     768        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    919769    }
    920770    else if (lpToolInfo->lpszText) {
    921         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW) {
    922 //          TRACE (tooltips, "add CALLBACK!\n");
    923             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    924         }
    925         else {
    926             INT len = lstrlenW (lpToolInfo->lpszText);
    927 //          TRACE (tooltips, "add text \"%s\"!\n",
    928 //                 debugstr_w(lpToolInfo->lpszText));
    929             toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
    930             lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
    931         }
     771        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW) {
     772            TRACE("add CALLBACK!\n");
     773            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     774        }
     775        else {
     776            INT len = lstrlenW (lpToolInfo->lpszText);
     777            TRACE("add text %s!\n",
     778                   debugstr_w(lpToolInfo->lpszText));
     779            toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
     780            lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
     781        }
    932782    }
    933783
    934784    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    935         toolPtr->lParam = lpToolInfo->lParam;
     785        toolPtr->lParam = lpToolInfo->lParam;
    936786
    937787    /* install subclassing hook */
    938     TOOLTIPS_Subclass(hwnd,toolPtr);
     788    if (toolPtr->uFlags & TTF_SUBCLASS) {
     789        if (toolPtr->uFlags & TTF_IDISHWND) {
     790            LPTT_SUBCLASS_INFO lpttsi =
     791                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     792            if (lpttsi == NULL) {
     793                lpttsi =
     794                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     795                lpttsi->wpOrigProc =
     796                    (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
     797                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     798                lpttsi->hwndToolTip = hwnd;
     799                lpttsi->uRefCount++;
     800                SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
     801                            (HANDLE)lpttsi);
     802            }
     803            else
     804                WARN("A window tool must only be listed once!\n");
     805        }
     806        else {
     807            LPTT_SUBCLASS_INFO lpttsi =
     808                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     809            if (lpttsi == NULL) {
     810                lpttsi =
     811                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     812                lpttsi->wpOrigProc =
     813                    (WNDPROC)SetWindowLongA (toolPtr->hwnd,
     814                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     815                lpttsi->hwndToolTip = hwnd;
     816                lpttsi->uRefCount++;
     817                SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
     818            }
     819            else
     820                lpttsi->uRefCount++;
     821        }
     822        TRACE("subclassing installed!\n");
     823    }
    939824
    940825    return TRUE;
    … …  
    951836
    952837    if (lpToolInfo == NULL)
    953         return 0;
     838        return 0;
    954839    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    955         return 0;
     840        return 0;
    956841    if (infoPtr->uNumTools == 0)
    957         return 0;
     842        return 0;
    958843
    959844    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    960845    if (nTool == -1) return 0;
    961846
    962 //    TRACE (tooltips, "tool %d\n", nTool);
     847    TRACE("tool %d\n", nTool);
    963848
    964849    /* delete text string */
    965     toolPtr = &infoPtr->tools[nTool];
     850    toolPtr = &infoPtr->tools[nTool]; 
    966851    if ((toolPtr->hinst) && (toolPtr->lpszText)) {
    967         if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
    968              (HIWORD((INT)toolPtr->lpszText) != 0) )
    969             COMCTL32_Free (toolPtr->lpszText);
     852        if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
     853             (HIWORD((INT)toolPtr->lpszText) != 0) )
     854            COMCTL32_Free (toolPtr->lpszText);
    970855    }
    971856
    972857    /* remove subclassing */
    973     TOOLTIPS_Desubclass(toolPtr);
     858    if (toolPtr->uFlags & TTF_SUBCLASS) {
     859        if (toolPtr->uFlags & TTF_IDISHWND) {
     860            LPTT_SUBCLASS_INFO lpttsi =
     861                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     862            if (lpttsi) {
     863                SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     864                                  (LONG)lpttsi->wpOrigProc);
     865                RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     866                COMCTL32_Free (&lpttsi);
     867            }
     868            else
     869                ERR("Invalid data handle!\n");
     870        }
     871        else {
     872            LPTT_SUBCLASS_INFO lpttsi =
     873                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     874            if (lpttsi) {
     875                if (lpttsi->uRefCount == 1) {
     876                    SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     877                                      (LONG)lpttsi->wpOrigProc);
     878                    RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     879                    COMCTL32_Free (&lpttsi);
     880                }
     881                else
     882                    lpttsi->uRefCount--;
     883            }
     884            else
     885                ERR("Invalid data handle!\n");
     886        }
     887    }
    974888
    975889    /* delete tool from tool list */
    976890    if (infoPtr->uNumTools == 1) {
    977         COMCTL32_Free (infoPtr->tools);
    978         infoPtr->tools = NULL;
     891        COMCTL32_Free (infoPtr->tools);
     892        infoPtr->tools = NULL;
    979893    }
    980894    else {
    981         TTTOOL_INFO *oldTools = infoPtr->tools;
    982         infoPtr->tools =
    983             (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
    984 
    985         if (nTool > 0)
    986             memcpy (&infoPtr->tools[0], &oldTools[0],
    987                     nTool * sizeof(TTTOOL_INFO));
    988 
    989         if (nTool < infoPtr->uNumTools - 1)
    990             memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
    991                     (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
    992 
    993         COMCTL32_Free (oldTools);
     895        TTTOOL_INFO *oldTools = infoPtr->tools;
     896        infoPtr->tools =
     897            (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
     898
     899        if (nTool > 0)
     900            memcpy (&infoPtr->tools[0], &oldTools[0],
     901                    nTool * sizeof(TTTOOL_INFO));
     902
     903        if (nTool < infoPtr->uNumTools - 1)
     904            memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
     905                    (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
     906
     907        COMCTL32_Free (oldTools);
    994908    }
    995909
    … …  
    1009923
    1010924    if (lpToolInfo == NULL)
    1011         return 0;
     925        return 0;
    1012926    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1013         return 0;
     927        return 0;
    1014928    if (infoPtr->uNumTools == 0)
    1015         return 0;
     929        return 0;
    1016930
    1017931    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    1018932    if (nTool == -1) return 0;
    1019933
    1020 //    TRACE (tooltips, "tool %d\n", nTool);
     934    TRACE("tool %d\n", nTool);
    1021935
    1022936    /* delete text string */
    1023     toolPtr = &infoPtr->tools[nTool];
     937    toolPtr = &infoPtr->tools[nTool]; 
    1024938    if ((toolPtr->hinst) && (toolPtr->lpszText)) {
    1025         if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
    1026              (HIWORD((INT)toolPtr->lpszText) != 0) )
    1027             COMCTL32_Free (toolPtr->lpszText);
     939        if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
     940             (HIWORD((INT)toolPtr->lpszText) != 0) )
     941            COMCTL32_Free (toolPtr->lpszText);
    1028942    }
    1029943
    1030944    /* remove subclassing */
    1031     TOOLTIPS_Desubclass(toolPtr);
     945    if (toolPtr->uFlags & TTF_SUBCLASS) {
     946        if (toolPtr->uFlags & TTF_IDISHWND) {
     947            LPTT_SUBCLASS_INFO lpttsi =
     948                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     949            if (lpttsi) {
     950                SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     951                                  (LONG)lpttsi->wpOrigProc);
     952                RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     953                COMCTL32_Free (&lpttsi);
     954            }
     955            else
     956                ERR("Invalid data handle!\n");
     957        }
     958        else {
     959            LPTT_SUBCLASS_INFO lpttsi =
     960                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     961            if (lpttsi) {
     962                if (lpttsi->uRefCount == 1) {
     963                    SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     964                                      (LONG)lpttsi->wpOrigProc);
     965                    RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     966                    COMCTL32_Free (&lpttsi);
     967                }
     968                else
     969                    lpttsi->uRefCount--;
     970            }
     971            else
     972                ERR("Invalid data handle!\n");
     973        }
     974    }
    1032975
    1033976    /* delete tool from tool list */
    1034977    if (infoPtr->uNumTools == 1) {
    1035         COMCTL32_Free (infoPtr->tools);
    1036         infoPtr->tools = NULL;
     978        COMCTL32_Free (infoPtr->tools);
     979        infoPtr->tools = NULL;
    1037980    }
    1038981    else {
    1039         TTTOOL_INFO *oldTools = infoPtr->tools;
    1040         infoPtr->tools =
    1041             (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
    1042 
    1043         if (nTool > 0)
    1044             memcpy (&infoPtr->tools[0], &oldTools[0],
    1045                     nTool * sizeof(TTTOOL_INFO));
    1046 
    1047         if (nTool < infoPtr->uNumTools - 1)
    1048             memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
    1049                     (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
    1050 
    1051         COMCTL32_Free (oldTools);
     982        TTTOOL_INFO *oldTools = infoPtr->tools;
     983        infoPtr->tools =
     984            (TTTOOL_INFO*)COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
     985
     986        if (nTool > 0)
     987            memcpy (&infoPtr->tools[0], &oldTools[0],
     988                    nTool * sizeof(TTTOOL_INFO));
     989
     990        if (nTool < infoPtr->uNumTools - 1)
     991            memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
     992                    (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
     993
     994        COMCTL32_Free (oldTools);
    1052995    }
    1053996
    … …  
    10671010
    10681011    if (lpToolInfo == NULL)
    1069         return FALSE;
     1012        return FALSE;
    10701013    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1071         return FALSE;
     1014        return FALSE;
    10721015    if (uIndex >= infoPtr->uNumTools)
    1073         return FALSE;
    1074 
    1075 //    TRACE (tooltips, "index=%u\n", uIndex);
     1016        return FALSE;
     1017
     1018    TRACE("index=%u\n", uIndex);
    10761019
    10771020    toolPtr = &infoPtr->tools[uIndex];
    … …  
    10871030
    10881031    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    1089         lpToolInfo->lParam = toolPtr->lParam;
     1032        lpToolInfo->lParam = toolPtr->lParam;
    10901033
    10911034    return TRUE;
    … …  
    11021045
    11031046    if (lpToolInfo == NULL)
    1104         return FALSE;
     1047        return FALSE;
    11051048    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1106         return FALSE;
     1049        return FALSE;
    11071050    if (uIndex >= infoPtr->uNumTools)
    1108         return FALSE;
    1109 
    1110 //    TRACE (tooltips, "index=%u\n", uIndex);
     1051        return FALSE;
     1052
     1053    TRACE("index=%u\n", uIndex);
    11111054
    11121055    toolPtr = &infoPtr->tools[uIndex];
    … …  
    11221065
    11231066    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1124         lpToolInfo->lParam = toolPtr->lParam;
     1067        lpToolInfo->lParam = toolPtr->lParam;
    11251068
    11261069    return TRUE;
    … …  
    11361079
    11371080    if (lpToolInfo == NULL)
    1138         return FALSE;
     1081        return FALSE;
    11391082    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1140         return FALSE;
     1083        return FALSE;
    11411084
    11421085    if (lpToolInfo) {
    1143         if (infoPtr->nCurrentTool > -1) {
    1144             toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
    1145 
    1146             /* copy tool data */
    1147             lpToolInfo->uFlags   = toolPtr->uFlags;
    1148             lpToolInfo->rect     = toolPtr->rect;
    1149             lpToolInfo->hinst    = toolPtr->hinst;
    1150 /*          lpToolInfo->lpszText = toolPtr->lpszText; */
    1151             lpToolInfo->lpszText = NULL;  /* FIXME */
    1152 
    1153             if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    1154                 lpToolInfo->lParam = toolPtr->lParam;
    1155 
    1156             return TRUE;
    1157         }
    1158         else
    1159             return FALSE;
     1086        if (infoPtr->nCurrentTool > -1) {
     1087            toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
     1088
     1089            /* copy tool data */
     1090            lpToolInfo->uFlags   = toolPtr->uFlags;
     1091            lpToolInfo->rect     = toolPtr->rect;
     1092            lpToolInfo->hinst    = toolPtr->hinst;
     1093/*          lpToolInfo->lpszText = toolPtr->lpszText; */
     1094            lpToolInfo->lpszText = NULL;  /* FIXME */
     1095
     1096            if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
     1097                lpToolInfo->lParam = toolPtr->lParam;
     1098
     1099            return TRUE;
     1100        }
     1101        else
     1102            return FALSE;
    11601103    }
    11611104    else
    1162         return (infoPtr->nCurrentTool != -1);
     1105        return (infoPtr->nCurrentTool != -1);
    11631106
    11641107    return FALSE;
    … …  
    11741117
    11751118    if (lpToolInfo == NULL)
    1176         return FALSE;
     1119        return FALSE;
    11771120    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1178         return FALSE;
     1121        return FALSE;
    11791122
    11801123    if (lpToolInfo) {
    1181         if (infoPtr->nCurrentTool > -1) {
    1182             toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
    1183 
    1184             /* copy tool data */
    1185             lpToolInfo->uFlags   = toolPtr->uFlags;
    1186             lpToolInfo->rect     = toolPtr->rect;
    1187             lpToolInfo->hinst    = toolPtr->hinst;
    1188 /*          lpToolInfo->lpszText = toolPtr->lpszText; */
    1189             lpToolInfo->lpszText = NULL;  /* FIXME */
    1190 
    1191             if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1192                 lpToolInfo->lParam = toolPtr->lParam;
    1193 
    1194             return TRUE;
    1195         }
    1196         else
    1197             return FALSE;
     1124        if (infoPtr->nCurrentTool > -1) {
     1125            toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
     1126
     1127            /* copy tool data */
     1128            lpToolInfo->uFlags   = toolPtr->uFlags;
     1129            lpToolInfo->rect     = toolPtr->rect;
     1130            lpToolInfo->hinst    = toolPtr->hinst;
     1131/*          lpToolInfo->lpszText = toolPtr->lpszText; */
     1132            lpToolInfo->lpszText = NULL;  /* FIXME */
     1133
     1134            if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
     1135                lpToolInfo->lParam = toolPtr->lParam;
     1136
     1137            return TRUE;
     1138        }
     1139        else
     1140            return FALSE;
    11981141    }
    11991142    else
    1200         return (infoPtr->nCurrentTool != -1);
     1143        return (infoPtr->nCurrentTool != -1);
    12011144
    12021145    return FALSE;
    … …  
    12101153
    12111154    switch (wParam) {
    1212         case TTDT_AUTOMATIC:
    1213             return infoPtr->nAutomaticTime;
    1214 
    1215         case TTDT_RESHOW:
    1216             return infoPtr->nReshowTime;
    1217 
    1218         case TTDT_AUTOPOP:
    1219             return infoPtr->nAutoPopTime;
    1220 
    1221         case TTDT_INITIAL:
    1222             return infoPtr->nInitialTime;
    1223     }
    1224 
    1225     return 0;
     1155    case TTDT_RESHOW:
     1156        return infoPtr->nReshowTime;
     1157
     1158    case TTDT_AUTOPOP:
     1159        return infoPtr->nAutoPopTime;
     1160
     1161    case TTDT_INITIAL:
     1162    case TTDT_AUTOMATIC: /* Apparently TTDT_AUTOMATIC returns TTDT_INITIAL */
     1163        return infoPtr->nInitialTime;
     1164
     1165    default:
     1166        WARN("Invalid wParam %x\n", wParam);
     1167        break;
     1168    }
     1169
     1170    return -1;
    12261171}
    12271172
    … …  
    12421187
    12431188
    1244 static LRESULT
     1189inline static LRESULT
    12451190TOOLTIPS_GetMaxTipWidth (HWND hwnd, WPARAM wParam, LPARAM lParam)
    12461191{
    … …  
    12591204
    12601205    if (lpToolInfo == NULL)
    1261         return 0;
     1206        return 0;
    12621207    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1263         return 0;
     1208        return 0;
    12641209
    12651210    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    12661211    if (nTool == -1) return 0;
    12671212
    1268     TOOLTIPS_GetTipText(hwnd,infoPtr,nTool);
    1269 
    1270     lstrcpyWtoA(lpToolInfo->lpszText,infoPtr->szTipText);
     1213    /* NB this API is broken, there is no way for the app to determine
     1214       what size buffer it requires nor a way to specify how long the
     1215       one it supplies is.  We'll assume it's upto INFOTIPSIZE */
     1216
     1217    WideCharToMultiByte(CP_ACP, 0, infoPtr->tools[nTool].lpszText, -1,
     1218                        lpToolInfo->lpszText, INFOTIPSIZE, NULL, NULL);
    12711219
    12721220    return 0;
    … …  
    12821230
    12831231    if (lpToolInfo == NULL)
    1284         return 0;
     1232        return 0;
    12851233    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1286         return 0;
     1234        return 0;
    12871235
    12881236    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    12891237    if (nTool == -1) return 0;
    12901238
    1291     TOOLTIPS_GetTipText(hwnd,infoPtr,nTool);
    1292 
    1293     lstrcpyW(lpToolInfo->lpszText,infoPtr->szTipText);
    1294 
    1295     return 0;
    1296 }
    1297 
    1298 
    1299 static LRESULT
     1239    lstrcpyW (lpToolInfo->lpszText, infoPtr->tools[nTool].lpszText);
     1240
     1241    return 0;
     1242}
     1243
     1244
     1245inline static LRESULT
    13001246TOOLTIPS_GetTipBkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
    13011247{
    … …  
    13051251
    13061252
    1307 static LRESULT
     1253inline static LRESULT
    13081254TOOLTIPS_GetTipTextColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
    13091255{
    … …  
    13131259
    13141260
    1315 static LRESULT
     1261inline static LRESULT
    13161262TOOLTIPS_GetToolCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
    13171263{
    … …  
    13301276
    13311277    if (lpToolInfo == NULL)
    1332         return FALSE;
     1278        return FALSE;
    13331279    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1334         return FALSE;
     1280        return FALSE;
    13351281    if (infoPtr->uNumTools == 0)
    1336         return FALSE;
     1282        return FALSE;
    13371283
    13381284    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    13391285    if (nTool == -1)
    1340         return FALSE;
    1341 
    1342 //    TRACE (tooltips, "tool %d\n", nTool);
     1286        return FALSE;
     1287
     1288    TRACE("tool %d\n", nTool);
    13431289
    13441290    toolPtr = &infoPtr->tools[nTool];
    … …  
    13521298
    13531299    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    1354         lpToolInfo->lParam = toolPtr->lParam;
     1300        lpToolInfo->lParam = toolPtr->lParam;
    13551301
    13561302    return TRUE;
    … …  
    13671313
    13681314    if (lpToolInfo == NULL)
    1369         return FALSE;
     1315        return FALSE;
    13701316    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1371         return FALSE;
     1317        return FALSE;
    13721318    if (infoPtr->uNumTools == 0)
    1373         return FALSE;
     1319        return FALSE;
    13741320
    13751321    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    13761322    if (nTool == -1)
    1377         return FALSE;
    1378 
    1379 //    TRACE (tooltips, "tool %d\n", nTool);
     1323        return FALSE;
     1324
     1325    TRACE("tool %d\n", nTool);
    13801326
    13811327    toolPtr = &infoPtr->tools[nTool];
    … …  
    13891335
    13901336    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1391         lpToolInfo->lParam = toolPtr->lParam;
     1337        lpToolInfo->lParam = toolPtr->lParam;
    13921338
    13931339    return TRUE;
    … …  
    14041350
    14051351    if (lptthit == 0)
    1406         return FALSE;
     1352        return FALSE;
    14071353
    14081354    nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt);
    14091355    if (nTool == -1)
    1410         return FALSE;
    1411 
    1412 //    TRACE (tooltips, "tool %d!\n", nTool);
     1356        return FALSE;
     1357
     1358    TRACE("tool %d!\n", nTool);
    14131359
    14141360    /* copy tool data */
    14151361    if (lptthit->ti.cbSize >= sizeof(TTTOOLINFOA)) {
    1416         toolPtr = &infoPtr->tools[nTool];
    1417 
    1418         lptthit->ti.uFlags   = toolPtr->uFlags;
    1419         lptthit->ti.hwnd     = toolPtr->hwnd;
    1420         lptthit->ti.uId      = toolPtr->uId;
    1421         lptthit->ti.rect     = toolPtr->rect;
    1422         lptthit->ti.hinst    = toolPtr->hinst;
    1423 /*      lptthit->ti.lpszText = toolPtr->lpszText; */
    1424         lptthit->ti.lpszText = NULL;  /* FIXME */
    1425         lptthit->ti.lParam   = toolPtr->lParam;
     1362        toolPtr = &infoPtr->tools[nTool];
     1363
     1364        lptthit->ti.uFlags   = toolPtr->uFlags;
     1365        lptthit->ti.hwnd     = toolPtr->hwnd;
     1366        lptthit->ti.uId      = toolPtr->uId;
     1367        lptthit->ti.rect     = toolPtr->rect;
     1368        lptthit->ti.hinst    = toolPtr->hinst;
     1369/*      lptthit->ti.lpszText = toolPtr->lpszText; */
     1370        lptthit->ti.lpszText = NULL;  /* FIXME */
     1371        lptthit->ti.lParam   = toolPtr->lParam;
    14261372    }
    14271373
    … …  
    14391385
    14401386    if (lptthit == 0)
    1441         return FALSE;
     1387        return FALSE;
    14421388
    14431389    nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt);
    14441390    if (nTool == -1)
    1445         return FALSE;
    1446 
    1447 //    TRACE (tooltips, "tool %d!\n", nTool);
     1391        return FALSE;
     1392
     1393    TRACE("tool %d!\n", nTool);
    14481394
    14491395    /* copy tool data */
    14501396    if (lptthit->ti.cbSize >= sizeof(TTTOOLINFOW)) {
    1451         toolPtr = &infoPtr->tools[nTool];
    1452 
    1453         lptthit->ti.uFlags   = toolPtr->uFlags;
    1454         lptthit->ti.hwnd     = toolPtr->hwnd;
    1455         lptthit->ti.uId      = toolPtr->uId;
    1456         lptthit->ti.rect     = toolPtr->rect;
    1457         lptthit->ti.hinst    = toolPtr->hinst;
    1458 /*      lptthit->ti.lpszText = toolPtr->lpszText; */
    1459         lptthit->ti.lpszText = NULL;  /* FIXME */
    1460         lptthit->ti.lParam   = toolPtr->lParam;
     1397        toolPtr = &infoPtr->tools[nTool];
     1398
     1399        lptthit->ti.uFlags   = toolPtr->uFlags;
     1400        lptthit->ti.hwnd     = toolPtr->hwnd;
     1401        lptthit->ti.uId      = toolPtr->uId;
     1402        lptthit->ti.rect     = toolPtr->rect;
     1403        lptthit->ti.hinst    = toolPtr->hinst;
     1404/*      lptthit->ti.lpszText = toolPtr->lpszText; */
     1405        lptthit->ti.lpszText = NULL;  /* FIXME */
     1406        lptthit->ti.lParam   = toolPtr->lParam;
    14611407    }
    14621408
    … …  
    14731419
    14741420    if (lpti == NULL)
    1475         return 0;
     1421        return 0;
    14761422    if (lpti->cbSize < TTTOOLINFO_V1_SIZEA)
    1477         return FALSE;
     1423        return FALSE;
    14781424
    14791425    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpti);
    … …  
    14941440
    14951441    if (lpti == NULL)
    1496         return 0;
     1442        return 0;
    14971443    if (lpti->cbSize < TTTOOLINFO_V1_SIZEW)
    1498         return FALSE;
     1444        return FALSE;
    14991445
    15001446    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpti);
    … …  
    15071453
    15081454
    1509 static LRESULT
     1455inline static LRESULT
    15101456TOOLTIPS_Pop (HWND hwnd, WPARAM wParam, LPARAM lParam)
    15111457{
    15121458    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    1513 
    1514     /*
    1515      * Need to set nCurrentTool to nOldTool so we hide the tool.
    1516      *  nTool and nOldTool values change when the mouse leaves the window.
    1517      * If using TTM_UPDATETIPTEXT we can end up with an nCurrentTool = -1 if the
    1518      * text can't be found, thus the tooltip would never be hidden.
    1519      */
    1520     if (infoPtr->nTool != infoPtr->nOldTool)
    1521       infoPtr->nCurrentTool = infoPtr->nOldTool;
    1522 
    15231459    TOOLTIPS_Hide (hwnd, infoPtr);
    15241460
    … …  
    15331469    LPMSG lpMsg = (LPMSG)lParam;
    15341470    POINT pt;
    1535 
    1536     if (lParam == 0)
    1537     {
    1538 //    ERR (tooltips, "lpMsg == NULL!\n");
    1539       return 0;
    1540     }
    1541 
    1542     switch (lpMsg->message)
    1543     {
    1544         case WM_LBUTTONDOWN:
    1545         case WM_LBUTTONUP:
    1546         case WM_MBUTTONDOWN:
    1547         case WM_MBUTTONUP:
    1548         case WM_RBUTTONDOWN:
    1549         case WM_RBUTTONUP:
    1550             pt = lpMsg->pt;
    1551             ScreenToClient(lpMsg->hwnd,&pt);
    1552             infoPtr->nOldTool = infoPtr->nTool;
    1553             infoPtr->nTool = TOOLTIPS_GetToolFromPoint(infoPtr,lpMsg->hwnd,&pt);
    1554 //          TRACE (tooltips, "tool (%x) %d %d\n",
    1555 //                 hwnd, infoPtr->nOldTool, infoPtr->nTool);
    1556             TOOLTIPS_Hide (hwnd, infoPtr);
    1557             break;
    1558 
    1559         case WM_MOUSEMOVE:
    1560             pt = lpMsg->pt;
    1561             ScreenToClient(lpMsg->hwnd,&pt);
    1562             infoPtr->nOldTool = infoPtr->nTool;
    1563             infoPtr->nTool = TOOLTIPS_GetToolFromPoint(infoPtr,lpMsg->hwnd,&pt);
    1564             //TRACE (tooltips, "tool (%x) %d %d\n",
    1565             //       hwnd, infoPtr->nOldTool, infoPtr->nTool);
    1566             //TRACE (tooltips, "WM_MOUSEMOVE (%04x %ld %ld)\n",
    1567             //       hwnd, pt.x, pt.y);
    1568 
    1569             if (infoPtr->bActive && (infoPtr->nTool != infoPtr->nOldTool))
    1570             {
    1571               if (infoPtr->nOldTool == -1)
    1572               {
    1573                 SetTimer(hwnd,ID_TIMERSHOW,infoPtr->nInitialTime,0);
    1574                 //TRACE (tooltips, "timer 1 started!\n");
    1575               } else
    1576               {
    1577                 /*
    1578                  * Need to set nCurrentTool to nOldTool so we hide the tool.
    1579                  *  nTool and nOldTool values change when the mouse leaves the window.
    1580                  * If using TTM_UPDATETIPTEXT we can end up with an nCurrentTool = -1 if the
    1581                  * text can't be found, thus the tooltip would never be hidden.
    1582                  */
    1583                 if (infoPtr->nTool != infoPtr->nOldTool)
    1584                   infoPtr->nCurrentTool = infoPtr->nOldTool;
    1585 
    1586                 TOOLTIPS_Hide(hwnd,infoPtr);
    1587                 SetTimer (hwnd,ID_TIMERSHOW,infoPtr->nReshowTime,0);
    1588                 //TRACE (tooltips, "timer 2 started!\n");
    1589               }
    1590             }
    1591             if (infoPtr->nCurrentTool != -1)
    1592             {
    1593               SetTimer(hwnd,ID_TIMERLEAVE,100,0);
    1594               //TRACE (tooltips, "timer 3 started!\n");
    1595             }
    1596             break;
     1471    INT nOldTool;
     1472
     1473    if (lParam == 0) {
     1474        ERR("lpMsg == NULL!\n");
     1475        return 0;
     1476    }
     1477
     1478    switch (lpMsg->message) {
     1479        case WM_LBUTTONDOWN:
     1480        case WM_LBUTTONUP:
     1481        case WM_MBUTTONDOWN:
     1482        case WM_MBUTTONUP:
     1483        case WM_RBUTTONDOWN:
     1484        case WM_RBUTTONUP:
     1485            pt.x = LOWORD(lParam);
     1486            pt.y = HIWORD(lParam);
     1487            infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
     1488            TRACE("tool (%x) %d %d\n",
     1489                   hwnd, infoPtr->nTool, infoPtr->nCurrentTool);
     1490            TOOLTIPS_Hide (hwnd, infoPtr);
     1491            break;
     1492
     1493        case WM_MOUSEMOVE:
     1494            pt.x = LOWORD(lpMsg->lParam);
     1495            pt.y = HIWORD(lpMsg->lParam);
     1496            nOldTool = infoPtr->nTool;
     1497            infoPtr->nTool = TOOLTIPS_GetToolFromPoint(infoPtr, lpMsg->hwnd,
     1498                                                       &pt);
     1499            TRACE("tool (%x) %d %d %d\n", hwnd, nOldTool,
     1500                  infoPtr->nTool, infoPtr->nCurrentTool);
     1501            TRACE("WM_MOUSEMOVE (%04x %ld %ld)\n", hwnd, pt.x, pt.y);
     1502
     1503            if (infoPtr->nTool != nOldTool) {
     1504                if(infoPtr->nTool == -1) { /* Moved out of all tools */
     1505                    TOOLTIPS_Hide(hwnd, infoPtr);
     1506                    KillTimer(hwnd, ID_TIMERLEAVE);
     1507                } else if (nOldTool == -1) { /* Moved from outside */
     1508                    if(infoPtr->bActive) {
     1509                        SetTimer(hwnd, ID_TIMERSHOW, infoPtr->nInitialTime, 0);
     1510                        TRACE("timer 1 started!\n");
     1511                    }
     1512                } else { /* Moved from one to another */
     1513                    TOOLTIPS_Hide (hwnd, infoPtr);
     1514                    KillTimer(hwnd, ID_TIMERLEAVE);
     1515                    if(infoPtr->bActive) {
     1516                        SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nReshowTime, 0);
     1517                        TRACE("timer 1 started!\n");
     1518                    }
     1519                }
     1520            } else if(infoPtr->nCurrentTool != -1) { /* restart autopop */
     1521                KillTimer(hwnd, ID_TIMERPOP);
     1522                SetTimer(hwnd, ID_TIMERPOP, infoPtr->nAutoPopTime, 0);
     1523                TRACE("timer 2 restarted\n");
     1524            }
     1525            break;
    15971526    }
    15981527
    … …  
    16081537
    16091538    switch (wParam) {
    1610         case TTDT_AUTOMATIC:
    1611             if (nTime == 0) {
    1612                 infoPtr->nAutomaticTime = 500;
    1613                 infoPtr->nReshowTime    = 100;
    1614                 infoPtr->nAutoPopTime   = 5000;
    1615                 infoPtr->nInitialTime   = 500;
    1616             }
    1617             else {
    1618                 infoPtr->nAutomaticTime = nTime;
    1619                 infoPtr->nReshowTime    = nTime / 5;
    1620                 infoPtr->nAutoPopTime   = nTime * 10;
    1621                 infoPtr->nInitialTime   = nTime;
    1622             }
    1623             break;
    1624 
    1625         case TTDT_RESHOW:
    1626             infoPtr->nReshowTime = nTime;
    1627             break;
    1628 
    1629         case TTDT_AUTOPOP:
    1630             infoPtr->nAutoPopTime = nTime;
    1631             break;
    1632 
    1633         case TTDT_INITIAL:
    1634             infoPtr->nInitialTime = nTime;
    1635             break;
     1539    case TTDT_AUTOMATIC:
     1540        if (nTime <= 0)
     1541            nTime = GetDoubleClickTime();
     1542        infoPtr->nReshowTime    = nTime / 5;
     1543        infoPtr->nAutoPopTime   = nTime * 10;
     1544        infoPtr->nInitialTime   = nTime;
     1545        break;
     1546
     1547    case TTDT_RESHOW:
     1548        if(nTime < 0)
     1549            nTime = GetDoubleClickTime() / 5;
     1550        infoPtr->nReshowTime = nTime;
     1551        break;
     1552
     1553    case TTDT_AUTOPOP:
     1554        if(nTime < 0)
     1555            nTime = GetDoubleClickTime() * 10;
     1556        infoPtr->nAutoPopTime = nTime;
     1557        break;
     1558
     1559    case TTDT_INITIAL:
     1560        if(nTime < 0)
     1561            nTime = GetDoubleClickTime();
     1562        infoPtr->nInitialTime = nTime;
     1563            break;
     1564
     1565    default:
     1566        WARN("Invalid wParam %x\n", wParam);
     1567        break;
    16361568    }
    16371569
    … …  
    16551587
    16561588
    1657 static LRESULT
     1589inline static LRESULT
    16581590TOOLTIPS_SetMaxTipWidth (HWND hwnd, WPARAM wParam, LPARAM lParam)
    16591591{
    … …  
    16671599
    16681600
    1669 static LRESULT
     1601inline static LRESULT
    16701602TOOLTIPS_SetTipBkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
    16711603{
    … …  
    16781610
    16791611
    1680 static LRESULT
     1612inline static LRESULT
    16811613TOOLTIPS_SetTipTextColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
    16821614{
    … …  
    16981630
    16991631    if (lpToolInfo == NULL)
    1700         return 0;
     1632        return 0;
    17011633    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1702         return 0;
     1634        return 0;
    17031635
    17041636    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    17051637    if (nTool == -1) return 0;
    17061638
    1707 //    TRACE (tooltips, "tool %d\n", nTool);
     1639    TRACE("tool %d\n", nTool);
    17081640
    17091641    toolPtr = &infoPtr->tools[nTool];
    … …  
    17171649
    17181650    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
    1719 //      TRACE (tooltips, "set string id %x!\n", (INT)lpToolInfo->lpszText);
    1720         toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     1651        TRACE("set string id %x!\n", (INT)lpToolInfo->lpszText);
     1652        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    17211653    }
    17221654    else if (lpToolInfo->lpszText) {
    1723         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
    1724             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1725         else {
    1726             if ( (toolPtr->lpszText) &&
    1727                  (HIWORD((INT)toolPtr->lpszText) != 0) ) {
    1728                 COMCTL32_Free (toolPtr->lpszText);
    1729                 toolPtr->lpszText = NULL;
    1730             }
    1731             if (lpToolInfo->lpszText) {
    1732                 INT len = lstrlenA (lpToolInfo->lpszText);
    1733                 toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1734                 lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
    1735             }
    1736         }
     1655        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
     1656            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1657        else {
     1658            if ( (toolPtr->lpszText) &&
     1659                 (HIWORD((INT)toolPtr->lpszText) != 0) ) {
     1660                COMCTL32_Free (toolPtr->lpszText);
     1661                toolPtr->lpszText = NULL;
     1662            }
     1663            if (lpToolInfo->lpszText) {
     1664                INT len = MultiByteToWideChar(CP_ACP, 0, lpToolInfo->lpszText,
     1665                                              -1, NULL, 0);
     1666                toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc (len * sizeof(WCHAR));
     1667                MultiByteToWideChar(CP_ACP, 0, lpToolInfo->lpszText, -1,
     1668                                    toolPtr->lpszText, len);
     1669            }
     1670        }
    17371671    }
    17381672
    17391673    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    1740         toolPtr->lParam = lpToolInfo->lParam;
     1674        toolPtr->lParam = lpToolInfo->lParam;
    17411675
    17421676    return 0;
    … …  
    17531687
    17541688    if (lpToolInfo == NULL)
    1755         return 0;
     1689        return 0;
    17561690    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1757         return 0;
     1691        return 0;
    17581692
    17591693    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    17601694    if (nTool == -1) return 0;
    17611695
    1762 //    TRACE (tooltips, "tool %d\n", nTool);
     1696    TRACE("tool %d\n", nTool);
    17631697
    17641698    toolPtr = &infoPtr->tools[nTool];
    … …  
    17721706
    17731707    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
    1774 //      TRACE (tooltips, "set string id %x!\n", (INT)lpToolInfo->lpszText);
    1775         toolPtr->lpszText = lpToolInfo->lpszText;
     1708        TRACE("set string id %x!\n", (INT)lpToolInfo->lpszText);
     1709        toolPtr->lpszText = lpToolInfo->lpszText;
    17761710    }
    17771711    else if (lpToolInfo->lpszText) {
    1778         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
    1779             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1780         else {
    1781             if ( (toolPtr->lpszText) &&
    1782                 (HIWORD((INT)toolPtr->lpszText) != 0) ) {
    1783                 COMCTL32_Free (toolPtr->lpszText);
    1784                 toolPtr->lpszText = NULL;
    1785             }
    1786             if (lpToolInfo->lpszText) {
    1787                 INT len = lstrlenW (lpToolInfo->lpszText);
    1788                 toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1789                 lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
    1790             }
    1791         }
     1712        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
     1713            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1714        else {
     1715            if ( (toolPtr->lpszText) &&
     1716                (HIWORD((INT)toolPtr->lpszText) != 0) ) {
     1717                COMCTL32_Free (toolPtr->lpszText);
     1718                toolPtr->lpszText = NULL;
     1719            }
     1720            if (lpToolInfo->lpszText) {
     1721                INT len = lstrlenW (lpToolInfo->lpszText);
     1722                toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     1723                lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
     1724            }
     1725        }
    17921726    }
    17931727
    17941728    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1795         toolPtr->lParam = lpToolInfo->lParam;
     1729        toolPtr->lParam = lpToolInfo->lParam;
    17961730
    17971731    return 0;
    … …  
    18051739    LPTTTOOLINFOA lpToolInfo = (LPTTTOOLINFOA)lParam;
    18061740
    1807     if (lpToolInfo == NULL) return 0;
    1808     if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA) return FALSE;
    1809 
    1810     if ((BOOL)wParam)
    1811     {
    1812       /* activate */
    1813       infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA(infoPtr,lpToolInfo);
    1814       if (infoPtr->nTrackTool != -1)
    1815       {
    1816         //TRACE (tooltips, "activated!\n");
    1817         infoPtr->bTrackActive = TRUE;
    1818         TOOLTIPS_TrackShow(hwnd,infoPtr);
    1819       }
    1820     } else
    1821     {
    1822       /* deactivate */
    1823       TOOLTIPS_TrackHide(hwnd,infoPtr);
    1824 
    1825       infoPtr->bTrackActive = FALSE;
    1826       infoPtr->nTrackTool = -1;
    1827 
    1828       //TRACE (tooltips, "deactivated!\n");
     1741    if (lpToolInfo == NULL)
     1742        return 0;
     1743    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
     1744        return FALSE;
     1745
     1746    if ((BOOL)wParam) {
     1747        /* activate */
     1748        infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
     1749        if (infoPtr->nTrackTool != -1) {
     1750            TRACE("activated!\n");
     1751            infoPtr->bTrackActive = TRUE;
     1752            TOOLTIPS_TrackShow (hwnd, infoPtr);
     1753        }
     1754    }
     1755    else {
     1756        /* deactivate */
     1757        TOOLTIPS_TrackHide (hwnd, infoPtr);
     1758
     1759        infoPtr->bTrackActive = FALSE;
     1760        infoPtr->nTrackTool = -1;
     1761
     1762        TRACE("deactivated!\n");
    18291763    }
    18301764
    … …  
    18411775    infoPtr->yTrackPos = (INT)HIWORD(lParam);
    18421776
    1843     if (infoPtr->bTrackActive)
    1844     {
    1845 //      TRACE (tooltips, "[%d %d]\n",
    1846 //             infoPtr->xTrackPos, infoPtr->yTrackPos);
    1847       TOOLTIPS_TrackShow(hwnd,infoPtr);
     1777    if (infoPtr->bTrackActive) {
     1778        TRACE("[%d %d]\n",
     1779               infoPtr->xTrackPos, infoPtr->yTrackPos);
     1780
     1781        TOOLTIPS_TrackShow (hwnd, infoPtr);
    18481782    }
    18491783
    … …  
    18581792
    18591793    if (infoPtr->nCurrentTool != -1)
    1860         UpdateWindow (hwnd);
    1861 
    1862     return 0;
    1863 }
    1864 
    1865 
     1794        UpdateWindow (hwnd);
     1795
     1796    return 0;
     1797}
     1798
     1799
     1800static LRESULT
    18661801TOOLTIPS_UpdateTipTextA (HWND hwnd, WPARAM wParam, LPARAM lParam)
    18671802{
    … …  
    18721807
    18731808    if (lpToolInfo == NULL)
    1874         return 0;
     1809        return 0;
    18751810    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1876         return FALSE;
     1811        return FALSE;
    18771812
    18781813    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    18791814    if (nTool == -1) return 0;
    18801815
    1881 //    TRACE("tool %d\n", nTool);
     1816    TRACE("tool %d\n", nTool);
    18821817
    18831818    toolPtr = &infoPtr->tools[nTool];
    … …  
    18871822
    18881823    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)){
    1889         toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     1824        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    18901825    }
    18911826    else if (lpToolInfo->lpszText) {
    1892         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
    1893             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1894         else {
    1895             if ( (toolPtr->lpszText) &&
    1896                  (HIWORD((INT)toolPtr->lpszText) != 0) ) {
    1897                 COMCTL32_Free (toolPtr->lpszText);
    1898                 toolPtr->lpszText = NULL;
    1899             }
    1900             if (lpToolInfo->lpszText) {
    1901                 INT len = lstrlenA (lpToolInfo->lpszText);
    1902                 toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1903                 lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
    1904             }
    1905         }
     1827        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
     1828            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1829        else {
     1830            if ( (toolPtr->lpszText) &&
     1831                 (HIWORD((INT)toolPtr->lpszText) != 0) ) {
     1832                COMCTL32_Free (toolPtr->lpszText);
     1833                toolPtr->lpszText = NULL;
     1834            }
     1835            if (lpToolInfo->lpszText) {
     1836                INT len = MultiByteToWideChar(CP_ACP, 0, lpToolInfo->lpszText,
     1837                                              -1, NULL, 0);
     1838                toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc (len * sizeof(WCHAR));
     1839                MultiByteToWideChar(CP_ACP, 0, lpToolInfo->lpszText, -1,
     1840                                    toolPtr->lpszText, len);
     1841            }
     1842        }
    19061843    }
    19071844
    19081845    /* force repaint */
    19091846    if (infoPtr->bActive)
    1910         TOOLTIPS_Show (hwnd, infoPtr);
     1847        TOOLTIPS_Show (hwnd, infoPtr);
    19111848    else if (infoPtr->bTrackActive)
    1912         TOOLTIPS_TrackShow (hwnd, infoPtr);
     1849        TOOLTIPS_TrackShow (hwnd, infoPtr);
    19131850
    19141851    return 0;
    … …  
    19251862
    19261863    if (lpToolInfo == NULL)
    1927         return 0;
     1864        return 0;
    19281865    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1929         return FALSE;
     1866        return FALSE;
    19301867
    19311868    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    19321869    if (nTool == -1)
    1933         return 0;
    1934 
    1935 //    TRACE("tool %d\n", nTool);
     1870        return 0;
     1871
     1872    TRACE("tool %d\n", nTool);
    19361873
    19371874    toolPtr = &infoPtr->tools[nTool];
    … …  
    19411878
    19421879    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)){
    1943         toolPtr->lpszText = lpToolInfo->lpszText;
     1880        toolPtr->lpszText = lpToolInfo->lpszText;
    19441881    }
    19451882    else if (lpToolInfo->lpszText) {
    1946         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
    1947             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1948         else {
    1949             if ( (toolPtr->lpszText)  &&
    1950                 (HIWORD((INT)toolPtr->lpszText) != 0) ) {
    1951                 COMCTL32_Free (toolPtr->lpszText);
    1952                 toolPtr->lpszText = NULL;
    1953             }
    1954             if (lpToolInfo->lpszText) {
    1955                 INT len = lstrlenW (lpToolInfo->lpszText);
    1956                 toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1957                 lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
    1958             }
    1959         }
     1883        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
     1884            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1885        else {
     1886            if ( (toolPtr->lpszText)  &&
     1887                (HIWORD((INT)toolPtr->lpszText) != 0) ) {
     1888                COMCTL32_Free (toolPtr->lpszText);
     1889                toolPtr->lpszText = NULL;
     1890            }
     1891            if (lpToolInfo->lpszText) {
     1892                INT len = lstrlenW (lpToolInfo->lpszText);
     1893                toolPtr->lpszText = (WCHAR*)COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     1894                lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
     1895            }
     1896        }
    19601897    }
    19611898
    19621899    /* force repaint */
    19631900    if (infoPtr->bActive)
    1964         TOOLTIPS_Show (hwnd, infoPtr);
     1901        TOOLTIPS_Show (hwnd, infoPtr);
    19651902    else if (infoPtr->bTrackActive)
    1966         TOOLTIPS_TrackShow (hwnd, infoPtr);
     1903        TOOLTIPS_TrackShow (hwnd, infoPtr);
    19671904
    19681905    return 0;
    … …  
    19861923
    19871924    /* allocate memory for info structure */
    1988     infoPtr = (TOOLTIPS_INFO*)initControl(hwnd,sizeof(TOOLTIPS_INFO));
     1925    infoPtr = (TOOLTIPS_INFO *)COMCTL32_Alloc (sizeof(TOOLTIPS_INFO));
     1926    SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
    19891927
    19901928    /* initialize info structure */
    1991     infoPtr->szTipText[0] = '\0';
    19921929    infoPtr->bActive = TRUE;
    19931930    infoPtr->bTrackActive = FALSE;
    1994     infoPtr->clrBk   = GetSysColor(COLOR_INFOBK);
    1995     infoPtr->clrText = GetSysColor(COLOR_INFOTEXT);
    1996     infoPtr->xTrackPos = 0;
    1997     infoPtr->yTrackPos = 0;
     1931    infoPtr->clrBk   = GetSysColor (COLOR_INFOBK);
     1932    infoPtr->clrText = GetSysColor (COLOR_INFOTEXT);
    19981933
    19991934    nclm.cbSize = sizeof(NONCLIENTMETRICSA);
    2000     SystemParametersInfoA(SPI_GETNONCLIENTMETRICS,0,&nclm,0);
    2001     infoPtr->hFont = CreateFontIndirectA(&nclm.lfStatusFont);
     1935    SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
     1936    infoPtr->hFont = CreateFontIndirectA (&nclm.lfStatusFont);
    20021937
    20031938    infoPtr->nMaxTipWidth = -1;
    20041939    infoPtr->nTool = -1;
    2005     infoPtr->nOldTool = -1;
    20061940    infoPtr->nCurrentTool = -1;
    20071941    infoPtr->nTrackTool = -1;
    20081942
    2009     infoPtr->nAutomaticTime = 500;
    2010     infoPtr->nReshowTime    = 100;
    2011     infoPtr->nAutoPopTime   = 5000;
    2012     infoPtr->nInitialTime   = 500;
    2013 
    2014     SetRectEmpty(&infoPtr->rcMargin);
    2015 
    2016     SetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
     1943    TOOLTIPS_SetDelayTime(hwnd, TTDT_AUTOMATIC, 0L);
     1944
     1945    nResult = (INT) SendMessageA (GetParent (hwnd), WM_NOTIFYFORMAT,
     1946                                  (WPARAM)hwnd, (LPARAM)NF_QUERY);
     1947    if (nResult == NFR_ANSI) {
     1948        infoPtr->bNotifyUnicode = FALSE;
     1949        TRACE(" -- WM_NOTIFYFORMAT returns: NFR_ANSI\n");
     1950    }
     1951    else if (nResult == NFR_UNICODE) {
     1952        infoPtr->bNotifyUnicode = TRUE;
     1953        TRACE(" -- WM_NOTIFYFORMAT returns: NFR_UNICODE\n");
     1954    }
     1955    else {
     1956        ERR (" -- WM_NOTIFYFORMAT returns: error!\n");
     1957    }
     1958
     1959    SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
    20171960
    20181961    return 0;
    … …  
    20231966TOOLTIPS_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
    20241967{
    2025     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
     1968    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    20261969    TTTOOL_INFO *toolPtr;
    20271970    INT i;
    … …  
    20291972    /* free tools */
    20301973    if (infoPtr->tools) {
    2031         for (i = 0; i < infoPtr->uNumTools; i++) {
    2032             toolPtr = &infoPtr->tools[i];
    2033             if ((toolPtr->hinst) && (toolPtr->lpszText)) {
    2034                 if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
    2035                      (HIWORD((INT)toolPtr->lpszText) != 0) )
    2036                 {
    2037                     COMCTL32_Free (toolPtr->lpszText);
    2038                     toolPtr->lpszText = NULL;
    2039                 }
    2040             }
    2041 
    2042             /* remove subclassing */
    2043             if (toolPtr->uFlags & TTF_SUBCLASS) {
    2044                 LPTT_SUBCLASS_INFO lpttsi;
    2045 
    2046                 if (toolPtr->uFlags & TTF_IDISHWND)
    2047                     lpttsi = (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    2048                 else
    2049                     lpttsi = (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    2050 
    2051                 if (lpttsi) {
    2052                     SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    2053                                       (LONG)lpttsi->wpOrigProc);
    2054                     RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    2055                     COMCTL32_Free (&lpttsi);
    2056                 }
    2057             }
    2058       }
    2059       COMCTL32_Free (infoPtr->tools);
     1974        for (i = 0; i < infoPtr->uNumTools; i++) {
     1975            toolPtr = &infoPtr->tools[i];
     1976            if ((toolPtr->hinst) && (toolPtr->lpszText)) {
     1977                if ( (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) &&
     1978                     (HIWORD((INT)toolPtr->lpszText) != 0) )
     1979                {
     1980                    COMCTL32_Free (toolPtr->lpszText);
     1981                    toolPtr->lpszText = NULL;
     1982                }
     1983            }
     1984
     1985            /* remove subclassing */
     1986            if (toolPtr->uFlags & TTF_SUBCLASS) {
     1987                LPTT_SUBCLASS_INFO lpttsi;
     1988
     1989                if (toolPtr->uFlags & TTF_IDISHWND)
     1990                    lpttsi = (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     1991                else
     1992                    lpttsi = (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     1993
     1994                if (lpttsi) {
     1995                    SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     1996                                      (LONG)lpttsi->wpOrigProc);
     1997                    RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     1998                    COMCTL32_Free (&lpttsi);
     1999                }
     2000            }
     2001        }
     2002        COMCTL32_Free (infoPtr->tools);
    20602003    }
    20612004
    … …  
    20642007
    20652008    /* free tool tips info data */
    2066     doneControl(hwnd);
    2067 
     2009    COMCTL32_Free (infoPtr);
     2010    SetWindowLongA(hwnd, 0, 0);
    20682011    return 0;
    20692012}
    … …  
    20982041TOOLTIPS_MouseMessage (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    20992042{
    2100   TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    2101 
    2102   if (infoPtr->nTrackTool > -1)
    2103   {
    2104     //CB: tocheck: tracking tool without TTF_TRANSPARENT style
    2105   } else
    2106   {
     2043    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
     2044
    21072045    TOOLTIPS_Hide (hwnd, infoPtr);
    2108   }
    2109 
    2110   return 0;
     2046
     2047    return 0;
    21112048}
    21122049
    … …  
    21152052TOOLTIPS_NCCreate (HWND hwnd, WPARAM wParam, LPARAM lParam)
    21162053{
    2117     DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
    2118     DWORD dwExStyle = GetWindowLongA(hwnd,GWL_EXSTYLE);
     2054    DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
    21192055
    21202056    dwStyle &= 0x0000FFFF;
    21212057    dwStyle |= (WS_POPUP | WS_BORDER | WS_CLIPSIBLINGS);
    2122     SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
    2123 
    2124     SetWindowLongA(hwnd,GWL_EXSTYLE,dwExStyle | WS_EX_TOOLWINDOW);
     2058    SetWindowLongA (hwnd, GWL_STYLE, dwStyle);
    21252059
    21262060    return TRUE;
    … …  
    21342068    INT nTool = (infoPtr->bTrackActive) ? infoPtr->nTrackTool : infoPtr->nTool;
    21352069
    2136 //    TRACE (tooltips, " nTool=%d\n", nTool);
     2070    TRACE(" nTool=%d\n", nTool);
    21372071
    21382072    if ((nTool > -1) && (nTool < infoPtr->uNumTools)) {
    2139         if (infoPtr->tools[nTool].uFlags & TTF_TRANSPARENT) {
    2140 //          TRACE (tooltips, "-- in transparent mode!\n");
    2141             return HTTRANSPARENT;
    2142         }
     2073        if (infoPtr->tools[nTool].uFlags & TTF_TRANSPARENT) {
     2074            TRACE("-- in transparent mode!\n");
     2075            return HTTRANSPARENT;
     2076        }
    21432077    }
    21442078
    21452079    return DefWindowProcA (hwnd, WM_NCHITTEST, wParam, lParam);
    21462080}
     2081
     2082
     2083static LRESULT
     2084TOOLTIPS_NotifyFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
     2085{
     2086    FIXME ("hwnd=%x wParam=%x lParam=%lx\n", hwnd, wParam, lParam);
     2087
     2088    return 0;
     2089}
     2090
    21472091
    21482092static LRESULT
    … …  
    21532097
    21542098    hdc = (wParam == 0) ? BeginPaint (hwnd, &ps) : (HDC)wParam;
    2155     TOOLTIPS_Draw(hwnd, hdc);
     2099    TOOLTIPS_Refresh (hwnd, hdc);
    21562100    if (!wParam)
    2157         EndPaint (hwnd, &ps);
     2101        EndPaint (hwnd, &ps);
    21582102    return 0;
    21592103}
    … …  
    21672111    infoPtr->hFont = (HFONT)wParam;
    21682112
    2169     if ((LOWORD(lParam)) && (infoPtr->nCurrentTool != -1))
    2170     {
    2171       /* force repaint */
    2172       if (infoPtr->bActive) TOOLTIPS_Show(hwnd,infoPtr);
    2173       else if (infoPtr->bTrackActive) TOOLTIPS_TrackShow(hwnd,infoPtr);
     2113    if ((LOWORD(lParam)) && (infoPtr->nCurrentTool != -1)) {
     2114        FIXME("full redraw needed!\n");
    21742115    }
    21752116
    … …  
    21862127 * returns the length, in characters, of the tip text
    21872128 ******************************************************************/
    2188 
    21892129static LRESULT
    21902130TOOLTIPS_OnWMGetTextLength(HWND hwnd, WPARAM wParam, LPARAM lParam)
    … …  
    21932133    return lstrlenW(infoPtr->szTipText);
    21942134}
     2135
    21952136/******************************************************************
    21962137 * TOOLTIPS_OnWMGetText
    … …  
    22082149{
    22092150    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    2210     INT length;
    22112151
    22122152    if(!infoPtr || !(infoPtr->szTipText))
    22132153        return 0;
    22142154
    2215     length = lstrlenW(infoPtr->szTipText);
    2216     /* When wParam is smaller than the lenght of the tip text
    2217        copy wParam characters of the tip text and return wParam */
    2218     if(wParam < length)
    2219     {
    2220         lstrcpynWtoA((LPSTR)lParam,infoPtr->szTipText,(UINT)wParam);//includes 0 terminator
    2221         return wParam;
    2222     }
    2223     lstrcpyWtoA((LPSTR)lParam,infoPtr->szTipText);
    2224     return length;
    2225 
     2155    return WideCharToMultiByte(CP_ACP, 0, infoPtr->szTipText, -1,
     2156                               (LPSTR)lParam, wParam, NULL, NULL);
    22262157}
    22272158
    … …  
    22302161{
    22312162    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    2232 
    2233 //    TRACE (tooltips, "timer %d (%x) expired!\n", wParam, hwnd);
    2234     switch (wParam)
    2235     {
    2236       case ID_TIMERSHOW:
    2237           KillTimer(hwnd,ID_TIMERSHOW);
    2238           if (TOOLTIPS_CheckTool(hwnd,TRUE) == infoPtr->nTool)
    2239               TOOLTIPS_Show(hwnd,infoPtr);
    2240           break;
    2241 
    2242       case ID_TIMERPOP:
    2243           TOOLTIPS_Hide (hwnd, infoPtr);
    2244           break;
    2245 
    2246       case ID_TIMERLEAVE:
    2247           KillTimer (hwnd,ID_TIMERLEAVE);
    2248           if (TOOLTIPS_CheckTool(hwnd,FALSE) == -1)
    2249           {
    2250             infoPtr->nTool = -1;
    2251             infoPtr->nOldTool = -1;
    2252             TOOLTIPS_Hide(hwnd,infoPtr);
    2253           }
    2254           break;
    2255     }
    2256 
     2163    INT nOldTool;
     2164
     2165    TRACE("timer %d (%x) expired!\n", wParam, hwnd);
     2166
     2167    switch (wParam) {
     2168    case ID_TIMERSHOW:
     2169        KillTimer (hwnd, ID_TIMERSHOW);
     2170        nOldTool = infoPtr->nTool;
     2171        if ((infoPtr->nTool = TOOLTIPS_CheckTool (hwnd, TRUE)) == nOldTool)
     2172            TOOLTIPS_Show (hwnd, infoPtr);
     2173        break;
     2174
     2175    case ID_TIMERPOP:
     2176        TOOLTIPS_Hide (hwnd, infoPtr);
     2177        break;
     2178
     2179    case ID_TIMERLEAVE:
     2180        nOldTool = infoPtr->nTool;
     2181        infoPtr->nTool = TOOLTIPS_CheckTool (hwnd, FALSE);
     2182        TRACE("tool (%x) %d %d %d\n", hwnd, nOldTool,
     2183              infoPtr->nTool, infoPtr->nCurrentTool);
     2184        if (infoPtr->nTool != nOldTool) {
     2185            if(infoPtr->nTool == -1) { /* Moved out of all tools */
     2186                TOOLTIPS_Hide(hwnd, infoPtr);
     2187                KillTimer(hwnd, ID_TIMERLEAVE);
     2188            } else if (nOldTool == -1) { /* Moved from outside */
     2189                ERR("How did this happen?\n");
     2190            } else { /* Moved from one to another */
     2191                TOOLTIPS_Hide (hwnd, infoPtr);
     2192                KillTimer(hwnd, ID_TIMERLEAVE);
     2193                if(infoPtr->bActive) {
     2194                    SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nReshowTime, 0);
     2195                    TRACE("timer 1 started!\n");
     2196                }
     2197            }
     2198        }
     2199        break;
     2200
     2201    default:
     2202        ERR("Unknown timer id %d\n", wParam);
     2203        break;
     2204    }
    22572205    return 0;
    22582206}
    … …  
    22762224}
    22772225
    2278 LRESULT TOOLTIPS_MouseActivate(HWND hwnd,WPARAM wParam,LPARAM lParam)
    2279 {
    2280   return MA_NOACTIVATE;
    2281 }
    22822226
    22832227LRESULT CALLBACK
    … …  
    22852229{
    22862230    LPTT_SUBCLASS_INFO lpttsi =
    2287         (LPTT_SUBCLASS_INFO)GetPropA (hwnd, COMCTL32_aSubclass);
    2288     TOOLTIPS_INFO *infoPtr;
    2289     UINT nTool;
    2290 
    2291     switch (uMsg) {
    2292         case WM_LBUTTONDOWN:
    2293         case WM_LBUTTONUP:
    2294         case WM_MBUTTONDOWN:
    2295         case WM_MBUTTONUP:
    2296         case WM_RBUTTONDOWN:
    2297         case WM_RBUTTONUP:
    2298             infoPtr = TOOLTIPS_GetInfoPtr(lpttsi->hwndToolTip);
    2299             if (!infoPtr) break;
    2300             nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
    2301 
    2302             infoPtr->nOldTool = infoPtr->nTool;
    2303             infoPtr->nTool = nTool;
    2304             TOOLTIPS_Hide (lpttsi->hwndToolTip, infoPtr);
    2305             break;
    2306 
    2307         case WM_MOUSEMOVE:
    2308                 infoPtr = TOOLTIPS_GetInfoPtr (lpttsi->hwndToolTip);
    2309                 if (!infoPtr) break;
    2310                 nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
    2311 
    2312                 infoPtr->nOldTool = infoPtr->nTool;
    2313                 infoPtr->nTool = nTool;
    2314 
    2315                 if ((infoPtr->bActive) &&
    2316                     (infoPtr->nTool != infoPtr->nOldTool)) {
    2317                     if (infoPtr->nOldTool == -1) {
    2318                     SetTimer (hwnd, ID_TIMERSHOW,
    2319                                     infoPtr->nInitialTime, 0);
    2320                       //TRACE (tooltips, "timer 1 started!\n");
    2321                     }
    2322                     else {
    2323                     TOOLTIPS_Hide (lpttsi->hwndToolTip, infoPtr);
    2324                     SetTimer (hwnd, ID_TIMERSHOW,
    2325                                 infoPtr->nReshowTime, 0);
    2326 //                      TRACE (tooltips, "timer 2 started!\n");
    2327                     }
    2328                 }
    2329                 if (infoPtr->nCurrentTool != -1) {
    2330                 SetTimer (hwnd, ID_TIMERLEAVE, 100, 0);
    2331 //                  TRACE (tooltips, "timer 3 started!\n");
    2332                 }
    2333             break;
    2334     }
    2335 
     2231        (LPTT_SUBCLASS_INFO)GetPropA (hwnd, COMCTL32_aSubclass);
     2232    MSG msg;
     2233
     2234    switch(uMsg) {
     2235    case WM_MOUSEMOVE:
     2236    case WM_LBUTTONDOWN:
     2237    case WM_LBUTTONUP:
     2238    case WM_MBUTTONDOWN:
     2239    case WM_MBUTTONUP:
     2240    case WM_RBUTTONDOWN:
     2241    case WM_RBUTTONUP:
     2242        msg.hwnd = hwnd;
     2243        msg.message = uMsg;
     2244        msg.wParam = wParam;
     2245        msg.lParam = lParam;
     2246        TOOLTIPS_RelayEvent(lpttsi->hwndToolTip, 0, (LPARAM)&msg);
     2247        break;
     2248
     2249    default:
     2250        break;
     2251    }
    23362252    return CallWindowProcA (lpttsi->wpOrigProc, hwnd, uMsg, wParam, lParam);
    23372253}
    … …  
    23412257TOOLTIPS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    23422258{
     2259    TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
     2260    if (!TOOLTIPS_GetInfoPtr(hwnd) && (uMsg != WM_CREATE) && (uMsg != WM_NCCREATE))
     2261        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
    23432262    switch (uMsg)
    23442263    {
    2345         case TTM_ACTIVATE:
    2346             return TOOLTIPS_Activate (hwnd, wParam, lParam);
    2347 
    2348         case TTM_ADDTOOLA:
    2349             return TOOLTIPS_AddToolA (hwnd, wParam, lParam);
    2350 
    2351         case TTM_ADDTOOLW:
    2352             return TOOLTIPS_AddToolW (hwnd, wParam, lParam);
    2353 
    2354         case TTM_DELTOOLA:
    2355             return TOOLTIPS_DelToolA (hwnd, wParam, lParam);
    2356 
    2357         case TTM_DELTOOLW:
    2358             return TOOLTIPS_DelToolW (hwnd, wParam, lParam);
    2359 
    2360         case TTM_ENUMTOOLSA:
    2361             return TOOLTIPS_EnumToolsA (hwnd, wParam, lParam);
    2362 
    2363         case TTM_ENUMTOOLSW:
    2364             return TOOLTIPS_EnumToolsW (hwnd, wParam, lParam);
    2365 
    2366         case TTM_GETCURRENTTOOLA:
    2367             return TOOLTIPS_GetCurrentToolA (hwnd, wParam, lParam);
    2368 
    2369         case TTM_GETCURRENTTOOLW:
    2370             return TOOLTIPS_GetCurrentToolW (hwnd, wParam, lParam);
    2371 
    2372         case TTM_GETDELAYTIME:
    2373             return TOOLTIPS_GetDelayTime (hwnd, wParam, lParam);
    2374 
    2375         case TTM_GETMARGIN:
    2376             return TOOLTIPS_GetMargin (hwnd, wParam, lParam);
    2377 
    2378         case TTM_GETMAXTIPWIDTH:
    2379             return TOOLTIPS_GetMaxTipWidth (hwnd, wParam, lParam);
    2380 
    2381         case TTM_GETTEXTA:
    2382             return TOOLTIPS_GetTextA (hwnd, wParam, lParam);
    2383 
    2384         case TTM_GETTEXTW:
    2385             return TOOLTIPS_GetTextW (hwnd, wParam, lParam);
    2386 
    2387         case TTM_GETTIPBKCOLOR:
    2388             return TOOLTIPS_GetTipBkColor (hwnd, wParam, lParam);
    2389 
    2390         case TTM_GETTIPTEXTCOLOR:
    2391             return TOOLTIPS_GetTipTextColor (hwnd, wParam, lParam);
    2392 
    2393         case TTM_GETTOOLCOUNT:
    2394             return TOOLTIPS_GetToolCount (hwnd, wParam, lParam);
    2395 
    2396         case TTM_GETTOOLINFOA:
    2397             return TOOLTIPS_GetToolInfoA (hwnd, wParam, lParam);
    2398 
    2399         case TTM_GETTOOLINFOW:
    2400             return TOOLTIPS_GetToolInfoW (hwnd, wParam, lParam);
    2401 
    2402         case TTM_HITTESTA:
    2403             return TOOLTIPS_HitTestA (hwnd, wParam, lParam);
    2404 
    2405         case TTM_HITTESTW:
    2406             return TOOLTIPS_HitTestW (hwnd, wParam, lParam);
    2407 
    2408         case TTM_NEWTOOLRECTA:
    2409             return TOOLTIPS_NewToolRectA (hwnd, wParam, lParam);
    2410 
    2411         case TTM_NEWTOOLRECTW:
    2412             return TOOLTIPS_NewToolRectW (hwnd, wParam, lParam);
    2413 
    2414         case TTM_POP:
    2415             return TOOLTIPS_Pop (hwnd, wParam, lParam);
    2416 
    2417         case TTM_RELAYEVENT:
    2418             return TOOLTIPS_RelayEvent (hwnd, wParam, lParam);
    2419 
    2420         case TTM_SETDELAYTIME:
    2421             return TOOLTIPS_SetDelayTime (hwnd, wParam, lParam);
    2422 
    2423         case TTM_SETMARGIN:
    2424             return TOOLTIPS_SetMargin (hwnd, wParam, lParam);
    2425 
    2426         case TTM_SETMAXTIPWIDTH:
    2427             return TOOLTIPS_SetMaxTipWidth (hwnd, wParam, lParam);
    2428 
    2429         case TTM_SETTIPBKCOLOR:
    2430             return TOOLTIPS_SetTipBkColor (hwnd, wParam, lParam);
    2431 
    2432         case TTM_SETTIPTEXTCOLOR:
    2433             return TOOLTIPS_SetTipTextColor (hwnd, wParam, lParam);
    2434 
    2435         case TTM_SETTOOLINFOA:
    2436             return TOOLTIPS_SetToolInfoA (hwnd, wParam, lParam);
    2437 
    2438         case TTM_SETTOOLINFOW:
    2439             return TOOLTIPS_SetToolInfoW (hwnd, wParam, lParam);
    2440 
    2441         case TTM_TRACKACTIVATE:
    2442             return TOOLTIPS_TrackActivate (hwnd, wParam, lParam);
    2443 
    2444         case TTM_TRACKPOSITION:
    2445             return TOOLTIPS_TrackPosition (hwnd, wParam, lParam);
    2446 
    2447         case TTM_UPDATE:
    2448             return TOOLTIPS_Update (hwnd, wParam, lParam);
    2449 
    2450         case TTM_UPDATETIPTEXTA:
    2451             return TOOLTIPS_UpdateTipTextA (hwnd, wParam, lParam);
    2452 
    2453         case TTM_UPDATETIPTEXTW:
    2454             return TOOLTIPS_UpdateTipTextW (hwnd, wParam, lParam);
    2455 
    2456         case TTM_WINDOWFROMPOINT:
    2457             return TOOLTIPS_WindowFromPoint (hwnd, wParam, lParam);
    2458 
    2459 
    2460         case WM_CREATE:
    2461             return TOOLTIPS_Create (hwnd, wParam, lParam);
    2462 
    2463         case WM_DESTROY:
    2464             return TOOLTIPS_Destroy (hwnd, wParam, lParam);
    2465 
    2466         case WM_ERASEBKGND:
    2467             return TOOLTIPS_EraseBackground (hwnd, wParam, lParam);
    2468 
    2469         case WM_GETFONT:
    2470             return TOOLTIPS_GetFont (hwnd, wParam, lParam);
     2264        case TTM_ACTIVATE:
     2265            return TOOLTIPS_Activate (hwnd, wParam, lParam);
     2266
     2267        case TTM_ADDTOOLA:
     2268            return TOOLTIPS_AddToolA (hwnd, wParam, lParam);
     2269
     2270        case TTM_ADDTOOLW:
     2271            return TOOLTIPS_AddToolW (hwnd, wParam, lParam);
     2272
     2273        case TTM_DELTOOLA:
     2274            return TOOLTIPS_DelToolA (hwnd, wParam, lParam);
     2275
     2276        case TTM_DELTOOLW:
     2277            return TOOLTIPS_DelToolW (hwnd, wParam, lParam);
     2278
     2279        case TTM_ENUMTOOLSA:
     2280            return TOOLTIPS_EnumToolsA (hwnd, wParam, lParam);
     2281
     2282        case TTM_ENUMTOOLSW:
     2283            return TOOLTIPS_EnumToolsW (hwnd, wParam, lParam);
     2284
     2285        case TTM_GETCURRENTTOOLA:
     2286            return TOOLTIPS_GetCurrentToolA (hwnd, wParam, lParam);
     2287
     2288        case TTM_GETCURRENTTOOLW:
     2289            return TOOLTIPS_GetCurrentToolW (hwnd, wParam, lParam);
     2290
     2291        case TTM_GETDELAYTIME:
     2292            return TOOLTIPS_GetDelayTime (hwnd, wParam, lParam);
     2293
     2294        case TTM_GETMARGIN:
     2295            return TOOLTIPS_GetMargin (hwnd, wParam, lParam);
     2296
     2297        case TTM_GETMAXTIPWIDTH:
     2298            return TOOLTIPS_GetMaxTipWidth (hwnd, wParam, lParam);
     2299
     2300        case TTM_GETTEXTA:
     2301            return TOOLTIPS_GetTextA (hwnd, wParam, lParam);
     2302
     2303        case TTM_GETTEXTW:
     2304            return TOOLTIPS_GetTextW (hwnd, wParam, lParam);
     2305
     2306        case TTM_GETTIPBKCOLOR:
     2307            return TOOLTIPS_GetTipBkColor (hwnd, wParam, lParam);
     2308
     2309        case TTM_GETTIPTEXTCOLOR:
     2310            return TOOLTIPS_GetTipTextColor (hwnd, wParam, lParam);
     2311
     2312        case TTM_GETTOOLCOUNT:
     2313            return TOOLTIPS_GetToolCount (hwnd, wParam, lParam);
     2314
     2315        case TTM_GETTOOLINFOA:
     2316            return TOOLTIPS_GetToolInfoA (hwnd, wParam, lParam);
     2317
     2318        case TTM_GETTOOLINFOW:
     2319            return TOOLTIPS_GetToolInfoW (hwnd, wParam, lParam);
     2320
     2321        case TTM_HITTESTA:
     2322            return TOOLTIPS_HitTestA (hwnd, wParam, lParam);
     2323
     2324        case TTM_HITTESTW:
     2325            return TOOLTIPS_HitTestW (hwnd, wParam, lParam);
     2326
     2327        case TTM_NEWTOOLRECTA:
     2328            return TOOLTIPS_NewToolRectA (hwnd, wParam, lParam);
     2329
     2330        case TTM_NEWTOOLRECTW:
     2331            return TOOLTIPS_NewToolRectW (hwnd, wParam, lParam);
     2332
     2333        case TTM_POP:
     2334            return TOOLTIPS_Pop (hwnd, wParam, lParam);
     2335
     2336        case TTM_RELAYEVENT:
     2337            return TOOLTIPS_RelayEvent (hwnd, wParam, lParam);
     2338
     2339        case TTM_SETDELAYTIME:
     2340            return TOOLTIPS_SetDelayTime (hwnd, wParam, lParam);
     2341
     2342        case TTM_SETMARGIN:
     2343            return TOOLTIPS_SetMargin (hwnd, wParam, lParam);
     2344
     2345        case TTM_SETMAXTIPWIDTH:
     2346            return TOOLTIPS_SetMaxTipWidth (hwnd, wParam, lParam);
     2347
     2348        case TTM_SETTIPBKCOLOR:
     2349            return TOOLTIPS_SetTipBkColor (hwnd, wParam, lParam);
     2350
     2351        case TTM_SETTIPTEXTCOLOR:
     2352            return TOOLTIPS_SetTipTextColor (hwnd, wParam, lParam);
     2353
     2354        case TTM_SETTOOLINFOA:
     2355            return TOOLTIPS_SetToolInfoA (hwnd, wParam, lParam);
     2356
     2357        case TTM_SETTOOLINFOW:
     2358            return TOOLTIPS_SetToolInfoW (hwnd, wParam, lParam);
     2359
     2360        case TTM_TRACKACTIVATE:
     2361            return TOOLTIPS_TrackActivate (hwnd, wParam, lParam);
     2362
     2363        case TTM_TRACKPOSITION:
     2364            return TOOLTIPS_TrackPosition (hwnd, wParam, lParam);
     2365
     2366        case TTM_UPDATE:
     2367            return TOOLTIPS_Update (hwnd, wParam, lParam);
     2368
     2369        case TTM_UPDATETIPTEXTA:
     2370            return TOOLTIPS_UpdateTipTextA (hwnd, wParam, lParam);
     2371
     2372        case TTM_UPDATETIPTEXTW:
     2373            return TOOLTIPS_UpdateTipTextW (hwnd, wParam, lParam);
     2374
     2375        case TTM_WINDOWFROMPOINT:
     2376            return TOOLTIPS_WindowFromPoint (hwnd, wParam, lParam);
     2377
     2378
     2379        case WM_CREATE:
     2380            return TOOLTIPS_Create (hwnd, wParam, lParam);
     2381
     2382        case WM_DESTROY:
     2383            return TOOLTIPS_Destroy (hwnd, wParam, lParam);
     2384
     2385        case WM_ERASEBKGND:
     2386            return TOOLTIPS_EraseBackground (hwnd, wParam, lParam);
     2387
     2388        case WM_GETFONT:
     2389            return TOOLTIPS_GetFont (hwnd, wParam, lParam);
    24712390
    24722391        case WM_GETTEXT:
    24732392            return TOOLTIPS_OnWMGetText (hwnd, wParam, lParam);
    2474 
     2393       
    24752394        case WM_GETTEXTLENGTH:
    24762395            return TOOLTIPS_OnWMGetTextLength (hwnd, wParam, lParam);
    2477 
    2478 
    2479         case WM_LBUTTONDOWN:
    2480         case WM_LBUTTONUP:
    2481         case WM_LBUTTONDBLCLK:
    2482         case WM_MBUTTONDOWN:
    2483         case WM_MBUTTONUP:
    2484         case WM_MBUTTONDBLCLK:
    2485         case WM_RBUTTONDOWN:
    2486         case WM_RBUTTONUP:
    2487         case WM_RBUTTONDBLCLK:
    2488         case WM_MOUSEMOVE:
    2489             return TOOLTIPS_MouseMessage (hwnd, uMsg, wParam, lParam);
    2490 
    2491         case WM_MOUSEACTIVATE:
    2492             return TOOLTIPS_MouseActivate(hwnd,wParam,lParam);
    2493 
    2494         case WM_NCCREATE:
    2495             return TOOLTIPS_NCCreate (hwnd, wParam, lParam);
    2496 
    2497         case WM_NCHITTEST:
    2498             return TOOLTIPS_NCHitTest (hwnd, wParam, lParam);
    2499 
    2500         case WM_PAINT:
    2501             return TOOLTIPS_Paint (hwnd, wParam, lParam);
    2502 
    2503         case WM_SETFONT:
    2504             return TOOLTIPS_SetFont (hwnd, wParam, lParam);
    2505 
    2506         case WM_TIMER:
    2507             return TOOLTIPS_Timer (hwnd, wParam, lParam);
    2508 
    2509         case WM_WININICHANGE:
    2510             return TOOLTIPS_WinIniChange (hwnd, wParam, lParam);
    2511 
    2512         default:
    2513 //            if (uMsg >= WM_USER)
    2514 //              ERR (tooltips, "unknown msg %04x wp=%08x lp=%08lx\n",
    2515 //                   uMsg, wParam, lParam);
    2516             return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
     2396 
     2397
     2398        case WM_LBUTTONDOWN:
     2399        case WM_LBUTTONUP:
     2400        case WM_MBUTTONDOWN:
     2401        case WM_MBUTTONUP:
     2402        case WM_RBUTTONDOWN:
     2403        case WM_RBUTTONUP:
     2404        case WM_MOUSEMOVE:
     2405            return TOOLTIPS_MouseMessage (hwnd, uMsg, wParam, lParam);
     2406
     2407        case WM_NCCREATE:
     2408            return TOOLTIPS_NCCreate (hwnd, wParam, lParam);
     2409
     2410        case WM_NCHITTEST:
     2411            return TOOLTIPS_NCHitTest (hwnd, wParam, lParam);
     2412
     2413        case WM_NOTIFYFORMAT:
     2414            return TOOLTIPS_NotifyFormat (hwnd, wParam, lParam);
     2415
     2416        case WM_PAINT:
     2417            return TOOLTIPS_Paint (hwnd, wParam, lParam);
     2418
     2419        case WM_SETFONT:
     2420            return TOOLTIPS_SetFont (hwnd, wParam, lParam);
     2421
     2422        case WM_TIMER:
     2423            return TOOLTIPS_Timer (hwnd, wParam, lParam);
     2424
     2425        case WM_WININICHANGE:
     2426            return TOOLTIPS_WinIniChange (hwnd, wParam, lParam);
     2427
     2428        default:
     2429            if (uMsg >= WM_USER)
     2430                ERR("unknown msg %04x wp=%08x lp=%08lx\n",
     2431                     uMsg, wParam, lParam);
     2432            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
    25172433    }
    25182434    return 0;
    … …  
    25212437
    25222438VOID
    2523 TOOLTIPS_Register (VOID)
     2439TOOLTIPS_Register (void)
    25242440{
    25252441    WNDCLASSA wndClass;
    … …  
    25332449    wndClass.hbrBackground = 0;
    25342450    wndClass.lpszClassName = TOOLTIPS_CLASSA;
    2535 
     2451 
    25362452    RegisterClassA (&wndClass);
    25372453}
    … …  
    25392455
    25402456VOID
    2541 TOOLTIPS_Unregister (VOID)
     2457TOOLTIPS_Unregister (void)
    25422458{
    25432459    UnregisterClassA (TOOLTIPS_CLASSA, (HINSTANCE)NULL);
Note: See TracChangeset for help on using the changeset viewer.