src/msw/tooltip.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/tooltip.cpp
   3 // Purpose:     wxToolTip class implementation for MSW
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     31.01.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_TOOLTIPS
  27
  28 #include "wx/tooltip.h"
  29
  30 #ifndef WX_PRECOMP
  31     #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
  32     #include "wx/app.h"
  33     #include "wx/control.h"
  34 #endif
  35
  36 #include "wx/tokenzr.h"
  37 #include "wx/msw/private.h"
  38
  39 #ifndef TTTOOLINFO_V1_SIZE
  40     #define TTTOOLINFO_V1_SIZE 0x28
  41 #endif
  42
  43 #ifndef TTF_TRANSPARENT
  44     #define TTF_TRANSPARENT 0x0100
  45 #endif
  46
  47 // VZ: normally, the trick with subclassing the tooltip control and processing
  48 //     TTM_WINDOWFROMPOINT should work but, somehow, it doesn't. I leave the
  49 //     code here for now (but it's not compiled) in case we need it later.
  50 //
  51 //     For now I use an ugly workaround and process TTN_NEEDTEXT directly in
  52 //     radio button wnd proc - fixing TTM_WINDOWFROMPOINT code would be nice
  53 //     because it would then work for all controls, not only radioboxes but for
  54 //     now I don't understand what's wrong with it...
  55 #define wxUSE_TTM_WINDOWFROMPOINT   0
  56
  57 // ----------------------------------------------------------------------------
  58 // global variables
  59 // ----------------------------------------------------------------------------
  60
  61 // the tooltip parent window
  62 WXHWND wxToolTip::ms_hwndTT = (WXHWND)NULL;
  63
  64 // new tooltip maximum width, default value is set on first call to wxToolTip::Add()
  65 int wxToolTip::ms_maxWidth = 0;
  66
  67 #if wxUSE_TTM_WINDOWFROMPOINT
  68
  69 // the tooltip window proc
  70 static WNDPROC gs_wndprocToolTip = (WNDPROC)NULL;
  71
  72 #endif // wxUSE_TTM_WINDOWFROMPOINT
  73
  74 // ----------------------------------------------------------------------------
  75 // private classes
  76 // ----------------------------------------------------------------------------
  77
  78 // a wrapper around TOOLINFO Win32 structure
  79 #ifdef __VISUALC__
  80     #pragma warning( disable : 4097 ) // we inherit from a typedef - so what?
  81 #endif
  82
  83 class wxToolInfo : public TOOLINFO
  84 {
  85 public:
  86     wxToolInfo(HWND hwndOwner, unsigned int id, const wxRect& rc)
  87     {
  88         // initialize all members
  89         ::ZeroMemory(this, sizeof(TOOLINFO));
  90
  91         // the structure TOOLINFO has been extended with a 4 byte field in
  92         // version 4.70 of comctl32.dll and another one in 5.01 but we don't
  93         // use these extended fields so use the old struct size to ensure that
  94         // the tooltips work on old (Windows 95) systems too
  95         cbSize = TTTOOLINFO_V1_SIZE;
  96
  97         hwnd = hwndOwner;
  98
  99         if (rc.IsEmpty())
 100         {
 101             uFlags = TTF_IDISHWND;
 102             uId = (UINT_PTR)hwndOwner;
 103         }
 104         else
 105         {
 106             // this tooltip must be shown only if the mouse hovers a specific rect
 107             // of the hwnd parameter!
 108                     rect.left = rc.GetLeft();
 109                     rect.right = rc.GetRight();
 110                     rect.top = rc.GetTop();
 111                     rect.bottom = rc.GetBottom();
 112
 113             // note that not setting TTF_IDISHWND from the uFlags member means that the
 114             // ti.uId field should not contain the HWND but rather as MSDN says an
 115             // "Application-defined identifier of the tool"; this is used internally by
 116             // Windows to distinguish the different tooltips attached to the same window
 117             uId = id;
 118         }
 119
 120         // we use TTF_TRANSPARENT to fix a problem which arises at least with
 121         // the text controls but may presumably happen with other controls
 122         // which display the tooltip at mouse position: it can start flashing
 123         // then as the control gets "focus lost" events and dismisses the
 124         // tooltip which then reappears because mouse remains hovering over the
 125         // control, see SF patch 1821229
 126         if ( wxApp::GetComCtl32Version() >= 470 )
 127         {
 128             uFlags |= TTF_TRANSPARENT;
 129         }
 130     }
 131 };
 132
 133 #ifdef __VISUALC__
 134     #pragma warning( default : 4097 )
 135 #endif
 136
 137 // ----------------------------------------------------------------------------
 138 // private functions
 139 // ----------------------------------------------------------------------------
 140
 141 // send a message to the tooltip control if it exists
 142 //
 143 // NB: wParam is always 0 for the TTM_XXX messages we use
 144 static inline LRESULT SendTooltipMessage(WXHWND hwnd, UINT msg, void *lParam)
 145 {
 146     return hwnd ? ::SendMessage((HWND)hwnd, msg, 0, (LPARAM)lParam) : 0;
 147 }
 148
 149 // send a message to all existing tooltip controls
 150 static inline void
 151 SendTooltipMessageToAll(WXHWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 152 {
 153     if ( hwnd )
 154         ::SendMessage((HWND)hwnd, msg, wParam, lParam);
 155 }
 156
 157 // ============================================================================
 158 // implementation
 159 // ============================================================================
 160
 161 #if wxUSE_TTM_WINDOWFROMPOINT
 162
 163 // ----------------------------------------------------------------------------
 164 // window proc for our tooltip control
 165 // ----------------------------------------------------------------------------
 166
 167 LRESULT APIENTRY wxToolTipWndProc(HWND hwndTT,
 168                                   UINT msg,
 169                                   WPARAM wParam,
 170                                   LPARAM lParam)
 171 {
 172     if ( msg == TTM_WINDOWFROMPOINT )
 173     {
 174         LPPOINT ppt = (LPPOINT)lParam;
 175
 176         // the window on which event occurred
 177         HWND hwnd = ::WindowFromPoint(*ppt);
 178
 179         OutputDebugString("TTM_WINDOWFROMPOINT: ");
 180         OutputDebugString(wxString::Format("0x%08x => ", hwnd));
 181
 182         // return a HWND corresponding to a wxWindow because only wxWidgets are
 183         // associated with tooltips using TTM_ADDTOOL
 184         wxWindow *win = wxGetWindowFromHWND((WXHWND)hwnd);
 185
 186         if ( win )
 187         {
 188             hwnd = GetHwndOf(win);
 189             OutputDebugString(wxString::Format("0x%08x\r\n", hwnd));
 190
 191 #if 0
 192             // modify the point too!
 193             RECT rect;
 194             GetWindowRect(hwnd, &rect);
 195
 196             ppt->x = (rect.right - rect.left) / 2;
 197             ppt->y = (rect.bottom - rect.top) / 2;
 198 #endif // 0
 199             return (LRESULT)hwnd;
 200         }
 201         else
 202         {
 203             OutputDebugString("no window\r\n");
 204         }
 205     }
 206
 207     return ::CallWindowProc(CASTWNDPROC gs_wndprocToolTip, hwndTT, msg, wParam, lParam);
 208 }
 209
 210 #endif // wxUSE_TTM_WINDOWFROMPOINT
 211
 212 // ----------------------------------------------------------------------------
 213 // static functions
 214 // ----------------------------------------------------------------------------
 215
 216 void wxToolTip::Enable(bool flag)
 217 {
 218     SendTooltipMessageToAll(ms_hwndTT, TTM_ACTIVATE, flag, 0);
 219 }
 220
 221 void wxToolTip::SetDelay(long milliseconds)
 222 {
 223     SendTooltipMessageToAll(ms_hwndTT, TTM_SETDELAYTIME,
 224                             TTDT_INITIAL, milliseconds);
 225 }
 226
 227 void wxToolTip::SetAutoPop(long milliseconds)
 228 {
 229     SendTooltipMessageToAll(ms_hwndTT, TTM_SETDELAYTIME,
 230                             TTDT_AUTOPOP, milliseconds);
 231 }
 232
 233 void wxToolTip::SetReshow(long milliseconds)
 234 {
 235     SendTooltipMessageToAll(ms_hwndTT, TTM_SETDELAYTIME,
 236                             TTDT_RESHOW, milliseconds);
 237 }
 238
 239 void wxToolTip::SetMaxWidth(int width)
 240 {
 241     wxASSERT_MSG( width == -1 || width >= 0, _T("invalid width value") );
 242
 243     ms_maxWidth = width;
 244 }
 245
 246 // ---------------------------------------------------------------------------
 247 // implementation helpers
 248 // ---------------------------------------------------------------------------
 249
 250 // create the tooltip ctrl for our parent frame if it doesn't exist yet
 251 /* static */
 252 WXHWND wxToolTip::GetToolTipCtrl()
 253 {
 254     if ( !ms_hwndTT )
 255     {
 256         WXDWORD exflags = 0;
 257         if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
 258         {
 259             exflags |= WS_EX_LAYOUTRTL;
 260         }
 261
 262         // we want to show the tooltips always (even when the window is not
 263         // active) and we don't want to strip "&"s from them
 264         ms_hwndTT = (WXHWND)::CreateWindowEx(exflags,
 265                                              TOOLTIPS_CLASS,
 266                                              (LPCTSTR)NULL,
 267                                              TTS_ALWAYSTIP | TTS_NOPREFIX,
 268                                              CW_USEDEFAULT, CW_USEDEFAULT,
 269                                              CW_USEDEFAULT, CW_USEDEFAULT,
 270                                              NULL, (HMENU)NULL,
 271                                              wxGetInstance(),
 272                                              NULL);
 273        if ( ms_hwndTT )
 274        {
 275            HWND hwnd = (HWND)ms_hwndTT;
 276            SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
 277                         SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 278
 279 #if wxUSE_TTM_WINDOWFROMPOINT
 280            // subclass the newly created control
 281            gs_wndprocToolTip = wxSetWindowProc(hwnd, wxToolTipWndProc);
 282 #endif // wxUSE_TTM_WINDOWFROMPOINT
 283        }
 284     }
 285
 286     return ms_hwndTT;
 287 }
 288
 289 /* static */
 290 void wxToolTip::RelayEvent(WXMSG *msg)
 291 {
 292     (void)SendTooltipMessage(GetToolTipCtrl(), TTM_RELAYEVENT, msg);
 293 }
 294
 295 // ----------------------------------------------------------------------------
 296 // ctor & dtor
 297 // ----------------------------------------------------------------------------
 298
 299 IMPLEMENT_ABSTRACT_CLASS(wxToolTip, wxObject)
 300
 301 wxToolTip::wxToolTip(const wxString &tip)
 302          : m_text(tip)
 303 {
 304     m_window = NULL;
 305
 306     // make sure m_rect.IsEmpty() == true
 307     m_rect.SetWidth(0);
 308     m_rect.SetHeight(0);
 309
 310     // since m_rect is not valid, m_id is ignored by wxToolInfo ctor...
 311     m_id = 0;
 312 }
 313
 314 wxToolTip::wxToolTip(wxWindow* win, unsigned int id, const wxString &tip, const wxRect& rc)
 315          : m_text(tip), m_rect(rc), m_id(id)
 316 {
 317     m_window = NULL;
 318
 319     SetWindow(win);
 320 }
 321
 322 wxToolTip::~wxToolTip()
 323 {
 324     // the tooltip has to be removed before deleting. Otherwise, if it is visible
 325     // while being deleted, there will be a delay before it goes away.
 326     Remove();
 327 }
 328
 329 // ----------------------------------------------------------------------------
 330 // others
 331 // ----------------------------------------------------------------------------
 332
 333 /* static */
 334 void wxToolTip::Remove(WXHWND hWnd, unsigned int id, const wxRect& rc)
 335 {
 336     wxToolInfo ti((HWND)hWnd, id, rc);
 337
 338     (void)SendTooltipMessage(GetToolTipCtrl(), TTM_DELTOOL, &ti);
 339 }
 340
 341 void wxToolTip::Remove()
 342 {
 343     // remove this tool from the tooltip control
 344     if ( m_window )
 345     {
 346         Remove(m_window->GetHWND(), m_id, m_rect);
 347     }
 348 }
 349
 350 void wxToolTip::Add(WXHWND hWnd)
 351 {
 352     HWND hwnd = (HWND)hWnd;
 353
 354     wxToolInfo ti(hwnd, m_id, m_rect);
 355
 356     // another possibility would be to specify LPSTR_TEXTCALLBACK here as we
 357     // store the tooltip text ourselves anyhow, and provide it in response to
 358     // TTN_NEEDTEXT (sent via WM_NOTIFY), but then we would be limited to 79
 359     // character tooltips as this is the size of the szText buffer in
 360     // NMTTDISPINFO struct -- and setting the tooltip here we can have tooltips
 361     // of any length
 362     ti.hwnd = hwnd;
 363     ti.lpszText = const_cast<wxChar *>(m_text.wx_str());
 364
 365     if ( !SendTooltipMessage(GetToolTipCtrl(), TTM_ADDTOOL, &ti) )
 366     {
 367         wxLogDebug(_T("Failed to create the tooltip '%s'"), m_text.c_str());
 368
 369         return;
 370     }
 371
 372 #ifdef TTM_SETMAXTIPWIDTH
 373     if ( wxApp::GetComCtl32Version() >= 470 )
 374     {
 375         // use TTM_SETMAXTIPWIDTH to make tooltip multiline using the
 376         // extent of its first line as max value
 377         HFONT hfont = (HFONT)
 378             SendTooltipMessage(GetToolTipCtrl(), WM_GETFONT, 0);
 379
 380         if ( !hfont )
 381         {
 382             hfont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
 383             if ( !hfont )
 384             {
 385                 wxLogLastError(wxT("GetStockObject(DEFAULT_GUI_FONT)"));
 386             }
 387         }
 388
 389         MemoryHDC hdc;
 390         if ( !hdc )
 391         {
 392             wxLogLastError(wxT("CreateCompatibleDC(NULL)"));
 393         }
 394
 395         if ( !SelectObject(hdc, hfont) )
 396         {
 397             wxLogLastError(wxT("SelectObject(hfont)"));
 398         }
 399
 400         // find the width of the widest line
 401         int maxWidth = 0;
 402         wxStringTokenizer tokenizer(m_text, _T("\n"));
 403         while ( tokenizer.HasMoreTokens() )
 404         {
 405             const wxString token = tokenizer.GetNextToken();
 406
 407             SIZE sz;
 408             if ( !::GetTextExtentPoint32(hdc, token.wx_str(),
 409                                          token.length(), &sz) )
 410             {
 411                 wxLogLastError(wxT("GetTextExtentPoint32"));
 412             }
 413
 414             if ( sz.cx > maxWidth )
 415                 maxWidth = sz.cx;
 416         }
 417
 418         // limit size to ms_maxWidth, if set
 419         if ( ms_maxWidth == 0 )
 420         {
 421             // this is more or less arbitrary but seems to work well
 422             static const int DEFAULT_MAX_WIDTH = 400;
 423
 424             ms_maxWidth = wxGetClientDisplayRect().width / 2;
 425
 426             if ( ms_maxWidth > DEFAULT_MAX_WIDTH )
 427                 ms_maxWidth = DEFAULT_MAX_WIDTH;
 428         }
 429
 430         if ( ms_maxWidth != -1 && maxWidth > ms_maxWidth )
 431             maxWidth = ms_maxWidth;
 432
 433         // only set a new width if it is bigger than the current setting:
 434         // otherwise adding a tooltip with shorter line(s) than a previous
 435         // one would result in breaking the longer lines unnecessarily as
 436         // all our tooltips share the same maximal width
 437         if ( maxWidth > SendTooltipMessage(GetToolTipCtrl(),
 438                                            TTM_GETMAXTIPWIDTH, 0) )
 439         {
 440             SendTooltipMessage(GetToolTipCtrl(), TTM_SETMAXTIPWIDTH,
 441                                wxUIntToPtr(maxWidth));
 442         }
 443     }
 444     else
 445 #endif // TTM_SETMAXTIPWIDTH
 446     {
 447         // replace the '\n's with spaces because otherwise they appear as
 448         // unprintable characters in the tooltip string
 449         m_text.Replace(_T("\n"), _T(" "));
 450         ti.lpszText = const_cast<wxChar *>(m_text.wx_str());
 451
 452         if ( !SendTooltipMessage(GetToolTipCtrl(), TTM_ADDTOOL, &ti) )
 453         {
 454             wxLogDebug(_T("Failed to create the tooltip '%s'"), m_text.c_str());
 455         }
 456     }
 457 }
 458
 459 void wxToolTip::SetWindow(wxWindow *win)
 460 {
 461     Remove();
 462
 463     m_window = win;
 464
 465     // add the window itself
 466     if ( m_window )
 467     {
 468         Add(m_window->GetHWND());
 469     }
 470 #if !defined(__WXUNIVERSAL__)
 471     // and all of its subcontrols (e.g. radio buttons in a radiobox) as well
 472     wxControl *control = wxDynamicCast(m_window, wxControl);
 473     if ( control )
 474     {
 475         const wxArrayLong& subcontrols = control->GetSubcontrols();
 476         size_t count = subcontrols.GetCount();
 477         for ( size_t n = 0; n < count; n++ )
 478         {
 479             int id = subcontrols[n];
 480             HWND hwnd = GetDlgItem(GetHwndOf(m_window), id);
 481             if ( !hwnd )
 482             {
 483                 // may be it's a child of parent of the control, in fact?
 484                 // (radiobuttons are subcontrols, i.e. children of the radiobox
 485                 // for wxWidgets but are its siblings at Windows level)
 486                 hwnd = GetDlgItem(GetHwndOf(m_window->GetParent()), id);
 487             }
 488
 489             // must have it by now!
 490             wxASSERT_MSG( hwnd, _T("no hwnd for subcontrol?") );
 491
 492             Add((WXHWND)hwnd);
 493         }
 494     }
 495 #endif // !defined(__WXUNIVERSAL__)
 496 }
 497
 498 void wxToolTip::SetRect(const wxRect& rc)
 499 {
 500     m_rect = rc;
 501
 502     if ( m_window )
 503     {
 504         wxToolInfo ti(GetHwndOf(m_window), m_id, m_rect);
 505         (void)SendTooltipMessage(GetToolTipCtrl(), TTM_NEWTOOLRECT, &ti);
 506     }
 507 }
 508
 509 void wxToolTip::SetTip(const wxString& tip)
 510 {
 511     m_text = tip;
 512
 513     if ( m_window )
 514     {
 515         // update the tip text shown by the control
 516         wxToolInfo ti(GetHwndOf(m_window), m_id, m_rect);
 517
 518         // for some reason, changing the tooltip text directly results in
 519         // repaint of the controls under it, see #10520 -- but this doesn't
 520         // happen if we reset it first
 521         ti.lpszText = const_cast<wxChar *>(_T(""));
 522         (void)SendTooltipMessage(GetToolTipCtrl(), TTM_UPDATETIPTEXT, &ti);
 523
 524         ti.lpszText = const_cast<wxChar *>(m_text.wx_str());
 525         (void)SendTooltipMessage(GetToolTipCtrl(), TTM_UPDATETIPTEXT, &ti);
 526     }
 527 }
 528
 529 #endif // wxUSE_TOOLTIPS