class CHyperLink
{
public:
   CHyperLink(void);
   virtual ~CHyperLink(void);

   BOOL ConvertStaticToHyperlink(HWND hwndCtl, LPCTSTR strURL);
   BOOL ConvertStaticToHyperlink(HWND hwndParent,
                                 UINT uiCtlId, LPCTSTR strURL);

   BOOL setURL( LPCTSTR strURL);
   LPCTSTR getURL(void) const { return m_strURL; }

protected:
   /*
    * Override if you want to perform some  action when
    * the link has the focus or when the cursor is over
    * the link such as displaying the URL somewhere.
    */
   virtual void OnSelect(void)   {}
   virtual void OnDeselect(void) {}

   LPTSTR   m_strURL;      // hyperlink URL

private:
   // Hyperlink colors
   static COLORREF g_crLinkColor, g_crVisitedColor;
   static HCURSOR  g_hLinkCursor;      // Cursor for hyperlink
   static HFONT    g_UnderlineFont;    // Font for underline display
   static int      g_counter;          // Global resources user
                                       // counter
   BOOL     m_bOverControl;            // cursor over control?
   BOOL     m_bVisited;                // Has it been visited?
   HFONT    m_StdFont;                 // Standard font
   WNDPROC  m_pfnOrigCtlProc;

   void createUnderlineFont(void);
   static void createLinkCursor(void);
   void createGlobalResources(void)
   {
      createUnderlineFont();
      createLinkCursor();
   }
   static void destroyGlobalResources(void)
   {
      /*
       * No need to call DestroyCursor() for cursors
       * acquired through LoadCursor().
       */
      g_hLinkCursor   = NULL;
      DeleteObject(g_UnderlineFont);
      g_UnderlineFont = NULL;
   }

   void Navigate(void);

   static void DrawFocusRect(HWND hwnd);
   static LRESULT CALLBACK _HyperlinkParentProc(HWND hwnd,
                  UINT message, WPARAM wParam, LPARAM lParam);
   static LRESULT CALLBACK _HyperlinkProc(HWND hwnd,
                  UINT message, WPARAM wParam, LPARAM lParam);
};

if( g_counter++ == 0 )
{
   createGlobalResources();
}

if( --CHyperLink::g_counter <= 0 )
{
   destroyGlobalResources();
}

case WM_SETCURSOR:
{
   SetCursor(CHyperLink::g_hLinkCursor);
   return TRUE;
}

inline void CHyperLink::Navigate(void)
{
   SHELLEXECUTEINFO sei;
   ::ZeroMemory(&sei,sizeof(SHELLEXECUTEINFO));
   sei.cbSize = sizeof( SHELLEXECUTEINFO );  // Set Size
   sei.lpVerb = TEXT( "open" );              // Set Verb
   sei.lpFile = m_strURL;                    // Set Target
                                             // To Open
   sei.nShow = SW_SHOWNORMAL;                // Show Normal

   WINXDISPLAY(ShellExecuteEx(&sei));
   m_bVisited = TRUE;
}

case WM_CTLCOLORSTATIC:
{
   HDC hdc = (HDC) wParam;
   HWND hwndCtl = (HWND) lParam;
   CHyperLink *pHyperLink =
      (CHyperLink *)GetProp(hwndCtl, PROP_OBJECT_PTR);

   if(pHyperLink)
   {
      LRESULT lr = CallWindowProc(pfnOrigProc,
                   hwnd, message, wParam, lParam);
      if (!pHyperLink->m_bVisited)
      {
         // This is the most common case for static
         // branch prediction optimization
         SetTextColor(hdc, CHyperLink::g_crLinkColor);
      }
      else
      {
         SetTextColor(hdc, CHyperLink::g_crVisitedColor);
      }
      return lr;
   }
   break;
}

inline void CHyperLink::DrawFocusRect(HWND hwnd)
{
   HWND hwndParent = GetParent(hwnd);

   if( hwndParent )
   {
      // calculate where to draw focus rectangle, in screen
      // coords
      RECT rc;
      GetWindowRect(hwnd, &rc);

      INFLATERECT(&rc,1,1); // add one pixel all around
                            // convert to parent
                            // window client coords
      ::ScreenToClient(hwndParent, (LPPOINT)&rc);
      ::ScreenToClient(hwndParent, ((LPPOINT)&rc)+1);
      HDC dcParent = GetDC(hwndParent);  // parent window’s DC
      ::DrawFocusRect(dcParent, &rc);    // draw it!
      ReleaseDC(hwndParent,dcParent);
   }
}

case WM_KEYUP:
{
   if( wParam != VK_SPACE )
   {
      break;
   }
}

// Fall through
case WM_LBUTTONUP:
{
   pHyperLink->Navigate();
   return 0;
}
case WM_SETFOCUS:    // Fall through
case WM_KILLFOCUS:
{
   if( message == WM_SETFOCUS )
   {
      pHyperLink->OnSelect();
   }
   else    // WM_KILLFOCUS
   {
      pHyperLink->OnDeselect();
   }
   CHyperLink::DrawFocusRect(hwnd);
   return 0;
}

