Ignore:
Timestamp:
Jun 28, 1999, 5:46:28 PM (26 years ago)
Author:
cbratschi
Message:

bug fixes (unicode) and improvements

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/tooltips.c

    r219 r236  
    1 /* $Id: tooltips.c,v 1.7 1999-06-26 14:20:31 cbratschi Exp $ */
     1/* $Id: tooltips.c,v 1.8 1999-06-28 15:46:27 cbratschi Exp $ */
    22/*
    33 * Tool tip control
    … …  
    2929#include "comctl32.h"
    3030
    31 
    3231#define ID_TIMERSHOW   1    /* show delay timer */
    3332#define ID_TIMERPOP    2    /* auto pop timer */
    … …  
    4140
    4241#define TOOLTIPS_GetInfoPtr(hWindow) ((TOOLTIPS_INFO *)GetWindowLongA (hWindow, 0))
    43 
    4442
    4543LRESULT CALLBACK
    … …  
    119117        } else if (ttnmdi.szText[0])
    120118        {
    121           lstrcpynAtoW (infoPtr->szTipText,ttnmdi.szText,80);
     119          lstrcpynAtoW(infoPtr->szTipText,ttnmdi.szText,MIN(INFOTIPSIZE-1,lstrlenA(ttnmdi.szText)));
    122120          if (ttnmdi.uFlags & TTF_DI_SETITEM)
    123121          {
    … …  
    130128        {
    131129          /* no text available */
    132           infoPtr->szTipText[0] = L'\0';
     130          infoPtr->szTipText[0] = '\0';
    133131        } else if (ttnmdi.lpszText != LPSTR_TEXTCALLBACKA)
    134132        {
    135           lstrcpynAtoW(infoPtr->szTipText,ttnmdi.lpszText,INFOTIPSIZE);
     133          lstrcpynAtoW(infoPtr->szTipText,ttnmdi.lpszText,MIN(INFOTIPSIZE-1,lstrlenA(ttnmdi.lpszText)));
    136134          if (ttnmdi.uFlags & TTF_DI_SETITEM)
    137135          {
    … …  
    149147      {
    150148        /* the item is a usual (unicode) text */
    151       lstrcpynW (infoPtr->szTipText,toolPtr->lpszText,INFOTIPSIZE);
     149        lstrcpynW(infoPtr->szTipText,toolPtr->lpszText,MIN(INFOTIPSIZE-1,lstrlenW(toolPtr->lpszText)));
    152150      }
    153151    }
    … …  
    155153    {
    156154      /* no text available */
    157       infoPtr->szTipText[0] = L'\0';
     155      infoPtr->szTipText[0] = '\0';
    158156    }
    159157
    … …  
    206204
    207205//    TRACE (tooltips, "Show tooltip pre %d!\n", infoPtr->nTool);
    208 
    209206    TOOLTIPS_GetTipText(hwnd,infoPtr,infoPtr->nCurrentTool);
    210207
    211     if (infoPtr->szTipText[0] == L'\0')
     208    if (infoPtr->szTipText[0] == '\0')
    212209    {
    213210        infoPtr->nCurrentTool = -1;
    … …  
    316313    TOOLTIPS_GetTipText(hwnd,infoPtr,infoPtr->nTrackTool);
    317314
    318     if (infoPtr->szTipText[0] == L'\0')
     315    if (infoPtr->szTipText[0] == '\0')
    319316    {
    320317      infoPtr->nTrackTool = -1;
    … …  
    558555TOOLTIPS_Activate (HWND hwnd, WPARAM wParam, LPARAM lParam)
    559556{
    560     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
     557    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
    561558
    562559    infoPtr->bActive = (BOOL)wParam;
    … …  
    572569
    573570
    574 static LRESULT
    575 TOOLTIPS_AddToolA(HWND hwnd,WPARAM wParam,LPARAM lParam)
    576 {
    577     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
    578     LPTTTOOLINFOA lpToolInfo = (LPTTTOOLINFOA)lParam;
    579     TTTOOL_INFO *toolPtr;
    580 
    581     if (lpToolInfo == NULL) return FALSE;
    582     if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA) return FALSE;
    583 
    584 //    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
    585 //         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
    586 //         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
    587 
    588     if (infoPtr->uNumTools == 0)
    589     {
    590       infoPtr->tools = COMCTL32_Alloc(sizeof(TTTOOL_INFO));
    591       toolPtr = infoPtr->tools;
    592     } else
    593     {
    594       TTTOOL_INFO *oldTools = infoPtr->tools;
    595 
    596       //CB: check if already exists!
    597 
    598       infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO)*(infoPtr->uNumTools+1));
    599       memcpy (infoPtr->tools,oldTools,infoPtr->uNumTools*sizeof(TTTOOL_INFO));
    600       COMCTL32_Free(oldTools);
    601       toolPtr = &infoPtr->tools[infoPtr->uNumTools];
    602     }
    603 
    604     infoPtr->uNumTools++;
    605 
    606     /* copy tool data */
    607     toolPtr->uFlags = lpToolInfo->uFlags;
    608     toolPtr->hwnd   = lpToolInfo->hwnd;
    609     toolPtr->uId    = lpToolInfo->uId;
    610     toolPtr->rect   = lpToolInfo->rect;
    611     toolPtr->hinst  = lpToolInfo->hinst;
    612 
    613     if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0))
    614     {
    615 //    TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
    616       toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
    617     } else if (lpToolInfo->lpszText)
    618     {
    619       if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
    620       {
    621 //      TRACE (tooltips, "add CALLBACK!\n");
    622         toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
    623       } else
    624       {
    625         INT len = lstrlenA (lpToolInfo->lpszText);
    626 //          TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
    627         toolPtr->lpszText = COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    628         lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
    629       }
    630     } else toolPtr->lpszText = NULL;
    631 
    632     if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
    633         toolPtr->lParam = lpToolInfo->lParam;
    634 
    635     /* install subclassing hook */
     571static VOID TOOLTIPS_Subclass(HWND hwnd,TTTOOL_INFO *toolPtr)
     572{
    636573    if (toolPtr->uFlags & TTF_SUBCLASS)
    637574    {
    … …  
    669606//      TRACE (tooltips, "subclassing installed!\n");
    670607    }
    671 
    672     return TRUE;
    673 }
    674 
    675 
    676 static LRESULT
    677 TOOLTIPS_AddToolW (HWND hwnd, WPARAM wParam, LPARAM lParam)
    678 {
    679     TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
    680     LPTTTOOLINFOW lpToolInfo = (LPTTTOOLINFOW)lParam;
     608}
     609
     610static VOID TOOLTIPS_Desubclass(TTTOOL_INFO *toolPtr)
     611{
     612    if (toolPtr->uFlags & TTF_SUBCLASS)
     613    {
     614      if (toolPtr->uFlags & TTF_IDISHWND)
     615      {
     616        LPTT_SUBCLASS_INFO lpttsi =
     617            (LPTT_SUBCLASS_INFO)GetPropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
     618        if (lpttsi)
     619        {
     620          SetWindowLongA ((HWND)toolPtr->uId,GWL_WNDPROC,(LONG)lpttsi->wpOrigProc);
     621          RemovePropA ((HWND)toolPtr->uId,COMCTL32_aSubclass);
     622          COMCTL32_Free(&lpttsi);
     623        }
     624//          else
     625//              ERR (tooltips, "Invalid data handle!\n");
     626      } else
     627      {
     628        LPTT_SUBCLASS_INFO lpttsi =
     629            (LPTT_SUBCLASS_INFO)GetPropA(toolPtr->hwnd,COMCTL32_aSubclass);
     630        if (lpttsi)
     631        {
     632          if (lpttsi->uRefCount == 1)
     633          {
     634            SetWindowLongA((HWND)toolPtr->uId,GWL_WNDPROC,(LONG)lpttsi->wpOrigProc);
     635            RemovePropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
     636            COMCTL32_Free(&lpttsi);
     637          } else lpttsi->uRefCount--;
     638        }
     639//          else
     640//              ERR (tooltips, "Invalid data handle!\n");
     641      }
     642    }
     643}
     644
     645static LRESULT
     646TOOLTIPS_AddToolA(HWND hwnd,WPARAM wParam,LPARAM lParam)
     647{
     648    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr(hwnd);
     649    LPTTTOOLINFOA lpToolInfo = (LPTTTOOLINFOA)lParam;
    681650    TTTOOL_INFO *toolPtr;
    682651
    683     if (lpToolInfo == NULL)
    684         return FALSE;
    685     if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
    686         return FALSE;
     652    if (lpToolInfo == NULL) return FALSE;
     653    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEA) return FALSE;
    687654
    688655//    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
    … …  
    690657//         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
    691658
    692     if (infoPtr->uNumTools == 0) {
    693         infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO));
    694         toolPtr = infoPtr->tools;
    695     }
    696     else {
    697         TTTOOL_INFO *oldTools = infoPtr->tools;
    698         infoPtr->tools =
    699             COMCTL32_Alloc (sizeof(TTTOOL_INFO) * (infoPtr->uNumTools + 1));
    700         memcpy (infoPtr->tools, oldTools,
    701                 infoPtr->uNumTools * sizeof(TTTOOL_INFO));
    702         COMCTL32_Free (oldTools);
     659    if (infoPtr->uNumTools == 0)
     660    {
     661      infoPtr->tools = COMCTL32_Alloc(sizeof(TTTOOL_INFO));
     662      toolPtr = infoPtr->tools;
     663    } else
     664    {
     665      TTTOOL_INFO *oldTools = infoPtr->tools;
     666      INT x;
     667
     668      toolPtr = NULL;
     669
     670      //check if toolinfo already exists
     671      for (x = 0;x < infoPtr->uNumTools;x++)
     672      {
     673        if (lpToolInfo->hwnd == infoPtr->tools[x].hwnd && lpToolInfo->uId == infoPtr->tools[x].uId)
     674        {
     675          //return toolPtr
     676          toolPtr = &infoPtr->tools[x];
     677          //free allocated memory
     678          TOOLTIPS_Desubclass(toolPtr);
     679          if ((toolPtr->hinst) && (toolPtr->lpszText))
     680          {
     681            if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(toolPtr->lpszText);
     682          }
     683
     684          break;
     685        }
     686      }
     687
     688      if (toolPtr == NULL)
     689      {
     690        infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO)*(infoPtr->uNumTools+1));
     691        memcpy(infoPtr->tools,oldTools,infoPtr->uNumTools*sizeof(TTTOOL_INFO));
     692        COMCTL32_Free(oldTools);
    703693        toolPtr = &infoPtr->tools[infoPtr->uNumTools];
     694      }
     695    }
     696
     697    infoPtr->uNumTools++;
     698
     699    /* copy tool data */
     700    toolPtr->uFlags = lpToolInfo->uFlags;
     701    toolPtr->hwnd   = lpToolInfo->hwnd;
     702    toolPtr->uId    = lpToolInfo->uId;
     703    toolPtr->rect   = lpToolInfo->rect;
     704    toolPtr->hinst  = lpToolInfo->hinst;
     705
     706    if ((lpToolInfo->hinst) && (HIWORD((INT)lpToolInfo->lpszText) == 0))
     707    {
     708//    TRACE (tooltips, "add string id %x!\n", (int)lpToolInfo->lpszText);
     709      toolPtr->lpszText = (LPWSTR)lpToolInfo->lpszText;
     710    } else if (lpToolInfo->lpszText)
     711    {
     712      if (lpToolInfo->lpszText == LPSTR_TEXTCALLBACKA)
     713      {
     714//      TRACE (tooltips, "add CALLBACK!\n");
     715        toolPtr->lpszText = LPSTR_TEXTCALLBACKW;
     716      } else
     717      {
     718        INT len = lstrlenA (lpToolInfo->lpszText);
     719//          TRACE (tooltips, "add text \"%s\"!\n", lpToolInfo->lpszText);
     720        toolPtr->lpszText = COMCTL32_Alloc((len+1)*sizeof(WCHAR));
     721        lstrcpyAtoW (toolPtr->lpszText, lpToolInfo->lpszText);
     722      }
     723    } else toolPtr->lpszText = NULL;
     724
     725    if (lpToolInfo->cbSize >= sizeof(TTTOOLINFOA))
     726        toolPtr->lParam = lpToolInfo->lParam;
     727
     728    /* install subclassing hook */
     729    TOOLTIPS_Subclass(hwnd,toolPtr);
     730
     731    return TRUE;
     732}
     733
     734
     735static LRESULT
     736TOOLTIPS_AddToolW (HWND hwnd, WPARAM wParam, LPARAM lParam)
     737{
     738    TOOLTIPS_INFO *infoPtr = TOOLTIPS_GetInfoPtr (hwnd);
     739    LPTTTOOLINFOW lpToolInfo = (LPTTTOOLINFOW)lParam;
     740    TTTOOL_INFO *toolPtr;
     741
     742    if (lpToolInfo == NULL)
     743        return FALSE;
     744    if (lpToolInfo->cbSize < TTTOOLINFO_V1_SIZEW)
     745        return FALSE;
     746
     747//    TRACE (tooltips, "add tool (%x) %x %d%s!\n",
     748//         hwnd, lpToolInfo->hwnd, lpToolInfo->uId,
     749//         (lpToolInfo->uFlags & TTF_IDISHWND) ? " TTF_IDISHWND" : "");
     750
     751    if (infoPtr->uNumTools == 0)
     752    {
     753      infoPtr->tools = COMCTL32_Alloc (sizeof(TTTOOL_INFO));
     754      toolPtr = infoPtr->tools;
     755    } else
     756    {
     757      TTTOOL_INFO *oldTools = infoPtr->tools;
     758      INT x;
     759
     760      toolPtr = NULL;
     761
     762      //check if toolinfo already exists
     763      for (x = 0;x < infoPtr->uNumTools;x++)
     764      {
     765        if (lpToolInfo->hwnd == infoPtr->tools[x].hwnd && lpToolInfo->uId == infoPtr->tools[x].uId)
     766        {
     767          //return toolPtr
     768          toolPtr = &infoPtr->tools[x];
     769          //free allocated memory
     770          TOOLTIPS_Desubclass(toolPtr);
     771          if ((toolPtr->hinst) && (toolPtr->lpszText))
     772          {
     773            if (toolPtr->lpszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(toolPtr->lpszText);
     774          }
     775
     776          break;
     777        }
     778      }
     779
     780      if (toolPtr == NULL)
     781      {
     782        infoPtr->tools = COMCTL32_Alloc(sizeof(TTTOOL_INFO)*(infoPtr->uNumTools+1));
     783        memcpy (infoPtr->tools,oldTools,infoPtr->uNumTools*sizeof(TTTOOL_INFO));
     784        COMCTL32_Free(oldTools);
     785        toolPtr = &infoPtr->tools[infoPtr->uNumTools];
     786      }
    704787    }
    705788
    … …  
    735818
    736819    /* install subclassing hook */
    737     if (toolPtr->uFlags & TTF_SUBCLASS) {
    738         if (toolPtr->uFlags & TTF_IDISHWND) {
    739             LPTT_SUBCLASS_INFO lpttsi =
    740                 (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    741             if (lpttsi == NULL) {
    742                 lpttsi =
    743                     (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
    744                 lpttsi->wpOrigProc =
    745                     (WNDPROC)SetWindowLongA ((HWND)toolPtr->uId,
    746                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    747                 lpttsi->hwndToolTip = hwnd;
    748                 lpttsi->uRefCount++;
    749                 SetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass,
    750                             (HANDLE)lpttsi);
    751             }
    752 //          else
    753 //              WARN (tooltips, "A window tool must only be listed once!\n");
    754         }
    755         else {
    756             LPTT_SUBCLASS_INFO lpttsi =
    757                 (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    758             if (lpttsi == NULL) {
    759                 lpttsi =
    760                     (LPTT_SUBCLASS_INFO)COMCTL32_Alloc (sizeof(TT_SUBCLASS_INFO));
    761                 lpttsi->wpOrigProc =
    762                     (WNDPROC)SetWindowLongA (toolPtr->hwnd,
    763                     GWL_WNDPROC,(LONG)TOOLTIPS_SubclassProc);
    764                 lpttsi->hwndToolTip = hwnd;
    765                 lpttsi->uRefCount++;
    766                 SetPropA (toolPtr->hwnd, COMCTL32_aSubclass, (HANDLE)lpttsi);
    767             }
    768             else
    769                 lpttsi->uRefCount++;
    770         }
    771 //      TRACE (tooltips, "subclassing installed!\n");
    772     }
     820    TOOLTIPS_Subclass(hwnd,toolPtr);
    773821
    774822    return TRUE;
    … …  
    804852
    805853    /* remove subclassing */
    806     if (toolPtr->uFlags & TTF_SUBCLASS) {
    807         if (toolPtr->uFlags & TTF_IDISHWND) {
    808             LPTT_SUBCLASS_INFO lpttsi =
    809                 (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    810             if (lpttsi) {
    811                 SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    812                                   (LONG)lpttsi->wpOrigProc);
    813                 RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    814                 COMCTL32_Free (&lpttsi);
    815             }
    816 //          else
    817 //              ERR (tooltips, "Invalid data handle!\n");
    818         }
    819         else {
    820             LPTT_SUBCLASS_INFO lpttsi =
    821                 (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    822             if (lpttsi) {
    823                 if (lpttsi->uRefCount == 1) {
    824                     SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    825                                       (LONG)lpttsi->wpOrigProc);
    826                     RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    827                     COMCTL32_Free (&lpttsi);
    828                 }
    829                 else
    830                     lpttsi->uRefCount--;
    831             }
    832 //          else
    833 //              ERR (tooltips, "Invalid data handle!\n");
    834         }
    835     }
     854    TOOLTIPS_Desubclass(toolPtr);
    836855
    837856    /* delete tool from tool list */
    … …  
    890909
    891910    /* remove subclassing */
    892     if (toolPtr->uFlags & TTF_SUBCLASS) {
    893         if (toolPtr->uFlags & TTF_IDISHWND) {
    894             LPTT_SUBCLASS_INFO lpttsi =
    895                 (LPTT_SUBCLASS_INFO)GetPropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    896             if (lpttsi) {
    897                 SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    898                                   (LONG)lpttsi->wpOrigProc);
    899                 RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    900                 COMCTL32_Free (&lpttsi);
    901             }
    902 //          else
    903 //              ERR (tooltips, "Invalid data handle!\n");
    904         }
    905         else {
    906             LPTT_SUBCLASS_INFO lpttsi =
    907                 (LPTT_SUBCLASS_INFO)GetPropA (toolPtr->hwnd, COMCTL32_aSubclass);
    908             if (lpttsi) {
    909                 if (lpttsi->uRefCount == 1) {
    910                     SetWindowLongA ((HWND)toolPtr->uId, GWL_WNDPROC,
    911                                       (LONG)lpttsi->wpOrigProc);
    912                     RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    913                     COMCTL32_Free (&lpttsi);
    914                 }
    915                 else
    916                     lpttsi->uRefCount--;
    917             }
    918 //          else
    919 //              ERR (tooltips, "Invalid data handle!\n");
    920         }
    921     }
     911    TOOLTIPS_Desubclass(toolPtr);
    922912
    923913    /* delete tool from tool list */
    … …  
    14431433//          TRACE (tooltips, "WM_MOUSEMOVE (%04x %ld %ld)\n",
    14441434//                 hwnd, pt.x, pt.y);
    1445 infoPtr->bActive = TRUE;//CB: somewhere reset, find it!!!
     1435
    14461436            if (infoPtr->bActive && (infoPtr->nTool != infoPtr->nOldTool))
    14471437            {
    … …  
    18551845
    18561846    /* initialize info structure */
     1847    infoPtr->szTipText[0] = '\0';
    18571848    infoPtr->bActive = TRUE;
    18581849    infoPtr->bTrackActive = FALSE;
    18591850    infoPtr->clrBk   = GetSysColor(COLOR_INFOBK);
    18601851    infoPtr->clrText = GetSysColor(COLOR_INFOTEXT);
     1852    infoPtr->xTrackPos = 0;
     1853    infoPtr->yTrackPos = 0;
    18611854
    18621855    nclm.cbSize = sizeof(NONCLIENTMETRICSA);
    … …  
    19101903
    19111904        /* remove subclassing */
    1912         if (toolPtr->uFlags & TTF_SUBCLASS)
    1913         {
    1914           LPTT_SUBCLASS_INFO lpttsi;
    1915 
    1916           if (toolPtr->uFlags & TTF_IDISHWND)
    1917               lpttsi = (LPTT_SUBCLASS_INFO)GetPropA((HWND)toolPtr->uId,COMCTL32_aSubclass);
    1918           else
    1919               lpttsi = (LPTT_SUBCLASS_INFO)GetPropA(toolPtr->hwnd,COMCTL32_aSubclass);
    1920 
    1921           if (lpttsi)
    1922           {
    1923             SetWindowLongA ((HWND)toolPtr->uId,GWL_WNDPROC,(LONG)lpttsi->wpOrigProc);
    1924             RemovePropA ((HWND)toolPtr->uId, COMCTL32_aSubclass);
    1925             COMCTL32_Free (&lpttsi);
    1926           }
    1927         }
     1905        TOOLTIPS_Desubclass(toolPtr);
     1906
    19281907      }
    19291908      COMCTL32_Free (infoPtr->tools);
    … …  
    20792058    if(wParam < length)
    20802059    {
    2081         lstrcpynWtoA((LPSTR)lParam, infoPtr->szTipText,(UINT)wParam);
     2060        lstrcpynWtoA((LPSTR)lParam,infoPtr->szTipText,MIN((UINT)wParam,lstrlenW(infoPtr->szTipText)));
    20822061        return wParam;
    20832062    }
    2084     lstrcpyWtoA((LPSTR)lParam, infoPtr->szTipText);
     2063    lstrcpyWtoA((LPSTR)lParam,infoPtr->szTipText);
    20852064    return length;
    20862065
    … …  
    20932072
    20942073//    TRACE (tooltips, "timer %d (%x) expired!\n", wParam, hwnd);
    2095 
    20962074    switch (wParam)
    20972075    {
    20982076      case ID_TIMERSHOW:
    2099           KillTimer (hwnd,ID_TIMERSHOW);
     2077          KillTimer(hwnd,ID_TIMERSHOW);
    21002078          if (TOOLTIPS_CheckTool(hwnd,TRUE) == infoPtr->nTool)
    21012079              TOOLTIPS_Show(hwnd,infoPtr);
    … …  
    21162094          break;
    21172095    }
     2096
    21182097    return 0;
    21192098}
Note: See TracChangeset for help on using the changeset viewer.