root/trunk/GUIComponents/XHyperLink.cpp

// XHyperLink.cpp  Version 1.0
//
// XHyperLink static control. Will open the default browser with the given URL
// when the user clicks on the link.
//
// Copyright (C) 1997 - 1999 Chris Maunder
// All rights reserved. May not be sold for profit.
//
// Thanks to Pål K. Tønder for auto-size and window caption changes.
//
// "GotoURL" function by Stuart Patterson
// As seen in the August, 1997 Windows Developer's Journal.
// Copyright 1997 by Miller Freeman, Inc. All rights reserved.
// Modified by Chris Maunder to use TCHARs instead of chars.
//
// "Default hand cursor" from Paul DiLascia's Jan 1998 MSJ article.
//
// 2/29/00 -- P. Shaffer standard font mod.
//
///////////////////////////////////////////////////////////////////////////////
//
// Modified by:  Hans Dietrich
//               hdietrich2@hotmail.com
//
///////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "XHyperLink.h"
#include "atlconv.h"        // for Unicode conversion

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

#define TOOLTIP_ID 1

// Uncomment following line to enable error message box for URL navigation
//#define XHYPERLINK_REPORT_ERROR


#ifndef IDC_HAND
#define IDC_HAND MAKEINTRESOURCE(32649)   // From WINUSER.H
#endif

// sends message to parent when hyperlink is clicked (see SetNotifyParent())
UINT WM_XHYPERLINK_CLICKED = ::RegisterWindowMessage(_T("WM_XHYPERLINK_CLICKED"));

///////////////////////////////////////////////////////////////////////////////
// CXHyperLink

BEGIN_MESSAGE_MAP(CXHyperLink, CStatic)
    //{{AFX_MSG_MAP(CXHyperLink)
    ON_WM_CTLCOLOR_REFLECT()
    ON_WM_SETCURSOR()
    ON_WM_MOUSEMOVE()
    ON_WM_TIMER()
    ON_CONTROL_REFLECT(STN_CLICKED, OnClicked)
    ON_WM_ERASEBKGND()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

///////////////////////////////////////////////////////////////////////////////
// ctor
CXHyperLink::CXHyperLink()
{
    m_hLinkCursor     = NULL;           // No cursor as yet
    m_crLinkColour    = RGB(0,0,238);   // Blue
    m_crVisitedColour = RGB(85,26,139); // Purple
    m_crHoverColour   = RGB(255,0,0);   // Red
    m_bOverControl    = FALSE;          // Cursor not yet over control
    m_bVisited        = FALSE;          // Hasn't been visited yet.
    m_nUnderline      = ulHover;        // Underline the link?
    m_bAdjustToFit    = TRUE;           // Resize the window to fit the text?
    m_strURL          = _T("");
    m_nTimerID        = 100;
    m_bNotifyParent   = FALSE;          // TRUE = notify parent
    m_bIsURLEnabled   = TRUE;           // TRUE = navigate to url
    m_bToolTip        = TRUE;           // TRUE = display tooltip
    m_crBackground    = (UINT) -1;      // set to default (no bg color)
    m_bAlwaysOpenNew  = FALSE;          // TRUE = always open new browser window
}

///////////////////////////////////////////////////////////////////////////////
// dtor
CXHyperLink::~CXHyperLink()
{
    TRACE(_T("in CXHyperLink::~CXHyperLink\n"));

    if (m_hLinkCursor)
        DestroyCursor(m_hLinkCursor);
    m_hLinkCursor = NULL;
    m_UnderlineFont.DeleteObject();
    if (m_Brush.GetSafeHandle())
        m_Brush.DeleteObject();
}

/////////////////////////////////////////////////////////////////////////////
// CXHyperLink overrides

///////////////////////////////////////////////////////////////////////////////
// DestroyWindow
BOOL CXHyperLink::DestroyWindow() 
{
    KillTimer(m_nTimerID);
    return CStatic::DestroyWindow();
}

///////////////////////////////////////////////////////////////////////////////
// PreTranslateMessage
BOOL CXHyperLink::PreTranslateMessage(MSG* pMsg) 
{
    m_ToolTip.RelayEvent(pMsg);
    return CStatic::PreTranslateMessage(pMsg);
}