case WM_MOUSEMOVE:
{
   if ( pHyperLink->m_bOverControl )
   {
      // This is the most common case for static branch
      // prediction optimization
      RECT rect;
      GetClientRect(hwnd,&rect);

      POINT pt = { LOWORD(lParam), HIWORD(lParam) };

      if (!PTINRECT(&rect,pt))
      {
         ReleaseCapture();
      }
   }
   else
   {
      pHyperLink->m_bOverControl = TRUE;
      SendMessage(hwnd, WM_SETFONT,
                  (WPARAM)CHyperLink::g_UnderlineFont, FALSE);
      InvalidateRect(hwnd, NULL, FALSE);
      pHyperLink->OnSelect();
      SetCapture(hwnd);
   }
   return 0;
}
case WM_CAPTURECHANGED:
{
   pHyperLink->m_bOverControl = FALSE;
   pHyperLink->OnDeselect();
   SendMessage(hwnd, WM_SETFONT,
      (WPARAM)pHyperLink->m_StdFont, FALSE);
   InvalidateRect(hwnd, NULL, FALSE);
   return 0;
}

/*
 * typedefs
 */
class CGlobalAtom
{
public:
   CGlobalAtom(void)
   { atom = GlobalAddAtom(TEXT("_Hyperlink_Object_Pointer_")
            TEXT("{AFEED740-CC6D-47c5-831D-9848FD916EEF}")); }
   ~CGlobalAtom(void)
   { DeleteAtom(atom); }

   ATOM atom;
};

/*
 * Local variables
 */
static CGlobalAtom ga;

#define PROP_OBJECT_PTR       ((LPCTSTR)(DWORD)ga.atom)
#define PROP_ORIGINAL_PROC    ((LPCTSTR)(DWORD)ga.atom)

class CDemoLink : public CHyperLink
{
protected:
   virtual void OnSelect(void)
   { ((CFrameWnd *)AfxGetMainWnd())->SetMessageText(m_strURL); }
   virtual void OnDeselect(void)
   { ((CFrameWnd *)AfxGetMainWnd())->
      SetMessageText(AFX_IDS_IDLEMESSAGE); }
};

void CAboutDlg::setURL(CHyperLink &ctr, int id)
{
   TCHAR buffer[128];
   int nLen = ::LoadString(AfxGetResourceHandle(),
                           id, buffer, 128);
   if( !nLen )
   {
      lstrcpy( buffer, __TEXT(""));
   }
    ctr.ConvertStaticToHyperlink(GetSafeHwnd(),id,buffer);
}

BOOL CAboutDlg::OnInitDialog()
{
   CDialog::OnInitDialog();

   // TODO: Add extra initialization here
   setURL(m_DemoLink,IDC_HOMEPAGE);
   setURL(m_DemoMail,IDC_EMAIL);

   return TRUE;  // return TRUE unless you set the focus
                 // to a control
                 // EXCEPTION: OCX Property Pages should
                 // return FALSE
}

BOOL CAboutDlgWithToolTipURL::OnInitDialog()
{
   CAboutDlg::OnInitDialog();

   // TODO: Add extra initialization here
   m_ctlTT.Create(this);
   setURL(m_DemoLink,IDC_HOMEPAGE);
   setURL(m_DemoMail,IDC_EMAIL);

   /*
    * It is OK to add a Window tool to the tool tip
    * control with the CHyperLink dynamically allocated
    * URL string because the windows are destroyed with
    * WM_DESTROY before the CHyperLink destructor where
    * the URL string is freed.
    */
   m_ctlTT.AddWindowTool(GetDlgItem(IDC_HOMEPAGE)
      ->GetSafeHwnd(),
      (LPTSTR)m_DemoLink.getURL());
   m_ctlTT.AddWindowTool(GetDlgItem(IDC_EMAIL)->GetSafeHwnd(),
      (LPTSTR)m_DemoMail.getURL());

   return TRUE;  // return TRUE unless you set the focus
                 // to a control
                 // EXCEPTION: OCX Property Pages should
                 // return FALSE
}

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

// Operations
public:
/*********************************************************
 *
 * Name      : AddWindowTool
 *
 * Purpose   : Add a window tool by using the Tooltip
 *             subclass feature
 *
 * Parameters:
 *     hWin    (HWND)    Tool window
 *     pszText (LPCTSTR) Tip text (can also be
 *                       a string resource ID).
 *
 * Return value : Returns TRUE if successful,
 *                or FALSE otherwise.
 *
 *********************************************************/
    BOOL AddWindowTool( HWND hWin, LPTSTR pszText );

// Implementation
public:
   virtual ~CSubclassToolTipCtrl();
};

/*
 * Function CSubclassToolTipCtrl::AddWindowTool
 */
BOOL CSubclassToolTipCtrl::AddWindowTool(
                           HWND hWin, LPTSTR pszText )
{
   TOOLINFO ti;
   ::ZeroMemory(&ti, sizeof(TOOLINFO));
   ti.cbSize   = sizeof(TOOLINFO);
   ti.uFlags   = TTF_IDISHWND 
| TTF_SUBCLASS;

   ti.hwnd     = ::GetParent(hWin);
   ti.uId      = (UINT)hWin;
   ti.hinst    = AfxGetInstanceHandle();
   ti.lpszText = pszText;

   return (BOOL)SendMessage(TTM_ADDTOOL,0,(LPARAM)&ti);
}