Re: Creating Tooltips in MFC ActiveX ctrl using VC6.0

"Ajay" wrote:


Hi Ajay,

Thanks for the response. I looked up AfxEnableTips() and didn't find
anything.

I am using the CTooltipCtrl (well a derivative of it), but it seems to be
lacking in that it doesn't work. :( I was able to find some ancient MS doc
that told me that I would have to make a message handler for each and every
control by deriving a separate class that will have a tooltip associated with
it. That was nuts, so I just made it so that I subclassed each window with a
tooltip. Unfortunatly, I've lost the link to that document.

Almost everything works, however, I couldn't get the TTN_NEEDTEXT to fire.
Can't figure out why. I passed LPSTR_TEXTCALLBACK to the AddTool() member
function, but to no avail. I probably need to do something that isn't
documented, or isn't documented well. :(

Any help would be appreciated.

Here is the source files:

#if !defined(AFX_TOOLTIPS_H__994CD4F8_AB0D_43CD_AAC5_A8BE6CB4C1D8__INCLUDED_)
#define AFX_TOOLTIPS_H__994CD4F8_AB0D_43CD_AAC5_A8BE6CB4C1D8__INCLUDED_

#include <set>

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// ToolTipCtrlEx.h : header file
//

/////////////////////////////////////////////////////////////////////////////
// CToolTipCtrlEx window
#if !defined ULONG_PTR
# define ULONG_PTR DWORD
#endif

/*****************************************************************************
 HOW TO SET TOOLTIP UP
******************************************************************************
1. Add variable CToolTipCtrlEx m_tooltip to a window. Should be one that is
    going to be showing all the time.

2. Setup an WM_CREATE event handler for that window and add this to it:

    int C_Dialog::OnCreate(LPCREATESTRUCT lpCreateStruct)
    {
        if (CDialog::OnCreate(lpCreateStruct) == -1)
            return -1;

        // VVVVVVVVVVVVVVV add between here VVVVVVVVVVVVVVVV

        if (!m_tooltip.Create(this)) {
            TRACE0("Unable to create tip window.");
        }
        else {
            // need to set max tip width to something to allow for multiline tooltips
            m_tooltip.SetMaxTipWidth(800);
            m_tooltip.Activate(true);
        }

        // ^^^^^^^^^^^^^^^^^^ and here ^^^^^^^^^^^^^^^^^^^^
        return 0;
    }

3. Use that tooltip all over your programme. Doesn't seem to have to be a
direct
    decendent of the parent of the tooltip.
******************************************************************************/

class CToolTipCtrlEx : public CToolTipCtrl
{
// Construction
public:
    CToolTipCtrlEx();

// Attributes
public:

// Operations
public:

// Overrides
    // ClassWizard generated virtual function overrides
    //{{AFX_VIRTUAL(CToolTipCtrlEx)
    protected:
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
    //}}AFX_VIRTUAL

// Implementation
public:
    virtual ~CToolTipCtrlEx();

    // Yes this is not virtual, but CToolTipCtrl wasn't designed to be derrived
from. This function is an override, so
    // don't go calling the base class' AddTool function directly or pass this
CToolTipCtrlEx to something that expects
    // a CToolTipCtrl, you'll mess up the memory allocation of text and cause
unpredicable things to happen.
    BOOL AddTool(CWnd* pWnd, LPCTSTR lpszText = LPSTR_TEXTCALLBACK, LPCRECT
lpRectTool = NULL, UINT nIDTool = 0);
    BOOL AddTool(CWnd* pWnd, LPCTSTR lpszEnabledText, LPCTSTR lpszDisabledText,
LPCRECT lpRectTool = NULL, UINT nIDTool = 0);

    // Yes this is not virtual, but CToolTipCtrl wasn't designed to be derrived
from. This function is an override, so
    // don't go calling the base class' UpdateTipText function directly or pass
this CToolTipCtrlEx to something that expects
    // a CToolTipCtrl, you'll mess up the memory allocation of text and cause
unpredicable things to happen.
    void UpdateTipText(LPCTSTR lpszText, CWnd* pWnd, UINT nIDTool = 0);
    void UpdateTipText(LPCTSTR lpszEnabledText, LPCTSTR lpszDisabledText, CWnd*
pWnd, UINT nIDTool = 0);