///////////////////////////////////////////////////////////////////////////////
// PreSubclassWindow
void CXHyperLink::PreSubclassWindow() 
{
    // We want to get mouse clicks via STN_CLICKED
    DWORD dwStyle = GetStyle();
    ::SetWindowLong(GetSafeHwnd(), GWL_STYLE, dwStyle | SS_NOTIFY);
    
    // Set the URL as the window text
    if (m_strURL.IsEmpty())
        GetWindowText(m_strURL);

    // Check that the window text isn't empty. If it is, set it as the URL.
    CString strWndText;
    GetWindowText(strWndText);
    if (strWndText.IsEmpty()) 
    {
        ASSERT(!m_strURL.IsEmpty());    // Window and URL both NULL. DUH!
        SetWindowText(m_strURL);
    }

    CFont* pFont = GetFont();
    if (!pFont)
    {
        HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
        if (hFont == NULL)
            hFont = (HFONT) GetStockObject(ANSI_VAR_FONT);
        if (hFont)
            pFont = CFont::FromHandle(hFont);
    }
    ASSERT(pFont->GetSafeHandle());

    // Create the underline font
    LOGFONT lf;
    pFont->GetLogFont(&lf);
    m_StdFont.CreateFontIndirect(&lf);
    lf.lfUnderline = (BYTE) TRUE;
    m_UnderlineFont.CreateFontIndirect(&lf);

    PositionWindow();       // Adjust size of window to fit URL if necessary
    SetDefaultCursor();     // Try and load up a "hand" cursor
    SetUnderline();

    // Create the tooltip
    if (m_bToolTip)
    {
        CRect rect; 
        GetClientRect(rect);
        m_ToolTip.Create(this);
        m_ToolTip.AddTool(this, m_strURL, rect, TOOLTIP_ID);
    }

    CStatic::PreSubclassWindow();
}

/////////////////////////////////////////////////////////////////////////////
// CXHyperLink message handlers

///////////////////////////////////////////////////////////////////////////////
// OnClicked
void CXHyperLink::OnClicked()
{
    m_bOverControl = FALSE;
    int result = HINSTANCE_ERROR + 1;
    if (m_bIsURLEnabled)
        result = (int)GotoURL(m_strURL, SW_SHOW, m_bAlwaysOpenNew);
    m_bVisited = (result > HINSTANCE_ERROR);
    if (!m_bVisited)
    {
        MessageBeep(MB_ICONEXCLAMATION);     // Unable to follow link
        ReportError(result);
    }
    else 
        SetVisited();                       // Repaint to show visited colour

    NotifyParent();
}

///////////////////////////////////////////////////////////////////////////////
// CtlColor
#ifdef _DEBUG
HBRUSH CXHyperLink::CtlColor(CDC* pDC, UINT nCtlColor) 
#else
HBRUSH CXHyperLink::CtlColor(CDC* pDC, UINT /*nCtlColor*/) 
#endif
{
    ASSERT(nCtlColor == CTLCOLOR_STATIC);

    if (m_bOverControl)
        pDC->SetTextColor(m_crHoverColour);
    else if (m_bVisited)
        pDC->SetTextColor(m_crVisitedColour);
    else
        pDC->SetTextColor(m_crLinkColour);

    // transparent text.
    pDC->SetBkMode(TRANSPARENT);

    if (m_Brush.GetSafeHandle())
    {
        pDC->SetBkColor(m_crBackground);
        return (HBRUSH) m_Brush;
    }
    else
    {
        return (HBRUSH)GetStockObject(NULL_BRUSH);
    }
}

///////////////////////////////////////////////////////////////////////////////
// OnMouseMove
void CXHyperLink::OnMouseMove(UINT nFlags, CPoint point) 
{
    if (!m_bOverControl)        // Cursor has just moved over control
    {
        m_bOverControl = TRUE;

        if (m_nUnderline == ulHover)
            SetFont(&m_UnderlineFont);
        Invalidate();

        SetTimer(m_nTimerID, 100, NULL);
    }
    CStatic::OnMouseMove(nFlags, point);
}

