src/Utils/MiscUI/Balloon.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "stdafx.h"
  20 #include "Balloon.h"
  21
  22 tagBALLOON_INFO::tagBALLOON_INFO()
  23     : hIcon(NULL),
  24           sBalloonTip(),
  25           nMask(0),
  26           nStyles(0),
  27           nDirection(0),
  28           nEffect(0),
  29           nBehaviour(0),
  30           crBegin(0),
  31           crMid(0),
  32           crEnd(0)
  33 {
  34 }
  35
  36 CBalloon::CBalloon()
  37     : m_nStyles (0)
  38 {
  39         m_pParentWnd = NULL;
  40         m_hCurrentWnd = NULL;
  41         m_hDisplayedWnd = NULL;
  42
  43         m_rgnShadow.CreateRectRgn(0, 0, 1, 1);
  44         m_rgnBalloon.CreateRectRgn(0, 0, 1, 1);
  45
  46         m_ptOriginal.x = -1;
  47         m_ptOriginal.y = -1;
  48
  49         SetDelayTime(TTDT_INITIAL, 500);
  50         SetDelayTime(TTDT_AUTOPOP, 30000);
  51         SetNotify(FALSE);
  52         SetDirection();
  53         SetBehaviour();
  54         SetDefaultStyles();
  55         SetDefaultColors();
  56         SetDefaultSizes();
  57         SetEffectBk(BALLOON_EFFECT_SOLID);
  58         RemoveAllTools();
  59         m_bButtonPushed = FALSE;
  60
  61         // Register the window class if it has not already been registered.
  62         WNDCLASS wndcls;
  63         HINSTANCE hInst = AfxGetInstanceHandle();
  64         if(!(::GetClassInfo(hInst, BALLOON_CLASSNAME, &wndcls)))
  65         {
  66                 // otherwise we need to register a new class
  67                 wndcls.style                    = CS_SAVEBITS;
  68                 wndcls.lpfnWndProc              = ::DefWindowProc;
  69                 wndcls.cbClsExtra               = wndcls.cbWndExtra = 0;
  70                 wndcls.hInstance                = hInst;
  71                 wndcls.hIcon                    = NULL;
  72                 wndcls.hCursor                  = LoadCursor(hInst, IDC_ARROW );
  73                 wndcls.hbrBackground    = NULL;
  74                 wndcls.lpszMenuName             = NULL;
  75                 wndcls.lpszClassName    = BALLOON_CLASSNAME;
  76
  77                 if (!AfxRegisterClass(&wndcls))
  78                         AfxThrowResourceException();
  79         }
  80 }
  81
  82 CBalloon::~CBalloon()
  83 {
  84         RemoveAllTools();
  85
  86         m_rgnBalloon.DeleteObject();
  87         m_rgnShadow.DeleteObject();
  88
  89         if (IsWindow(m_hWnd))
  90         DestroyWindow();
  91 }
  92
  93
  94 BEGIN_MESSAGE_MAP(CBalloon, CWnd)
  95         //{{AFX_MSG_MAP(CBalloon)
  96         ON_WM_PAINT()
  97         ON_WM_TIMER()
  98         ON_WM_DESTROY()
  99         ON_WM_KILLFOCUS()
 100         //}}AFX_MSG_MAP
 101         ON_WM_MOUSEMOVE()
 102         ON_WM_LBUTTONDOWN()
 103         ON_WM_LBUTTONUP()
 104 END_MESSAGE_MAP()
 105
 106
 107 /////////////////////////////////////////////////////////////////////////////
 108 // CBalloon message handlers
 109
 110 BOOL CBalloon::Create(CWnd* pParentWnd)
 111 {
 112         DWORD dwStyle = WS_POPUP;
 113         DWORD dwExStyle = WS_EX_TOOLWINDOW | WS_EX_TOPMOST;
 114
 115         m_pParentWnd = pParentWnd;
 116
 117         if (!CreateEx(dwExStyle, BALLOON_CLASSNAME, NULL, dwStyle, 0, 0, 0, 0, m_pParentWnd->GetSafeHwnd(), NULL, NULL))
 118         {
 119                 return FALSE;
 120         }
 121         SetDefaultFont();
 122
 123         return TRUE;
 124 }
 125
 126 void CBalloon::OnDestroy()
 127 {
 128         TRACE("OnDestroy()\n");
 129         KillTimers();
 130
 131         CWnd::OnDestroy();
 132 }
 133
 134
 135
 136 void CBalloon::OnKillFocus(CWnd* pNewWnd)
 137 {
 138         CWnd::OnKillFocus(pNewWnd);
 139         Pop();
 140 }
 141
 142
 143 BOOL CBalloon::PreTranslateMessage(MSG* pMsg)
 144 {
 145         RelayEvent(pMsg);
 146
 147         return CWnd::PreTranslateMessage(pMsg);
 148 }
 149
 150 LRESULT CBalloon::SendNotify(CWnd * pWnd, CPoint * pt, BALLOON_INFO & bi)
 151 {
 152         //make sure this is a valid window
 153         if (!IsWindow(GetSafeHwnd()))
 154                 return 0L;
 155
 156         //see if the user wants to be notified
 157         if (!GetNotify())
 158                 return 0L;
 159
 160         NM_BALLOON_DISPLAY lpnm;
 161
 162         lpnm.pWnd                 = pWnd;
 163         lpnm.pt                   = pt;
 164         lpnm.bi                   = &bi;
 165         lpnm.hdr.hwndFrom = m_hWnd;
 166     lpnm.hdr.idFrom   = GetDlgCtrlID();
 167     lpnm.hdr.code     = UDM_TOOLTIP_DISPLAY;
 168
 169         ::SendMessage(m_hNotifyWnd, WM_NOTIFY, lpnm.hdr.idFrom, (LPARAM)&lpnm);
 170
 171         return 0L;
 172 }
 173
 174 void CBalloon::OnPaint()
 175 {
 176         //if (!m_pCurrentWnd)
 177         //      return;
 178
 179         m_hDisplayedWnd = m_hCurrentWnd;
 180
 181         CPaintDC dc(this); // device context for painting
 182
 183         CRect rect;
 184         GetClientRect(&rect);
 185         rect.DeflateRect(0, 0, 1, 1);
 186
 187         //create a memory device-context. This is done to help reduce
 188         //screen flicker, since we will paint the entire control to the
 189         //off screen device context first.CDC memDC;
 190         CDC memDC;
 191         CBitmap bitmap;
 192         memDC.CreateCompatibleDC(&dc);
 193         bitmap.CreateCompatibleBitmap(&dc, rect.Width(), rect.Height());
 194         CBitmap* pOldBitmap = memDC.SelectObject(&bitmap);
 195
 196         memDC.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &dc, 0, 0, SRCCOPY);
 197
 198         //draw the tooltip
 199         OnDraw(&memDC, rect);
 200
 201         //Copy the memory device context back into the original DC.
 202         dc.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &memDC, 0,0, SRCCOPY);
 203
 204         //Cleanup resources.
 205         memDC.SelectObject(pOldBitmap);
 206         memDC.DeleteDC();
 207         bitmap.DeleteObject();
 208 }
 209
 210 void CBalloon::OnDraw(CDC * pDC, CRect rect)
 211 {
 212         CBrush brBackground(m_crColor [BALLOON_COLOR_BK_BEGIN]);
 213         CBrush brShadow(m_crColor [BALLOON_COLOR_SHADOW]);
 214         CBrush brBorder(m_crColor [BALLOON_COLOR_BORDER]);
 215
 216         pDC->SetBkMode(TRANSPARENT);
 217         pDC->SetTextColor(m_crColor [BALLOON_COLOR_FG]);
 218         //set clip region of the tooltip and draw the shadow if needed
 219         if (m_pToolInfo.nStyles & BALLOON_SHADOW)
 220         {
 221                 //draw the shadow for the tooltip
 222                 int nRop2Mode = pDC->SetROP2(R2_MASKPEN);
 223                 pDC->FillRgn(&m_rgnShadow, &brShadow);
 224                 pDC->SetROP2(nRop2Mode);
 225                 rect.DeflateRect(0, 0, m_nSizes[XBLSZ_SHADOW_CX], m_nSizes[XBLSZ_SHADOW_CY]);
 226         }
 227         pDC->SelectClipRgn(&m_rgnBalloon);
 228
 229         OnDrawBackground(pDC, &rect);
 230
 231         //draw the main region's border of the tooltip
 232         pDC->FrameRgn(&m_rgnBalloon, &brBorder, m_nSizes[XBLSZ_BORDER_CX], m_nSizes[XBLSZ_BORDER_CY]);
 233
 234         if ((m_nLastDirection == BALLOON_RIGHT_BOTTOM) || (m_nLastDirection == BALLOON_LEFT_BOTTOM))
 235                 rect.top += m_nSizes[XBLSZ_HEIGHT_ANCHOR];
 236         else
 237                 rect.bottom -= m_nSizes[XBLSZ_HEIGHT_ANCHOR];
 238
 239         if (m_pToolInfo.nStyles & BALLOON_CLOSEBUTTON)
 240         {
 241                 m_rtCloseButton = CRect(
 242                         rect.right - m_szCloseButton.cx - m_nSizes[XBLSZ_BUTTON_MARGIN_CX] , rect.top + m_nSizes[XBLSZ_BUTTON_MARGIN_CY],
 243                         rect.right - m_nSizes[XBLSZ_BUTTON_MARGIN_CX], rect.top + m_szCloseButton.cy + m_nSizes[XBLSZ_BUTTON_MARGIN_CY]);
 244                 pDC->DrawFrameControl(m_rtCloseButton, DFC_CAPTION, DFCS_CAPTIONCLOSE|DFCS_FLAT|DFCS_TRANSPARENT);
 245                 rect.right -= (m_szCloseButton.cx + m_nSizes[XBLSZ_BUTTON_MARGIN_CX]);
 246         }
 247
 248         //get the rectangle to draw the tooltip text
 249         rect.DeflateRect(m_nSizes[XBLSZ_MARGIN_CX], m_nSizes[XBLSZ_MARGIN_CY]);
 250
 251         //draw the icon
 252         if (m_pToolInfo.hIcon != NULL)
 253         {
 254                 DrawIconEx(pDC->m_hDC, m_nSizes[XBLSZ_MARGIN_CX], rect.top + (rect.Height() - m_szBalloonIcon.cy) / 2,
 255                         m_pToolInfo.hIcon, m_szBalloonIcon.cx, m_szBalloonIcon.cy, 0, NULL, DI_NORMAL);
 256
 257                 rect.left += m_szBalloonIcon.cx + m_nSizes[XBLSZ_MARGIN_CX];
 258         }
 259
 260
 261         //aligns tool tip's text
 262         if (m_pToolInfo.nStyles & BALLOON_BOTTOM_ALIGN)
 263                 rect.top = rect.bottom - m_szBalloonText.cy;
 264         else if (m_pToolInfo.nStyles & BALLOON_VCENTER_ALIGN)
 265                 rect.top += (rect.Height() - m_szBalloonText.cy) / 2;
 266
 267         //prints the tool tip's text
 268         DrawHTML(pDC, rect, m_pToolInfo.sBalloonTip, m_LogFont, FALSE);
 269
 270         //free resources
 271         brBackground.DeleteObject();
 272         brShadow.DeleteObject();
 273         brBorder.DeleteObject();
 274 }
 275
 276 void CBalloon::OnDrawBackground(CDC * pDC, CRect * pRect)
 277 {
 278 #ifdef USE_GDI_GRADIENT
 279         #define DRAW CGradient::DrawGDI
 280 #else
 281         #define DRAW CGradient::Draw
 282 #endif
 283         switch (m_pToolInfo.nEffect)
 284         {
 285         case BALLOON_EFFECT_HGRADIENT:
 286                 DRAW(pDC, pRect, m_crColor[BALLOON_COLOR_BK_BEGIN], m_crColor[BALLOON_COLOR_BK_END]);
 287                 break;
 288         case BALLOON_EFFECT_VGRADIENT:
 289                 DRAW(pDC, pRect, m_crColor[BALLOON_COLOR_BK_BEGIN], m_crColor[BALLOON_COLOR_BK_END], FALSE);
 290                 break;
 291         case BALLOON_EFFECT_HCGRADIENT:
 292                 DRAW(pDC, pRect, m_crColor[BALLOON_COLOR_BK_BEGIN], m_crColor[BALLOON_COLOR_BK_END], m_crColor[BALLOON_COLOR_BK_BEGIN]);
 293                 break;
 294         case BALLOON_EFFECT_VCGRADIENT:
 295                 DRAW(pDC, pRect, m_crColor[BALLOON_COLOR_BK_BEGIN], m_crColor[BALLOON_COLOR_BK_END], m_crColor[BALLOON_COLOR_BK_BEGIN], FALSE);
 296                 break;
 297         case BALLOON_EFFECT_3HGRADIENT:
 298                 DRAW(pDC, pRect, m_crColor[BALLOON_COLOR_BK_BEGIN], m_crColor[BALLOON_COLOR_BK_MID], m_crColor[BALLOON_COLOR_BK_END]);
 299                 break;
 300         case BALLOON_EFFECT_3VGRADIENT:
 301                 DRAW(pDC, pRect, m_crColor[BALLOON_COLOR_BK_BEGIN], m_crColor[BALLOON_COLOR_BK_MID], m_crColor[BALLOON_COLOR_BK_END], FALSE);
 302                 break;
 303 #undef DRAW
 304         default:
 305                 pDC->FillSolidRect(pRect, m_crColor[BALLOON_COLOR_BK_BEGIN]);
 306                 break;
 307         }
 308 }
 309
 310 CRect CBalloon::GetWindowRegion(CRgn * rgn, CSize sz, CPoint pt) const
 311 {
 312         CRect rect;
 313         rect.SetRect(0, 0, sz.cx, sz.cy);
 314         CRgn rgnRect;
 315         CRgn rgnAnchor;
 316         CPoint ptAnchor [3];
 317         ptAnchor [0] = pt;
 318         ScreenToClient(&ptAnchor [0]);
 319
 320         switch (m_nLastDirection)
 321         {
 322         case BALLOON_LEFT_TOP:
 323         case BALLOON_RIGHT_TOP:
 324                 rect.bottom -= m_nSizes[XBLSZ_HEIGHT_ANCHOR];
 325                 ptAnchor [1].y = ptAnchor [2].y = rect.bottom;
 326                 break;
 327         case BALLOON_LEFT_BOTTOM:
 328         case BALLOON_RIGHT_BOTTOM:
 329                 rect.top += m_nSizes[XBLSZ_HEIGHT_ANCHOR];
 330                 ptAnchor [1].y = ptAnchor [2].y = rect.top;
 331                 break;
 332         }
 333
 334         //get the region for rectangle with the text
 335         if (m_pToolInfo.nStyles & BALLOON_ROUNDED)
 336                 rgnRect.CreateRoundRectRgn(rect.left, rect.top, rect.right + 1, rect.bottom + 1,
 337                         m_nSizes[XBLSZ_ROUNDED_CX], m_nSizes[XBLSZ_ROUNDED_CY]);
 338         else rgnRect.CreateRectRgn(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
 339
 340         //gets the region for the anchor
 341         if (m_pToolInfo.nStyles & BALLOON_ANCHOR)
 342         {
 343                 switch (m_nLastDirection)
 344                 {
 345                 case BALLOON_LEFT_TOP:
 346                 case BALLOON_LEFT_BOTTOM:
 347                         ptAnchor [1].x = rect.right - m_nSizes[XBLSZ_MARGIN_ANCHOR];
 348                         ptAnchor [2].x = ptAnchor [1].x - m_nSizes[XBLSZ_WIDTH_ANCHOR];
 349                         break;
 350                 case BALLOON_RIGHT_TOP:
 351                 case BALLOON_RIGHT_BOTTOM:
 352                         ptAnchor [1].x = rect.left + m_nSizes[XBLSZ_MARGIN_ANCHOR];
 353                         ptAnchor [2].x = ptAnchor [1].x + m_nSizes[XBLSZ_WIDTH_ANCHOR];
 354                         break;
 355                 }
 356                 rgnAnchor.CreatePolygonRgn(ptAnchor, 3, ALTERNATE);
 357         }
 358         else
 359                 rgnAnchor.CreateRectRgn(0, 0, 0, 0);
 360
 361         rgn->CreateRectRgn(0, 0, 1, 1);
 362         rgn->CombineRgn(&rgnRect, &rgnAnchor, RGN_OR);
 363
 364         rgnAnchor.DeleteObject();
 365         rgnRect.DeleteObject();
 366
 367         return rect;
 368 }
 369
 370 void CBalloon::RelayEvent(MSG* pMsg)
 371 {
 372         HWND hWnd = NULL;
 373         CPoint pt;
 374         CString str;
 375         CRect rect;
 376
 377         BALLOON_INFO  Info;
 378
 379         switch(pMsg->message)
 380         {
 381         case WM_MOUSEMOVE:
 382                 if (m_ptOriginal == pMsg->pt)
 383                         return;
 384
 385                 m_ptOriginal = pMsg->pt;
 386
 387                 //get the real window under the mouse pointer
 388                 pt = pMsg->pt;
 389                 if (m_pParentWnd)
 390                         m_pParentWnd->ScreenToClient(&pt);
 391                 hWnd = GetChildWindowFromPoint(pt);
 392
 393                 if (!hWnd)
 394                 {
 395                         if (!(GetBehaviour() & BALLOON_DIALOG))
 396                         {
 397                                 Pop();
 398                                 m_hCurrentWnd = NULL;
 399                                 m_hDisplayedWnd = NULL;
 400                                 return;
 401                         }
 402                 }
 403                 else
 404                 {
 405                         UINT behaviour = GetBehaviour(CWnd::FromHandle(hWnd));
 406                         if (hWnd == m_hDisplayedWnd)
 407                         {
 408                                 if (IsWindowVisible())
 409                                 {
 410                                         if ((behaviour & BALLOON_TRACK_MOUSE)&&(!(behaviour & BALLOON_DIALOG)))
 411                                         {
 412                                                 //mouse moved, so move the tooltip too
 413                                                 CRect rect;
 414                                                 GetWindowRect(rect);
 415                                                 CalculateInfoBoxRect(&m_ptOriginal, &rect);
 416                                                 SetWindowPos(NULL, rect.left, rect.top, 0, 0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
 417                                         }
 418                                         else
 419                                                 return;
 420                                 }
 421                                 else if ((behaviour & BALLOON_MULTIPLE_SHOW)&&(!(behaviour & BALLOON_DIALOG)))
 422                                 {
 423                                         SetNewToolTip(CWnd::FromHandle(hWnd));
 424                                 }
 425                                 else
 426                                         Pop();
 427                         }
 428                         else
 429                         {
 430                                 SetNewToolTip(CWnd::FromHandle(hWnd));
 431                         }
 432                 }
 433                 break;
 434         }
 435 }
 436
 437 void CBalloon::SetNewToolTip(CWnd * pWnd)
 438 {
 439         m_hDisplayedWnd = NULL;
 440         Pop();
 441
 442         if (!pWnd->IsWindowEnabled())
 443                 return;
 444
 445         if (!GetTool(pWnd, m_pToolInfo))
 446                 return;
 447
 448         m_hCurrentWnd = pWnd->GetSafeHwnd();
 449
 450         SetTimer(BALLOON_SHOW, m_nTimeInitial, NULL);
 451 }
 452
 453 void CBalloon::OnTimer(UINT_PTR nIDEvent)
 454 {
 455         CPoint pt, point;
 456         CString str;
 457         HWND hWnd;
 458
 459         switch (nIDEvent)
 460         {
 461         case BALLOON_SHOW:
 462                 KillTimers(BALLOON_SHOW);
 463                 //check if mouse pointer is still over the right window
 464                 GetCursorPos(&pt);
 465                 point = pt;
 466                 if (m_pParentWnd)
 467                         m_pParentWnd->ScreenToClient(&point);
 468                 hWnd = GetChildWindowFromPoint(point);
 469                 if (hWnd == m_hCurrentWnd)
 470                 {
 471                         DisplayToolTip(&pt);
 472                         SetTimer(BALLOON_HIDE, m_nTimeAutoPop, NULL);
 473                 }
 474                 break;
 475         case BALLOON_HIDE:
 476                 KillTimers(BALLOON_HIDE);
 477                 Pop();
 478                 if (GetBehaviour() & BALLOON_DIALOG_DESTROY)
 479                 {
 480                         CWnd::OnTimer(nIDEvent);
 481                         DestroyWindow();
 482                         return;
 483                 }
 484                 break;
 485         }
 486
 487         CWnd::OnTimer(nIDEvent);
 488 }
 489
 490 HWND CBalloon::GetChildWindowFromPoint(CPoint & point) const
 491 {
 492         if (!m_pParentWnd)
 493                 return NULL;
 494     CPoint pt = point;
 495     m_pParentWnd->ClientToScreen(&pt);
 496     HWND hWnd = ::WindowFromPoint(pt);
 497
 498     //::WindowFromPoint misses disabled windows and such - go for a more
 499     //comprehensive search in this case.
 500     if (hWnd == m_pParentWnd->GetSafeHwnd())
 501         hWnd = m_pParentWnd->ChildWindowFromPoint(point, CWP_ALL)->GetSafeHwnd();
 502
 503     //check that we aren't over the parent or out of client area
 504     if (!hWnd || hWnd == m_pParentWnd->GetSafeHwnd())
 505         return NULL;
 506
 507     //if it's not part of the main parent window hierarchy, then we are
 508     //not interested
 509     if (!::IsChild(m_pParentWnd->GetSafeHwnd(), hWnd))
 510         return NULL;
 511
 512     return hWnd;
 513 }
 514
 515 BOOL CBalloon::IsCursorInToolTip() const
 516 {
 517     if (!IsVisible() || !IsWindow(m_hWnd))
 518            return FALSE;
 519
 520     CPoint pt;
 521     GetCursorPos(&pt);
 522
 523         CBalloon * pWnd = (CBalloon*)WindowFromPoint(pt);
 524
 525         return (pWnd == this);
 526 }
 527
 528 void CBalloon::KillTimers(UINT nIDTimer /* = NULL */)
 529 {
 530         if (nIDTimer == NULL)
 531         {
 532                 KillTimer(BALLOON_SHOW);
 533                 KillTimer(BALLOON_HIDE);
 534         }
 535         else if (nIDTimer == BALLOON_SHOW)
 536                 KillTimer(BALLOON_SHOW);
 537         else if (nIDTimer == BALLOON_HIDE)
 538                 KillTimer(BALLOON_HIDE);
 539 }
 540
 541 void CBalloon::DisplayToolTip(CPoint * pt /* = NULL */)
 542 {
 543         if(!GetTool(CWnd::FromHandle(m_hCurrentWnd), m_pToolInfo) || m_pToolInfo.sBalloonTip.IsEmpty())
 544                 return;
 545         //if a mask is set then use the default values for the tooltip
 546         if (!(m_pToolInfo.nMask & BALLOON_MASK_STYLES))
 547                 m_pToolInfo.nStyles = m_nStyles;
 548         if (!(m_pToolInfo.nMask & BALLOON_MASK_EFFECT))
 549         {
 550                 m_pToolInfo.nEffect = m_nEffect;
 551         }
 552         if (!(m_pToolInfo.nMask & BALLOON_MASK_COLORS))
 553         {
 554                 m_pToolInfo.crBegin = m_crColor[BALLOON_COLOR_BK_BEGIN];
 555                 m_pToolInfo.crMid = m_crColor[BALLOON_COLOR_BK_MID];
 556                 m_pToolInfo.crEnd = m_crColor[BALLOON_COLOR_BK_END];
 557         }
 558         if (!(m_pToolInfo.nMask & BALLOON_MASK_DIRECTION))
 559                 m_pToolInfo.nDirection = m_nDirection;
 560
 561         //send notification
 562         SendNotify(CWnd::FromHandle(m_hCurrentWnd), pt, m_pToolInfo);
 563
 564         //calculate the width and height of the box dynamically
 565     CSize sz = GetTooltipSize(m_pToolInfo.sBalloonTip);
 566         m_szBalloonText = sz;
 567
 568         //get the size of the current icon
 569         m_szBalloonIcon = GetSizeIcon(m_pToolInfo.hIcon);
 570         if (m_szBalloonIcon.cx || m_szBalloonIcon.cy)
 571         {
 572                 sz.cx += m_szBalloonIcon.cx + m_nSizes[XBLSZ_MARGIN_CX];
 573                 sz.cy = max(m_szBalloonIcon.cy, sz.cy);
 574         }
 575
 576         //get the size of the close button
 577         m_szCloseButton = CSize(::GetSystemMetrics(SM_CXMENUSIZE), ::GetSystemMetrics(SM_CYMENUSIZE));
 578         if (m_pToolInfo.nStyles & BALLOON_CLOSEBUTTON)
 579         {
 580                 sz.cx += m_szCloseButton.cx + m_nSizes[XBLSZ_BUTTON_MARGIN_CX];
 581         }
 582
 583         //get size of the tooltip with margins
 584         sz.cx += m_nSizes[XBLSZ_MARGIN_CX] * 2;
 585         sz.cy += m_nSizes[XBLSZ_MARGIN_CY] * 2 + m_nSizes[XBLSZ_HEIGHT_ANCHOR];
 586         if (m_pToolInfo.nStyles & BALLOON_SHADOW)
 587         {
 588                 sz.cx += m_nSizes[XBLSZ_SHADOW_CX];
 589                 sz.cy += m_nSizes[XBLSZ_SHADOW_CY];
 590         }
 591
 592         CRect rect (0, 0, sz.cx, sz.cy);
 593
 594         DisplayToolTip(pt, &rect);
 595 }
 596
 597 void CBalloon::DisplayToolTip(CPoint * pt, CRect * rect)
 598 {
 599         CalculateInfoBoxRect(pt, rect);
 600
 601         SetWindowPos(
 602                 NULL, rect->left, rect->top, rect->Width() + 2, rect->Height() + 2,
 603                 SWP_SHOWWINDOW|SWP_NOCOPYBITS|SWP_NOACTIVATE|SWP_NOZORDER);
 604
 605         CRgn rgn;
 606         rgn.CreateRectRgn(0, 0, 1, 1);
 607         if (m_pToolInfo.nStyles & BALLOON_SHADOW)
 608         {
 609                 rect->right -= m_nSizes[XBLSZ_SHADOW_CX];
 610                 rect->bottom -= m_nSizes[XBLSZ_SHADOW_CY];
 611         }
 612
 613         m_rgnBalloon.DeleteObject();
 614         GetWindowRegion(&m_rgnBalloon, CSize (rect->Width(), rect->Height()), *pt);
 615         rgn.CopyRgn(&m_rgnBalloon);
 616         if (m_pToolInfo.nStyles & BALLOON_SHADOW)
 617         {
 618                 m_rgnShadow.DeleteObject();
 619                 m_rgnShadow.CreateRectRgn(0, 0, 1, 1);
 620                 m_rgnShadow.CopyRgn(&m_rgnBalloon);
 621                 m_rgnShadow.OffsetRgn(m_nSizes[XBLSZ_SHADOW_CX], m_nSizes[XBLSZ_SHADOW_CY]);
 622                 rgn.CombineRgn(&rgn, &m_rgnShadow, RGN_OR);
 623         }
 624         SetWindowRgn(rgn, FALSE);
 625
 626         rgn.DeleteObject();
 627 }
 628
 629 void CBalloon::Pop()
 630 {
 631         KillTimers();
 632         ShowWindow(SW_HIDE);
 633         m_bButtonPushed = FALSE;
 634 }
 635
 636 CSize CBalloon::GetTooltipSize(const CString& str)
 637 {
 638         CRect rect;
 639         GetWindowRect(&rect);
 640
 641         CDC * pDC = GetDC();
 642
 643         CDC memDC;
 644         CBitmap bitmap;
 645         memDC.CreateCompatibleDC(pDC);
 646         bitmap.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
 647         CBitmap* pOldBitmap = memDC.SelectObject(&bitmap);
 648
 649         //get the minimum size of the rectangle of the tooltip
 650         CSize sz = DrawHTML(&memDC, rect, str, m_LogFont, TRUE);
 651
 652         memDC.SelectObject(pOldBitmap);
 653         memDC.DeleteDC();
 654         bitmap.DeleteObject();
 655
 656         ReleaseDC(pDC);
 657
 658         return sz;
 659 }
 660
 661 CSize CBalloon::GetSizeIcon(HICON hIcon) const
 662 {
 663         ICONINFO ii;
 664         CSize sz (0, 0);
 665
 666         if (hIcon != NULL)
 667         {
 668                 //get icon dimensions
 669                 ::SecureZeroMemory(&ii, sizeof(ICONINFO));
 670                 if (::GetIconInfo(hIcon, &ii))
 671                 {
 672                         sz.cx = (DWORD)(ii.xHotspot * 2);
 673                         sz.cy = (DWORD)(ii.yHotspot * 2);
 674                         //release icon mask bitmaps
 675                         if(ii.hbmMask)
 676                                 ::DeleteObject(ii.hbmMask);
 677                         if(ii.hbmColor)
 678                                 ::DeleteObject(ii.hbmColor);
 679                 }
 680         }
 681         return sz;
 682 }
 683
 684 void CBalloon::CalculateInfoBoxRect(CPoint * pt, CRect * rect)
 685 {
 686         CRect monitorRect;
 687         GetMonitorWorkArea(*pt, monitorRect);
 688
 689         CPoint ptEnd;
 690         m_nLastDirection = m_pToolInfo.nDirection;
 691         BOOL horzAdjusted = TestHorizDirection(pt->x, rect->Width(), monitorRect, m_nLastDirection, rect);
 692         if (!horzAdjusted)
 693         {
 694                 m_nLastDirection = GetNextHorizDirection(m_nLastDirection);
 695                 horzAdjusted = TestHorizDirection(pt->x, rect->Width(), monitorRect, m_nLastDirection, rect);
 696         }
 697         BOOL vertAdjusted = TestVertDirection(pt->y, rect->Height(), monitorRect, m_nLastDirection, rect);
 698         if (!vertAdjusted)
 699         {
 700                 m_nLastDirection = GetNextVertDirection(m_nLastDirection);
 701                 vertAdjusted = TestVertDirection(pt->y, rect->Height(), monitorRect, m_nLastDirection, rect);
 702         }
 703         // in case the rectangle wasn't adjusted which can happen if the tooltip is
 704         // larger than half the monitor size, we center the tooltip around the mouse pointer
 705         if (!horzAdjusted)
 706         {
 707                 int cx = rect->Width() / 2;
 708                 rect->right = pt->x + cx;
 709                 rect->left = pt->x - cx;
 710         }
 711         if (!vertAdjusted)
 712         {
 713                 int cy = rect->Height() / 2;
 714                 rect->bottom = pt->y + cy;
 715                 rect->top = pt->y - cy;
 716         }
 717         if ((m_pToolInfo.nStyles & BALLOON_SHADOW) &&
 718                 ((m_nLastDirection == BALLOON_LEFT_TOP) || (m_nLastDirection == BALLOON_LEFT_BOTTOM)))
 719                 rect->OffsetRect(m_nSizes[XBLSZ_SHADOW_CX], m_nSizes[XBLSZ_SHADOW_CY]);
 720 }
 721
 722
 723 int CBalloon::GetNextHorizDirection(int nDirection) const
 724 {
 725         switch (nDirection)
 726         {
 727         case BALLOON_LEFT_TOP:
 728                 nDirection = BALLOON_RIGHT_TOP;
 729                 break;
 730         case BALLOON_RIGHT_TOP:
 731                 nDirection = BALLOON_LEFT_TOP;
 732                 break;
 733         case BALLOON_LEFT_BOTTOM:
 734                 nDirection = BALLOON_RIGHT_BOTTOM;
 735                 break;
 736         case BALLOON_RIGHT_BOTTOM:
 737                 nDirection = BALLOON_LEFT_BOTTOM;
 738                 break;
 739         }
 740         return nDirection;
 741 }
 742
 743 int CBalloon::GetNextVertDirection(int nDirection) const
 744 {
 745         switch (nDirection)
 746         {
 747         case BALLOON_LEFT_TOP:
 748                 nDirection = BALLOON_LEFT_BOTTOM;
 749                 break;
 750         case BALLOON_LEFT_BOTTOM:
 751                 nDirection = BALLOON_LEFT_TOP;
 752                 break;
 753         case BALLOON_RIGHT_TOP:
 754                 nDirection = BALLOON_RIGHT_BOTTOM;
 755                 break;
 756         case BALLOON_RIGHT_BOTTOM:
 757                 nDirection = BALLOON_RIGHT_TOP;
 758                 break;
 759         }
 760         return nDirection;
 761 }
 762
 763 BOOL CBalloon::TestHorizDirection(int x, int cx, const CRect& monitorRect,
 764                                                                   int nDirection, LPRECT rect)
 765 {
 766         int left = 0;
 767         int right = 0;
 768         int anchorMarginSize = (int)m_nSizes[XBLSZ_MARGIN_ANCHOR];
 769
 770         switch (nDirection)
 771         {
 772         case BALLOON_LEFT_TOP:
 773         case BALLOON_LEFT_BOTTOM:
 774                 right = ((x + anchorMarginSize) > monitorRect.right) ? monitorRect.right : (x + anchorMarginSize);
 775                 left = right - cx;
 776                 break;
 777         case BALLOON_RIGHT_TOP:
 778         case BALLOON_RIGHT_BOTTOM:
 779                 left = (x - anchorMarginSize)<monitorRect.left ? monitorRect.left : (x - anchorMarginSize);
 780                 right = left + cx;
 781                 break;
 782         }
 783
 784         BOOL bTestOk = ((left >= monitorRect.left) && (right <= monitorRect.right)) ? TRUE : FALSE;
 785         if (bTestOk)
 786         {
 787                 rect->left = left;
 788                 rect->right = right;
 789         }
 790
 791         return bTestOk;
 792 }
 793
 794 BOOL CBalloon::TestVertDirection(int y, int cy, const CRect& monitorRect,
 795                                                                  int nDirection, LPRECT rect)
 796 {
 797         int top = 0;
 798         int bottom = 0;
 799
 800         switch (nDirection)
 801         {
 802         case BALLOON_LEFT_TOP:
 803         case BALLOON_RIGHT_TOP:
 804                 bottom = y;
 805                 top = bottom - cy;
 806                 break;
 807         case BALLOON_LEFT_BOTTOM:
 808         case BALLOON_RIGHT_BOTTOM:
 809                 top = y;
 810                 bottom = top + cy;
 811                 break;
 812         }
 813
 814         BOOL bTestOk = ((top >= monitorRect.top) && (bottom <= monitorRect.bottom)) ? TRUE : FALSE;
 815         if (bTestOk)
 816         {
 817                 rect->top = top;
 818                 rect->bottom = bottom;
 819         }
 820
 821         return bTestOk;
 822 }
 823
 824 LPLOGFONT CBalloon::GetSystemToolTipFont() const
 825 {
 826     static LOGFONT LogFont;
 827
 828     NONCLIENTMETRICS ncm;
 829         OSVERSIONINFO vers;
 830
 831         memset(&vers, 0, sizeof(OSVERSIONINFO));
 832         ncm.cbSize = sizeof(NONCLIENTMETRICS);
 833         vers.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 834
 835         if(!GetVersionEx(&vers))
 836                 return NULL;
 837
 838         if(vers.dwMajorVersion < 6)
 839         {
 840                 ncm.cbSize -= sizeof(ncm.iPaddedBorderWidth);
 841         }
 842
 843     if (!SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0))
 844         return NULL;
 845
 846     memcpy(&LogFont, &(ncm.lfStatusFont), sizeof(LOGFONT));
 847
 848     return &LogFont;
 849 }
 850
 851
 852 void CBalloon::Redraw(BOOL /*bRedraw*/ /* = TRUE */)
 853 {
 854 }
 855
 856 void CBalloon::SetStyles(DWORD nStyles, CWnd * pWnd /* = NULL */)
 857 {
 858         ModifyStyles(nStyles, (DWORD)-1, pWnd);
 859 }
 860
 861 void CBalloon::ModifyStyles(DWORD nAddStyles, DWORD nRemoveStyles, CWnd * pWnd /* = NULL */)
 862 {
 863         if (!pWnd)
 864         {
 865                 m_nStyles &= ~nRemoveStyles;
 866                 m_nStyles |= nAddStyles;
 867         }
 868         else
 869         {
 870                 BALLOON_INFO bi;
 871                 if (GetTool(pWnd, bi))
 872                 {
 873                         if (!(bi.nMask & BALLOON_MASK_STYLES))
 874                                 bi.nStyles = m_nStyles;
 875                         bi.nStyles &= ~nRemoveStyles;
 876                         bi.nStyles |= nAddStyles;
 877                         bi.nMask |= BALLOON_MASK_STYLES;
 878                         AddTool(pWnd, bi);
 879                 }
 880         }
 881 }
 882
 883 DWORD CBalloon::GetStyles(CWnd * pWnd /* = NULL */) const
 884 {
 885         if (pWnd)
 886         {
 887                 BALLOON_INFO bi;
 888                 if (GetTool(pWnd, bi))
 889                 {
 890                         if (bi.nMask & BALLOON_MASK_STYLES)
 891                                 return bi.nStyles;
 892                 }
 893         }
 894         return m_nStyles;
 895 }
 896
 897 void CBalloon::SetDefaultStyles(CWnd * pWnd /* = NULL */)
 898 {
 899         SetStyles(BALLOON_RSA, pWnd);
 900 }
 901
 902 void CBalloon::SetColor(int nIndex, COLORREF crColor)
 903 {
 904         if (nIndex >= BALLOON_MAX_COLORS)
 905                 return;
 906
 907         m_crColor [nIndex] = crColor;
 908 }
 909
 910 COLORREF CBalloon::GetColor(int nIndex) const
 911 {
 912         if (nIndex >= BALLOON_MAX_COLORS)
 913                 nIndex = BALLOON_COLOR_FG;
 914
 915         return m_crColor [nIndex];
 916 }
 917
 918 void CBalloon::SetDefaultColors()
 919 {
 920         SetColor(BALLOON_COLOR_FG, ::GetSysColor(COLOR_INFOTEXT));
 921         SetColor(BALLOON_COLOR_BK_BEGIN, ::GetSysColor(COLOR_INFOBK));
 922         SetColor(BALLOON_COLOR_BK_MID, ::GetSysColor(COLOR_INFOBK));
 923         SetColor(BALLOON_COLOR_BK_END, ::GetSysColor(COLOR_INFOBK));
 924         SetColor(BALLOON_COLOR_SHADOW, ::GetSysColor(COLOR_3DSHADOW));
 925         SetColor(BALLOON_COLOR_BORDER, ::GetSysColor(COLOR_WINDOWFRAME));
 926 }
 927
 928 void CBalloon::SetGradientColors(COLORREF crBegin, COLORREF crMid, COLORREF crEnd, CWnd * pWnd /* = NULL */)
 929 {
 930         if (!pWnd)
 931         {
 932                 SetColor(BALLOON_COLOR_BK_BEGIN, crBegin);
 933                 SetColor(BALLOON_COLOR_BK_MID, crMid);
 934                 SetColor(BALLOON_COLOR_BK_END, crEnd);
 935         }
 936         else
 937         {
 938                 BALLOON_INFO bi;
 939                 if (GetTool(pWnd, bi))
 940                 {
 941                         bi.crBegin = crBegin;
 942                         bi.crMid = crMid;
 943                         bi.crEnd = crEnd;
 944                         bi.nMask |= BALLOON_MASK_COLORS;
 945                         AddTool(pWnd, bi);
 946                 }
 947         }
 948 }
 949
 950 void CBalloon::GetGradientColors(COLORREF & crBegin, COLORREF & crMid, COLORREF & crEnd, CWnd * pWnd /* = NULL */) const
 951 {
 952         if (pWnd)
 953         {
 954                 BALLOON_INFO bi;
 955                 if (GetTool(pWnd, bi))
 956                 {
 957                         if (bi.nMask & BALLOON_MASK_COLORS)
 958                         {
 959                                 crBegin = bi.crBegin;
 960                                 crMid = bi.crMid;
 961                                 crEnd = bi.crEnd;
 962                                 return;
 963                         }
 964                 }
 965         }
 966         crBegin = GetColor(BALLOON_COLOR_BK_BEGIN);
 967         crMid = GetColor(BALLOON_COLOR_BK_MID);
 968         crEnd = GetColor(BALLOON_COLOR_BK_END);
 969 }
 970
 971 void CBalloon::ShowBalloon(CWnd * pWnd, CPoint pt, UINT nIdText, BOOL showCloseButton, LPCTSTR szIcon)
 972 {
 973         CString str;
 974         str.LoadString(nIdText);
 975         HICON hIcon = (HICON)::LoadImage(NULL, szIcon, IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE);
 976         ShowBalloon(pWnd, pt, str, showCloseButton, hIcon);
 977 }
 978
 979 void CBalloon::ShowBalloon(
 980         CWnd * pWnd, CPoint pt, const CString& sText, BOOL showCloseButton, HICON hIcon,
 981         UINT nDirection, UINT nEffect, COLORREF crStart, COLORREF crMid, COLORREF crEnd)
 982 {
 983         BALLOON_INFO Info;
 984         Info.hIcon = hIcon;
 985         Info.sBalloonTip = sText;
 986         Info.nMask = 0;
 987
 988         CBalloon * pSB = new CBalloon();
 989         if (pWnd == NULL)
 990                 pWnd = GetDesktopWindow();
 991         pSB->Create(pWnd);
 992         pSB->AddTool(pWnd, Info);
 993         pSB->m_hCurrentWnd = pWnd->GetSafeHwnd();
 994         pSB->SetDirection(nDirection);
 995         pSB->SetEffectBk(nEffect);
 996         if (crStart == NULL)
 997                 crStart = ::GetSysColor(COLOR_INFOBK);
 998         if (crMid == NULL)
 999                 crMid = ::GetSysColor(COLOR_INFOBK);
1000         if (crEnd == NULL)
1001                 crEnd = ::GetSysColor(COLOR_INFOBK);
1002         pSB->SetGradientColors(crStart, crMid, crEnd);
1003         pSB->SetBehaviour(BALLOON_DIALOG | BALLOON_DIALOG_DESTROY);
1004         if (showCloseButton)
1005         {
1006                 pSB->ModifyStyles(BALLOON_CLOSEBUTTON, 0);
1007         }
1008         pSB->DisplayToolTip(&pt);
1009         if (!showCloseButton)
1010                 pSB->SetTimer(BALLOON_HIDE, 5000, NULL); //auto close the dialog if no close button is shown
1011 }
1012
1013 void CBalloon::AddTool(int nIdWnd, UINT nIdText, HICON hIcon/* = NULL*/)
1014 {
1015         AddTool(m_pParentWnd->GetDlgItem(nIdWnd), nIdText, hIcon);
1016 }
1017 void CBalloon::AddTool(int nIdWnd, UINT nIdText, UINT nIdIcon)
1018 {
1019         AddTool(m_pParentWnd->GetDlgItem(nIdWnd), nIdText, nIdIcon);
1020 }
1021 void CBalloon::AddTool(int nIdWnd, const CString& sBalloonTipText, HICON hIcon/* = NULL*/)
1022 {
1023         AddTool(m_pParentWnd->GetDlgItem(nIdWnd), sBalloonTipText, hIcon);
1024 }
1025 void CBalloon::AddTool(int nIdWnd, const CString& sBalloonTipText, UINT nIdIcon)
1026 {
1027         AddTool(m_pParentWnd->GetDlgItem(nIdWnd), sBalloonTipText, nIdIcon);
1028 }
1029
1030 void CBalloon::AddTool(CWnd * pWnd, UINT nIdText, HICON hIcon /* = NULL */)
1031 {
1032         CString str;
1033     str.LoadString(nIdText);
1034         AddTool(pWnd, str, hIcon);
1035 }
1036
1037 void CBalloon::AddTool(CWnd * pWnd, UINT nIdText, UINT nIdIcon)
1038 {
1039         CString str;
1040     str.LoadString(nIdText);
1041         AddTool(pWnd, str, nIdIcon);
1042 }
1043
1044 void CBalloon::AddTool(CWnd * pWnd, const CString& sBalloonTipText, UINT nIdIcon)
1045 {
1046         HICON hIcon     = NULL;
1047         HINSTANCE hInstResource = NULL;
1048
1049         if (nIdIcon >= 0)
1050         {
1051                 hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nIdIcon), RT_GROUP_ICON);
1052
1053                 hIcon = (HICON)::LoadImage(hInstResource, MAKEINTRESOURCE(nIdIcon), IMAGE_ICON, 0, 0, 0);
1054         }
1055
1056         AddTool(pWnd, sBalloonTipText, hIcon);
1057 }
1058
1059 void CBalloon::AddTool(CWnd * pWnd, const CString& sBalloonTipText, HICON hIcon /* = NULL */)
1060 {
1061         //store the tool information
1062         BALLOON_INFO Info;
1063         Info.hIcon = hIcon;
1064         Info.sBalloonTip = sBalloonTipText;
1065         Info.nMask = 0;
1066
1067         AddTool(pWnd, Info);
1068 }
1069
1070 void CBalloon::AddTool(CWnd * pWnd, BALLOON_INFO & bi)
1071 {
1072         if (pWnd)
1073                 m_ToolMap.SetAt(pWnd->m_hWnd, bi);
1074         else
1075                 m_ToolMap.SetAt(NULL, bi);
1076 }
1077
1078 BOOL CBalloon::GetTool(CWnd * pWnd, CString & sBalloonTipText, HICON & hIcon) const
1079 {
1080         BALLOON_INFO bi;
1081         BOOL bFound = GetTool(pWnd, bi);
1082         if (bFound)
1083         {
1084                 sBalloonTipText = bi.sBalloonTip;
1085                 hIcon = bi.hIcon;
1086         }
1087
1088         return bFound;
1089 }
1090
1091 BOOL CBalloon::GetTool(CWnd * pWnd, BALLOON_INFO & bi) const
1092 {
1093         if (pWnd)
1094                 return m_ToolMap.Lookup(pWnd->m_hWnd, bi);
1095         return m_ToolMap.Lookup(NULL, bi);
1096 }
1097
1098 void CBalloon::RemoveTool(CWnd * pWnd)
1099 {
1100         if (pWnd)
1101                 m_ToolMap.RemoveKey(pWnd->m_hWnd);
1102         m_ToolMap.RemoveKey(NULL);
1103 }
1104
1105 void CBalloon::RemoveAllTools()
1106 {
1107         m_ToolMap.RemoveAll();
1108 }
1109
1110 void CBalloon::SetMaskTool(CWnd * pWnd, UINT nMask /* = 0 */)
1111 {
1112         ModifyMaskTool(pWnd, nMask, (UINT)-1);
1113 }
1114
1115 void CBalloon::ModifyMaskTool(CWnd * pWnd, UINT nAddMask, UINT nRemoveMask)
1116 {
1117         ASSERT(pWnd);
1118
1119         BALLOON_INFO bi;
1120         if (GetTool(pWnd, bi))
1121         {
1122                 bi.nMask &= ~nRemoveMask;
1123                 bi.nMask |= nAddMask;
1124                 AddTool(pWnd, bi);
1125         }
1126 }
1127
1128 UINT CBalloon::GetMaskTool(CWnd * pWnd) const
1129 {
1130         ASSERT(pWnd);
1131
1132         UINT nMask = 0;
1133         BALLOON_INFO bi;
1134         if (GetTool(pWnd, bi))
1135                 nMask = bi.nMask;
1136         return nMask;
1137 }
1138
1139 void CBalloon::SetEffectBk(UINT nEffect, CWnd * pWnd /* = NULL */)
1140 {
1141         if (!pWnd)
1142         {
1143                 m_nEffect = nEffect;
1144         }
1145         else
1146         {
1147                 BALLOON_INFO bi;
1148                 if (GetTool(pWnd, bi))
1149                 {
1150                         bi.nEffect = nEffect;
1151                         bi.nMask |= BALLOON_MASK_EFFECT;
1152                         AddTool(pWnd, bi);
1153                 }
1154         }
1155 }
1156
1157 UINT CBalloon::GetEffectBk(CWnd * pWnd /* = NULL */) const
1158 {
1159         if (pWnd)
1160         {
1161                 BALLOON_INFO bi;
1162                 if (GetTool(pWnd, bi))
1163                 {
1164                         if (bi.nMask & BALLOON_MASK_EFFECT)
1165                         {
1166                                 return bi.nEffect;
1167                         }
1168                 }
1169         }
1170         return m_nEffect;
1171 }
1172
1173 void CBalloon::SetNotify(BOOL bParentNotify /* = TRUE */)
1174 {
1175         HWND hWnd = NULL;
1176
1177         if (bParentNotify)
1178                 hWnd = m_pParentWnd->GetSafeHwnd();
1179
1180         SetNotify(hWnd);
1181 }
1182
1183 void CBalloon::SetNotify(HWND hWnd)
1184 {
1185         m_hNotifyWnd = hWnd;
1186 }
1187
1188 BOOL CBalloon::GetNotify() const
1189 {
1190         return (m_hNotifyWnd != NULL);
1191 }
1192
1193 void CBalloon::SetDelayTime(DWORD dwDuration, UINT nTime)
1194 {
1195         switch (dwDuration)
1196         {
1197         case TTDT_AUTOPOP:
1198                 m_nTimeAutoPop = nTime;
1199                 break;
1200         case TTDT_INITIAL :
1201                 m_nTimeInitial = nTime;
1202                 break;
1203         }
1204 }
1205
1206 UINT CBalloon::GetDelayTime(DWORD dwDuration) const
1207 {
1208         UINT nTime = 0;
1209         switch (dwDuration)
1210         {
1211         case TTDT_AUTOPOP:
1212                 nTime = m_nTimeAutoPop;
1213                 break;
1214         case TTDT_INITIAL:
1215                 nTime = m_nTimeInitial;
1216                 break;
1217         }
1218
1219         return nTime;
1220 }
1221
1222 void CBalloon::SetSize(int nSizeIndex, UINT nValue)
1223 {
1224         if (nSizeIndex >= XBLSZ_MAX_SIZES)
1225                 return;
1226
1227         m_nSizes [nSizeIndex] = nValue;
1228 }
1229
1230 UINT CBalloon::GetSize(int nSizeIndex) const
1231 {
1232         if (nSizeIndex >= XBLSZ_MAX_SIZES)
1233                 return 0;
1234
1235         return m_nSizes [nSizeIndex];
1236 }
1237
1238 void CBalloon::SetDefaultSizes()
1239 {
1240         SetSize(XBLSZ_ROUNDED_CX, 16);
1241         SetSize(XBLSZ_ROUNDED_CY, 16);
1242         SetSize(XBLSZ_MARGIN_CX, 12);
1243         SetSize(XBLSZ_MARGIN_CY, 12);
1244         SetSize(XBLSZ_SHADOW_CX, 4);
1245         SetSize(XBLSZ_SHADOW_CY, 4);
1246         SetSize(XBLSZ_WIDTH_ANCHOR, 12);
1247         SetSize(XBLSZ_HEIGHT_ANCHOR, 16);
1248         SetSize(XBLSZ_MARGIN_ANCHOR, 16);
1249         SetSize(XBLSZ_BORDER_CX, 1);
1250         SetSize(XBLSZ_BORDER_CY, 1);
1251         SetSize(XBLSZ_BUTTON_MARGIN_CX, 5);
1252         SetSize(XBLSZ_BUTTON_MARGIN_CY, 5);
1253 }
1254
1255 void CBalloon::SetDirection(UINT nDirection /* = BALLOON_RIGHT_TOP */, CWnd * pWnd /* = NULL */)
1256 {
1257         if (nDirection >= BALLOON_MAX_DIRECTIONS)
1258                 return;
1259
1260         if (!pWnd)
1261         {
1262                 m_nDirection = nDirection;
1263         }
1264         else
1265         {
1266                 BALLOON_INFO bi;
1267                 if (GetTool(pWnd, bi))
1268                 {
1269                         bi.nDirection = nDirection;
1270                         bi.nMask |= BALLOON_MASK_DIRECTION;
1271                         AddTool(pWnd, bi);
1272                 }
1273         }
1274 }
1275
1276 UINT CBalloon::GetDirection(CWnd * pWnd /* = NULL */) const
1277 {
1278         if (pWnd)
1279         {
1280                 BALLOON_INFO bi;
1281                 if (GetTool(pWnd, bi))
1282                 {
1283                         if (bi.nMask & BALLOON_MASK_DIRECTION)
1284                                 return bi.nDirection;
1285                 }
1286         }
1287         return m_nDirection;
1288 }
1289
1290 void CBalloon::SetBehaviour(UINT nBehaviour /* = 0 */, CWnd * pWnd /* = NULL */)
1291 {
1292         if (!pWnd)
1293         {
1294                 m_nBehaviour = nBehaviour;
1295         }
1296         else
1297         {
1298                 BALLOON_INFO bi;
1299                 if (GetTool(pWnd, bi))
1300                 {
1301                         bi.nBehaviour = nBehaviour;
1302                         bi.nMask |= BALLOON_MASK_BEHAVIOUR;
1303                         AddTool(pWnd, bi);
1304                 }
1305         }
1306 }
1307
1308 UINT CBalloon::GetBehaviour(CWnd * pWnd /* = NULL */) const
1309 {
1310         if (pWnd)
1311         {
1312                 BALLOON_INFO bi;
1313                 if (GetTool(pWnd, bi))
1314                 {
1315                         if (bi.nMask & BALLOON_MASK_BEHAVIOUR)
1316                                 return bi.nBehaviour;
1317                 }
1318         }
1319         return m_nBehaviour;
1320 }
1321
1322 BOOL CBalloon::SetFont(CFont & font)
1323 {
1324         LOGFONT lf;
1325         font.GetLogFont (&lf);
1326
1327         return SetFont(&lf);
1328 }
1329
1330 BOOL CBalloon::SetFont(LPLOGFONT lf)
1331 {
1332     memcpy(&m_LogFont, lf, sizeof(LOGFONT));
1333
1334         return TRUE;
1335 }
1336
1337 BOOL CBalloon::SetFont(LPCTSTR lpszFaceName, int nSizePoints /* = 8 */,
1338                                                                         BOOL bUnderline /* = FALSE */, BOOL bBold /* = FALSE */,
1339                                                                         BOOL bStrikeOut /* = FALSE */, BOOL bItalic /* = FALSE */)
1340 {
1341         CDC* pDC = GetDC();
1342         LOGFONT lf;
1343         memset (&lf, 0, sizeof(LOGFONT));
1344
1345         _tcscpy_s (lf.lfFaceName, 32, lpszFaceName);
1346         lf.lfHeight = -MulDiv (nSizePoints, GetDeviceCaps (pDC->m_hDC, LOGPIXELSY), 72);
1347         lf.lfUnderline = (BYTE)bUnderline;
1348         lf.lfWeight = bBold ? FW_BOLD : FW_NORMAL;
1349         lf.lfStrikeOut = (BYTE)bStrikeOut;
1350         lf.lfItalic = (BYTE)bItalic;
1351
1352         if (pDC)
1353                 ReleaseDC(pDC);
1354
1355         return SetFont(&lf);
1356 }
1357
1358 void CBalloon::SetDefaultFont()
1359 {
1360         LPLOGFONT lpSysFont = GetSystemToolTipFont();
1361         if(lpSysFont)
1362                 SetFont(lpSysFont);
1363 }
1364
1365 void CBalloon::GetFont(CFont & font) const
1366 {
1367         font.CreateFontIndirect(&m_LogFont);
1368 }
1369
1370 void CBalloon::GetFont(LPLOGFONT lf) const
1371 {
1372         memcpy(lf, &m_LogFont, sizeof(LOGFONT));
1373 }
1374
1375 void CBalloon::OnMouseMove(UINT nFlags, CPoint point)
1376 {
1377         if (m_pToolInfo.nStyles & BALLOON_CLOSEBUTTON)
1378         {
1379                 UINT nState = DFCS_CAPTIONCLOSE | DFCS_FLAT | DFCS_TRANSPARENT;
1380                 if (m_rtCloseButton.PtInRect(point))
1381                 {
1382                         nState |= DFCS_HOT;
1383                         if (m_bButtonPushed)
1384                                 nState |= DFCS_PUSHED;
1385                 }
1386                 CClientDC dc(this);
1387                 dc.DrawFrameControl(m_rtCloseButton, DFC_CAPTION, nState);
1388
1389                 if (IsPointOverALink(point))
1390                         m_Cursor.SetCursor(IDC_HAND);
1391                 else
1392                         m_Cursor.Restore();
1393         }
1394
1395         CWnd::OnMouseMove(nFlags, point);
1396 }
1397
1398 void CBalloon::OnLButtonDown(UINT nFlags, CPoint point)
1399 {
1400         if ((m_pToolInfo.nStyles & BALLOON_CLOSEBUTTON) && m_rtCloseButton.PtInRect(point))
1401         {
1402                 m_bButtonPushed = TRUE;
1403                 OnMouseMove(0, point);
1404         }
1405
1406         CWnd::OnLButtonDown(nFlags, point);
1407 }
1408
1409 void CBalloon::OnLButtonUp(UINT nFlags, CPoint point)
1410 {
1411         if (IsPointOverALink(point))
1412         {
1413                 CString url = GetLinkForPoint(point);
1414                 ShellExecute(NULL, _T("open"), url, NULL,NULL, 0);
1415         }
1416         else if (
1417                 // Dialog has close button, but user has clicked somewhere else.
1418                 (m_pToolInfo.nStyles & BALLOON_CLOSEBUTTON) &&
1419                 (!m_rtCloseButton.PtInRect(point) || !m_bButtonPushed))
1420         {
1421                 m_bButtonPushed =  FALSE;
1422         }
1423         else
1424         {
1425                 Pop();
1426                 if (GetBehaviour() & BALLOON_DIALOG_DESTROY)
1427                 {
1428                         CWnd::OnLButtonUp(nFlags, point);
1429                         DestroyWindow();
1430                         return;
1431                 }
1432         }
1433         CWnd::OnLButtonUp(nFlags, point);
1434 }
1435
1436 void CBalloon::PostNcDestroy()
1437 {
1438         CWnd::PostNcDestroy();
1439         TRACE("CBalloon: PostNcDestroy()\n");
1440
1441         if (GetBehaviour() & BALLOON_DIALOG_DESTROY)
1442         {
1443                 TRACE("CBalloon: object deleted\n");
1444                 delete this;
1445         }
1446 }
1447
1448 void CBalloon::GetMonitorWorkArea(const CPoint& sourcePoint, CRect& monitorRect) const
1449 {
1450         // identify the monitor that contains the sourcePoint
1451         // and return the work area (the portion of the screen
1452         // not obscured by the system task bar or by application
1453         // desktop tool bars) of that monitor
1454         OSVERSIONINFOEX VersionInformation;
1455         SecureZeroMemory(&VersionInformation, sizeof(OSVERSIONINFOEX));
1456         VersionInformation.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1457         GetVersionEx((OSVERSIONINFO *)&VersionInformation);
1458
1459         ::GetWindowRect(GetDesktopWindow()->m_hWnd, &monitorRect);
1460
1461         if (VersionInformation.dwMajorVersion >= 5)
1462         {
1463                 MONITORINFO mi;
1464
1465                 //
1466                 // get the work area
1467                 //
1468                 mi.cbSize = sizeof(mi);
1469                 HMODULE hUser32 = ::GetModuleHandle (_T("USER32.DLL"));
1470                 if (hUser32 != NULL)
1471                 {
1472                         typedef HMONITOR (WINAPI *FN_MonitorFromPoint) (POINT pt, DWORD dwFlags);
1473                         typedef BOOL (WINAPI *FN_GetMonitorInfo) (HMONITOR hMonitor, LPMONITORINFO lpmi);
1474                         FN_MonitorFromPoint pfnMonitorFromPoint = (FN_MonitorFromPoint)
1475                                 ::GetProcAddress (hUser32, "MonitorFromPoint");
1476                         FN_GetMonitorInfo pfnGetMonitorInfo = (FN_GetMonitorInfo)
1477                                 ::GetProcAddress (hUser32, "GetMonitorInfoW");
1478                         if (pfnMonitorFromPoint != NULL && pfnGetMonitorInfo != NULL)
1479                         {
1480                                 MONITORINFO mi;
1481                                 HMONITOR hMonitor = pfnMonitorFromPoint (sourcePoint,
1482                                         MONITOR_DEFAULTTONEAREST);
1483                                 mi.cbSize = sizeof (mi);
1484                                 pfnGetMonitorInfo (hMonitor, &mi);
1485                                 monitorRect = mi.rcWork;
1486                         }
1487                 }
1488         }
1489
1490 }
1491
1492 CPoint
1493 CBalloon::GetCtrlCentre(CWnd* pDlgWnd, UINT ctrlId)
1494 {
1495         CWnd* pCtrl = pDlgWnd->GetDlgItem(ctrlId);
1496         if(pCtrl == NULL)
1497         {
1498                 ASSERT(FALSE);
1499                 return CPoint(200,200);
1500         }
1501         CRect ctrlRect;
1502         pCtrl->GetWindowRect(ctrlRect);
1503         return ctrlRect.CenterPoint();
1504 }