    void DelTool(CWnd* pWnd, UINT nIDTool = 0);

private:
    // For debugging
    static int count;
    // Last window that was hit
    static HWND lastWindow;
    // Last point in the last window that was hit
    static CPoint lastPoint;

    // Update the tooltips for a window based on if the window is enabled or not
    static void UpdateToolTipText(HWND hwnd);
    // Helper function to update the tooltips
    static BOOL CALLBACK UpdateTextPropEnumProcEx(
        HWND hwnd,
        LPTSTR lpszString,
        HANDLE hData,
        ULONG_PTR dwData
    );

    // Deallocate the tooltip related data for a window
    static void CToolTipCtrlEx::DeallocateToolTipText(HWND hwnd);
    // Helper function to deallocate tooltip related data
    static BOOL CALLBACK DeallocateTextPropEnumProcEx(
        HWND hwnd,
        LPTSTR lpszString,
        HANDLE hData,
        ULONG_PTR dwData
    );

    // Subclass WINPROC window function for a window to have a tooltip
    static LRESULT CALLBACK WindowProc(
        HWND hwnd,
        UINT uMsg,
        WPARAM wParam,
        LPARAM lParam
    );
    // Subclass WINPROC window function for a window's parent to have a tooltip
    static LRESULT CALLBACK ParentWindowProc(
        HWND hwnd,
        UINT uMsg,
        WPARAM wParam,
        LPARAM lParam
    );
    // RelayEvent function
    static void RelayEvent(HWND hwnd, UINT message, WPARAM wParam, LPARAM
lParam);

    // Generated message map functions
protected:
    //{{AFX_MSG(CToolTipCtrlEx)
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    //}}AFX_MSG

    DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately
before the previous line.

#endif //
!defined(AFX_TOOLTIPS_H__994CD4F8_AB0D_43CD_AAC5_A8BE6CB4C1D8__INCLUDED_)

// ToolTipCtrlEx.cpp : implementation file
//

#include "stdafx.h"
#include "ToolTipCtrlEx.h"
#include <windowsx.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CToolTipCtrlEx

static char const * const TT_OLD_WINPROC = TEXT("TT_OldWinProc");
static char const * const TT_OLD_PARENT_WINPROC = TEXT("TT_OldParentWinProc");
static char const * const TT_TOOLTIP = TEXT("TT_ToolTip");
static char const * const TT_ENABLED_TEXT = TEXT("TT_EnabledText_%d");
static char const * const TT_DISABLED_TEXT = TEXT("TT_DisabledText_%d");

CToolTipCtrlEx::CToolTipCtrlEx()
{
}

CToolTipCtrlEx::~CToolTipCtrlEx()
{
}

BOOL CToolTipCtrlEx::AddTool(CWnd* pWnd, LPCTSTR lpszText /*=
LPSTR_TEXTCALLBACK*/, LPCRECT lpRectTool /*= NULL*/, UINT nIDTool /*= 0*/)
{
    long oldWindowProc = (long)::GetProp(pWnd->m_hWnd, TT_OLD_WINPROC);
    if (oldWindowProc == 0) {
        oldWindowProc = ::SetWindowLong(pWnd->m_hWnd, GWL_WNDPROC,
(long)WindowProc);
        TRACE("(0x%08x): Inserted WindowProc (0x%08x) before oldWindowProc
(0x%08x)\n", pWnd->m_hWnd, WindowProc, oldWindowProc);
        ::SetProp(pWnd->m_hWnd, TT_OLD_WINPROC, (HANDLE)oldWindowProc);
        ::SetProp(pWnd->m_hWnd, TT_TOOLTIP, (HANDLE)this);
    }

    HWND hParent = ::GetParent(pWnd->m_hWnd);
    long oldParentWindowProc = (long)::GetProp(hParent, TT_OLD_PARENT_WINPROC);
    if (oldParentWindowProc == 0) {
        oldParentWindowProc = ::SetWindowLong(hParent, GWL_WNDPROC,
(long)ParentWindowProc);
        TRACE("(0x%08x): Inserted ParentWindowProc (0x%08x) before
oldParentWindowProc (0x%08x)\n", hParent, ParentWindowProc,
oldParentWindowProc);
        ::SetProp(hParent, TT_OLD_PARENT_WINPROC, (HANDLE)oldParentWindowProc);

        // An attempt to get the TTN_NEEDTEXT event to be fired. Didn't work. :(
        //CWnd::FromHandle(hParent)->ModifyStyle(0, TBSTYLE_TOOLTIPS);
    }

    int result = CToolTipCtrl::AddTool(pWnd, lpszText, lpRectTool, nIDTool);
    UpdateToolTipText(pWnd->m_hWnd);
    return result;
}

BOOL CToolTipCtrlEx::AddTool(CWnd* pWnd, LPCTSTR lpszEnabledText, LPCTSTR
lpszDisabledText, LPCRECT lpRectTool /*= NULL*/, UINT nIDTool /*= 0*/)
{
    {
        CString id;
        id.Format(TT_ENABLED_TEXT, nIDTool);
        ::SetProp(pWnd->m_hWnd, id, (HANDLE)new CString(lpszEnabledText));
    }

    {
        CString id;
        id.Format(TT_DISABLED_TEXT, nIDTool);
        ::SetProp(pWnd->m_hWnd, id, (HANDLE)new CString(lpszDisabledText));
    }

    // An attempt to get the TTN_NEEDTEXT event to be fired. Didn't work. :(
    //return AddTool(pWnd, LPSTR_TEXTCALLBACK, lpRectTool, nIDTool);
    return AddTool(pWnd, lpszEnabledText, lpRectTool, nIDTool);
}

void CToolTipCtrlEx::UpdateTipText(LPCTSTR lpszText, CWnd* pWnd, UINT
nIDTool /*= 0*/)
{
    CString id;

    id.Format(TT_ENABLED_TEXT, nIDTool);
    delete (CString*)::RemoveProp(pWnd->m_hWnd, id);

    id.Format(TT_DISABLED_TEXT, nIDTool);
    delete (CString*)::RemoveProp(pWnd->m_hWnd, id);

    ((CToolTipCtrlEx*)::GetProp(pWnd->m_hWnd,
TT_TOOLTIP))->CToolTipCtrl::UpdateTipText(lpszText, pWnd, nIDTool);
}

void CToolTipCtrlEx::UpdateTipText(LPCTSTR lpszEnabledText, LPCTSTR
lpszDisabledText, CWnd* pWnd, UINT nIDTool /*= 0*/)
{
    {
        CString id;

        id.Format(TT_ENABLED_TEXT, nIDTool);
        delete (CString*)::RemoveProp(pWnd->m_hWnd, id);
        ::SetProp(pWnd->m_hWnd, id, new CString(lpszEnabledText));

        id.Format(TT_DISABLED_TEXT, nIDTool);
        delete (CString*)::RemoveProp(pWnd->m_hWnd, id);
        ::SetProp(pWnd->m_hWnd, id, new CString(lpszDisabledText));
    }
    UpdateToolTipText(pWnd->m_hWnd);
}

void CToolTipCtrlEx::DelTool(CWnd* pWnd, UINT nIDTool /*= 0*/)
{
    {
        CString id;

        id.Format(TT_ENABLED_TEXT, nIDTool);
        delete (CString*)::RemoveProp(pWnd->m_hWnd, id);

        id.Format(TT_DISABLED_TEXT, nIDTool);
        delete (CString*)::RemoveProp(pWnd->m_hWnd, id);
    }
    if (m_hWnd) {
        CToolTipCtrl::DelTool(pWnd, nIDTool);
    }
}

int CToolTipCtrlEx::count = 0;
HWND CToolTipCtrlEx::lastWindow = 0;
CPoint CToolTipCtrlEx::lastPoint(-1, -1);

BOOL CALLBACK CToolTipCtrlEx::UpdateTextPropEnumProcEx(
    HWND hwnd,
    LPTSTR lpszString,
    HANDLE hData,
    ULONG_PTR dwData
)
{
    CToolTipCtrlEx* pToolTipCtrlEx = (CToolTipCtrlEx*)dwData;
    if ((HIWORD(lpszString)) > 0) { // Not sure why I have to filter this.
Maybe an ATOM?
        if (::IsWindowEnabled(hwnd)) {
            int id = -1;
            ::sscanf(lpszString, TT_ENABLED_TEXT, &id);
            if (id != -1) {
                ((CToolTipCtrl*)pToolTipCtrlEx)->UpdateTipText(*(CString*)::GetProp(hwnd, lpszString), CWnd::FromHandle(hwnd), id);
            }
        }
        else {
            int id = -1;
            ::sscanf(lpszString, TT_DISABLED_TEXT, &id);
            if (id != -1) {
                ((CToolTipCtrl*)pToolTipCtrlEx)->UpdateTipText(*(CString*)::GetProp(hwnd, lpszString), CWnd::FromHandle(hwnd), id);
            }
        }
    }
    return TRUE;
}

void CToolTipCtrlEx::UpdateToolTipText(HWND hwnd)
{
    ::EnumPropsEx(hwnd, UpdateTextPropEnumProcEx,
(LPARAM)(CToolTipCtrlEx*)::GetProp(hwnd, TT_TOOLTIP));
}

BOOL CALLBACK CToolTipCtrlEx::DeallocateTextPropEnumProcEx(
    HWND hwnd,
    LPTSTR lpszString,
    HANDLE hData,
    ULONG_PTR dwData
)
{
    CToolTipCtrlEx* pToolTipCtrlEx = (CToolTipCtrlEx*)dwData;
    if ((HIWORD(lpszString)) > 0) { // Not sure why I have to filter this.
Maybe an ATOM?
        int id = -1;
        ::sscanf(lpszString, TT_ENABLED_TEXT, &id);
        if (id != -1) {
            delete (CString*)::RemoveProp(hwnd, lpszString);
        }
        else {
            ::sscanf(lpszString, TT_DISABLED_TEXT, &id);
            if (id != -1) {
                delete (CString*)::RemoveProp(hwnd, lpszString);
            }
        }
    }
    return TRUE;
}

void CToolTipCtrlEx::DeallocateToolTipText(HWND hwnd)
{
    ::EnumPropsEx(hwnd, DeallocateTextPropEnumProcEx,
(LPARAM)(CToolTipCtrlEx*)::GetProp(hwnd, TT_TOOLTIP));
}

LRESULT CALLBACK CToolTipCtrlEx::WindowProc(
    HWND hwnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
)
{
    WNDPROC oldWindowProc = (WNDPROC)::GetProp(hwnd, TT_OLD_WINPROC);

    switch (uMsg) {
        case WM_LBUTTONDOWN:
        case WM_LBUTTONUP:
        case WM_MOUSEMOVE:
            if (hwnd != ::GetParent(lastWindow)) {
                // If the last window looked at is a child of this one, then don't relay
this one's message to the tooltip
                CPoint point(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
                if (lastWindow != hwnd || lastPoint != point) {
                    TRACE("relay from window %d: %x\n", ++count, uMsg);
                    RelayEvent(hwnd, uMsg, wParam, lParam);
                    lastWindow = hwnd;
                    lastPoint = point;
                }
            }
            break;

        case TTN_NEEDTEXTA:
        case TTN_NEEDTEXTW:
            TRACE("Received a TTN_NEEDTEXT message for window associated with
tooltip.");
            break;

        case WM_ENABLE:
  UpdateToolTipText(hwnd);
            break;

        case WM_NCDESTROY:
            ::RemoveProp(hwnd, TT_OLD_WINPROC);
            ::RemoveProp(hwnd, TT_TOOLTIP);
            DeallocateToolTipText(hwnd);
            {
                WNDPROC windowProc = (WNDPROC)::GetWindowLong(hwnd, GWL_WNDPROC);
                ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG)oldWindowProc);
            }
            break;

        default:
            break;
    }

    return ::CallWindowProc(oldWindowProc, hwnd, uMsg, wParam, lParam);
}

LRESULT CALLBACK CToolTipCtrlEx::ParentWindowProc(
    HWND hwnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
)
{
    WNDPROC oldWindowProc = (WNDPROC)::GetProp(hwnd, TT_OLD_PARENT_WINPROC);

    switch (uMsg) {
        case WM_LBUTTONDOWN:
        case WM_LBUTTONUP:
        case WM_MOUSEMOVE:
            {
                CPoint point(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
                HWND childHwnd = ::ChildWindowFromPoint(hwnd, point);
                if (childHwnd != NULL) {
                    // Remap point to the child window's client area
                    ::ClientToScreen(hwnd, &point);
                    ::ScreenToClient(childHwnd, &point);
                    if (childHwnd != lastWindow || lastPoint != point) {
                        // Relay more messages from this child window to the tooltip only if
cursor haven't moved
                        TRACE("relay from parent %d: %x\n", ++count, uMsg);
                        lastPoint = point;
                        lParam = MAKELPARAM(point.x, point.y);
                        RelayEvent(childHwnd, uMsg, wParam, lParam);
                    }
                }
                lastWindow = childHwnd;
            }
            break;

        case TTN_NEEDTEXTA:
        case TTN_NEEDTEXTW:
            // Can't get these messages to be fired.
            // So now changing TT text when enabled status changes on the control
itself.
            // Would like to know why I can't get the TTN_NEEDTEXT message though.
Looked at all parent windows for it too! :(
            {
                LPNMTTDISPINFO lpnmtdi = (LPNMTTDISPINFO) lParam;
                CString id;
                HWND childHwnd = lpnmtdi->hdr.hwndFrom;
                int nIDTool = lpnmtdi->hdr.idFrom;
                if (::IsWindowEnabled(childHwnd)) {
                    id.Format(TT_ENABLED_TEXT, nIDTool);
                }
                else {
                    id.Format(TT_DISABLED_TEXT, nIDTool);
                }
                CString* pTTText = (CString*)::GetProp(childHwnd, id);
                lpnmtdi->lpszText = (char *)(char const *)*pTTText;
                return 0;
            }
            break;

        case WM_NCDESTROY:
            ::RemoveProp(hwnd, TT_OLD_PARENT_WINPROC);
            {
                WNDPROC windowProc = (WNDPROC)::GetWindowLong(hwnd, GWL_WNDPROC);
                ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG)oldWindowProc);
            }
            break;

        default:
            break;
    }

    return ::CallWindowProc(oldWindowProc, hwnd, uMsg, wParam, lParam);
}

void CToolTipCtrlEx::RelayEvent(HWND hwnd, UINT message, WPARAM wParam,
LPARAM lParam)
{
    CToolTipCtrlEx* pTooltip = (CToolTipCtrlEx*)::GetProp(hwnd, TT_TOOLTIP);
    if (pTooltip != NULL && NULL != pTooltip->m_hWnd) {
        MSG msg;

        msg.hwnd= hwnd;
        msg.message= message;
        msg.wParam= wParam;
        msg.lParam= lParam;
        msg.time= 0;
        msg.pt.x= LOWORD (lParam);
        msg.pt.y= HIWORD (lParam);

        ((CToolTipCtrl*)pTooltip)->RelayEvent(&msg);
    }
}

BEGIN_MESSAGE_MAP(CToolTipCtrlEx, CToolTipCtrl)
    //{{AFX_MSG_MAP(CToolTipCtrlEx)
    ON_WM_CREATE()
    ON_WM_PAINT()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CToolTipCtrlEx message handlers

BOOL CToolTipCtrlEx::PreCreateWindow(CREATESTRUCT& cs)
{
    // TODO: Add your specialized code here and/or call the base class
    return CToolTipCtrl::PreCreateWindow(cs);
}

int CToolTipCtrlEx::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CToolTipCtrl::OnCreate(lpCreateStruct) == -1)
        return -1;

    // TODO: Add your specialized creation code here
    ModifyStyle(0, TTS_NOPREFIX);

    return 0;
}