src/Utils/MiscUI/hyperlink_base.cpp

   1 /*
   2  * Module ID: hyperlink.cpp
   3  * Title    : CHyperLink definition.
   4  *
   5  * Author   : Olivier Langlois <olanglois@sympatico.ca>
   6  * Date     : November 15, 2005
   7  *
   8  * To read the article describing this class, visit
   9  * http://www3.sympatico.ca/olanglois/hyperlinkdemo.htm
  10  *
  11  * Note: Strongly inspired by Neal Stublen code
  12  *       Minor ideas come from Chris Maunder and Paul DiLascia code
  13  *
  14  * Revision :
  15  *
  16  * 001        26-Nov-2005 - Olivier Langlois
  17  *            - Added changes to make CHyperLink compatible with UNICODE
  18  *            - Use dynamic memory allocation for the URL string
  19  *            - Use of the MAKEINTATOM macro
  20  */
  21 #include "stdafx.h"
  22 #include "hyperlink_base.h"
  23 #include <shellapi.h>
  24
  25 /*
  26  * If you do not wish to link with the windebug module,
  27  * comment out the next include directive and uncomment the
  28  * define directive.
  29  */
  30 //#include "win/windebug.h"
  31 #define LASTERRORDISPLAYR(a) (a)
  32
  33 /*
  34  * Defines
  35  */
  36 #ifndef IDC_HAND
  37 #define IDC_HAND MAKEINTRESOURCE(32649)
  38 #endif
  39
  40 #define PROP_OBJECT_PTR                 MAKEINTATOM(ga.atom)
  41 #define PROP_ORIGINAL_PROC              MAKEINTATOM(ga.atom)
  42
  43 /*
  44  * typedefs
  45  */
  46 class CGlobalAtom
  47 {
  48 public:
  49         CGlobalAtom(void)
  50         { atom = GlobalAddAtom(TEXT("_Hyperlink_Object_Pointer_")
  51                  TEXT("\\{AFEED740-CC6D-47c5-831D-9848FD916EEF}")); }
  52         ~CGlobalAtom(void)
  53         { DeleteAtom(atom); }
  54
  55         ATOM atom;
  56 };
  57
  58 /*
  59  * Local variables
  60  */
  61 static CGlobalAtom ga;
  62
  63 /*
  64  * Static members initialization
  65  */
  66 COLORREF CHyperLink::g_crLinkColor     = RGB(  0,   0, 255);   // Blue;
  67 COLORREF CHyperLink::g_crVisitedColor  = RGB( 128,  0, 128);   // Purple;
  68 HCURSOR  CHyperLink::g_hLinkCursor     = NULL;
  69 HFONT    CHyperLink::g_UnderlineFont   = NULL;
  70 int      CHyperLink::g_counter         = 0;
  71
  72 /*
  73  * Macros and inline functions
  74  */
  75 inline bool PTINRECT( LPCRECT r, const POINT &pt )
  76 { return  ( pt.x >= r->left && pt.x < r->right && pt.y >= r->top && pt.y < r->bottom ); }
  77 inline void INFLATERECT( PRECT r, int dx, int dy )
  78 { r->left -= dx; r->right += dx; r->top -= dy; r->bottom += dy; }
  79
  80 /////////////////////////////////////////////////////////////////////////////
  81 // CHyperLink
  82
  83 CHyperLink::CHyperLink(void)
  84 {
  85     m_bOverControl      = FALSE;                // Cursor not yet over control
  86     m_bVisited          = FALSE;                // Hasn't been visited yet.
  87         m_StdFont           = NULL;
  88         m_pfnOrigCtlProc    = NULL;
  89     m_strURL            = NULL;
  90 }
  91
  92 CHyperLink::~CHyperLink(void)
  93 {
  94         delete [] m_strURL;
  95 }
  96
  97 /*-----------------------------------------------------------------------------
  98  * Public functions
  99  */
 100
 101 /*
 102  * Function CHyperLink::ConvertStaticToHyperlink
 103  */
 104 BOOL CHyperLink::ConvertStaticToHyperlink(HWND hwndCtl, LPCTSTR strURL)
 105 {
 106     if( !(setURL(strURL)) )
 107                 return FALSE;
 108
 109         // Subclass the parent so we can color the controls as we desire.
 110
 111         HWND hwndParent = GetParent(hwndCtl);
 112         if (NULL != hwndParent)
 113         {
 114                 WNDPROC pfnOrigProc = (WNDPROC) GetWindowLongPtr(hwndParent, GWLP_WNDPROC);
 115                 if (pfnOrigProc != _HyperlinkParentProc)
 116                 {
 117                         SetProp( hwndParent, PROP_ORIGINAL_PROC, (HANDLE)pfnOrigProc );
 118                         SetWindowLongPtr( hwndParent, GWLP_WNDPROC,
 119                                            (LONG) (WNDPROC) _HyperlinkParentProc );
 120                 }
 121         }
 122
 123         // Make sure the control will send notifications.
 124
 125         LONG_PTR Style = GetWindowLongPtr(hwndCtl, GWL_STYLE);
 126         SetWindowLongPtr(hwndCtl, GWL_STYLE, Style | SS_NOTIFY);
 127
 128         // Create an updated font by adding an underline.
 129
 130         m_StdFont = (HFONT) SendMessage(hwndCtl, WM_GETFONT, 0, 0);
 131
 132         if( g_counter++ == 0 )
 133         {
 134                 createGlobalResources();
 135         }
 136
 137         // Subclass the existing control.
 138
 139         m_pfnOrigCtlProc = (WNDPROC) GetWindowLongPtr(hwndCtl, GWLP_WNDPROC);
 140         SetProp(hwndCtl, PROP_OBJECT_PTR, (HANDLE) this);
 141         SetWindowLongPtr(hwndCtl, GWLP_WNDPROC, (LONG) (WNDPROC) _HyperlinkProc);
 142
 143         return TRUE;
 144 }
 145
 146 /*
 147  * Function CHyperLink::ConvertStaticToHyperlink
 148  */
 149 BOOL CHyperLink::ConvertStaticToHyperlink(HWND hwndParent, UINT uiCtlId,
 150                                                                                   LPCTSTR strURL)
 151 {
 152         return ConvertStaticToHyperlink(GetDlgItem(hwndParent, uiCtlId), strURL);
 153 }
 154
 155 /*
 156  * Function CHyperLink::setURL
 157  */
 158 BOOL CHyperLink::setURL(LPCTSTR strURL)
 159 {
 160         if( m_strURL )
 161         {
 162                 delete [] m_strURL;
 163         }
 164         if( (m_strURL = new TCHAR[lstrlen(strURL)+1])==0 )
 165         {
 166                 return FALSE;
 167         }
 168
 169     lstrcpy(m_strURL, strURL);
 170
 171         return TRUE;
 172 }
 173
 174 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 175  * Private functions
 176  */
 177
 178 /*
 179  * Function CHyperLink::_HyperlinkParentProc
 180  */
 181 LRESULT CALLBACK CHyperLink::_HyperlinkParentProc(HWND hwnd, UINT message,
 182                                                          WPARAM wParam, LPARAM lParam)
 183 {
 184         WNDPROC pfnOrigProc = (WNDPROC) GetProp(hwnd, PROP_ORIGINAL_PROC);
 185
 186         switch (message)
 187         {
 188         case WM_CTLCOLORSTATIC:
 189                 {
 190                         HDC hdc = (HDC) wParam;
 191                         HWND hwndCtl = (HWND) lParam;
 192                         CHyperLink *pHyperLink = (CHyperLink *)GetProp(hwndCtl,
 193                                                                            PROP_OBJECT_PTR);
 194
 195                         if(pHyperLink)
 196                         {
 197                                 LRESULT lr = CallWindowProc(pfnOrigProc, hwnd, message,
 198                                                                 wParam, lParam);
 199                                 if (!pHyperLink->m_bVisited)
 200                                 {
 201                                         // This is the most common case for static branch prediction
 202                                         // optimization
 203                                         SetTextColor(hdc, CHyperLink::g_crLinkColor);
 204                                 }
 205                                 else
 206                                 {
 207                                         SetTextColor(hdc, CHyperLink::g_crVisitedColor);
 208                                 }
 209                                 return lr;
 210                         }
 211                         break;
 212                 }
 213         case WM_DESTROY:
 214                 {
 215                         SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG) pfnOrigProc);
 216                         RemoveProp(hwnd, PROP_ORIGINAL_PROC);
 217                         break;
 218                 }
 219         }
 220         return CallWindowProc(pfnOrigProc, hwnd, message, wParam, lParam);
 221 }
 222
 223 /*
 224  * Function CHyperLink::Navigate
 225  */
 226 inline void CHyperLink::Navigate(void)
 227 {
 228         SHELLEXECUTEINFO sei;
 229         ::SecureZeroMemory(&sei,sizeof(SHELLEXECUTEINFO));
 230         sei.cbSize = sizeof( SHELLEXECUTEINFO );                // Set Size
 231         sei.lpVerb = TEXT( "open" );                                    // Set Verb
 232         sei.lpFile = m_strURL;                                                  // Set Target To Open
 233         sei.nShow = SW_SHOWNORMAL;                                              // Show Normal
 234
 235         LASTERRORDISPLAYR(ShellExecuteEx(&sei));
 236         m_bVisited = TRUE;
 237 }
 238
 239 /*
 240  * Function CHyperLink::DrawFocusRect
 241  */
 242 inline void CHyperLink::DrawFocusRect(HWND hwnd)
 243 {
 244         HWND hwndParent = ::GetParent(hwnd);
 245
 246         if( hwndParent )
 247     {
 248                 // calculate where to draw focus rectangle, in screen coords
 249                 RECT rc;
 250                 GetWindowRect(hwnd, &rc);
 251
 252                 INFLATERECT(&rc,1,1);                                    // add one pixel all around
 253                                                                                                  // convert to parent window client coords
 254                 ::ScreenToClient(hwndParent, (LPPOINT)&rc);
 255                 ::ScreenToClient(hwndParent, ((LPPOINT)&rc)+1);
 256                 HDC dcParent = GetDC(hwndParent);                // parent window's DC
 257                 ::DrawFocusRect(dcParent, &rc);                  // draw it!
 258                 ReleaseDC(hwndParent,dcParent);
 259         }
 260 }
 261
 262 /*
 263  * Function CHyperLink::_HyperlinkProc
 264  *
 265  * Note: Processed messages are not passed back to the static control
 266  *       procedure. It does work fine but be aware that it could cause
 267  *       some problems if the static control is already subclassed.
 268  *       Consider the example where the static control would be already
 269  *       subclassed with the ToolTip control that needs to process mouse
 270  *       messages. In that situation, the ToolTip control would not work
 271  *       as expected.
 272  */
 273 LRESULT CALLBACK CHyperLink::_HyperlinkProc(HWND hwnd, UINT message,
 274                                                    WPARAM wParam, LPARAM lParam)
 275 {
 276         CHyperLink *pHyperLink = (CHyperLink *)GetProp(hwnd, PROP_OBJECT_PTR);
 277
 278         switch (message)
 279         {
 280         case WM_MOUSEMOVE:
 281                 {
 282                         if ( pHyperLink->m_bOverControl )
 283                         {
 284                                 // This is the most common case for static branch prediction
 285                                 // optimization
 286                                 RECT rect;
 287                                 GetClientRect(hwnd,&rect);
 288
 289                                 POINT pt = { LOWORD(lParam), HIWORD(lParam) };
 290
 291                                 if (!PTINRECT(&rect,pt))
 292                                 {
 293                                         ReleaseCapture();
 294                                 }
 295                         }
 296                         else
 297                         {
 298                                 pHyperLink->m_bOverControl = TRUE;
 299                                 SendMessage(hwnd, WM_SETFONT,
 300                                                 (WPARAM)CHyperLink::g_UnderlineFont, FALSE);
 301                                 InvalidateRect(hwnd, NULL, FALSE);
 302                                 pHyperLink->OnSelect();
 303                                 SetCapture(hwnd);
 304                         }
 305                         return 0;
 306                 }
 307         case WM_SETCURSOR:
 308                 {
 309                         SetCursor(CHyperLink::g_hLinkCursor);
 310                         return TRUE;
 311                 }
 312         case WM_CAPTURECHANGED:
 313                 {
 314                         pHyperLink->m_bOverControl = FALSE;
 315                         pHyperLink->OnDeselect();
 316                         SendMessage(hwnd, WM_SETFONT,
 317                                         (WPARAM)pHyperLink->m_StdFont, FALSE);
 318                         InvalidateRect(hwnd, NULL, FALSE);
 319                         return 0;
 320                 }
 321         case WM_KEYUP:
 322                 {
 323                         if( wParam != VK_SPACE )
 324                         {
 325                                 break;
 326                         }
 327                 }
 328                                                 // Fall through
 329         case WM_LBUTTONUP:
 330                 {
 331                         pHyperLink->Navigate();
 332                         return 0;
 333                 }
 334         case WM_SETFOCUS:       // Fall through
 335         case WM_KILLFOCUS:
 336                 {
 337                         if( message == WM_SETFOCUS )
 338                         {
 339                                 pHyperLink->OnSelect();
 340                         }
 341                         else            // WM_KILLFOCUS
 342                         {
 343                                 pHyperLink->OnDeselect();
 344                         }
 345                         CHyperLink::DrawFocusRect(hwnd);
 346                         return 0;
 347                 }
 348         case WM_DESTROY:
 349                 {
 350                         SetWindowLongPtr(hwnd, GWLP_WNDPROC,
 351                                           (LONG) pHyperLink->m_pfnOrigCtlProc);
 352
 353                         SendMessage(hwnd, WM_SETFONT, (WPARAM) pHyperLink->m_StdFont, 0);
 354
 355                         if( --CHyperLink::g_counter <= 0 )
 356                         {
 357                                 destroyGlobalResources();
 358                         }
 359
 360                         RemoveProp(hwnd, PROP_OBJECT_PTR);
 361                         break;
 362                 }
 363         }
 364
 365         return CallWindowProc(pHyperLink->m_pfnOrigCtlProc, hwnd, message,
 366                                   wParam, lParam);
 367 }
 368
 369 /*
 370  * Function CHyperLink::createUnderlineFont
 371  */
 372 void CHyperLink::createUnderlineFont(void)
 373 {
 374         LOGFONT lf;
 375         GetObject(m_StdFont, sizeof(lf), &lf);
 376         lf.lfUnderline = TRUE;
 377
 378         g_UnderlineFont = CreateFontIndirect(&lf);
 379 }
 380
 381 /*
 382  * Function CHyperLink::createLinkCursor
 383  */
 384 void CHyperLink::createLinkCursor(void)
 385 {
 386         g_hLinkCursor = ::LoadCursor(NULL, IDC_HAND); // Load Windows' hand cursor
 387         if( !g_hLinkCursor )    // if not available, use the standard Arrow cursor
 388     {
 389                 /*
 390                  * There exist an alternative way to get the IDC_HAND by loading winhlp32.exe but I
 391                  * estimated that it didn't worth the trouble as IDC_HAND is supported since Win98.
 392                  * I consider that if a user is happy with 10 years old OS, he won't bother to have
 393                  * an arrow cursor.
 394                  */
 395                 g_hLinkCursor = ::LoadCursor(NULL, IDC_ARROW);
 396         }
 397 }