///////////////////////////////////////////////////////////////////////////////
// OnTimer
void CXHyperLink::OnTimer(UINT nIDEvent) 
{
    CPoint p(GetMessagePos());
    ScreenToClient(&p);

    CRect rect;
    GetClientRect(rect);
    if (!rect.PtInRect(p))
    {
        m_bOverControl = FALSE;
        KillTimer(m_nTimerID);

        if (m_nUnderline != ulAlways)
            SetFont(&m_StdFont);
        rect.bottom+=10;
        InvalidateRect(rect);
    }
    
    CStatic::OnTimer(nIDEvent);
}

///////////////////////////////////////////////////////////////////////////////
// OnSetCursor
BOOL CXHyperLink::OnSetCursor(CWnd* /*pWnd*/, UINT /*nHitTest*/, UINT /*message*/) 
{
    if (m_hLinkCursor)
    {
        ::SetCursor(m_hLinkCursor);
        return TRUE;
    }
    return FALSE;
}

///////////////////////////////////////////////////////////////////////////////
// OnEraseBkgnd
BOOL CXHyperLink::OnEraseBkgnd(CDC* pDC) 
{
    CRect rect;
    GetClientRect(rect);
    if (m_crBackground != (UINT)-1)
        pDC->FillSolidRect(rect, m_crBackground);
    else
        pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DFACE));

    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CXHyperLink operations

///////////////////////////////////////////////////////////////////////////////
// SetURL
void CXHyperLink::SetURL(CString strURL)
{
    m_strURL = strURL;

    if (::IsWindow(GetSafeHwnd())) 
    {
        PositionWindow();
        m_ToolTip.UpdateTipText(strURL, this, TOOLTIP_ID);
    }
}

///////////////////////////////////////////////////////////////////////////////
// SetColours
void CXHyperLink::SetColours(COLORREF crLinkColour, 
                             COLORREF crVisitedColour,  
                             COLORREF crHoverColour /* = -1 */) 
{ 
    m_crLinkColour  = crLinkColour; 
    m_crVisitedColour = crVisitedColour;

    if (crHoverColour == -1)
        m_crHoverColour = ::GetSysColor(COLOR_HIGHLIGHT);
    else
        m_crHoverColour = crHoverColour;

    if (::IsWindow(m_hWnd))
        Invalidate(); 
}

///////////////////////////////////////////////////////////////////////////////
// SetBackgroundColour
void CXHyperLink::SetBackgroundColour(COLORREF crBackground)
{
    m_crBackground = crBackground;
    if (m_Brush.GetSafeHandle())
        m_Brush.DeleteObject();
    m_Brush.CreateSolidBrush(m_crBackground);
}

///////////////////////////////////////////////////////////////////////////////
// SetVisited
void CXHyperLink::SetVisited(BOOL bVisited /* = TRUE */) 
{ 
    m_bVisited = bVisited; 

    if (::IsWindow(GetSafeHwnd()))
        Invalidate(); 
}

///////////////////////////////////////////////////////////////////////////////
// SetLinkCursor
void CXHyperLink::SetLinkCursor(HCURSOR hCursor)
{ 
    m_hLinkCursor = hCursor;
    if (m_hLinkCursor == NULL)
        SetDefaultCursor();
}

///////////////////////////////////////////////////////////////////////////////
// SetUnderline
void CXHyperLink::SetUnderline(int nUnderline /*=ulHover*/)
{
    if (m_nUnderline == nUnderline)
        return;

    if (::IsWindow(GetSafeHwnd()))
    {
        if (nUnderline == ulAlways)
            SetFont(&m_UnderlineFont);
        else
            SetFont(&m_StdFont);

        Invalidate(); 
    }

    m_nUnderline = nUnderline;
}

///////////////////////////////////////////////////////////////////////////////
// SetAutoSize
void CXHyperLink::SetAutoSize(BOOL bAutoSize /* = TRUE */)
{
    m_bAdjustToFit = bAutoSize;

    if (::IsWindow(GetSafeHwnd()))
        PositionWindow();
}

///////////////////////////////////////////////////////////////////////////////
// SetWindowText
void CXHyperLink::SetWindowText(LPCTSTR lpszString)
{
    ASSERT(lpszString);
    if (!lpszString)
        return;
    CStatic::SetWindowText(_T(""));
    RedrawWindow();
    CStatic::SetWindowText(lpszString);
    PositionWindow();
}

///////////////////////////////////////////////////////////////////////////////
// PositionWindow

