Ignore:
Timestamp:
Jun 16, 1999, 10:25:45 PM (26 years ago)
Author:
cbratschi
Message:

comctl32 wine conversion bugs fixed
trackbar: TRACKBAR_Draw prototype

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/tooltips.c

    r94 r110  
    1 /* $Id: tooltips.c,v 1.4 1999-06-10 16:22:02 achimha Exp $ */
     1/* $Id: tooltips.c,v 1.5 1999-06-16 20:25:44 cbratschi Exp $ */
    22/*
    33 * Tool tip control
    … …  
    55 * Copyright 1998 Eric Kohl
    66 * Copyright 1999 Achim Hasenmueller
     7 * Copyright 1999 Christoph Bratschi
    78 *
    89 * TODO:
    … …  
    5354
    5455    if (infoPtr->nMaxTipWidth > -1)
    55         uFlags |= DT_WORDBREAK;
     56        uFlags |= DT_WORDBREAK;
    5657    if (GetWindowLongA (hwnd, GWL_STYLE) & TTS_NOPREFIX)
    57         uFlags |= DT_NOPREFIX;
     58        uFlags |= DT_NOPREFIX;
    5859    GetClientRect (hwnd, &rc);
    5960
    … …  
    7677    SelectObject (hdc, hOldFont);
    7778    if (oldBkMode != TRANSPARENT)
    78         SetBkMode (hdc, oldBkMode);
     79        SetBkMode (hdc, oldBkMode);
    7980}
    8081
    … …  
    8687
    8788    if ((toolPtr->hinst) && (HIWORD((UINT)toolPtr->lpszText) == 0)) {
    88         /* load a resource */
    89 //      TRACE (tooltips, "load res string %x %x\n",
    90 //             toolPtr->hinst, (int)toolPtr->lpszText);
    91         LoadStringW (toolPtr->hinst, (UINT)toolPtr->lpszText,
    92                        infoPtr->szTipText, INFOTIPSIZE);
     89        /* load a resource */
     90//      TRACE (tooltips, "load res string %x %x\n",
     91//             toolPtr->hinst, (int)toolPtr->lpszText);
     92        LoadStringW (toolPtr->hinst, (UINT)toolPtr->lpszText,
     93                       infoPtr->szTipText, INFOTIPSIZE);
    9394    }
    9495    else if (toolPtr->lpszText) {
    95         if (toolPtr->lpszText == LPSTR_TEXTCALLBACKW) {
    96             NMTTDISPINFOA ttnmdi;
    97 
    98             /* fill NMHDR struct */
    99             ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFOA));
    100             ttnmdi.hdr.hwndFrom = hwnd;
    101             ttnmdi.hdr.idFrom = toolPtr->uId;
    102             ttnmdi.hdr.code = TTN_GETDISPINFOA;
    103             ttnmdi.lpszText = (LPSTR)&ttnmdi.szText;
    104             ttnmdi.uFlags = toolPtr->uFlags;
    105             ttnmdi.lParam = toolPtr->lParam;
    106 
    107 //          TRACE (tooltips, "hdr.idFrom = %x\n", ttnmdi.hdr.idFrom);
    108             SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    109                             (WPARAM)toolPtr->uId, (LPARAM)&ttnmdi);
    110 
    111             if ((ttnmdi.hinst) && (HIWORD((UINT)ttnmdi.szText) == 0)) {
    112                 LoadStringW (ttnmdi.hinst, (UINT)ttnmdi.szText,
    113                                infoPtr->szTipText, INFOTIPSIZE);
    114                 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
    115                     toolPtr->hinst = ttnmdi.hinst;
    116                     toolPtr->lpszText = (LPWSTR)ttnmdi.szText;
    117                 }
    118             }
    119             else if (ttnmdi.szText[0]) {
    120                 lstrcpynAtoW (infoPtr->szTipText, ttnmdi.szText, 80);
    121                 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
    122                     INT len = lstrlenA (ttnmdi.szText);
    123                     toolPtr->hinst = 0;
    124                     toolPtr->lpszText = COMCTL32_Alloc ((len+1)* sizeof(WCHAR));
    125                     lstrcpyAtoW (toolPtr->lpszText, ttnmdi.szText);
    126                 }
    127             }
    128             else if (ttnmdi.lpszText == 0) {
    129                 /* no text available */
    130                 infoPtr->szTipText[0] = L'\0';
    131             }
    132             else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA) {
    133                 lstrcpynAtoW (infoPtr->szTipText, ttnmdi.lpszText, INFOTIPSIZE);
    134                 if (ttnmdi.uFlags & TTF_DI_SETITEM) {
    135                     INT len = lstrlenA (ttnmdi.lpszText);
    136                     toolPtr->hinst = 0;
    137                     toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    138                     lstrcpyAtoW (toolPtr->lpszText, ttnmdi.lpszText);
    139                 }
    140             }
    141             else {
    142 //              ERR (tooltips, "recursive text callback!\n");
    143                 infoPtr->szTipText[0] = '\0';
    144             }
    145         }
    146         else {
    147             /* the item is a usual (unicode) text */
    148 //          lstrcpynW (infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
    149             strncpy(infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
    150         }
     96        if (toolPtr->lpszText == LPSTR_TEXTCALLBACKW) {
     97            NMTTDISPINFOA ttnmdi;
     98
     99            /* fill NMHDR struct */
     100            ZeroMemory (&ttnmdi, sizeof(NMTTDISPINFOA));
     101            ttnmdi.hdr.hwndFrom = hwnd;
     102            ttnmdi.hdr.idFrom = toolPtr->uId;
     103            ttnmdi.hdr.code = TTN_GETDISPINFOA;
     104            ttnmdi.lpszText = (LPSTR)&ttnmdi.szText;
     105            ttnmdi.uFlags = toolPtr->uFlags;
     106            ttnmdi.lParam = toolPtr->lParam;
     107
     108//          TRACE (tooltips, "hdr.idFrom = %x\n", ttnmdi.hdr.idFrom);
     109            SendMessageA (toolPtr->hwnd, WM_NOTIFY,
     110                            (WPARAM)toolPtr->uId, (LPARAM)&ttnmdi);
     111
     112            if ((ttnmdi.hinst) && (HIWORD((UINT)ttnmdi.szText) == 0)) {
     113                LoadStringW (ttnmdi.hinst, (UINT)ttnmdi.szText,
     114                               infoPtr->szTipText, INFOTIPSIZE);
     115                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
     116                    toolPtr->hinst = ttnmdi.hinst;
     117                    toolPtr->lpszText = (LPWSTR)ttnmdi.szText;
     118                }
     119            }
     120            else if (ttnmdi.szText[0]) {
     121                lstrcpynAtoW (infoPtr->szTipText, ttnmdi.szText, 80);
     122                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
     123                    INT len = lstrlenA (ttnmdi.szText);
     124                    toolPtr->hinst = 0;
     125                    toolPtr->lpszText = COMCTL32_Alloc ((len+1)* sizeof(WCHAR));
     126                    lstrcpyAtoW (toolPtr->lpszText, ttnmdi.szText);
     127                }
     128            }
     129            else if (ttnmdi.lpszText == 0) {
     130                /* no text available */
     131                infoPtr->szTipText[0] = L'\0';
     132            }
     133            else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA) {
     134                lstrcpynAtoW (infoPtr->szTipText, ttnmdi.lpszText, INFOTIPSIZE);
     135                if (ttnmdi.uFlags & TTF_DI_SETITEM) {
     136                    INT len = lstrlenA (ttnmdi.lpszText);
     137                    toolPtr->hinst = 0;
     138                    toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     139                    lstrcpyAtoW (toolPtr->lpszText, ttnmdi.lpszText);
     140                }
     141            }
     142            else {
     143//              ERR (tooltips, "recursive text callback!\n");
     144                infoPtr->szTipText[0] = '\0';
     145            }
     146        }
     147        else {
     148            /* the item is a usual (unicode) text */
     149//          lstrcpynW (infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
     150            strncpy(infoPtr->szTipText, toolPtr->lpszText, INFOTIPSIZE);
     151        }
    151152    }
    152153    else {
    153         /* no text available */
    154         infoPtr->szTipText[0] = L'\0';
     154        /* no text available */
     155        infoPtr->szTipText[0] = L'\0';
    155156    }
    156157
    … …  
    168169
    169170    if (infoPtr->nMaxTipWidth > -1) {
    170         rc.right = infoPtr->nMaxTipWidth;
    171         uFlags |= DT_WORDBREAK;
     171        rc.right = infoPtr->nMaxTipWidth;
     172        uFlags |= DT_WORDBREAK;
    172173    }
    173174    if (GetWindowLongA (hwnd, GWL_STYLE) & TTS_NOPREFIX)
    174         uFlags |= DT_NOPREFIX;
     175        uFlags |= DT_NOPREFIX;
    175176//    TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
    176177
    … …  
    181182    ReleaseDC (hwnd, hdc);
    182183
    183     lpSize->cx = rc.right - rc.left + 4 + 
    184                 infoPtr->rcMargin.left + infoPtr->rcMargin.right;
     184    lpSize->cx = rc.right - rc.left + 4 +
     185                infoPtr->rcMargin.left + infoPtr->rcMargin.right;
    185186    lpSize->cy = rc.bottom - rc.top + 4 +
    186                 infoPtr->rcMargin.bottom + infoPtr->rcMargin.top;
     187                infoPtr->rcMargin.bottom + infoPtr->rcMargin.top;
    187188}
    188189
    … …  
    198199
    199200    if (infoPtr->nTool == -1) {
    200 //      TRACE (tooltips, "invalid tool (-1)!\n");
    201         return;
     201//      TRACE (tooltips, "invalid tool (-1)!\n");
     202        return;
    202203    }
    203204
    … …  
    209210
    210211    if (infoPtr->szTipText[0] == L'\0') {
    211         infoPtr->nCurrentTool = -1;
    212         return;
     212        infoPtr->nCurrentTool = -1;
     213        return;
    213214    }
    214215
    … …  
    220221    hdr.code = TTN_SHOW;
    221222    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    222                     (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     223                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
    223224
    224225//    TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
    … …  
    228229
    229230    if (toolPtr->uFlags & TTF_CENTERTIP) {
    230         RECT rc;
    231 
    232         if (toolPtr->uFlags & TTF_IDISHWND)
    233             GetWindowRect ((HWND)toolPtr->uId, &rc);
    234         else {
    235             rc = toolPtr->rect;
    236             MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rc, 2);
    237         }
    238         rect.left = (rc.left + rc.right - size.cx) / 2;
    239         rect.top  = rc.bottom + 2;
     231        RECT rc;
     232
     233        if (toolPtr->uFlags & TTF_IDISHWND)
     234            GetWindowRect ((HWND)toolPtr->uId, &rc);
     235        else {
     236            rc = toolPtr->rect;
     237            MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rc, 2);
     238        }
     239        rect.left = (rc.left + rc.right - size.cx) / 2;
     240        rect.top  = rc.bottom + 2;
    240241    }
    241242    else {
    242         GetCursorPos ((LPPOINT)&rect);
    243         rect.top += 20;
     243        GetCursorPos ((LPPOINT)&rect);
     244        rect.top += 20;
    244245    }
    245246
    … …  
    252253
    253254    AdjustWindowRectEx (&rect, GetWindowLongA (hwnd, GWL_STYLE),
    254                         FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
     255                        FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
    255256
    256257    SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
    257                     rect.right - rect.left, rect.bottom - rect.top,
    258                     SWP_SHOWWINDOW | SWP_NOACTIVATE);
     258                    rect.right - rect.left, rect.bottom - rect.top,
     259                    SWP_SHOWWINDOW | SWP_NOACTIVATE);
    259260
    260261    /* repaint the tooltip */
    … …  
    274275
    275276    if (infoPtr->nCurrentTool == -1)
    276         return;
     277        return;
    277278
    278279    toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
    … …  
    284285    hdr.code = TTN_POP;
    285286    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    286                     (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     287                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
    287288
    288289    infoPtr->nCurrentTool = -1;
    289290
    290291    SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0,
    291                     SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
     292                    SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
    292293}
    293294
    … …  
    303304
    304305    if (infoPtr->nTrackTool == -1) {
    305 //      TRACE (tooltips, "invalid tracking tool (-1)!\n");
    306         return;
     306//      TRACE (tooltips, "invalid tracking tool (-1)!\n");
     307        return;
    307308    }
    308309
    … …  
    312313
    313314    if (infoPtr->szTipText[0] == L'\0') {
    314         infoPtr->nTrackTool = -1;
    315         return;
     315        infoPtr->nTrackTool = -1;
     316        return;
    316317    }
    317318
    … …  
    323324    hdr.code = TTN_SHOW;
    324325    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    325                     (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     326                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
    326327
    327328//    TRACE (tooltips, "\"%s\"\n", debugstr_w(infoPtr->szTipText));
    … …  
    331332
    332333    if (toolPtr->uFlags & TTF_ABSOLUTE) {
    333         rect.left = infoPtr->xTrackPos;
    334         rect.top  = infoPtr->yTrackPos;
    335 
    336         if (toolPtr->uFlags & TTF_CENTERTIP) {
    337             rect.left -= (size.cx / 2);
    338             rect.top  -= (size.cy / 2);
    339         }
     334        rect.left = infoPtr->xTrackPos;
     335        rect.top  = infoPtr->yTrackPos;
     336
     337        if (toolPtr->uFlags & TTF_CENTERTIP) {
     338            rect.left -= (size.cx / 2);
     339            rect.top  -= (size.cy / 2);
     340        }
    340341    }
    341342    else {
    342         RECT rcTool;
    343 
    344         if (toolPtr->uFlags & TTF_IDISHWND)
    345             GetWindowRect ((HWND)toolPtr->uId, &rcTool);
    346         else {
    347             rcTool = toolPtr->rect;
    348             MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rcTool, 2);
    349         }
    350 
    351         GetCursorPos ((LPPOINT)&rect);
    352         rect.top += 20;
    353 
    354         if (toolPtr->uFlags & TTF_CENTERTIP) {
    355             rect.left -= (size.cx / 2);
    356             rect.top  -= (size.cy / 2);
    357         }
    358 
    359         /* smart placement */
    360         if ((rect.left + size.cx > rcTool.left) && (rect.left < rcTool.right) &&
    361             (rect.top + size.cy > rcTool.top) && (rect.top < rcTool.bottom))
    362             rect.left = rcTool.right;
     343        RECT rcTool;
     344
     345        if (toolPtr->uFlags & TTF_IDISHWND)
     346            GetWindowRect ((HWND)toolPtr->uId, &rcTool);
     347        else {
     348            rcTool = toolPtr->rect;
     349            MapWindowPoints (toolPtr->hwnd, (HWND)0, (LPPOINT)&rcTool, 2);
     350        }
     351
     352        GetCursorPos ((LPPOINT)&rect);
     353        rect.top += 20;
     354
     355        if (toolPtr->uFlags & TTF_CENTERTIP) {
     356            rect.left -= (size.cx / 2);
     357            rect.top  -= (size.cy / 2);
     358        }
     359
     360        /* smart placement */
     361        if ((rect.left + size.cx > rcTool.left) && (rect.left < rcTool.right) &&
     362            (rect.top + size.cy > rcTool.top) && (rect.top < rcTool.bottom))
     363            rect.left = rcTool.right;
    363364    }
    364365
    … …  
    369370
    370371    AdjustWindowRectEx (&rect, GetWindowLongA (hwnd, GWL_STYLE),
    371                         FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
     372                        FALSE, GetWindowLongA (hwnd, GWL_EXSTYLE));
    372373
    373374    SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
    374                     rect.right - rect.left, rect.bottom - rect.top,
    375                     SWP_SHOWWINDOW | SWP_NOACTIVATE );
     375                    rect.right - rect.left, rect.bottom - rect.top,
     376                    SWP_SHOWWINDOW | SWP_NOACTIVATE );
    376377
    377378    hdc = GetDC (hwnd);
    … …  
    388389
    389390    if (infoPtr->nTrackTool == -1)
    390         return;
     391        return;
    391392
    392393    toolPtr = &infoPtr->tools[infoPtr->nTrackTool];
    … …  
    397398    hdr.code = TTN_POP;
    398399    SendMessageA (toolPtr->hwnd, WM_NOTIFY,
    399                     (WPARAM)toolPtr->uId, (LPARAM)&hdr);
     400                    (WPARAM)toolPtr->uId, (LPARAM)&hdr);
    400401
    401402    SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0,
    402                     SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
     403                    SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
    403404}
    404405
    … …  
    411412
    412413    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    413         toolPtr = &infoPtr->tools[nTool];
    414 
    415         if (!(toolPtr->uFlags & TTF_IDISHWND) &&
    416             (lpToolInfo->hwnd == toolPtr->hwnd) &&
    417             (lpToolInfo->uId == toolPtr->uId))
    418             return nTool;
     414        toolPtr = &infoPtr->tools[nTool];
     415
     416        if (!(toolPtr->uFlags & TTF_IDISHWND) &&
     417            (lpToolInfo->hwnd == toolPtr->hwnd) &&
     418            (lpToolInfo->uId == toolPtr->uId))
     419            return nTool;
    419420    }
    420421
    421422    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    422         toolPtr = &infoPtr->tools[nTool];
    423 
    424         if ((toolPtr->uFlags & TTF_IDISHWND) &&
    425             (lpToolInfo->uId == toolPtr->uId))
    426             return nTool;
     423        toolPtr = &infoPtr->tools[nTool];
     424
     425        if ((toolPtr->uFlags & TTF_IDISHWND) &&
     426            (lpToolInfo->uId == toolPtr->uId))
     427            return nTool;
    427428    }
    428429
    … …  
    438439
    439440    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    440         toolPtr = &infoPtr->tools[nTool];
    441 
    442         if (!(toolPtr->uFlags & TTF_IDISHWND) &&
    443             (lpToolInfo->hwnd == toolPtr->hwnd) &&
    444             (lpToolInfo->uId == toolPtr->uId))
    445             return nTool;
     441        toolPtr = &infoPtr->tools[nTool];
     442
     443        if (!(toolPtr->uFlags & TTF_IDISHWND) &&
     444            (lpToolInfo->hwnd == toolPtr->hwnd) &&
     445            (lpToolInfo->uId == toolPtr->uId))
     446            return nTool;
    446447    }
    447448
    448449    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    449         toolPtr = &infoPtr->tools[nTool];
    450 
    451         if ((toolPtr->uFlags & TTF_IDISHWND) &&
    452             (lpToolInfo->uId == toolPtr->uId))
    453             return nTool;
     450        toolPtr = &infoPtr->tools[nTool];
     451
     452        if ((toolPtr->uFlags & TTF_IDISHWND) &&
     453            (lpToolInfo->uId == toolPtr->uId))
     454            return nTool;
    454455    }
    455456
    … …  
    465466
    466467    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    467         toolPtr = &infoPtr->tools[nTool];
    468 
    469         if (!(toolPtr->uFlags & TTF_IDISHWND)) {
    470             if (hwnd != toolPtr->hwnd)
    471                 continue;
    472             if (!PtInRect (&toolPtr->rect, *lpPt))
    473                 continue;
    474             return nTool;
    475         }
     468        toolPtr = &infoPtr->tools[nTool];
     469
     470        if (!(toolPtr->uFlags & TTF_IDISHWND)) {
     471            if (hwnd != toolPtr->hwnd)
     472                continue;
     473            if (!PtInRect (&toolPtr->rect, *lpPt))
     474                continue;
     475            return nTool;
     476        }
    476477    }
    477478
    478479    for (nTool = 0; nTool < infoPtr->uNumTools; nTool++) {
    479         toolPtr = &infoPtr->tools[nTool];
    480 
    481         if (toolPtr->uFlags & TTF_IDISHWND) {
    482             if ((HWND)toolPtr->uId == hwnd)
    483                 return nTool;
    484         }
     480        toolPtr = &infoPtr->tools[nTool];
     481
     482        if (toolPtr->uFlags & TTF_IDISHWND) {
     483            if ((HWND)toolPtr->uId == hwnd)
     484                return nTool;
     485        }
    485486    }
    486487
    … …  
    509510    HWND hwndActive = GetActiveWindow ();
    510511    if (!hwndActive)
    511         return FALSE;
     512        return FALSE;
    512513    if (hwndActive == hwnd)
    513         return TRUE;
     514        return TRUE;
    514515    return IsChild (hwndActive, hwnd);
    515516}
    … …  
    527528    hwndTool = SendMessageA (hwnd, TTM_WINDOWFROMPOINT, 0, (LPARAM)&pt);
    528529    if (hwndTool == 0)
    529         return -1;
     530        return -1;
    530531
    531532    ScreenToClient (hwndTool, &pt);
    532533    nTool = TOOLTIPS_GetToolFromPoint (infoPtr, hwndTool, &pt);
    533534    if (nTool == -1)
    534         return -1;
     535        return -1;
    535536
    536537    if (!(GetWindowLongA (hwnd, GWL_STYLE) & TTS_ALWAYSTIP) && bShowTest) {
    537         if (!TOOLTIPS_IsWindowActive (GetWindow (hwnd, GW_OWNER)))
    538             return -1;
     538        if (!TOOLTIPS_IsWindowActive (GetWindow (hwnd, GW_OWNER)))
     539            return -1;
    539540    }
    540541
    … …  
    553554
    554555//    if (infoPtr->bActive)
    555 //      TRACE (tooltips, "activate!\n");
    556 
    557     if (!(infoPtr->bActive) && (infoPtr->nCurrentTool != -1)) 
    558         TOOLTIPS_Hide (hwnd, infoPtr);
     556//      TRACE (tooltips, "activate!\n");
     557
     558    if (!(infoPtr->bActive) && (infoPtr->nCurrentTool != -1))
     559        TOOLTIPS_Hide (hwnd, infoPtr);
    559560
    560561    return 0;
    … …  
    570571
    571572    if (lpToolInfo == NULL)
    572         return FALSE;
     573        return FALSE;
    573574    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    574         return FALSE;
     575        return FALSE;
    575576
    576577//    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
    577 //         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
    578 //         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
     578//         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
     579//         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
    579580
    580581    if (infoPtr->uNumTools == 0) {
    581         infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO));
    582         toolPtr = infoPtr->tools;
     582        infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO));
     583        toolPtr = infoPtr->tools;
    583584    }
    584585    else {
    585         TTTOOL_INFO *oldTools = infoPtr->tools;
    586         infoPtr->tools =
    587             COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
    588         memcpy (infoPtr->tools, oldTools,
    589                 infoPtr->uNumTools * sizeof(TTTOOL_INFO));
    590         COMCTL32_Free (oldTools);
    591         toolPtr = &infoPtr->tools[infoPtr->uNumTools];
     586        TTTOOL_INFO *oldTools = infoPtr->tools;
     587        infoPtr->tools =
     588            COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
     589        memcpy (infoPtr->tools, oldTools,
     590                infoPtr->uNumTools * sizeof(TTTOOL_INFO));
     591        COMCTL32_Free (oldTools);
     592        toolPtr = &infoPtr->tools[infoPtr->uNumTools];
    592593    }
    593594
    … …  
    602603
    603604    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
    604 //      TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
    605         toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     605//      TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
     606        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    606607    }
    607608    else if (lpToolInfo->lpszText) {
    608         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA) {
    609 //          TRACE (tooltips, "add CALLBACK!\n");
    610             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    611         }
    612         else {
    613             INT len = lstrlenA (lpToolInfo->lpszText);
    614 //          TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
    615             toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
    616             lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
    617         }
     609        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA) {
     610//          TRACE (tooltips, "add CALLBACK!\n");
     611            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     612        }
     613        else {
     614            INT len = lstrlenA (lpToolInfo->lpszText);
     615//          TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
     616            toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
     617            lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
     618        }
    618619    }
    619620
    620621    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    621         toolPtr->lParam = lpToolInfo->lParam;
     622        toolPtr->lParam = lpToolInfo->lParam;
    622623
    623624    /* install subclassing hook */
    624625    if (toolPtr->uFlags & TTF_SUBCLASS) {
    625         if (toolPtr->uFlags & TTF_IDISHWND) {
    626             LPTT_SUBCLASS_INFO lpttsi =
    627                 (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    628             if (lpttsi == NULL) {
    629                 lpttsi =
    630                     (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
    631                 lpttsi->wpOrigProc =
    632                     (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
    633                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    634                 lpttsi->hwndToolTip = hwnd;
    635                 lpttsi->uRefCount++;
    636                 SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
    637                             (HANDLE)lpttsi);
    638             }
    639 //          else
    640 //              WARN (tooltips, "A window tool must only be listed once!\n");
    641         }
    642         else {
    643             LPTT_SUBCLASS_INFO lpttsi =
    644                 (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    645             if (lpttsi == NULL) {
    646                 lpttsi =
    647                     (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
    648                 lpttsi->wpOrigProc =
    649                     (WNDPROC)SetWindowLongA (toolPtr->hwnd,
    650                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    651                 lpttsi->hwndToolTip = hwnd;
    652                 lpttsi->uRefCount++;
    653                 SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
    654             }
    655             else
    656                 lpttsi->uRefCount++;
    657         }
    658 //      TRACE (tooltips, "subclassing installed!\n");
     626        if (toolPtr->uFlags & TTF_IDISHWND) {
     627            LPTT_SUBCLASS_INFO lpttsi =
     628                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     629            if (lpttsi == NULL) {
     630                lpttsi =
     631                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     632                lpttsi->wpOrigProc =
     633                    (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
     634                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     635                lpttsi->hwndToolTip = hwnd;
     636                lpttsi->uRefCount++;
     637                SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
     638                            (HANDLE)lpttsi);
     639            }
     640//          else
     641//              WARN (tooltips, "A window tool must only be listed once!\n");
     642        }
     643        else {
     644            LPTT_SUBCLASS_INFO lpttsi =
     645                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     646            if (lpttsi == NULL) {
     647                lpttsi =
     648                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     649                lpttsi->wpOrigProc =
     650                    (WNDPROC)SetWindowLongA (toolPtr->hwnd,
     651                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     652                lpttsi->hwndToolTip = hwnd;
     653                lpttsi->uRefCount++;
     654                SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
     655            }
     656            else
     657                lpttsi->uRefCount++;
     658        }
     659//      TRACE (tooltips, "subclassing installed!\n");
    659660    }
    660661
    … …  
    671672
    672673    if (lpToolInfo == NULL)
    673         return FALSE;
     674        return FALSE;
    674675    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    675         return FALSE;
     676        return FALSE;
    676677
    677678//    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
    678 //         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
    679 //         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
     679//         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
     680//         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
    680681
    681682    if (infoPtr->uNumTools == 0) {
    682         infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO));
    683         toolPtr = infoPtr->tools;
     683        infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO));
     684        toolPtr = infoPtr->tools;
    684685    }
    685686    else {
    686         TTTOOL_INFO *oldTools = infoPtr->tools;
    687         infoPtr->tools =
    688             COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
    689         memcpy (infoPtr->tools, oldTools,
    690                 infoPtr->uNumTools * sizeof(TTTOOL_INFO));
    691         COMCTL32_Free (oldTools);
    692         toolPtr = &infoPtr->tools[infoPtr->uNumTools];
     687        TTTOOL_INFO *oldTools = infoPtr->tools;
     688        infoPtr->tools =
     689            COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
     690        memcpy (infoPtr->tools, oldTools,
     691                infoPtr->uNumTools * sizeof(TTTOOL_INFO));
     692        COMCTL32_Free (oldTools);
     693        toolPtr = &infoPtr->tools[infoPtr->uNumTools];
    693694    }
    694695
    … …  
    703704
    704705    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
    705 //      TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
    706         toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     706//      TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
     707        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    707708    }
    708709    else if (lpToolInfo->lpszText) {
    709         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW) {
    710 //          TRACE (tooltips, "add CALLBACK!\n");
    711             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    712         }
    713         else {
    714             INT len = lstrlenW (lpToolInfo->lpszText);
    715 //          TRACE (tooltips, "add text \"%s\"!\n",
    716 //                 debugstr_w(lpToolInfo->lpszText));
    717             toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
    718             lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
    719         }
     710        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW) {
     711//          TRACE (tooltips, "add CALLBACK!\n");
     712            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     713        }
     714        else {
     715            INT len = lstrlenW (lpToolInfo->lpszText);
     716//          TRACE (tooltips, "add text \"%s\"!\n",
     717//                 debugstr_w(lpToolInfo->lpszText));
     718            toolPtr->lpszText = COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
     719            lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
     720        }
    720721    }
    721722
    722723    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    723         toolPtr->lParam = lpToolInfo->lParam;
     724        toolPtr->lParam = lpToolInfo->lParam;
    724725
    725726    /* install subclassing hook */
    726727    if (toolPtr->uFlags & TTF_SUBCLASS) {
    727         if (toolPtr->uFlags & TTF_IDISHWND) {
    728             LPTT_SUBCLASS_INFO lpttsi =
    729                 (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    730             if (lpttsi == NULL) {
    731                 lpttsi =
    732                     (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
    733                 lpttsi->wpOrigProc =
    734                     (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
    735                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    736                 lpttsi->hwndToolTip = hwnd;
    737                 lpttsi->uRefCount++;
    738                 SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
    739                             (HANDLE)lpttsi);
    740             }
    741 //          else
    742 //              WARN (tooltips, "A window tool must only be listed once!\n");
    743         }
    744         else {
    745             LPTT_SUBCLASS_INFO lpttsi =
    746                 (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    747             if (lpttsi == NULL) {
    748                 lpttsi =
    749                     (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
    750                 lpttsi->wpOrigProc =
    751                     (WNDPROC)SetWindowLongA (toolPtr->hwnd,
    752                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    753                 lpttsi->hwndToolTip = hwnd;
    754                 lpttsi->uRefCount++;
    755                 SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
    756             }
    757             else
    758                 lpttsi->uRefCount++;
    759         }
    760 //      TRACE (tooltips, "subclassing installed!\n");
     728        if (toolPtr->uFlags & TTF_IDISHWND) {
     729            LPTT_SUBCLASS_INFO lpttsi =
     730                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     731            if (lpttsi == NULL) {
     732                lpttsi =
     733                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     734                lpttsi->wpOrigProc =
     735                    (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
     736                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     737                lpttsi->hwndToolTip = hwnd;
     738                lpttsi->uRefCount++;
     739                SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
     740                            (HANDLE)lpttsi);
     741            }
     742//          else
     743//              WARN (tooltips, "A window tool must only be listed once!\n");
     744        }
     745        else {
     746            LPTT_SUBCLASS_INFO lpttsi =
     747                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     748            if (lpttsi == NULL) {
     749                lpttsi =
     750                    (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
     751                lpttsi->wpOrigProc =
     752                    (WNDPROC)SetWindowLongA (toolPtr->hwnd,
     753                    GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
     754                lpttsi->hwndToolTip = hwnd;
     755                lpttsi->uRefCount++;
     756                SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
     757            }
     758            else
     759                lpttsi->uRefCount++;
     760        }
     761//      TRACE (tooltips, "subclassing installed!\n");
    761762    }
    762763
    … …  
    774775
    775776    if (lpToolInfo == NULL)
    776         return 0;
     777        return 0;
    777778    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    778         return 0;
     779        return 0;
    779780    if (infoPtr->uNumTools == 0)
    780         return 0;
     781        return 0;
    781782
    782783    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    … …  
    786787
    787788    /* delete text string */
    788     toolPtr = &infoPtr->tools[nTool]; 
     789    toolPtr = &infoPtr->tools[nTool];
    789790    if ((toolPtr->hinst) && (toolPtr->lpszText)) {
    790         if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
    791             COMCTL32_Free (toolPtr->lpszText);
     791        if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
     792            COMCTL32_Free (toolPtr->lpszText);
    792793    }
    793794
    794795    /* remove subclassing */
    795796    if (toolPtr->uFlags & TTF_SUBCLASS) {
    796         if (toolPtr->uFlags & TTF_IDISHWND) {
    797             LPTT_SUBCLASS_INFO lpttsi =
    798                 (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    799             if (lpttsi) {
    800                 SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    801                                   (LONG)lpttsi->wpOrigProc);
    802                 RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    803                 COMCTL32_Free (&lpttsi);
    804             }
    805 //          else
    806 //              ERR (tooltips, "Invalid data handle!\n");
    807         }
    808         else {
    809             LPTT_SUBCLASS_INFO lpttsi =
    810                 (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    811             if (lpttsi) {
    812                 if (lpttsi->uRefCount == 1) {
    813                     SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    814                                       (LONG)lpttsi->wpOrigProc);
    815                     RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    816                     COMCTL32_Free (&lpttsi);
    817                 }
    818                 else
    819                     lpttsi->uRefCount--;
    820             }
    821 //          else
    822 //              ERR (tooltips, "Invalid data handle!\n");
    823         }
     797        if (toolPtr->uFlags & TTF_IDISHWND) {
     798            LPTT_SUBCLASS_INFO lpttsi =
     799                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     800            if (lpttsi) {
     801                SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     802                                  (LONG)lpttsi->wpOrigProc);
     803                RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     804                COMCTL32_Free (&lpttsi);
     805            }
     806//          else
     807//              ERR (tooltips, "Invalid data handle!\n");
     808        }
     809        else {
     810            LPTT_SUBCLASS_INFO lpttsi =
     811                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     812            if (lpttsi) {
     813                if (lpttsi->uRefCount == 1) {
     814                    SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     815                                      (LONG)lpttsi->wpOrigProc);
     816                    RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     817                    COMCTL32_Free (&lpttsi);
     818                }
     819                else
     820                    lpttsi->uRefCount--;
     821            }
     822//          else
     823//              ERR (tooltips, "Invalid data handle!\n");
     824        }
    824825    }
    825826
    826827    /* delete tool from tool list */
    827828    if (infoPtr->uNumTools == 1) {
    828         COMCTL32_Free (infoPtr->tools);
    829         infoPtr->tools = NULL;
     829        COMCTL32_Free (infoPtr->tools);
     830        infoPtr->tools = NULL;
    830831    }
    831832    else {
    832         TTTOOL_INFO *oldTools = infoPtr->tools;
    833         infoPtr->tools =
    834             COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
    835 
    836         if (nTool > 0)
    837             memcpy (&infoPtr->tools[0], &oldTools[0],
    838                     nTool * sizeof(TTTOOL_INFO));
    839 
    840         if (nTool < infoPtr->uNumTools - 1)
    841             memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
    842                     (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
    843 
    844         COMCTL32_Free (oldTools);
     833        TTTOOL_INFO *oldTools = infoPtr->tools;
     834        infoPtr->tools =
     835            COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
     836
     837        if (nTool > 0)
     838            memcpy (&infoPtr->tools[0], &oldTools[0],
     839                    nTool * sizeof(TTTOOL_INFO));
     840
     841        if (nTool < infoPtr->uNumTools - 1)
     842            memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
     843                    (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
     844
     845        COMCTL32_Free (oldTools);
    845846    }
    846847
    … …  
    860861
    861862    if (lpToolInfo == NULL)
    862         return 0;
     863        return 0;
    863864    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    864         return 0;
     865        return 0;
    865866    if (infoPtr->uNumTools == 0)
    866         return 0;
     867        return 0;
    867868
    868869    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    … …  
    872873
    873874    /* delete text string */
    874     toolPtr = &infoPtr->tools[nTool]; 
     875    toolPtr = &infoPtr->tools[nTool];
    875876    if ((toolPtr->hinst) && (toolPtr->lpszText)) {
    876         if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
    877             COMCTL32_Free (toolPtr->lpszText);
     877        if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
     878            COMCTL32_Free (toolPtr->lpszText);
    878879    }
    879880
    880881    /* remove subclassing */
    881882    if (toolPtr->uFlags & TTF_SUBCLASS) {
    882         if (toolPtr->uFlags & TTF_IDISHWND) {
    883             LPTT_SUBCLASS_INFO lpttsi =
    884                 (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    885             if (lpttsi) {
    886                 SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    887                                   (LONG)lpttsi->wpOrigProc);
    888                 RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    889                 COMCTL32_Free (&lpttsi);
    890             }
    891 //          else
    892 //              ERR (tooltips, "Invalid data handle!\n");
    893         }
    894         else {
    895             LPTT_SUBCLASS_INFO lpttsi =
    896                 (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    897             if (lpttsi) {
    898                 if (lpttsi->uRefCount == 1) {
    899                     SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    900                                       (LONG)lpttsi->wpOrigProc);
    901                     RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    902                     COMCTL32_Free (&lpttsi);
    903                 }
    904                 else
    905                     lpttsi->uRefCount--;
    906             }
    907 //          else
    908 //              ERR (tooltips, "Invalid data handle!\n");
    909         }
     883        if (toolPtr->uFlags & TTF_IDISHWND) {
     884            LPTT_SUBCLASS_INFO lpttsi =
     885                (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     886            if (lpttsi) {
     887                SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     888                                  (LONG)lpttsi->wpOrigProc);
     889                RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     890                COMCTL32_Free (&lpttsi);
     891            }
     892//          else
     893//              ERR (tooltips, "Invalid data handle!\n");
     894        }
     895        else {
     896            LPTT_SUBCLASS_INFO lpttsi =
     897                (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     898            if (lpttsi) {
     899                if (lpttsi->uRefCount == 1) {
     900                    SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     901                                      (LONG)lpttsi->wpOrigProc);
     902                    RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     903                    COMCTL32_Free (&lpttsi);
     904                }
     905                else
     906                    lpttsi->uRefCount--;
     907            }
     908//          else
     909//              ERR (tooltips, "Invalid data handle!\n");
     910        }
    910911    }
    911912
    912913    /* delete tool from tool list */
    913914    if (infoPtr->uNumTools == 1) {
    914         COMCTL32_Free (infoPtr->tools);
    915         infoPtr->tools = NULL;
     915        COMCTL32_Free (infoPtr->tools);
     916        infoPtr->tools = NULL;
    916917    }
    917918    else {
    918         TTTOOL_INFO *oldTools = infoPtr->tools;
    919         infoPtr->tools =
    920             COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
    921 
    922         if (nTool > 0)
    923             memcpy (&infoPtr->tools[0], &oldTools[0],
    924                     nTool * sizeof(TTTOOL_INFO));
    925 
    926         if (nTool < infoPtr->uNumTools - 1)
    927             memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
    928                     (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
    929 
    930         COMCTL32_Free (oldTools);
     919        TTTOOL_INFO *oldTools = infoPtr->tools;
     920        infoPtr->tools =
     921            COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools - 1));
     922
     923        if (nTool > 0)
     924            memcpy (&infoPtr->tools[0], &oldTools[0],
     925                    nTool * sizeof(TTTOOL_INFO));
     926
     927        if (nTool < infoPtr->uNumTools - 1)
     928            memcpy (&infoPtr->tools[nTool], &oldTools[nTool + 1],
     929                    (infoPtr->uNumTools - nTool - 1) * sizeof(TTTOOL_INFO));
     930
     931        COMCTL32_Free (oldTools);
    931932    }
    932933
    … …  
    946947
    947948    if (lpToolInfo == NULL)
    948         return FALSE;
     949        return FALSE;
    949950    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    950         return FALSE;
     951        return FALSE;
    951952    if (uIndex >= infoPtr->uNumTools)
    952         return FALSE;
     953        return FALSE;
    953954
    954955//    TRACE (tooltips, "index=%u\n", uIndex);
    … …  
    966967
    967968    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    968         lpToolInfo->lParam = toolPtr->lParam;
     969        lpToolInfo->lParam = toolPtr->lParam;
    969970
    970971    return TRUE;
    … …  
    981982
    982983    if (lpToolInfo == NULL)
    983         return FALSE;
     984        return FALSE;
    984985    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    985         return FALSE;
     986        return FALSE;
    986987    if (uIndex >= infoPtr->uNumTools)
    987         return FALSE;
     988        return FALSE;
    988989
    989990//    TRACE (tooltips, "index=%u\n", uIndex);
    … …  
    10011002
    10021003    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1003         lpToolInfo->lParam = toolPtr->lParam;
     1004        lpToolInfo->lParam = toolPtr->lParam;
    10041005
    10051006    return TRUE;
    … …  
    10151016
    10161017    if (lpToolInfo == NULL)
    1017         return FALSE;
     1018        return FALSE;
    10181019    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1019         return FALSE;
     1020        return FALSE;
    10201021
    10211022    if (lpToolInfo) {
    1022         if (infoPtr->nCurrentTool > -1) {
    1023             toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
    1024 
    1025             /* copy tool data */
    1026             lpToolInfo->uFlags   = toolPtr->uFlags;
    1027             lpToolInfo->rect     = toolPtr->rect;
    1028             lpToolInfo->hinst    = toolPtr->hinst;
    1029 /*          lpToolInfo->lpszText = toolPtr->lpszText; */
    1030             lpToolInfo->lpszText = NULL;  /* FIXME */
    1031 
    1032             if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    1033                 lpToolInfo->lParam = toolPtr->lParam;
    1034 
    1035             return TRUE;
    1036         }
    1037         else
    1038             return FALSE;
     1023        if (infoPtr->nCurrentTool > -1) {
     1024            toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
     1025
     1026            /* copy tool data */
     1027            lpToolInfo->uFlags   = toolPtr->uFlags;
     1028            lpToolInfo->rect     = toolPtr->rect;
     1029            lpToolInfo->hinst    = toolPtr->hinst;
     1030/*          lpToolInfo->lpszText = toolPtr->lpszText; */
     1031            lpToolInfo->lpszText = NULL;  /* FIXME */
     1032
     1033            if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
     1034                lpToolInfo->lParam = toolPtr->lParam;
     1035
     1036            return TRUE;
     1037        }
     1038        else
     1039            return FALSE;
    10391040    }
    10401041    else
    1041         return (infoPtr->nCurrentTool != -1);
     1042        return (infoPtr->nCurrentTool != -1);
    10421043
    10431044    return FALSE;
    … …  
    10531054
    10541055    if (lpToolInfo == NULL)
    1055         return FALSE;
     1056        return FALSE;
    10561057    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1057         return FALSE;
     1058        return FALSE;
    10581059
    10591060    if (lpToolInfo) {
    1060         if (infoPtr->nCurrentTool > -1) {
    1061             toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
    1062 
    1063             /* copy tool data */
    1064             lpToolInfo->uFlags   = toolPtr->uFlags;
    1065             lpToolInfo->rect     = toolPtr->rect;
    1066             lpToolInfo->hinst    = toolPtr->hinst;
    1067 /*          lpToolInfo->lpszText = toolPtr->lpszText; */
    1068             lpToolInfo->lpszText = NULL;  /* FIXME */
    1069 
    1070             if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1071                 lpToolInfo->lParam = toolPtr->lParam;
    1072 
    1073             return TRUE;
    1074         }
    1075         else
    1076             return FALSE;
     1061        if (infoPtr->nCurrentTool > -1) {
     1062            toolPtr = &infoPtr->tools[infoPtr->nCurrentTool];
     1063
     1064            /* copy tool data */
     1065            lpToolInfo->uFlags   = toolPtr->uFlags;
     1066            lpToolInfo->rect     = toolPtr->rect;
     1067            lpToolInfo->hinst    = toolPtr->hinst;
     1068/*          lpToolInfo->lpszText = toolPtr->lpszText; */
     1069            lpToolInfo->lpszText = NULL;  /* FIXME */
     1070
     1071            if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
     1072                lpToolInfo->lParam = toolPtr->lParam;
     1073
     1074            return TRUE;
     1075        }
     1076        else
     1077            return FALSE;
    10771078    }
    10781079    else
    1079         return (infoPtr->nCurrentTool != -1);
     1080        return (infoPtr->nCurrentTool != -1);
    10801081
    10811082    return FALSE;
    … …  
    10891090
    10901091    switch (wParam) {
    1091         case TTDT_AUTOMATIC:
    1092             return infoPtr->nAutomaticTime;
    1093 
    1094         case TTDT_RESHOW:
    1095             return infoPtr->nReshowTime;
    1096 
    1097         case TTDT_AUTOPOP:
    1098             return infoPtr->nAutoPopTime;
    1099 
    1100         case TTDT_INITIAL:
    1101             return infoPtr->nInitialTime;
     1092        case TTDT_AUTOMATIC:
     1093            return infoPtr->nAutomaticTime;
     1094
     1095        case TTDT_RESHOW:
     1096            return infoPtr->nReshowTime;
     1097
     1098        case TTDT_AUTOPOP:
     1099            return infoPtr->nAutoPopTime;
     1100
     1101        case TTDT_INITIAL:
     1102            return infoPtr->nInitialTime;
    11021103    }
    11031104
    … …  
    11381139
    11391140    if (lpToolInfo == NULL)
    1140         return 0;
     1141        return 0;
    11411142    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1142         return 0;
     1143        return 0;
    11431144
    11441145    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    … …  
    11591160
    11601161    if (lpToolInfo == NULL)
    1161         return 0;
     1162        return 0;
    11621163    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1163         return 0;
     1164        return 0;
    11641165
    11651166    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    … …  
    12051206
    12061207    if (lpToolInfo == NULL)
    1207         return FALSE;
     1208        return FALSE;
    12081209    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1209         return FALSE;
     1210        return FALSE;
    12101211    if (infoPtr->uNumTools == 0)
    1211         return FALSE;
     1212        return FALSE;
    12121213
    12131214    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    12141215    if (nTool == -1)
    1215         return FALSE;
     1216        return FALSE;
    12161217
    12171218//    TRACE (tooltips, "tool %d\n", nTool);
    … …  
    12271228
    12281229    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    1229         lpToolInfo->lParam = toolPtr->lParam;
     1230        lpToolInfo->lParam = toolPtr->lParam;
    12301231
    12311232    return TRUE;
    … …  
    12421243
    12431244    if (lpToolInfo == NULL)
    1244         return FALSE;
     1245        return FALSE;
    12451246    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1246         return FALSE;
     1247        return FALSE;
    12471248    if (infoPtr->uNumTools == 0)
    1248         return FALSE;
     1249        return FALSE;
    12491250
    12501251    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    12511252    if (nTool == -1)
    1252         return FALSE;
     1253        return FALSE;
    12531254
    12541255//    TRACE (tooltips, "tool %d\n", nTool);
    … …  
    12641265
    12651266    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1266         lpToolInfo->lParam = toolPtr->lParam;
     1267        lpToolInfo->lParam = toolPtr->lParam;
    12671268
    12681269    return TRUE;
    … …  
    12791280
    12801281    if (lptthit == 0)
    1281         return FALSE;
     1282        return FALSE;
    12821283
    12831284    nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt);
    12841285    if (nTool == -1)
    1285         return FALSE;
     1286        return FALSE;
    12861287
    12871288//    TRACE (tooltips, "tool %d!\n", nTool);
    … …  
    12891290    /* copy tool data */
    12901291    if (lptthit->ti.cbSize >= sizeof(TTTOOLINFOA)) {
    1291         toolPtr = &infoPtr->tools[nTool];
    1292 
    1293         lptthit->ti.uFlags   = toolPtr->uFlags;
    1294         lptthit->ti.hwnd     = toolPtr->hwnd;
    1295         lptthit->ti.uId      = toolPtr->uId;
    1296         lptthit->ti.rect     = toolPtr->rect;
    1297         lptthit->ti.hinst    = toolPtr->hinst;
    1298 /*      lptthit->ti.lpszText = toolPtr->lpszText; */
    1299         lptthit->ti.lpszText = NULL;  /* FIXME */
    1300         lptthit->ti.lParam   = toolPtr->lParam;
     1292        toolPtr = &infoPtr->tools[nTool];
     1293
     1294        lptthit->ti.uFlags   = toolPtr->uFlags;
     1295        lptthit->ti.hwnd     = toolPtr->hwnd;
     1296        lptthit->ti.uId      = toolPtr->uId;
     1297        lptthit->ti.rect     = toolPtr->rect;
     1298        lptthit->ti.hinst    = toolPtr->hinst;
     1299/*      lptthit->ti.lpszText = toolPtr->lpszText; */
     1300        lptthit->ti.lpszText = NULL;  /* FIXME */
     1301        lptthit->ti.lParam   = toolPtr->lParam;
    13011302    }
    13021303
    … …  
    13141315
    13151316    if (lptthit == 0)
    1316         return FALSE;
     1317        return FALSE;
    13171318
    13181319    nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lptthit->hwnd, &lptthit->pt);
    13191320    if (nTool == -1)
    1320         return FALSE;
     1321        return FALSE;
    13211322
    13221323//    TRACE (tooltips, "tool %d!\n", nTool);
    … …  
    13241325    /* copy tool data */
    13251326    if (lptthit->ti.cbSize >= sizeof(TTTOOLINFOW)) {
    1326         toolPtr = &infoPtr->tools[nTool];
    1327 
    1328         lptthit->ti.uFlags   = toolPtr->uFlags;
    1329         lptthit->ti.hwnd     = toolPtr->hwnd;
    1330         lptthit->ti.uId      = toolPtr->uId;
    1331         lptthit->ti.rect     = toolPtr->rect;
    1332         lptthit->ti.hinst    = toolPtr->hinst;
    1333 /*      lptthit->ti.lpszText = toolPtr->lpszText; */
    1334         lptthit->ti.lpszText = NULL;  /* FIXME */
    1335         lptthit->ti.lParam   = toolPtr->lParam;
     1327        toolPtr = &infoPtr->tools[nTool];
     1328
     1329        lptthit->ti.uFlags   = toolPtr->uFlags;
     1330        lptthit->ti.hwnd     = toolPtr->hwnd;
     1331        lptthit->ti.uId      = toolPtr->uId;
     1332        lptthit->ti.rect     = toolPtr->rect;
     1333        lptthit->ti.hinst    = toolPtr->hinst;
     1334/*      lptthit->ti.lpszText = toolPtr->lpszText; */
     1335        lptthit->ti.lpszText = NULL;  /* FIXME */
     1336        lptthit->ti.lParam   = toolPtr->lParam;
    13361337    }
    13371338
    … …  
    13481349
    13491350    if (lpti == NULL)
    1350         return 0;
     1351        return 0;
    13511352    if (lpti->cbSize < TTTOOLINFO_V1_SIZEA)
    1352         return FALSE;
     1353        return FALSE;
    13531354
    13541355    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpti);
    … …  
    13691370
    13701371    if (lpti == NULL)
    1371         return 0;
     1372        return 0;
    13721373    if (lpti->cbSize < TTTOOLINFO_V1_SIZEW)
    1373         return FALSE;
     1374        return FALSE;
    13741375
    13751376    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpti);
    … …  
    14011402
    14021403    if (lParam == 0) {
    1403 //      ERR (tooltips, "lpMsg == NULL!\n");
    1404         return 0;
     1404//      ERR (tooltips, "lpMsg == NULL!\n");
     1405        return 0;
    14051406    }
    14061407
    14071408    switch (lpMsg->message) {
    1408         case WM_LBUTTONDOWN:
    1409         case WM_LBUTTONUP:
    1410         case WM_MBUTTONDOWN:
    1411         case WM_MBUTTONUP:
    1412         case WM_RBUTTONDOWN:
    1413         case WM_RBUTTONUP:
    1414             pt = lpMsg->pt;
    1415             ScreenToClient (lpMsg->hwnd, &pt);
    1416             infoPtr->nOldTool = infoPtr->nTool;
    1417             infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
    1418 //          TRACE (tooltips, "tool (%x) %d %d\n",
    1419 //                 hwnd, infoPtr->nOldTool, infoPtr->nTool);
    1420             TOOLTIPS_Hide (hwnd, infoPtr);
    1421             break;
    1422 
    1423         case WM_MOUSEMOVE:
    1424             pt = lpMsg->pt;
    1425             ScreenToClient (lpMsg->hwnd, &pt);
    1426             infoPtr->nOldTool = infoPtr->nTool;
    1427             infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
    1428 //          TRACE (tooltips, "tool (%x) %d %d\n",
    1429 //                 hwnd, infoPtr->nOldTool, infoPtr->nTool);
    1430 //          TRACE (tooltips, "WM_MOUSEMOVE (%04x %ld %ld)\n",
    1431 //                 hwnd, pt.x, pt.y);
    1432             if ((infoPtr->bActive) && (infoPtr->nTool != infoPtr->nOldTool)) {
    1433                 if (infoPtr->nOldTool == -1) {
    1434                     SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nInitialTime, 0);
    1435 //                  TRACE (tooltips, "timer 1 started!\n");
    1436                 }
    1437                 else {
    1438                     TOOLTIPS_Hide (hwnd, infoPtr);
    1439                     SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nReshowTime, 0);
    1440 //                  TRACE (tooltips, "timer 2 started!\n");
    1441                 }
    1442             }
    1443             if (infoPtr->nCurrentTool != -1) {
    1444                 SetTimer (hwnd, ID_TIMERLEAVE, 100, 0);
    1445 //              TRACE (tooltips, "timer 3 started!\n");
    1446             }
    1447             break;
     1409        case WM_LBUTTONDOWN:
     1410        case WM_LBUTTONUP:
     1411        case WM_MBUTTONDOWN:
     1412        case WM_MBUTTONUP:
     1413        case WM_RBUTTONDOWN:
     1414        case WM_RBUTTONUP:
     1415            pt = lpMsg->pt;
     1416            ScreenToClient (lpMsg->hwnd, &pt);
     1417            infoPtr->nOldTool = infoPtr->nTool;
     1418            infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
     1419//          TRACE (tooltips, "tool (%x) %d %d\n",
     1420//                 hwnd, infoPtr->nOldTool, infoPtr->nTool);
     1421            TOOLTIPS_Hide (hwnd, infoPtr);
     1422            break;
     1423
     1424        case WM_MOUSEMOVE:
     1425            pt = lpMsg->pt;
     1426            ScreenToClient (lpMsg->hwnd, &pt);
     1427            infoPtr->nOldTool = infoPtr->nTool;
     1428            infoPtr->nTool = TOOLTIPS_GetToolFromPoint (infoPtr, lpMsg->hwnd, &pt);
     1429//          TRACE (tooltips, "tool (%x) %d %d\n",
     1430//                 hwnd, infoPtr->nOldTool, infoPtr->nTool);
     1431//          TRACE (tooltips, "WM_MOUSEMOVE (%04x %ld %ld)\n",
     1432//                 hwnd, pt.x, pt.y);
     1433            if ((infoPtr->bActive) && (infoPtr->nTool != infoPtr->nOldTool)) {
     1434                if (infoPtr->nOldTool == -1) {
     1435                    SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nInitialTime, 0);
     1436//                  TRACE (tooltips, "timer 1 started!\n");
     1437                }
     1438                else {
     1439                    TOOLTIPS_Hide (hwnd, infoPtr);
     1440                    SetTimer (hwnd, ID_TIMERSHOW, infoPtr->nReshowTime, 0);
     1441//                  TRACE (tooltips, "timer 2 started!\n");
     1442                }
     1443            }
     1444            if (infoPtr->nCurrentTool != -1) {
     1445                SetTimer (hwnd, ID_TIMERLEAVE, 100, 0);
     1446//              TRACE (tooltips, "timer 3 started!\n");
     1447            }
     1448            break;
    14481449    }
    14491450
    … …  
    14591460
    14601461    switch (wParam) {
    1461         case TTDT_AUTOMATIC:
    1462             if (nTime == 0) {
    1463                 infoPtr->nAutomaticTime = 500;
    1464                 infoPtr->nReshowTime    = 100;
    1465                 infoPtr->nAutoPopTime   = 5000;
    1466                 infoPtr->nInitialTime   = 500;
    1467             }
    1468             else {
    1469                 infoPtr->nAutomaticTime = nTime;
    1470                 infoPtr->nReshowTime    = nTime / 5;
    1471                 infoPtr->nAutoPopTime   = nTime * 10;
    1472                 infoPtr->nInitialTime   = nTime;
    1473             }
    1474             break;
    1475 
    1476         case TTDT_RESHOW:
    1477             infoPtr->nReshowTime = nTime;
    1478             break;
    1479 
    1480         case TTDT_AUTOPOP:
    1481             infoPtr->nAutoPopTime = nTime;
    1482             break;
    1483 
    1484         case TTDT_INITIAL:
    1485             infoPtr->nInitialTime = nTime;
    1486             break;
     1462        case TTDT_AUTOMATIC:
     1463            if (nTime == 0) {
     1464                infoPtr->nAutomaticTime = 500;
     1465                infoPtr->nReshowTime    = 100;
     1466                infoPtr->nAutoPopTime   = 5000;
     1467                infoPtr->nInitialTime   = 500;
     1468            }
     1469            else {
     1470                infoPtr->nAutomaticTime = nTime;
     1471                infoPtr->nReshowTime    = nTime / 5;
     1472                infoPtr->nAutoPopTime   = nTime * 10;
     1473                infoPtr->nInitialTime   = nTime;
     1474            }
     1475            break;
     1476
     1477        case TTDT_RESHOW:
     1478            infoPtr->nReshowTime = nTime;
     1479            break;
     1480
     1481        case TTDT_AUTOPOP:
     1482            infoPtr->nAutoPopTime = nTime;
     1483            break;
     1484
     1485        case TTDT_INITIAL:
     1486            infoPtr->nInitialTime = nTime;
     1487            break;
    14871488    }
    14881489
    … …  
    15491550
    15501551    if (lpToolInfo == NULL)
    1551         return 0;
     1552        return 0;
    15521553    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1553         return 0;
     1554        return 0;
    15541555
    15551556    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    … …  
    15681569
    15691570    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
    1570 //      TRACE (tooltips, "set string id %x!\n", (INT)lpToolInfo->lpszText);
    1571         toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     1571//      TRACE (tooltips, "set string id %x!\n", (INT)lpToolInfo->lpszText);
     1572        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    15721573    }
    15731574    else if (lpToolInfo->lpszText) {
    1574         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
    1575             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1576         else {
    1577             if (toolPtr->lpszText) {
    1578                 COMCTL32_Free (toolPtr->lpszText);
    1579                 toolPtr->lpszText = NULL;
    1580             }
    1581             if (lpToolInfo->lpszText) {
    1582                 INT len = lstrlenA (lpToolInfo->lpszText);
    1583                 toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1584                 lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
    1585             }
    1586         }
     1575        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
     1576            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1577        else {
     1578            if (toolPtr->lpszText) {
     1579                COMCTL32_Free (toolPtr->lpszText);
     1580                toolPtr->lpszText = NULL;
     1581            }
     1582            if (lpToolInfo->lpszText) {
     1583                INT len = lstrlenA (lpToolInfo->lpszText);
     1584                toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     1585                lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
     1586            }
     1587        }
    15871588    }
    15881589
    15891590    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    1590         toolPtr->lParam = lpToolInfo->lParam;
     1591        toolPtr->lParam = lpToolInfo->lParam;
    15911592
    15921593    return 0;
    … …  
    16031604
    16041605    if (lpToolInfo == NULL)
    1605         return 0;
     1606        return 0;
    16061607    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1607         return 0;
     1608        return 0;
    16081609
    16091610    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    … …  
    16221623
    16231624    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)) {
    1624 //      TRACE (tooltips, "set string id %x!\n", (INT)lpToolInfo->lpszText);
    1625         toolPtr->lpszText = lpToolInfo->lpszText;
     1625//      TRACE (tooltips, "set string id %x!\n", (INT)lpToolInfo->lpszText);
     1626        toolPtr->lpszText = lpToolInfo->lpszText;
    16261627    }
    16271628    else if (lpToolInfo->lpszText) {
    1628         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
    1629             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1630         else {
    1631             if (toolPtr->lpszText) {
    1632                 COMCTL32_Free (toolPtr->lpszText);
    1633                 toolPtr->lpszText = NULL;
    1634             }
    1635             if (lpToolInfo->lpszText) {
    1636                 INT len = lstrlenW (lpToolInfo->lpszText);
    1637                 toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1638                 lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
    1639             }
    1640         }
     1629        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
     1630            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1631        else {
     1632            if (toolPtr->lpszText) {
     1633                COMCTL32_Free (toolPtr->lpszText);
     1634                toolPtr->lpszText = NULL;
     1635            }
     1636            if (lpToolInfo->lpszText) {
     1637                INT len = lstrlenW (lpToolInfo->lpszText);
     1638                toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     1639                lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
     1640            }
     1641        }
    16411642    }
    16421643
    16431644    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOW))
    1644         toolPtr->lParam = lpToolInfo->lParam;
     1645        toolPtr->lParam = lpToolInfo->lParam;
    16451646
    16461647    return 0;
    … …  
    16551656
    16561657    if (lpToolInfo == NULL)
    1657         return 0;
     1658        return 0;
    16581659    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1659         return FALSE;
     1660        return FALSE;
    16601661
    16611662    if ((BOOL)wParam) {
    1662         /* activate */
    1663         infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    1664         if (infoPtr->nTrackTool != -1) {
    1665 //          TRACE (tooltips, "activated!\n");
    1666             infoPtr->bTrackActive = TRUE;
    1667             TOOLTIPS_TrackShow (hwnd, infoPtr);
    1668         }
     1663        /* activate */
     1664        infoPtr->nTrackTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
     1665        if (infoPtr->nTrackTool != -1) {
     1666//          TRACE (tooltips, "activated!\n");
     1667            infoPtr->bTrackActive = TRUE;
     1668            TOOLTIPS_TrackShow (hwnd, infoPtr);
     1669        }
    16691670    }
    16701671    else {
    1671         /* deactivate */
    1672         TOOLTIPS_TrackHide (hwnd, infoPtr);
    1673 
    1674         infoPtr->bTrackActive = FALSE;
    1675         infoPtr->nTrackTool = -1;
    1676 
    1677 //      TRACE (tooltips, "deactivated!\n");
     1672        /* deactivate */
     1673        TOOLTIPS_TrackHide (hwnd, infoPtr);
     1674
     1675        infoPtr->bTrackActive = FALSE;
     1676        infoPtr->nTrackTool = -1;
     1677
     1678//      TRACE (tooltips, "deactivated!\n");
    16781679    }
    16791680
    … …  
    16911692
    16921693    if (infoPtr->bTrackActive) {
    1693 //      TRACE (tooltips, "[%d %d]\n",
    1694 //             infoPtr->xTrackPos, infoPtr->yTrackPos);
    1695 
    1696         TOOLTIPS_TrackShow (hwnd, infoPtr);
     1694//      TRACE (tooltips, "[%d %d]\n",
     1695//             infoPtr->xTrackPos, infoPtr->yTrackPos);
     1696
     1697        TOOLTIPS_TrackShow (hwnd, infoPtr);
    16971698    }
    16981699
    … …  
    17071708
    17081709    if (infoPtr->nCurrentTool != -1)
    1709         UpdateWindow (hwnd);
     1710        UpdateWindow (hwnd);
    17101711
    17111712    return 0;
    … …  
    17221723
    17231724    if (lpToolInfo == NULL)
    1724         return 0;
     1725        return 0;
    17251726    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA)
    1726         return FALSE;
     1727        return FALSE;
    17271728
    17281729    nTool = TOOLTIPS_GetToolFromInfoA (infoPtr, lpToolInfo);
    … …  
    17371738
    17381739    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)){
    1739         toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     1740        toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    17401741    }
    17411742    else if (lpToolInfo->lpszText) {
    1742         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
    1743             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1744         else {
    1745             if (toolPtr->lpszText) {
    1746                 COMCTL32_Free (toolPtr->lpszText);
    1747                 toolPtr->lpszText = NULL;
    1748             }
    1749             if (lpToolInfo->lpszText) {
    1750                 INT len = lstrlenA (lpToolInfo->lpszText);
    1751                 toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1752                 lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
    1753             }
    1754         }
     1743        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
     1744            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1745        else {
     1746            if (toolPtr->lpszText) {
     1747                COMCTL32_Free (toolPtr->lpszText);
     1748                toolPtr->lpszText = NULL;
     1749            }
     1750            if (lpToolInfo->lpszText) {
     1751                INT len = lstrlenA (lpToolInfo->lpszText);
     1752                toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     1753                lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
     1754            }
     1755        }
    17551756    }
    17561757
    17571758    /* force repaint */
    17581759    if (infoPtr->bActive)
    1759         TOOLTIPS_Show (hwnd, infoPtr);
     1760        TOOLTIPS_Show (hwnd, infoPtr);
    17601761    else if (infoPtr->bTrackActive)
    1761         TOOLTIPS_TrackShow (hwnd, infoPtr);
     1762        TOOLTIPS_TrackShow (hwnd, infoPtr);
    17621763
    17631764    return 0;
    … …  
    17741775
    17751776    if (lpToolInfo == NULL)
    1776         return 0;
     1777        return 0;
    17771778    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    1778         return FALSE;
     1779        return FALSE;
    17791780
    17801781    nTool = TOOLTIPS_GetToolFromInfoW (infoPtr, lpToolInfo);
    17811782    if (nTool == -1)
    1782         return 0;
     1783        return 0;
    17831784
    17841785//    TRACE (tooltips, "tool %d\n", nTool);
    … …  
    17901791
    17911792    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0)){
    1792         toolPtr->lpszText = lpToolInfo->lpszText;
     1793        toolPtr->lpszText = lpToolInfo->lpszText;
    17931794    }
    17941795    else if (lpToolInfo->lpszText) {
    1795         if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
    1796             toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    1797         else {
    1798             if (toolPtr->lpszText) {
    1799                 COMCTL32_Free (toolPtr->lpszText);
    1800                 toolPtr->lpszText = NULL;
    1801             }
    1802             if (lpToolInfo->lpszText) {
    1803                 INT len = lstrlenW (lpToolInfo->lpszText);
    1804                 toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
    1805                 lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
    1806             }
    1807         }
     1796        if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKW)
     1797            toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     1798        else {
     1799            if (toolPtr->lpszText) {
     1800                COMCTL32_Free (toolPtr->lpszText);
     1801                toolPtr->lpszText = NULL;
     1802            }
     1803            if (lpToolInfo->lpszText) {
     1804                INT len = lstrlenW (lpToolInfo->lpszText);
     1805                toolPtr->lpszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
     1806                lstrcpyW (toolPtr->lpszText, lpToolInfo->lpszText);
     1807            }
     1808        }
    18081809    }
    18091810
    18101811    /* force repaint */
    18111812    if (infoPtr->bActive)
    1812         TOOLTIPS_Show (hwnd, infoPtr);
     1813        TOOLTIPS_Show (hwnd, infoPtr);
    18131814    else if (infoPtr->bTrackActive)
    1814         TOOLTIPS_TrackShow (hwnd, infoPtr);
     1815        TOOLTIPS_TrackShow (hwnd, infoPtr);
    18151816
    18161817    return 0;
    … …  
    18591860
    18601861    nResult = (INT) SendMessageA (GetParent (hwnd), WM_NOTIFYFORMAT,
    1861                                   (WPARAM)hwnd, (LPARAM)NF_QUERY);
     1862                                  (WPARAM)hwnd, (LPARAM)NF_QUERY);
    18621863//    if (nResult == NFR_ANSI)
    1863 //      TRACE (tooltips, " -- WM_NOTIFYFORMAT returns: NFR_ANSI\n");
     1864//      TRACE (tooltips, " -- WM_NOTIFYFORMAT returns: NFR_ANSI\n");
    18641865//    else if (nResult == NFR_UNICODE)
    1865 //      FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: NFR_UNICODE\n");
     1866//      FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: NFR_UNICODE\n");
    18661867//    else
    1867 //      FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: error!\n");
     1868//      FIXME (tooltips, " -- WM_NOTIFYFORMAT returns: error!\n");
    18681869
    18691870    SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE);
    … …  
    18821883    /* free tools */
    18831884    if (infoPtr->tools) {
    1884         for (i = 0; i < infoPtr->uNumTools; i++) {
    1885             toolPtr = &infoPtr->tools[i];
    1886             if ((toolPtr->hinst) && (toolPtr->lpszText)) {
    1887                 if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
    1888                     COMCTL32_Free (toolPtr->lpszText);
    1889             }
    1890 
    1891             /* remove subclassing */
    1892             if (toolPtr->uFlags & TTF_SUBCLASS) {
    1893                 LPTT_SUBCLASS_INFO lpttsi;
    1894 
    1895                 if (toolPtr->uFlags & TTF_IDISHWND)
    1896                     lpttsi = (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    1897                 else
    1898                     lpttsi = (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    1899 
    1900                 if (lpttsi) {
    1901                     SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    1902                                       (LONG)lpttsi->wpOrigProc);
    1903                     RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    1904                     COMCTL32_Free (&lpttsi);
    1905                 }
    1906             }
    1907         }
    1908         COMCTL32_Free (infoPtr->tools);
     1885        for (i = 0; i < infoPtr->uNumTools; i++) {
     1886            toolPtr = &infoPtr->tools[i];
     1887            if ((toolPtr->hinst) && (toolPtr->lpszText)) {
     1888                if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW)
     1889                    COMCTL32_Free (toolPtr->lpszText);
     1890            }
     1891
     1892            /* remove subclassing */
     1893            if (toolPtr->uFlags & TTF_SUBCLASS) {
     1894                LPTT_SUBCLASS_INFO lpttsi;
     1895
     1896                if (toolPtr->uFlags & TTF_IDISHWND)
     1897                    lpttsi = (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     1898                else
     1899                    lpttsi = (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
     1900
     1901                if (lpttsi) {
     1902                    SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
     1903                                      (LONG)lpttsi->wpOrigProc);
     1904                    RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
     1905                    COMCTL32_Free (&lpttsi);
     1906                }
     1907            }
     1908        }
     1909        COMCTL32_Free (infoPtr->tools);
    19091910    }
    19101911
    … …  
    19771978
    19781979    if ((nTool > -1) && (nTool < infoPtr->uNumTools)) {
    1979         if (infoPtr->tools[nTool].uFlags & TTF_TRANSPARENT) {
    1980 //          TRACE (tooltips, "-- in transparent mode!\n");
    1981             return HTTRANSPARENT;
    1982         }
     1980        if (infoPtr->tools[nTool].uFlags & TTF_TRANSPARENT) {
     1981//          TRACE (tooltips, "-- in transparent mode!\n");
     1982            return HTTRANSPARENT;
     1983        }
    19831984    }
    19841985
    … …  
    19961997    TOOLTIPS_Refresh (hwnd, hdc);
    19971998    if (!wParam)
    1998         EndPaint (hwnd, &ps);
     1999        EndPaint (hwnd, &ps);
    19992000    return 0;
    20002001}
    … …  
    20092010
    20102011    if ((LOWORD(lParam)) & (infoPtr->nCurrentTool != -1)) {
    2011 //      FIXME (tooltips, "full redraw needed!\n");
     2012//      FIXME (tooltips, "full redraw needed!\n");
    20122013    }
    20132014
    … …  
    20722073    switch (wParam)
    20732074    {
    2074         case ID_TIMERSHOW:
    2075             KillTimer (hwnd, ID_TIMERSHOW);
    2076             if (TOOLTIPS_CheckTool (hwnd, TRUE) == infoPtr->nTool)
    2077                 TOOLTIPS_Show (hwnd, infoPtr);
    2078             break;
    2079 
    2080         case ID_TIMERPOP:
    2081             TOOLTIPS_Hide (hwnd, infoPtr);
    2082             break;
    2083 
    2084         case ID_TIMERLEAVE:
    2085             KillTimer (hwnd, ID_TIMERLEAVE);
    2086             if (TOOLTIPS_CheckTool (hwnd, FALSE) == -1) {
    2087                 infoPtr->nTool = -1;
    2088                 infoPtr->nOldTool = -1;
    2089                 TOOLTIPS_Hide (hwnd, infoPtr);
    2090             }
    2091             break;
     2075        case ID_TIMERSHOW:
     2076            KillTimer (hwnd, ID_TIMERSHOW);
     2077            if (TOOLTIPS_CheckTool (hwnd, TRUE) == infoPtr->nTool)
     2078                TOOLTIPS_Show (hwnd, infoPtr);
     2079            break;
     2080
     2081        case ID_TIMERPOP:
     2082            TOOLTIPS_Hide (hwnd, infoPtr);
     2083            break;
     2084
     2085        case ID_TIMERLEAVE:
     2086            KillTimer (hwnd, ID_TIMERLEAVE);
     2087            if (TOOLTIPS_CheckTool (hwnd, FALSE) == -1) {
     2088                infoPtr->nTool = -1;
     2089                infoPtr->nOldTool = -1;
     2090                TOOLTIPS_Hide (hwnd, infoPtr);
     2091            }
     2092            break;
    20922093    }
    20932094    return 0;
    … …  
    21172118{
    21182119    LPTT_SUBCLASS_INFO lpttsi =
    2119         (LPTT_SUBCLASS_INFO)GetPropA (hwnd, COMCTL32_aSubclass);
     2120        (LPTT_SUBCLASS_INFO)GetPropA (hwnd, COMCTL32_aSubclass);
    21202121    TOOLTIPS_INFO *infoPtr;
    21212122    UINT nTool;
    21222123
    21232124    switch (uMsg) {
    2124         case WM_LBUTTONDOWN:
    2125         case WM_LBUTTONUP:
    2126         case WM_MBUTTONDOWN:
    2127         case WM_MBUTTONUP:
    2128         case WM_RBUTTONDOWN:
    2129         case WM_RBUTTONUP:
    2130             infoPtr = TOOLTIPS_GetInfoPtr(lpttsi->hwndToolTip);
    2131                 nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
    2132 
    2133 //              TRACE (tooltips, "subclassed mouse message %04x\n", uMsg);
    2134                 infoPtr->nOldTool = infoPtr->nTool;
    2135                 infoPtr->nTool = nTool;
    2136             TOOLTIPS_Hide (lpttsi->hwndToolTip, infoPtr);
    2137             break;
    2138 
    2139         case WM_MOUSEMOVE:
    2140             infoPtr = TOOLTIPS_GetInfoPtr (lpttsi->hwndToolTip);
    2141                 nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
    2142 
    2143 //              TRACE (tooltips, "subclassed WM_MOUSEMOVE\n");
    2144                 infoPtr->nOldTool = infoPtr->nTool;
    2145                 infoPtr->nTool = nTool;
    2146 
    2147                 if ((infoPtr->bActive) &&
    2148                     (infoPtr->nTool != infoPtr->nOldTool)) {
    2149                     if (infoPtr->nOldTool == -1) {
    2150                     SetTimer (hwnd, ID_TIMERSHOW,
    2151                                     infoPtr->nInitialTime, 0);
    2152 //                      TRACE (tooltips, "timer 1 started!\n");
    2153                     }
    2154                     else {
    2155                     TOOLTIPS_Hide (lpttsi->hwndToolTip, infoPtr);
    2156                     SetTimer (hwnd, ID_TIMERSHOW,
    2157                                 infoPtr->nReshowTime, 0);
    2158 //                      TRACE (tooltips, "timer 2 started!\n");
    2159                     }
    2160                 }
    2161                 if (infoPtr->nCurrentTool != -1) {
    2162                 SetTimer (hwnd, ID_TIMERLEAVE, 100, 0);
    2163 //                  TRACE (tooltips, "timer 3 started!\n");
    2164                 }
    2165             break;
     2125        case WM_LBUTTONDOWN:
     2126        case WM_LBUTTONUP:
     2127        case WM_MBUTTONDOWN:
     2128        case WM_MBUTTONUP:
     2129        case WM_RBUTTONDOWN:
     2130        case WM_RBUTTONUP:
     2131            infoPtr = TOOLTIPS_GetInfoPtr(lpttsi->hwndToolTip);
     2132                nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
     2133
     2134//              TRACE (tooltips, "subclassed mouse message %04x\n", uMsg);
     2135                infoPtr->nOldTool = infoPtr->nTool;
     2136                infoPtr->nTool = nTool;
     2137            TOOLTIPS_Hide (lpttsi->hwndToolTip, infoPtr);
     2138            break;
     2139
     2140        case WM_MOUSEMOVE:
     2141            infoPtr = TOOLTIPS_GetInfoPtr (lpttsi->hwndToolTip);
     2142                nTool = TOOLTIPS_GetToolFromMessage (infoPtr, hwnd);
     2143
     2144//              TRACE (tooltips, "subclassed WM_MOUSEMOVE\n");
     2145                infoPtr->nOldTool = infoPtr->nTool;
     2146                infoPtr->nTool = nTool;
     2147
     2148                if ((infoPtr->bActive) &&
     2149                    (infoPtr->nTool != infoPtr->nOldTool)) {
     2150                    if (infoPtr->nOldTool == -1) {
     2151                    SetTimer (hwnd, ID_TIMERSHOW,
     2152                                    infoPtr->nInitialTime, 0);
     2153//                      TRACE (tooltips, "timer 1 started!\n");
     2154                    }
     2155                    else {
     2156                    TOOLTIPS_Hide (lpttsi->hwndToolTip, infoPtr);
     2157                    SetTimer (hwnd, ID_TIMERSHOW,
     2158                                infoPtr->nReshowTime, 0);
     2159//                      TRACE (tooltips, "timer 2 started!\n");
     2160                    }
     2161                }
     2162                if (infoPtr->nCurrentTool != -1) {
     2163                SetTimer (hwnd, ID_TIMERLEAVE, 100, 0);
     2164//                  TRACE (tooltips, "timer 3 started!\n");
     2165                }
     2166            break;
    21662167    }
    21672168
    … …  
    21752176    switch (uMsg)
    21762177    {
    2177         case TTM_ACTIVATE:
    2178             return TOOLTIPS_Activate (hwnd, wParam, lParam);
    2179 
    2180         case TTM_ADDTOOLA:
    2181             return TOOLTIPS_AddToolA (hwnd, wParam, lParam);
    2182 
    2183         case TTM_ADDTOOLW:
    2184             return TOOLTIPS_AddToolW (hwnd, wParam, lParam);
    2185 
    2186         case TTM_DELTOOLA:
    2187             return TOOLTIPS_DelToolA (hwnd, wParam, lParam);
    2188 
    2189         case TTM_DELTOOLW:
    2190             return TOOLTIPS_DelToolW (hwnd, wParam, lParam);
    2191 
    2192         case TTM_ENUMTOOLSA:
    2193             return TOOLTIPS_EnumToolsA (hwnd, wParam, lParam);
    2194 
    2195         case TTM_ENUMTOOLSW:
    2196             return TOOLTIPS_EnumToolsW (hwnd, wParam, lParam);
    2197 
    2198         case TTM_GETCURRENTTOOLA:
    2199             return TOOLTIPS_GetCurrentToolA (hwnd, wParam, lParam);
    2200 
    2201         case TTM_GETCURRENTTOOLW:
    2202             return TOOLTIPS_GetCurrentToolW (hwnd, wParam, lParam);
    2203 
    2204         case TTM_GETDELAYTIME:
    2205             return TOOLTIPS_GetDelayTime (hwnd, wParam, lParam);
    2206 
    2207         case TTM_GETMARGIN:
    2208             return TOOLTIPS_GetMargin (hwnd, wParam, lParam);
    2209 
    2210         case TTM_GETMAXTIPWIDTH:
    2211             return TOOLTIPS_GetMaxTipWidth (hwnd, wParam, lParam);
    2212 
    2213         case TTM_GETTEXTA:
    2214             return TOOLTIPS_GetTextA (hwnd, wParam, lParam);
    2215 
    2216         case TTM_GETTEXTW:
    2217             return TOOLTIPS_GetTextW (hwnd, wParam, lParam);
    2218 
    2219         case TTM_GETTIPBKCOLOR:
    2220             return TOOLTIPS_GetTipBkColor (hwnd, wParam, lParam);
    2221 
    2222         case TTM_GETTIPTEXTCOLOR:
    2223             return TOOLTIPS_GetTipTextColor (hwnd, wParam, lParam);
    2224 
    2225         case TTM_GETTOOLCOUNT:
    2226             return TOOLTIPS_GetToolCount (hwnd, wParam, lParam);
    2227 
    2228         case TTM_GETTOOLINFOA:
    2229             return TOOLTIPS_GetToolInfoA (hwnd, wParam, lParam);
    2230 
    2231         case TTM_GETTOOLINFOW:
    2232             return TOOLTIPS_GetToolInfoW (hwnd, wParam, lParam);
    2233 
    2234         case TTM_HITTESTA:
    2235             return TOOLTIPS_HitTestA (hwnd, wParam, lParam);
    2236 
    2237         case TTM_HITTESTW:
    2238             return TOOLTIPS_HitTestW (hwnd, wParam, lParam);
    2239 
    2240         case TTM_NEWTOOLRECTA:
    2241             return TOOLTIPS_NewToolRectA (hwnd, wParam, lParam);
    2242 
    2243         case TTM_NEWTOOLRECTW:
    2244             return TOOLTIPS_NewToolRectW (hwnd, wParam, lParam);
    2245 
    2246         case TTM_POP:
    2247             return TOOLTIPS_Pop (hwnd, wParam, lParam);
    2248 
    2249         case TTM_RELAYEVENT:
    2250             return TOOLTIPS_RelayEvent (hwnd, wParam, lParam);
    2251 
    2252         case TTM_SETDELAYTIME:
    2253             return TOOLTIPS_SetDelayTime (hwnd, wParam, lParam);
    2254 
    2255         case TTM_SETMARGIN:
    2256             return TOOLTIPS_SetMargin (hwnd, wParam, lParam);
    2257 
    2258         case TTM_SETMAXTIPWIDTH:
    2259             return TOOLTIPS_SetMaxTipWidth (hwnd, wParam, lParam);
    2260 
    2261         case TTM_SETTIPBKCOLOR:
    2262             return TOOLTIPS_SetTipBkColor (hwnd, wParam, lParam);
    2263 
    2264         case TTM_SETTIPTEXTCOLOR:
    2265             return TOOLTIPS_SetTipTextColor (hwnd, wParam, lParam);
    2266 
    2267         case TTM_SETTOOLINFOA:
    2268             return TOOLTIPS_SetToolInfoA (hwnd, wParam, lParam);
    2269 
    2270         case TTM_SETTOOLINFOW:
    2271             return TOOLTIPS_SetToolInfoW (hwnd, wParam, lParam);
    2272 
    2273         case TTM_TRACKACTIVATE:
    2274             return TOOLTIPS_TrackActivate (hwnd, wParam, lParam);
    2275 
    2276         case TTM_TRACKPOSITION:
    2277             return TOOLTIPS_TrackPosition (hwnd, wParam, lParam);
    2278 
    2279         case TTM_UPDATE:
    2280             return TOOLTIPS_Update (hwnd, wParam, lParam);
    2281 
    2282         case TTM_UPDATETIPTEXTA:
    2283             return TOOLTIPS_UpdateTipTextA (hwnd, wParam, lParam);
    2284 
    2285         case TTM_UPDATETIPTEXTW:
    2286             return TOOLTIPS_UpdateTipTextW (hwnd, wParam, lParam);
    2287 
    2288         case TTM_WINDOWFROMPOINT:
    2289             return TOOLTIPS_WindowFromPoint (hwnd, wParam, lParam);
    2290 
    2291 
    2292         case WM_CREATE:
    2293             return TOOLTIPS_Create (hwnd, wParam, lParam);
    2294 
    2295         case WM_DESTROY:
    2296             return TOOLTIPS_Destroy (hwnd, wParam, lParam);
    2297 
    2298         case WM_ERASEBKGND:
    2299             return TOOLTIPS_EraseBackground (hwnd, wParam, lParam);
    2300 
    2301         case WM_GETFONT:
    2302             return TOOLTIPS_GetFont (hwnd, wParam, lParam);
     2178        case TTM_ACTIVATE:
     2179            return TOOLTIPS_Activate (hwnd, wParam, lParam);
     2180
     2181        case TTM_ADDTOOLA:
     2182            return TOOLTIPS_AddToolA (hwnd, wParam, lParam);
     2183
     2184        case TTM_ADDTOOLW:
     2185            return TOOLTIPS_AddToolW (hwnd, wParam, lParam);
     2186
     2187        case TTM_DELTOOLA:
     2188            return TOOLTIPS_DelToolA (hwnd, wParam, lParam);
     2189
     2190        case TTM_DELTOOLW:
     2191            return TOOLTIPS_DelToolW (hwnd, wParam, lParam);
     2192
     2193        case TTM_ENUMTOOLSA:
     2194            return TOOLTIPS_EnumToolsA (hwnd, wParam, lParam);
     2195
     2196        case TTM_ENUMTOOLSW:
     2197            return TOOLTIPS_EnumToolsW (hwnd, wParam, lParam);
     2198
     2199        case TTM_GETCURRENTTOOLA:
     2200            return TOOLTIPS_GetCurrentToolA (hwnd, wParam, lParam);
     2201
     2202        case TTM_GETCURRENTTOOLW:
     2203            return TOOLTIPS_GetCurrentToolW (hwnd, wParam, lParam);
     2204
     2205        case TTM_GETDELAYTIME:
     2206            return TOOLTIPS_GetDelayTime (hwnd, wParam, lParam);
     2207
     2208        case TTM_GETMARGIN:
     2209            return TOOLTIPS_GetMargin (hwnd, wParam, lParam);
     2210
     2211        case TTM_GETMAXTIPWIDTH:
     2212            return TOOLTIPS_GetMaxTipWidth (hwnd, wParam, lParam);
     2213
     2214        case TTM_GETTEXTA:
     2215            return TOOLTIPS_GetTextA (hwnd, wParam, lParam);
     2216
     2217        case TTM_GETTEXTW:
     2218            return TOOLTIPS_GetTextW (hwnd, wParam, lParam);
     2219
     2220        case TTM_GETTIPBKCOLOR:
     2221            return TOOLTIPS_GetTipBkColor (hwnd, wParam, lParam);
     2222
     2223        case TTM_GETTIPTEXTCOLOR:
     2224            return TOOLTIPS_GetTipTextColor (hwnd, wParam, lParam);
     2225
     2226        case TTM_GETTOOLCOUNT:
     2227            return TOOLTIPS_GetToolCount (hwnd, wParam, lParam);
     2228
     2229        case TTM_GETTOOLINFOA:
     2230            return TOOLTIPS_GetToolInfoA (hwnd, wParam, lParam);
     2231
     2232        case TTM_GETTOOLINFOW:
     2233            return TOOLTIPS_GetToolInfoW (hwnd, wParam, lParam);
     2234
     2235        case TTM_HITTESTA:
     2236            return TOOLTIPS_HitTestA (hwnd, wParam, lParam);
     2237
     2238        case TTM_HITTESTW:
     2239            return TOOLTIPS_HitTestW (hwnd, wParam, lParam);
     2240
     2241        case TTM_NEWTOOLRECTA:
     2242            return TOOLTIPS_NewToolRectA (hwnd, wParam, lParam);
     2243
     2244        case TTM_NEWTOOLRECTW:
     2245            return TOOLTIPS_NewToolRectW (hwnd, wParam, lParam);
     2246
     2247        case TTM_POP:
     2248            return TOOLTIPS_Pop (hwnd, wParam, lParam);
     2249
     2250        case TTM_RELAYEVENT:
     2251            return TOOLTIPS_RelayEvent (hwnd, wParam, lParam);
     2252
     2253        case TTM_SETDELAYTIME:
     2254            return TOOLTIPS_SetDelayTime (hwnd, wParam, lParam);
     2255
     2256        case TTM_SETMARGIN:
     2257            return TOOLTIPS_SetMargin (hwnd, wParam, lParam);
     2258
     2259        case TTM_SETMAXTIPWIDTH:
     2260            return TOOLTIPS_SetMaxTipWidth (hwnd, wParam, lParam);
     2261
     2262        case TTM_SETTIPBKCOLOR:
     2263            return TOOLTIPS_SetTipBkColor (hwnd, wParam, lParam);
     2264
     2265        case TTM_SETTIPTEXTCOLOR:
     2266            return TOOLTIPS_SetTipTextColor (hwnd, wParam, lParam);
     2267
     2268        case TTM_SETTOOLINFOA:
     2269            return TOOLTIPS_SetToolInfoA (hwnd, wParam, lParam);
     2270
     2271        case TTM_SETTOOLINFOW:
     2272            return TOOLTIPS_SetToolInfoW (hwnd, wParam, lParam);
     2273
     2274        case TTM_TRACKACTIVATE:
     2275            return TOOLTIPS_TrackActivate (hwnd, wParam, lParam);
     2276
     2277        case TTM_TRACKPOSITION:
     2278            return TOOLTIPS_TrackPosition (hwnd, wParam, lParam);
     2279
     2280        case TTM_UPDATE:
     2281            return TOOLTIPS_Update (hwnd, wParam, lParam);
     2282
     2283        case TTM_UPDATETIPTEXTA:
     2284            return TOOLTIPS_UpdateTipTextA (hwnd, wParam, lParam);
     2285
     2286        case TTM_UPDATETIPTEXTW:
     2287            return TOOLTIPS_UpdateTipTextW (hwnd, wParam, lParam);
     2288
     2289        case TTM_WINDOWFROMPOINT:
     2290            return TOOLTIPS_WindowFromPoint (hwnd, wParam, lParam);
     2291
     2292
     2293        case WM_CREATE:
     2294            return TOOLTIPS_Create (hwnd, wParam, lParam);
     2295
     2296        case WM_DESTROY:
     2297            return TOOLTIPS_Destroy (hwnd, wParam, lParam);
     2298
     2299        case WM_ERASEBKGND:
     2300            return TOOLTIPS_EraseBackground (hwnd, wParam, lParam);
     2301
     2302        case WM_GETFONT:
     2303            return TOOLTIPS_GetFont (hwnd, wParam, lParam);
    23032304
    23042305        case WM_GETTEXT:
    23052306            return TOOLTIPS_OnWMGetText (hwnd, wParam, lParam);
    2306        
     2307
    23072308        case WM_GETTEXTLENGTH:
    23082309            return TOOLTIPS_OnWMGetTextLength (hwnd, wParam, lParam);
    2309  
    2310 
    2311         case WM_LBUTTONDOWN:
    2312         case WM_LBUTTONUP:
    2313         case WM_MBUTTONDOWN:
    2314         case WM_MBUTTONUP:
    2315         case WM_RBUTTONDOWN:
    2316         case WM_RBUTTONUP:
    2317         case WM_MOUSEMOVE:
    2318             return TOOLTIPS_MouseMessage (hwnd, uMsg, wParam, lParam);
    2319 
    2320         case WM_NCCREATE:
    2321             return TOOLTIPS_NCCreate (hwnd, wParam, lParam);
    2322 
    2323         case WM_NCHITTEST:
    2324             return TOOLTIPS_NCHitTest (hwnd, wParam, lParam);
    2325 
    2326 /*      case WM_NOTIFYFORMAT: */
    2327 /*          return TOOLTIPS_NotifyFormat (hwnd, wParam, lParam); */
    2328 
    2329         case WM_PAINT:
    2330             return TOOLTIPS_Paint (hwnd, wParam, lParam);
    2331 
    2332         case WM_SETFONT:
    2333             return TOOLTIPS_SetFont (hwnd, wParam, lParam);
    2334 
    2335         case WM_TIMER:
    2336             return TOOLTIPS_Timer (hwnd, wParam, lParam);
    2337 
    2338         case WM_WININICHANGE:
    2339             return TOOLTIPS_WinIniChange (hwnd, wParam, lParam);
    2340 
    2341         default:
    2342             if (uMsg >= WM_USER)
    2343 //              ERR (tooltips, "unknown msg %04x wp=%08x lp=%08lx\n",
    2344 //                   uMsg, wParam, lParam);
    2345             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     2310
     2311
     2312        case WM_LBUTTONDOWN:
     2313        case WM_LBUTTONUP:
     2314        case WM_MBUTTONDOWN:
     2315        case WM_MBUTTONUP:
     2316        case WM_RBUTTONDOWN:
     2317        case WM_RBUTTONUP:
     2318        case WM_MOUSEMOVE:
     2319            return TOOLTIPS_MouseMessage (hwnd, uMsg, wParam, lParam);
     2320
     2321        case WM_NCCREATE:
     2322            return TOOLTIPS_NCCreate (hwnd, wParam, lParam);
     2323
     2324        case WM_NCHITTEST:
     2325            return TOOLTIPS_NCHitTest (hwnd, wParam, lParam);
     2326
     2327/*      case WM_NOTIFYFORMAT: */
     2328/*          return TOOLTIPS_NotifyFormat (hwnd, wParam, lParam); */
     2329
     2330        case WM_PAINT:
     2331            return TOOLTIPS_Paint (hwnd, wParam, lParam);
     2332
     2333        case WM_SETFONT:
     2334            return TOOLTIPS_SetFont (hwnd, wParam, lParam);
     2335
     2336        case WM_TIMER:
     2337            return TOOLTIPS_Timer (hwnd, wParam, lParam);
     2338
     2339        case WM_WININICHANGE:
     2340            return TOOLTIPS_WinIniChange (hwnd, wParam, lParam);
     2341
     2342        default:
     2343//            if (uMsg >= WM_USER)
     2344//              ERR (tooltips, "unknown msg %04x wp=%08x lp=%08lx\n",
     2345//                   uMsg, wParam, lParam);
     2346            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
    23462347    }
    23472348    return 0;
    … …  
    23642365    wndClass.hbrBackground = 0;
    23652366    wndClass.lpszClassName = TOOLTIPS_CLASSA;
    2366  
     2367
    23672368    RegisterClassA (&wndClass);
    23682369}
    … …  
    23732374{
    23742375    if (GlobalFindAtomA (TOOLTIPS_CLASSA))
    2375         UnregisterClassA (TOOLTIPS_CLASSA, (HINSTANCE)NULL);
    2376 }
    2377 
     2376        UnregisterClassA (TOOLTIPS_CLASSA, (HINSTANCE)NULL);
     2377}
     2378
Note: See TracChangeset for help on using the changeset viewer.