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, (LONG_PTR)(WNDPROC) _HyperlinkParentProc );
 119                 }
 120         }
 121
 122         // Make sure the control will send notifications.
 123
 124         LONG_PTR Style = GetWindowLongPtr(hwndCtl, GWL_STYLE);
 125         SetWindowLongPtr(hwndCtl, GWL_STYLE, Style | SS_NOTIFY);
 126
 127         // Create an updated font by adding an underline.
 128
 129         m_StdFont = (HFONT) SendMessage(hwndCtl, WM_GETFONT, 0, 0);
 130
 131         if( g_counter++ == 0 )
 132         {
 133                 createGlobalResources();
 134         }
 135
 136         // Subclass the existing control.
 137
 138         m_pfnOrigCtlProc = (WNDPROC) GetWindowLongPtr(hwndCtl, GWLP_WNDPROC);
 139         SetProp(hwndCtl, PROP_OBJECT_PTR, (HANDLE) this);
 140         SetWindowLongPtr(hwndCtl, GWLP_WNDPROC, (LONG_PTR)(WNDPROC) _HyperlinkProc);
 141
 142         return TRUE;
 143 }
 144
 145 /*
 146  * Function CHyperLink::ConvertStaticToHyperlink
 147  */
 148 BOOL CHyperLink::ConvertStaticToHyperlink(HWND hwndParent, UINT uiCtlId,
 149                                                                                   LPCTSTR strURL)
 150 {
 151         return ConvertStaticToHyperlink(GetDlgItem(hwndParent, uiCtlId), strURL);
 152 }
 153
 154 /*
 155  * Function CHyperLink::setURL
 156  */
 157 BOOL CHyperLink::setURL(LPCTSTR strURL)
 158 {
 159         if( m_strURL )
 160         {
 161                 delete [] m_strURL;
 162         }
 163         if( (m_strURL = new TCHAR[lstrlen(strURL)+1])==0 )
 164         {
 165                 return FALSE;
 166         }
 167
 168     lstrcpy(m_strURL, strURL);
 169
 170         return TRUE;
 171 }
 172
 173 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 174  * Private functions
 175  */
 176
 177 /*
 178  * Function CHyperLink::_HyperlinkParentProc
 179  */
 180 LRESULT CALLBACK CHyperLink::_HyperlinkParentProc(HWND hwnd, UINT message,
 181                                                          WPARAM wParam, LPARAM lParam)
 182 {
 183         WNDPROC pfnOrigProc = (WNDPROC) GetProp(hwnd, PROP_ORIGINAL_PROC);
 184
 185         switch (message)
 186         {
 187         case WM_CTLCOLORSTATIC:
 188                 {
 189                         HDC hdc = (HDC) wParam;
 190                         HWND hwndCtl = (HWND) lParam;
 191                         CHyperLink *pHyperLink = (CHyperLink *)GetProp(hwndCtl,
 192                                                                            PROP_OBJECT_PTR);
 193
 194                         if(pHyperLink)
 195                         {
 196                                 LRESULT lr = CallWindowProc(pfnOrigProc, hwnd, message,
 197                                                                 wParam, lParam);
 198                                 if (!pHyperLink->m_bVisited)
 199                                 {
 200                                         // This is the most common case for static branch prediction
 201                                         // optimization
 202                                         SetTextColor(hdc, CHyperLink::g_crLinkColor);
 203                                 }
 204                                 else
 205                                 {
 206                                         SetTextColor(hdc, CHyperLink::g_crVisitedColor);
 207                                 }
 208                                 return lr;
 209                         }
 210                         break;
 211                 }
 212         case WM_DESTROY:
 213                 {
 214                         SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) pfnOrigProc);
 215                         RemoveProp(hwnd, PROP_ORIGINAL_PROC);
 216                         break;
 217                 }
 218         }
 219         return CallWindowProc(pfnOrigProc, hwnd, message, wParam, lParam);
 220 }
 221
 222 /*
 223  * Function CHyperLink::Navigate
 224  */
 225 inline void CHyperLink::Navigate(void)
 226 {
 227         SHELLEXECUTEINFO sei;
 228         ::SecureZeroMemory(&sei,sizeof(SHELLEXECUTEINFO));
 229         sei.cbSize = sizeof( SHELLEXECUTEINFO );                // Set Size
 230         sei.lpVerb = TEXT( "open" );                                    // Set Verb
 231         sei.lpFile = m_strURL;                                                  // Set Target To Open
 232         sei.nShow = SW_SHOWNORMAL;                                              // Show Normal
 233
 234         LASTERRORDISPLAYR(ShellExecuteEx(&sei));
 235         m_bVisited = TRUE;
 236 }
 237
 238 /*
 239  * Function CHyperLink::DrawFocusRect
 240  */
 241 inline void CHyperLink::DrawFocusRect(HWND hwnd)
 242 {
 243         HWND hwndParent = ::GetParent(hwnd);
 244
 245         if( hwndParent )
 246     {
 247                 // calculate where to draw focus rectangle, in screen coords
 248                 RECT rc;
 249                 GetWindowRect(hwnd, &rc);
 250
 251                 INFLATERECT(&rc,1,1);                                    // add one pixel all around
 252                                                                                                  // convert to parent window client coords
 253                 ::ScreenToClient(hwndParent, (LPPOINT)&rc);
 254                 ::ScreenToClient(hwndParent, ((LPPOINT)&rc)+1);
 255                 HDC dcParent = GetDC(hwndParent);                // parent window's DC
 256                 ::DrawFocusRect(dcParent, &rc);                  // draw it!
 257                 ReleaseDC(hwndParent,dcParent);
 258         }
 259 }
 260
 261 /*
 262  * Function CHyperLink::_HyperlinkProc
 263  *
 264  * Note: Processed messages are not passed back to the static control
 265  *       procedure. It does work fine but be aware that it could cause
 266  *       some problems if the static control is already subclassed.
 267  *       Consider the example where the static control would be already
 268  *       subclassed with the ToolTip control that needs to process mouse
 269  *       messages. In that situation, the ToolTip control would not work
 270  *       as expected.
 271  */
 272 LRESULT CALLBACK CHyperLink::_HyperlinkProc(HWND hwnd, UINT message,
 273                                                    WPARAM wParam, LPARAM lParam)
 274 {
 275         CHyperLink *pHyperLink = (CHyperLink *)GetProp(hwnd, PROP_OBJECT_PTR);
 276
 277         switch (message)
 278         {
 279         case WM_MOUSEMOVE:
 280                 {
 281                         if ( pHyperLink->m_bOverControl )
 282                         {
 283                                 // This is the most common case for static branch prediction
 284                                 // optimization
 285                                 RECT rect;
 286                                 GetClientRect(hwnd,&rect);
 287
 288                                 POINT pt = { LOWORD(lParam), HIWORD(lParam) };
 289
 290                                 if (!PTINRECT(&rect,pt))
 291                                 {
 292                                         ReleaseCapture();
 293                                 }
 294                         }
 295                         else
 296                         {
 297                                 pHyperLink->m_bOverControl = TRUE;
 298                                 SendMessage(hwnd, WM_SETFONT,
 299                                                 (WPARAM)CHyperLink::g_UnderlineFont, FALSE);
 300                                 InvalidateRect(hwnd, NULL, FALSE);
 301                                 pHyperLink->OnSelect();
 302                                 SetCapture(hwnd);
 303                         }
 304                         return 0;
 305                 }
 306         case WM_SETCURSOR:
 307                 {
 308                         SetCursor(CHyperLink::g_hLinkCursor);
 309                         return TRUE;
 310                 }
 311         case WM_CAPTURECHANGED:
 312                 {
 313                         pHyperLink->m_bOverControl = FALSE;
 314                         pHyperLink->OnDeselect();
 315                         SendMessage(hwnd, WM_SETFONT,
 316                                         (WPARAM)pHyperLink->m_StdFont, FALSE);
 317                         InvalidateRect(hwnd, NULL, FALSE);
 318                         return 0;
 319                 }
 320         case WM_KEYUP:
 321                 {
 322                         if( wParam != VK_SPACE )
 323                         {
 324                                 break;
 325                         }
 326                 }
 327                                                 // Fall through
 328         case WM_LBUTTONUP:
 329                 {
 330                         pHyperLink->Navigate();
 331                         return 0;
 332                 }
 333         case WM_SETFOCUS:       // Fall through
 334         case WM_KILLFOCUS:
 335                 {
 336                         if( message == WM_SETFOCUS )
 337                         {
 338                                 pHyperLink->OnSelect();
 339                         }
 340                         else            // WM_KILLFOCUS
 341                         {
 342                                 pHyperLink->OnDeselect();
 343                         }
 344                         CHyperLink::DrawFocusRect(hwnd);
 345                         return 0;
 346                 }
 347         case WM_DESTROY:
 348                 {
 349                         SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) pHyperLink->m_pfnOrigCtlProc);
 350
 351                         SendMessage(hwnd, WM_SETFONT, (WPARAM) pHyperLink->m_StdFont, 0);
 352
 353                         if( --CHyperLink::g_counter <= 0 )
 354                         {
 355                                 destroyGlobalResources();
 356                         }
 357
 358                         RemoveProp(hwnd, PROP_OBJECT_PTR);
 359                         break;
 360                 }
 361         }
 362
 363         return CallWindowProc(pHyperLink->m_pfnOrigCtlProc, hwnd, message,
 364                                   wParam, lParam);
 365 }
 366
 367 /*
 368  * Function CHyperLink::createUnderlineFont
 369  */
 370 void CHyperLink::createUnderlineFont(void)
 371 {
 372         LOGFONT lf;
 373         GetObject(m_StdFont, sizeof(lf), &lf);
 374         lf.lfUnderline = TRUE;
 375
 376         g_UnderlineFont = CreateFontIndirect(&lf);
 377 }
 378
 379 /*
 380  * Function CHyperLink::createLinkCursor
 381  */
 382 void CHyperLink::createLinkCursor(void)
 383 {
 384         g_hLinkCursor = ::LoadCursor(NULL, IDC_HAND); // Load Windows' hand cursor
 385         if( !g_hLinkCursor )    // if not available, use the standard Arrow cursor
 386     {
 387                 /*
 388                  * There exist an alternative way to get the IDC_HAND by loading winhlp32.exe but I
 389                  * estimated that it didn't worth the trouble as IDC_HAND is supported since Win98.
 390                  * I consider that if a user is happy with 10 years old OS, he won't bother to have
 391                  * an arrow cursor.
 392                  */
 393                 g_hLinkCursor = ::LoadCursor(NULL, IDC_ARROW);
 394         }
 395 }