// Move and resize the window so that the window is the same size
// as the hyperlink text. This stops the hyperlink cursor being active
// when it is not directly over the text. If the text is left justified
// then the window is merely shrunk, but if it is centred or right
// justified then the window will have to be moved as well.
//
// Suggested by Pål K. Tønder 
//
void CXHyperLink::PositionWindow()
{
    if (!::IsWindow(GetSafeHwnd()) || !m_bAdjustToFit) 
        return;

    // Get the current window position
    CRect WndRect, ClientRect;
    GetWindowRect(WndRect);
    GetClientRect(ClientRect);

    ClientToScreen(ClientRect);

    CWnd* pParent = GetParent();
    if (pParent)
    {
        pParent->ScreenToClient(WndRect);
        pParent->ScreenToClient(ClientRect);
    }

    // Get the size of the window text
    CString strWndText;
    GetWindowText(strWndText);

    CDC* pDC = GetDC();
    CFont* pOldFont = pDC->SelectObject(&m_UnderlineFont);
    CSize Extent = pDC->GetTextExtent(strWndText);
    pDC->SelectObject(pOldFont);
    ReleaseDC(pDC);

    // Adjust for window borders
    Extent.cx += WndRect.Width() - ClientRect.Width(); 
    Extent.cy += WndRect.Height() - ClientRect.Height(); 

    // Get the text justification via the window style
    DWORD dwStyle = GetStyle();

    // Recalc the window size and position based on the text justification
    if (dwStyle & SS_CENTERIMAGE)
        WndRect.DeflateRect(0, (WndRect.Height() - Extent.cy)/2);
    else
        WndRect.bottom = WndRect.top + Extent.cy;

    if (dwStyle & SS_CENTER) 
        WndRect.DeflateRect((WndRect.Width() - Extent.cx)/2, 0);
    else if (dwStyle & SS_RIGHT) 
        WndRect.left = WndRect.right - Extent.cx;
    else // SS_LEFT = 0, so we can't test for it explicitly 
        WndRect.right = WndRect.left + Extent.cx;

    // Move the window
    SetWindowPos(NULL, 
                 WndRect.left, WndRect.top, 
                 WndRect.Width(), WndRect.Height(), 
                 SWP_NOZORDER);
}

/////////////////////////////////////////////////////////////////////////////
// CXHyperLink implementation

///////////////////////////////////////////////////////////////////////////////
// SetDefaultCursor
void CXHyperLink::SetDefaultCursor()
{
    if (m_hLinkCursor == NULL)              // No cursor handle - try to load one
    {
        // First try to load the Win98 / Windows 2000 hand cursor

        TRACE(_T("loading from IDC_HAND\n"));
        m_hLinkCursor = AfxGetApp()->LoadStandardCursor(IDC_HAND);

        if (m_hLinkCursor == NULL)          // Still no cursor handle - 
                                            // load the WinHelp hand cursor
        {
            // The following appeared in Paul DiLascia's Jan 1998 MSJ articles.
            // It loads a "hand" cursor from the winhlp32.exe module.

            TRACE(_T("loading from winhlp32\n"));

            // Get the windows directory
            CString strWndDir;
            GetWindowsDirectory(strWndDir.GetBuffer(MAX_PATH), MAX_PATH);
            strWndDir.ReleaseBuffer();

            strWndDir += _T("\\winhlp32.exe");

            // This retrieves cursor #106 from winhlp32.exe, which is a hand pointer
            HMODULE hModule = LoadLibrary(strWndDir);
            if (hModule) 
            {
                HCURSOR hHandCursor = ::LoadCursor(hModule, MAKEINTRESOURCE(106));
                if (hHandCursor)
                    m_hLinkCursor = CopyCursor(hHandCursor);
                FreeLibrary(hModule);
            }
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
// GetRegKey
LONG CXHyperLink::GetRegKey(HKEY key, LPCTSTR subkey, LPTSTR retdata)
{
    HKEY hkey;
    LONG retval = RegOpenKeyEx(key, subkey, 0, KEY_QUERY_VALUE, &hkey);

    if (retval == ERROR_SUCCESS) 
    {
        long datasize = MAX_PATH;
        TCHAR data[MAX_PATH];
        RegQueryValue(hkey, NULL, data, &datasize);
        _tcscpy(retdata, data);
        RegCloseKey(hkey);
    }

    return retval;
}

///////////////////////////////////////////////////////////////////////////////
// ReportError
void CXHyperLink::ReportError(int nError)
{
#ifdef XHYPERLINK_REPORT_ERROR

    CString str;
    switch (nError) 
    {
        case 0:                         str = "The operating system is out\nof memory or resources."; break;
        case SE_ERR_PNF:                str = "The specified path was not found."; break;
        case SE_ERR_FNF:                str = "The specified file was not found."; break;
        case ERROR_BAD_FORMAT:          str = "The .EXE file is invalid\n(non-Win32 .EXE or error in .EXE image)."; break;
        case SE_ERR_ACCESSDENIED:       str = "The operating system denied\naccess to the specified file."; break;
        case SE_ERR_ASSOCINCOMPLETE:    str = "The filename association is\nincomplete or invalid."; break;
        case SE_ERR_DDEBUSY:            str = "The DDE transaction could not\nbe completed because other DDE transactions\nwere being processed."; break;
        case SE_ERR_DDEFAIL:            str = "The DDE transaction failed."; break;
        case SE_ERR_DDETIMEOUT:         str = "The DDE transaction could not\nbe completed because the request timed out."; break;
        case SE_ERR_DLLNOTFOUND:        str = "The specified dynamic-link library was not found."; break;
        case SE_ERR_NOASSOC:            str = "There is no application associated\nwith the given filename extension."; break;
        case SE_ERR_OOM:                str = "There was not enough memory to complete the operation."; break;
        case SE_ERR_SHARE:              str = "A sharing violation occurred. ";
        default:                        str.Format(_T("Unknown Error (%d) occurred."), nError); break;
    }
    str = "Unable to open hyperlink:\n\n" + str;
    AfxMessageBox(str, MB_ICONEXCLAMATION | MB_OK);

#else

    UNUSED_ALWAYS(nError);

#endif  // XHYPERLINK_REPORT_ERROR
}

///////////////////////////////////////////////////////////////////////////////
// NotifyParent
void CXHyperLink::NotifyParent()
{
    if (m_bNotifyParent)
    {
        CWnd *pParent = GetParent();
        if (pParent && ::IsWindow(pParent->m_hWnd))
        {
            // wParam will contain control id
            pParent->SendMessage(WM_XHYPERLINK_CLICKED, GetDlgCtrlID());
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
// GotoURL
HINSTANCE CXHyperLink::GotoURL(LPCTSTR url, int showcmd, BOOL bAlwaysOpenNew /*= FALSE*/)
{
    // if no url then this is not an internet link
    if (!url || url[0] == _T('\0'))
        return (HINSTANCE) HINSTANCE_ERROR + 1;

    TCHAR key[MAX_PATH*2];

    // First try ShellExecute()
    TCHAR *verb = _T("open");
    if (bAlwaysOpenNew)
        verb = _T("new");
    HINSTANCE result = ShellExecute(NULL, verb, url, NULL,NULL, showcmd);

    // If it failed, get the .htm regkey and lookup the program
    if ((UINT)result <= HINSTANCE_ERROR) 
    {
        if (GetRegKey(HKEY_CLASSES_ROOT, _T(".htm"), key) == ERROR_SUCCESS) 
        {
            _tcscat(key, _T("\\shell\\open\\command"));

            if (GetRegKey(HKEY_CLASSES_ROOT,key,key) == ERROR_SUCCESS) 
            {
                TCHAR *pos;
                pos = _tcsstr(key, _T("\"%1\""));
                if (pos == NULL) 
                {                   // No quotes found
                    pos = _tcsstr(key, _T("%1"));   // Check for %1, without quotes 
                    if (pos == NULL)                // No parameter at all...
                        pos = key + _tcslen(key)-1;
                    else
                        *pos = _T('\0');                // Remove the parameter
                }
                else
                {
                    *pos = _T('\0');                    // Remove the parameter
                }

                _tcscat(pos, _T(" "));
                _tcscat(pos, url);

                USES_CONVERSION;
                result = (HINSTANCE) WinExec(T2A(key),showcmd);
            }
        }
    }

    return result;
}