开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 文件操作 > 查看源码
PPTooltip.cpp
资源名称：VC++Excel.rar　[点击查看]
上传用户：jinq198
上传日期：2014-05-21
资源大小：111k
文件大小：98k
源码类别：

文件操作

开发平台：

Visual C++

PPTooltip.cpp：源码内容
  1. /********************************************************************
  2. created: 2003/04/12
  3. created: 12:04:2003   10:50
  4. file base: PPTooltip
  5. file ext: cpp
  6. author: Eugene Pustovoyt
  8. purpose:
  9. *********************************************************************/
  10. #include "stdafx.h"
  11. #include "PPToolTip.h"
  13. #ifdef _DEBUG
  14. #define new DEBUG_NEW
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  19. /////////////////////////////////////////////////////////////////////////////
  20. // CPPToolTip
  22. CPPToolTip::CPPToolTip()
  23. {
  24. m_pParentWnd = NULL;
  26. m_rgnShadow.CreateRectRgn(0, 0, 0, 0);
  27. m_rgnToolTip.CreateRectRgn(0, 0, 0, 0);
  28. // m_rgnCombo.CreateRectRgn(0, 0, 0, 0);
  30. m_ptOriginal.x = -1;
  31. m_ptOriginal.y = -1;
  33. m_nIndexCurrentWnd = PPTOOLTIP_TOOL_NOEXIST;
  34. m_nIndexDisplayWnd = PPTOOLTIP_TOOL_NOEXIST;
  36. SetDelayTime(TTDT_INITIAL, 500);
  37. SetDelayTime(TTDT_AUTOPOP, 5000);
  38. SetNotify(FALSE);
  39. SetDirection();
  40. SetBehaviour();
  41. SetDefaultStyles();
  42. SetDefaultColors();
  43. SetDefaultSizes();
  44. SetEffectBk(PPTOOLTIP_EFFECT_SOLID);
  45. RemoveAllTools();
  47. // Register the window class if it has not already been registered.
  48. WNDCLASS wndcls;
  49. HINSTANCE hInst = AfxGetInstanceHandle();
  50. if(!(::GetClassInfo(hInst, PPTOOLTIP_CLASSNAME, &wndcls)))
  51. {
  52. // otherwise we need to register a new class
  53. wndcls.style = CS_SAVEBITS;
  54. wndcls.lpfnWndProc = ::DefWindowProc;
  55. wndcls.cbClsExtra = wndcls.cbWndExtra = 0;
  56. wndcls.hInstance = hInst;
  57. wndcls.hIcon = NULL;
  58. wndcls.hCursor = LoadCursor(hInst, IDC_ARROW );
  59. wndcls.hbrBackground = NULL;
  60. wndcls.lpszMenuName = NULL;
  61. wndcls.lpszClassName = PPTOOLTIP_CLASSNAME;
  63. if (!AfxRegisterClass(&wndcls))
  64. AfxThrowResourceException();
  65. }
  66. }
  68. CPPToolTip::~CPPToolTip()
  69. {
  70. RemoveAllTools();
  71. RemoveAllNamesOfResource();
  73. m_nLengthLines.RemoveAll();
  74. m_nHeightLines.RemoveAll();
  76. // m_rgnCombo.Detach();
  77. // m_rgnCombo.DeleteObject();
  78. m_rgnToolTip.DeleteObject();
  79. m_rgnShadow.DeleteObject();
  81. if (IsWindow(m_hWnd))
  82.         DestroyWindow();
  83. }
  86. BEGIN_MESSAGE_MAP(CPPToolTip, CWnd)
  87. //{{AFX_MSG_MAP(CPPToolTip)
  88. ON_WM_PAINT()
  89. ON_WM_TIMER()
  90. ON_WM_DESTROY()
  91. ON_WM_KILLFOCUS()
  92. ON_WM_ERASEBKGND()
  93. //}}AFX_MSG_MAP
  94. END_MESSAGE_MAP()
  97. /////////////////////////////////////////////////////////////////////////////
  98. // CPPToolTip message handlers
  100. BOOL CPPToolTip::Create(CWnd* pParentWnd, BOOL bBalloonSize /* = TRUE */) 
  101. {
  102. TRACE(_T("CPPToolTip::Createn"));
  104. ASSERT_VALID(pParentWnd);
  106. DWORD dwStyle = WS_POPUP; 
  107. DWORD dwExStyle = WS_EX_TOOLWINDOW | WS_EX_TOPMOST;
  108. m_pParentWnd = pParentWnd;
  110. if (!CreateEx(dwExStyle, PPTOOLTIP_CLASSNAME, NULL, dwStyle, 0, 0, 0, 0, pParentWnd->GetSafeHwnd(), NULL, NULL))
  111. {
  112. return FALSE;
  113. }
  115. SetDefaultFont();
  116. SetDefaultSizes(bBalloonSize);
  118. return TRUE;
  119. }
  121. void CPPToolTip::OnDestroy() 
  122. {
  123. KillTimers();
  125. CWnd::OnDestroy();
  126. }
  128. void CPPToolTip::OnKillFocus(CWnd* pNewWnd) 
  129. {
  130. CWnd::OnKillFocus(pNewWnd);
  132. Pop();
  133. }
  135. BOOL CPPToolTip::OnEraseBkgnd(CDC* pDC) 
  136. {
  137. return FALSE;
  138. }
  140. void CPPToolTip::Pop()
  141. {
  142. if (m_nIndexDisplayWnd == PPTOOLTIP_TOOL_HELPER)
  143. m_nIndexDisplayWnd = PPTOOLTIP_TOOL_NOEXIST;
  144. KillTimers();
  145. ShowWindow(SW_HIDE);
  146. }
  148. BOOL CPPToolTip::PreTranslateMessage(MSG* pMsg) 
  149. {
  150. RelayEvent(pMsg);
  152. return CWnd::PreTranslateMessage(pMsg);
  153. }
  155. LRESULT CPPToolTip::SendNotify(CPoint * pt, PPTOOLTIP_INFO & ti) 
  156. { 
  157. TRACE(_T("CPPToolTip::SendNotify()n")); 
  158.   // Make sure this is a valid window  
  159. if (!IsWindow(GetSafeHwnd())) 
  160. return 0L; 
  161.   
  162. // See if the user wants to be notified  
  163. if (!GetNotify()) 
  164. return 0L; 
  165.   
  166. NM_PPTOOLTIP_DISPLAY lpnm; 
  167. PPTOOLTIP_INFO tiCopy = ti; 
  168. FromHandle(ti.hWnd)->ClientToScreen(&tiCopy.rectBounds); 
  169. m_pParentWnd->ScreenToClient(&tiCopy.rectBounds); 
  170. lpnm.pt = pt;  
  171. lpnm.ti = &tiCopy; 
  172. lpnm.hdr.hwndFrom = m_hWnd; 
  173. lpnm.hdr.idFrom   = GetDlgCtrlID(); 
  174. lpnm.hdr.code     = UDM_TOOLTIP_DISPLAY; 
  175.  
  176. ::SendMessage(m_hNotifyWnd, WM_NOTIFY, lpnm.hdr.idFrom, (LPARAM)&lpnm);  
  177. CRect rcBound = ti.rectBounds;  
  178. ti = tiCopy; 
  179. ti.rectBounds = rcBound;  
  180. return 0L; 
  181. }
  183. void CPPToolTip::OnPaint() 
  184. {
  185. if (!IsEnabledIndexTool(m_nIndexCurrentWnd))
  186. return;
  188. m_nIndexDisplayWnd = m_nIndexCurrentWnd;
  189. m_nIndexCurrentWnd = PPTOOLTIP_TOOL_NOEXIST;
  191. CPaintDC dc(this); // device context for painting
  193. CRect rect;
  194. GetClientRect(&rect);
  195. rect.DeflateRect(0, 0, 1, 1);
  197. // Create a memory device-context. This is done to help reduce
  198. // screen flicker, since we will paint the entire control to the
  199. // off screen device context first.CDC memDC;
  200. CDC memDC;
  201. CBitmap bitmap;
  202. memDC.CreateCompatibleDC(&dc);
  203. bitmap.CreateCompatibleBitmap(&dc, rect.Width(), rect.Height());
  204. CBitmap* pOldBitmap = memDC.SelectObject(&bitmap); 
  206. memDC.BitBlt(0, 0, rect.Width(), rect.Height(), &dc, 0,0, SRCCOPY);
  208. OnDraw(&memDC, rect);
  210. //Copy the memory device context back into the original DC via BitBlt().
  211. dc.BitBlt(0, 0, rect.Width(), rect.Height(), &memDC, 0,0, SRCCOPY);
  213. //Cleanup resources.
  214. memDC.SelectObject(pOldBitmap);
  215. memDC.DeleteDC();
  216. bitmap.DeleteObject(); 
  217. }
  219. void CPPToolTip::OnDraw(CDC * pDC, CRect rect)
  220. {
  221. CBrush brBackground(m_crColor [PPTOOLTIP_COLOR_BK_BEGIN]);
  222. CBrush brBorder(m_crColor [PPTOOLTIP_COLOR_BORDER]);
  224. pDC->SetBkMode(TRANSPARENT); 
  226. //Sets clip region of the tooltip and draws the shadow if you need
  227. if (m_pToolInfo.nStyles & PPTOOLTIP_SHADOW)
  228. {
  229. //Draws the shadow for the tooltip
  230. OnDrawShadow(pDC);
  231. rect.DeflateRect(0, 0, m_nSizes[PPTTSZ_SHADOW_CX], m_nSizes[PPTTSZ_SHADOW_CY]);
  232. }
  233. pDC->SelectClipRgn(&m_rgnToolTip);
  235. OnDrawBackground(pDC, &rect);
  237. //Draws the main region's border of the tooltip
  238. pDC->FrameRgn(&m_rgnToolTip, &brBorder, m_nSizes[PPTTSZ_BORDER_CX], m_nSizes[PPTTSZ_BORDER_CY]);
  240. //Gets the rectangle to draw the tooltip text
  241. rect.DeflateRect(m_nSizes[PPTTSZ_MARGIN_CX], m_nSizes[PPTTSZ_MARGIN_CY]);
  242. if ((m_nLastDirection == PPTOOLTIP_RIGHT_BOTTOM) || (m_nLastDirection == PPTOOLTIP_LEFT_BOTTOM))
  243. rect.top += m_nSizes[PPTTSZ_HEIGHT_ANCHOR];
  244. else
  245. rect.bottom -= m_nSizes[PPTTSZ_HEIGHT_ANCHOR];
  247. // Draw the icon
  248. if (m_pToolInfo.hIcon != NULL)
  249. {
  250. CPoint ptIcon;
  251. ptIcon.x = m_nSizes[PPTTSZ_MARGIN_CX];
  252. ptIcon.y = rect.top;
  253. if (m_pToolInfo.nStyles & PPTOOLTIP_ICON_VCENTER_ALIGN)
  254. ptIcon.y = rect.top + (rect.Height() - m_szToolIcon.cy) / 2;
  255. else if (m_pToolInfo.nStyles & PPTOOLTIP_ICON_BOTTOM_ALIGN)
  256. ptIcon.y = rect.bottom - m_szToolIcon.cy;
  257. //First variant
  258. // pDC->DrawIcon(m_nSizes[PPTTSZ_MARGIN_CX], rect.top + (rect.Height() - m_szToolIcon.cy) / 2, m_pToolInfo.hIcon);
  260. //Second variant
  261. pDC->DrawState(ptIcon, m_szToolIcon, m_pToolInfo.hIcon, DSS_NORMAL, (CBrush*)NULL);
  263. //Third variant
  264. // DrawIconEx(pDC->m_hDC, ptIcon.x, ptIcon.y, m_pToolInfo.hIcon, m_szToolIcon.cx, 
  265. // m_szToolIcon.cy, 0, NULL, DI_NORMAL);
  267. rect.left += m_szToolIcon.cx + m_nSizes[PPTTSZ_MARGIN_CX]; 
  268. }
  270. //Aligns tooltip's text
  271. if (m_pToolInfo.nStyles & PPTOOLTIP_BOTTOM_ALIGN)
  272. rect.top = rect.bottom - m_szTextTooltip.cy;
  273. else if (m_pToolInfo.nStyles & PPTOOLTIP_VCENTER_ALIGN)
  274. rect.top += (rect.Height() - m_szTextTooltip.cy) / 2;
  276. //Prints the tooltip's text
  277. PrintTitleString(pDC, rect, m_pToolInfo.sTooltip, FALSE);
  279. brBackground.DeleteObject();
  280. brBorder.DeleteObject();
  281. }
  283. void CPPToolTip::OnDrawShadow(CDC * pDC)
  284. {
  285. CBrush brShadow(m_crColor [PPTOOLTIP_COLOR_SHADOW]);
  286. //Draws the shadow for the tooltip
  287. int nRop2Mode = pDC->SetROP2(R2_MASKPEN);
  288. pDC->FillRgn(&m_rgnShadow, &brShadow);
  289. pDC->SetROP2(nRop2Mode);
  290. brShadow.DeleteObject();
  291. }
  293. void CPPToolTip::OnDrawBackground(CDC * pDC, CRect * pRect)
  294. {
  295. switch (m_pToolInfo.nEffect)
  296. {
  297. default:
  298. pDC->FillSolidRect(pRect, m_crColor[PPTOOLTIP_COLOR_BK_BEGIN]);
  299. break;
  300. case PPTOOLTIP_EFFECT_HGRADIENT:
  301. FillGradient(pDC, pRect, m_crColor[PPTOOLTIP_COLOR_BK_BEGIN], m_crColor [PPTOOLTIP_COLOR_BK_END], TRUE);
  302. break;
  303. case PPTOOLTIP_EFFECT_VGRADIENT:
  304. FillGradient(pDC, pRect, m_crColor[PPTOOLTIP_COLOR_BK_BEGIN], m_crColor [PPTOOLTIP_COLOR_BK_END], FALSE);
  305. break;
  306. case PPTOOLTIP_EFFECT_HCGRADIENT:
  307. FillGradient(pDC, CRect(pRect->left, pRect->top, pRect->left + pRect->Width() / 2, pRect->bottom), 
  308. m_crColor[PPTOOLTIP_COLOR_BK_BEGIN], m_crColor [PPTOOLTIP_COLOR_BK_END], TRUE);
  309. FillGradient(pDC, CRect(pRect->left + pRect->Width() / 2, pRect->top, pRect->right, pRect->bottom), 
  310. m_crColor[PPTOOLTIP_COLOR_BK_END], m_crColor [PPTOOLTIP_COLOR_BK_BEGIN], TRUE);
  311. break;
  312. case PPTOOLTIP_EFFECT_VCGRADIENT:
  313. FillGradient(pDC, CRect (pRect->left, pRect->top, pRect->right, pRect->top + pRect->Height() / 2), 
  314. m_crColor[PPTOOLTIP_COLOR_BK_BEGIN], m_crColor [PPTOOLTIP_COLOR_BK_END], FALSE);
  315. FillGradient(pDC, CRect (pRect->left, pRect->top + pRect->Height() / 2, pRect->right, pRect->bottom), 
  316. m_crColor[PPTOOLTIP_COLOR_BK_END], m_crColor [PPTOOLTIP_COLOR_BK_BEGIN], FALSE);
  317. break;
  318. case PPTOOLTIP_EFFECT_3HGRADIENT:
  319. FillGradient(pDC, CRect(pRect->left, pRect->top, pRect->left + pRect->Width()/2, pRect->bottom), 
  320. m_crColor[PPTOOLTIP_COLOR_BK_BEGIN], m_crColor [PPTOOLTIP_COLOR_BK_MID], TRUE);
  321. FillGradient(pDC, CRect(pRect->left + pRect->Width() / 2, pRect->top, pRect->right, pRect->bottom), 
  322. m_crColor[PPTOOLTIP_COLOR_BK_MID], m_crColor [PPTOOLTIP_COLOR_BK_END], TRUE);
  323. break;
  324. case PPTOOLTIP_EFFECT_3VGRADIENT:
  325. FillGradient(pDC, CRect (pRect->left, pRect->top, pRect->right, pRect->top + pRect->Height() / 2), 
  326. m_crColor[PPTOOLTIP_COLOR_BK_BEGIN], m_crColor [PPTOOLTIP_COLOR_BK_MID], FALSE);
  327. FillGradient(pDC, CRect (pRect->left, pRect->top + pRect->Height() / 2, pRect->right, pRect->bottom), 
  328. m_crColor[PPTOOLTIP_COLOR_BK_MID], m_crColor [PPTOOLTIP_COLOR_BK_END], FALSE);
  329. break;
  330. #ifdef PPTOOLTIP_USE_SHADE
  331. case PPTOOLTIP_EFFECT_NOISE:
  332. case PPTOOLTIP_EFFECT_DIAGSHADE:
  333. case PPTOOLTIP_EFFECT_HSHADE:
  334. case PPTOOLTIP_EFFECT_VSHADE:
  335. case PPTOOLTIP_EFFECT_HBUMP:
  336. case PPTOOLTIP_EFFECT_VBUMP:
  337. case PPTOOLTIP_EFFECT_SOFTBUMP:
  338. case PPTOOLTIP_EFFECT_HARDBUMP:
  339. case PPTOOLTIP_EFFECT_METAL:
  340. m_dNormal.Draw(pDC->GetSafeHdc(),0,0);
  341. break;
  342. #endif
  343. }
  344. }
  346. void CPPToolTip::RelayEvent(MSG* pMsg)
  347. {
  348. ASSERT(m_pParentWnd);
  349. CWnd * pWnd = NULL;
  350. CPoint pt;
  351. CRect rect;
  352. CString str;
  353. int nIndexTool = PPTOOLTIP_TOOL_NOEXIST;
  355. // PPTOOLTIP_INFO  Info;
  357. switch(pMsg->message)
  358. {
  359. case WM_LBUTTONDOWN:
  360. case WM_LBUTTONDBLCLK:
  361. case WM_RBUTTONDOWN:
  362. case WM_RBUTTONDBLCLK:
  363. case WM_MBUTTONDOWN:
  364. case WM_MBUTTONDBLCLK:
  365. case WM_NCLBUTTONDOWN:
  366. case WM_NCLBUTTONDBLCLK:
  367. case WM_NCRBUTTONDOWN:
  368. case WM_NCRBUTTONDBLCLK:
  369. case WM_NCMBUTTONDOWN:
  370. case WM_NCMBUTTONDBLCLK:
  371. case WM_KEYDOWN:
  372. case WM_SYSKEYDOWN:
  373. // The user has interupted the current tool - dismiss it
  374. Pop();
  375. break;
  376. case WM_MOUSEMOVE:
  377. // TRACE (_T("OnMouseMove()n"));
  378. if ((m_ptOriginal == pMsg->pt) || 
  379. (m_nIndexCurrentWnd == PPTOOLTIP_TOOL_HELPER) ||
  380. (m_nIndexDisplayWnd == PPTOOLTIP_TOOL_HELPER))
  381. return; //Mouse pointer was not move
  383. //Check Active window
  384. if (!(m_nStyles & PPTOOLTIP_SHOW_INACTIVE))
  385. {
  386. pWnd = GetActiveWindow();
  387. if (!pWnd)
  388. return;
  389. }
  391. m_ptOriginal = pMsg->pt; //Stores the mouse's coordinates
  393. //Gets the real window under the mouse
  394. pt = pMsg->pt;
  395. m_pParentWnd->ScreenToClient(&pt);
  397. nIndexTool = FindTool(pt);
  399. if (!IsExistTool(nIndexTool))
  400. {
  401. //If the window under the mouse isn't exist
  402. if (IsCursorInToolTip() && (m_pToolInfo.nBehaviour & PPTOOLTIP_CLOSE_LEAVEWND))
  403. return;
  404. Pop();
  405. m_nIndexCurrentWnd = PPTOOLTIP_TOOL_NOEXIST;
  406. m_nIndexDisplayWnd = PPTOOLTIP_TOOL_NOEXIST;
  407. return;
  408. }
  409. else
  410. {
  411. //The window under the mouse is exist
  412. if (nIndexTool == m_nIndexDisplayWnd)
  413. {
  414. if (IsVisible())
  415. {
  416. //Now the tooltip is visible
  417. if ((m_pToolInfo.nBehaviour & PPTOOLTIP_CLOSE_LEAVEWND))
  418. return;
  419. }
  420. if (m_pToolInfo.nBehaviour & PPTOOLTIP_MULTIPLE_SHOW)
  421. {
  422. SetNewToolTip(nIndexTool);
  423. }
  424. else Pop();
  425. }
  426. else
  427. {
  428. SetNewToolTip(nIndexTool, !IsVisible());
  429. }
  430. }
  431. break;
  432. }
  433. }
  435. void CPPToolTip::SetNewToolTip(int nIndexTool, BOOL bWithDelay /* = TRUE */)
  436. {
  437. TRACE (_T("CPPToolTip::SetNewToolTip(Index = 0x%X)n"), nIndexTool);
  439. m_nIndexDisplayWnd = PPTOOLTIP_TOOL_NOEXIST; //reset the displayed window
  440. Pop();
  442. //Gets the info about current tool
  443. if (!GetTool(nIndexTool, m_pToolInfo))
  444. return;
  446. //Remembers the pointer to the current window
  447. m_nIndexCurrentWnd = nIndexTool;
  449. //Start the show timer
  450. if (bWithDelay)
  451. SetTimer(PPTOOLTIP_SHOW, m_nTimeInitial, NULL);
  452. else
  453. OnTimer(PPTOOLTIP_SHOW);
  454. }
  456. void CPPToolTip::OnTimer(UINT nIDEvent) 
  457. {
  458. CPoint pt = m_ptOriginal, point;
  459. CString str;
  460. int nIndexTool = PPTOOLTIP_TOOL_HELPER;
  462. switch (nIDEvent)
  463. {
  464. case PPTOOLTIP_SHOW:
  465. TRACE(_T("OnTimerShown"));
  466. Pop();
  467. if (m_nIndexCurrentWnd != PPTOOLTIP_TOOL_HELPER)
  468. {
  469. GetCursorPos(&pt);
  470. point = pt;
  471. m_pParentWnd->ScreenToClient(&point);
  472. nIndexTool = FindTool(point);
  473. }
  474. if ((nIndexTool == m_nIndexCurrentWnd) && (pt == m_ptOriginal) && IsEnabledIndexTool(nIndexTool))
  475. {
  476. PrepareDisplayToolTip(&pt);
  477. if (m_nTimeAutoPop && !(m_pToolInfo.nBehaviour & PPTOOLTIP_DISABLE_AUTOPOP)) //Don't hide window if autopop is 0
  478. SetTimer(PPTOOLTIP_HIDE, m_nTimeAutoPop, NULL);
  479. }
  480. break;
  481. case PPTOOLTIP_HIDE:
  482. TRACE(_T("OnTimerHiden"));
  483. if (!IsCursorInToolTip() || 
  484. !IsVisible() || 
  485. !(m_pToolInfo.nBehaviour & PPTOOLTIP_NOCLOSE_OVER))
  486. Pop();
  487. break;
  488. }
  490. CWnd::OnTimer(nIDEvent);
  491. }
  493. BOOL CPPToolTip::IsEnabledIndexTool(int nIndex)
  494. {
  495. return (BOOL)(IsExistTool(nIndex) || (nIndex == PPTOOLTIP_TOOL_HELPER));
  496. }
  498. BOOL CPPToolTip::IsCursorInToolTip() const
  499. {
  500.     ASSERT(m_pParentWnd);
  502.     // Is tooltip visible?
  503.     if (!IsVisible() || !IsWindow(m_hWnd))
  504. return FALSE;
  506.     CPoint pt;
  507.     GetCursorPos(&pt);
  509. CPPToolTip * pWnd = (CPPToolTip*)WindowFromPoint(pt);
  511. return (pWnd == this);
  512. }
  514. void CPPToolTip::KillTimers(UINT nIDTimer /* = NULL */)
  515. {
  516. // TRACE (_T("CPPToolTip::KillTimersn"));
  517. if (nIDTimer == NULL)
  518. {
  519. KillTimer(PPTOOLTIP_SHOW);
  520. KillTimer(PPTOOLTIP_HIDE);
  521. }
  522. else if (nIDTimer == PPTOOLTIP_SHOW)
  523. KillTimer(PPTOOLTIP_SHOW);
  524. else if (nIDTimer == PPTOOLTIP_HIDE)
  525. KillTimer(PPTOOLTIP_HIDE);
  526. }
  528. void CPPToolTip::PrepareDisplayToolTip(CPoint * pt)
  529. {
  530. TRACE (_T("CPPToolTip::DisplayToolTip()n"));
  532. //Fills default members
  533. if (!(m_pToolInfo.nMask & PPTOOLTIP_MASK_STYLES))
  534. m_pToolInfo.nStyles = m_nStyles;
  535. if (!(m_pToolInfo.nMask & PPTOOLTIP_MASK_EFFECT))
  536. {
  537. m_pToolInfo.nEffect = m_nEffect;
  538. m_pToolInfo.nGranularity = m_nGranularity;
  539. }
  540. if (!(m_pToolInfo.nMask & PPTOOLTIP_MASK_COLORS))
  541. {
  542. m_pToolInfo.crBegin = m_crColor[PPTOOLTIP_COLOR_BK_BEGIN];
  543. m_pToolInfo.crMid = m_crColor[PPTOOLTIP_COLOR_BK_MID];
  544. m_pToolInfo.crEnd = m_crColor[PPTOOLTIP_COLOR_BK_END];
  545. }
  546. if (!(m_pToolInfo.nMask & PPTOOLTIP_MASK_DIRECTION))
  547. m_pToolInfo.nDirection = m_nDirection;
  548. if (!(m_pToolInfo.nMask & PPTOOLTIP_MASK_BEHAVIOUR))
  549. m_pToolInfo.nBehaviour = m_nBehaviour;
  551. //Send notify
  552. SendNotify(pt, m_pToolInfo);
  554. //If string and icon are not exist then exit
  555. if ((m_pToolInfo.hIcon == NULL) && m_pToolInfo.sTooltip.IsEmpty())
  556. return;
  558. //calculate the width and height of the box dynamically
  559.     CSize sz = GetTooltipSize(m_pToolInfo.sTooltip);
  560. m_szTextTooltip = sz; //Stores the real size of the tooltip's text
  562. //Gets size of the current icon
  563. m_szToolIcon = GetSizeIcon(m_pToolInfo.hIcon);
  564. if (m_szToolIcon.cx || m_szToolIcon.cy)
  565. {
  566. sz.cx += m_szToolIcon.cx;
  567. if (m_szTextTooltip.cx != 0)
  568. sz.cx += m_nSizes[PPTTSZ_MARGIN_CX]; //If text is exist then adds separator
  569. sz.cy = max(m_szToolIcon.cy, sz.cy);
  570. }
  572. //Gets size of the tooltip with margins
  573. sz.cx += m_nSizes[PPTTSZ_MARGIN_CX] * 2;
  574. sz.cy += m_nSizes[PPTTSZ_MARGIN_CY] * 2 + m_nSizes[PPTTSZ_HEIGHT_ANCHOR];
  575. if (m_pToolInfo.nStyles & PPTOOLTIP_SHADOW)
  576. {
  577. sz.cx += m_nSizes[PPTTSZ_SHADOW_CX];
  578. sz.cy += m_nSizes[PPTTSZ_SHADOW_CY];
  579. }
  581. CRect rect (0, 0, sz.cx, sz.cy);
  583. #ifdef PPTOOLTIP_USE_SHADE
  584. //If needed to create the bitmap of the background effect
  585. switch (m_pToolInfo.nEffect)
  586. {
  587. case PPTOOLTIP_EFFECT_NOISE:
  588. case PPTOOLTIP_EFFECT_DIAGSHADE:
  589. case PPTOOLTIP_EFFECT_HSHADE:
  590. case PPTOOLTIP_EFFECT_VSHADE:
  591. case PPTOOLTIP_EFFECT_HBUMP:
  592. case PPTOOLTIP_EFFECT_VBUMP:
  593. case PPTOOLTIP_EFFECT_SOFTBUMP:
  594. case PPTOOLTIP_EFFECT_HARDBUMP:
  595. case PPTOOLTIP_EFFECT_METAL:
  596. SetShade(rect, m_pToolInfo.nEffect, m_nGranularity, 5, m_pToolInfo.crBegin);
  597. }
  598. #endif
  600. DisplayToolTip(pt, &rect);
  601. }
  603. void CPPToolTip::DisplayToolTip(CPoint * pt, CRect * rect)
  604. {
  605. //Calculate the placement on the screen
  606. CalculateInfoBoxRect(pt, rect);
  608. SetWindowPos(NULL, 
  609.                  rect->left, rect->top,
  610.                  rect->Width() + 2, rect->Height() + 2,
  611.                  SWP_SHOWWINDOW|SWP_NOCOPYBITS|SWP_NOACTIVATE|SWP_NOZORDER);
  613. CRgn rgnCombo;
  614. rgnCombo.CreateRectRgn(0, 0, 0, 0);
  615. if (m_pToolInfo.nStyles & PPTOOLTIP_SHADOW)
  616. {
  617. rect->right -= m_nSizes[PPTTSZ_SHADOW_CX];
  618. rect->bottom -= m_nSizes[PPTTSZ_SHADOW_CY];
  619. }
  620. m_rgnToolTip.DeleteObject();
  621. GetWindowRegion(&m_rgnToolTip, CSize (rect->Width(), rect->Height()), *pt);
  622. rgnCombo.CopyRgn(&m_rgnToolTip);
  623. if (m_pToolInfo.nStyles & PPTOOLTIP_SHADOW)
  624. {
  625. m_rgnShadow.DeleteObject();
  626. m_rgnShadow.CreateRectRgn(0, 0, 0, 0);
  627. m_rgnShadow.CopyRgn(&m_rgnToolTip);
  628. m_rgnShadow.OffsetRgn(m_nSizes[PPTTSZ_SHADOW_CX], m_nSizes[PPTTSZ_SHADOW_CY]);
  629. rgnCombo.CombineRgn(&rgnCombo, &m_rgnShadow, RGN_OR);
  630. }
  631. SetWindowRgn((HRGN)rgnCombo.Detach(), FALSE);
  632. }
  634. CRect CPPToolTip::GetWindowRegion(CRgn * rgn, CSize sz, CPoint pt)
  635. {
  636. CRect rect;
  637. rect.SetRect(0, 0, sz.cx, sz.cy);
  638. CRgn rgnRect;
  639. CRgn rgnAnchor;
  640. CPoint ptAnchor [3];
  641. ptAnchor [0] = pt;
  642. ScreenToClient(&ptAnchor [0]);
  644. switch (m_nLastDirection)
  645. {
  646. case PPTOOLTIP_LEFT_TOP:
  647. case PPTOOLTIP_RIGHT_TOP:
  648. rect.bottom -= m_nSizes[PPTTSZ_HEIGHT_ANCHOR];
  649. ptAnchor [1].y = ptAnchor [2].y = rect.bottom;
  650. break;
  651. case PPTOOLTIP_LEFT_BOTTOM:
  652. case PPTOOLTIP_RIGHT_BOTTOM:
  653. rect.top += m_nSizes[PPTTSZ_HEIGHT_ANCHOR];
  654. ptAnchor [1].y = ptAnchor [2].y = rect.top;
  655. break;
  656. }
  658. //Gets the region for rectangle with the text
  659. if (m_pToolInfo.nStyles & PPTOOLTIP_ROUNDED)
  660. rgnRect.CreateRoundRectRgn(rect.left, rect.top, rect.right + 1, rect.bottom + 1, 
  661. m_nSizes[PPTTSZ_ROUNDED_CX], m_nSizes[PPTTSZ_ROUNDED_CY]);
  662. else rgnRect.CreateRectRgn(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  664. //Gets the region for anchor
  665. if (m_pToolInfo.nStyles & PPTOOLTIP_ANCHOR)
  666. {
  667. switch (m_nLastDirection)
  668. {
  669. case PPTOOLTIP_LEFT_TOP:
  670. case PPTOOLTIP_LEFT_BOTTOM:
  671. ptAnchor [1].x = rect.right - m_nSizes[PPTTSZ_MARGIN_ANCHOR];
  672. ptAnchor [2].x = ptAnchor [1].x - m_nSizes[PPTTSZ_WIDTH_ANCHOR];
  673. break;
  674. case PPTOOLTIP_RIGHT_TOP:
  675. case PPTOOLTIP_RIGHT_BOTTOM:
  676. ptAnchor [1].x = rect.left + m_nSizes[PPTTSZ_MARGIN_ANCHOR];
  677. ptAnchor [2].x = ptAnchor [1].x + m_nSizes[PPTTSZ_WIDTH_ANCHOR];
  678. break;
  679. }
  680. rgnAnchor.CreatePolygonRgn(ptAnchor, 3, ALTERNATE);
  681. }
  682. else
  683. rgnAnchor.CreateRectRgn(0, 0, 0, 0);
  685. rgn->CreateRectRgn(0, 0, 0, 0);
  686. rgn->CombineRgn(&rgnRect, &rgnAnchor, RGN_OR);
  688. rgnAnchor.DeleteObject();
  689. rgnRect.DeleteObject();
  691. return rect;
  692. }
  694. ///////////////////////////////////////////////////
  695. // Gets the size of the current tooltip text
  696. //
  697. // Parameters:
  698. // none
  699. //
  700. // Return value:
  701. // Size of current tooltip text
  702. ///////////////////////////////////////////////////
  703. CSize CPPToolTip::GetTooltipSize(CString str)
  704. {
  705. //Gets max windows rectangle
  706. CRect rect;
  707. GetWindowRect(&rect);
  709. //Creates compatibility context device in memory
  710. // CDC * pDC = GetDC();
  711. CWindowDC dc(NULL);
  713. CDC memDC;
  714. CBitmap bitmap;
  715. memDC.CreateCompatibleDC(&dc);
  716. // memDC.CreateCompatibleDC(pDC);
  717. bitmap.CreateCompatibleBitmap(&dc, rect.Width(), rect.Height());
  718. // bitmap.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
  719. CBitmap* pOldBitmap = memDC.SelectObject(&bitmap);
  721. //Prints the string on device context for gets minimal size of the rectangle 
  722. //of the tooltip
  723. CSize sz = PrintTitleString(&memDC, rect, str);
  725. memDC.SelectObject(pOldBitmap);
  726. memDC.DeleteDC();
  727. bitmap.DeleteObject();
  729. // ReleaseDC(pDC);
  731. //Returns minimal rectangle of the tooltip
  732. return sz;
  733. }
  735. CSize CPPToolTip::GetSizeIcon(HICON hIcon) const
  736. {
  737. ICONINFO ii;
  738. CSize sz (0, 0);
  740. if (hIcon != NULL)
  741. {
  742. // Gets icon dimension
  743. ::ZeroMemory(&ii, sizeof(ICONINFO));
  744. if (::GetIconInfo(hIcon, &ii))
  745. {
  746. sz.cx = (DWORD)(ii.xHotspot * 2);
  747. sz.cy = (DWORD)(ii.yHotspot * 2);
  748. //release icon mask bitmaps
  749. if(ii.hbmMask)
  750. ::DeleteObject(ii.hbmMask);
  751. if(ii.hbmColor)
  752. ::DeleteObject(ii.hbmColor);
  753. }
  754. }
  755. return sz;
  756. }
  758. ///////////////////////////////////////////////////
  759. // Calculates the real rect for the tooltip with margins
  760. //
  761. // Parameters:
  762. // pt [in] - the mouse coordinates (screen coordinates)
  763. // sz [in] - the size of the tooltip text
  764. //
  765. // Return value:
  766. // The rectangle when the tooltip will draw (screen coordinates)
  767. ///////////////////////////////////////////////////
  768. void CPPToolTip::CalculateInfoBoxRect(CPoint * pt, CRect * rect)
  769. {
  770. // Use the screen's right edge as the right hand border, not the right edge of the client.
  771. CWindowDC wdc(NULL);
  772. CRect rWindow(0, 0, 0, 0);
  773. rWindow.right = GetDeviceCaps(wdc, HORZRES);// - 8;
  774. rWindow.bottom = GetDeviceCaps(wdc, VERTRES);// - 8;
  775. /*
  776. m_szToolIcon = GetSizeIcon(m_pToolInfo.hIcon);
  777. if (m_szToolIcon.cx || m_szToolIcon.cy)
  778. {
  779. sz.cx += m_szToolIcon.cx + m_nSizes[PPTTSZ_MARGIN_CX];
  780. sz.cy = max(m_szToolIcon.cy, sz.cy);
  781. }
  783. //Gets size of the tooltip with margins
  784. sz.cx += m_nSizes[PPTTSZ_MARGIN_CX] * 2;
  785. sz.cy += m_nSizes[PPTTSZ_MARGIN_CY] * 2 + m_nSizes[PPTTSZ_HEIGHT_ANCHOR];
  786. if (m_pToolInfo.nStyles & PPTOOLTIP_SHADOW)
  787. {
  788. rWindow.right -= m_nSizes[PPTTSZ_SHADOW_CX];
  789. rWindow.bottom -= m_nSizes[PPTTSZ_SHADOW_CY];
  790. sz.cx += m_nSizes[PPTTSZ_SHADOW_CX];
  791. sz.cy += m_nSizes[PPTTSZ_SHADOW_CY];
  792. }
  793. */
  794. // CRect rect;
  795. // rect.SetRect(0, 0, sz.cx, sz.cy);
  796. // CRect rectCopy = *rect;
  798. //Offset the rect from the mouse pointer
  799. CPoint ptEnd;
  800. m_nLastDirection = m_pToolInfo.nDirection;
  802. if (!TestHorizDirection(pt->x, rect->Width(), rWindow.right, m_nLastDirection, rect))
  803. {
  804. m_nLastDirection = GetNextHorizDirection(m_nLastDirection);
  805. TestHorizDirection(pt->x, rect->Width(), rWindow.right, m_nLastDirection, rect);
  806. }
  807. if (!TestVertDirection(pt->y, rect->Height(), rWindow.bottom, m_nLastDirection, rect))
  808. {
  809. m_nLastDirection = GetNextVertDirection(m_nLastDirection);
  810. TestVertDirection(pt->y, rect->Height(), rWindow.bottom, m_nLastDirection, rect);
  811. }
  813. //Returns the rect of the tooltip
  814. if ((m_pToolInfo.nStyles & PPTOOLTIP_SHADOW) && 
  815. ((m_nLastDirection == PPTOOLTIP_LEFT_TOP) || (m_nLastDirection == PPTOOLTIP_LEFT_BOTTOM)))
  816. rect->OffsetRect(m_nSizes[PPTTSZ_SHADOW_CX], m_nSizes[PPTTSZ_SHADOW_CY]);
  817. }
  819. ///////////////////////////////////////////////////
  820. // Gets the next horizontal direction
  821. //
  822. // Parameters:
  823. // nDirection [in] - the current direction
  824. //
  825. // Return value:
  826. // The next horizontal direction
  827. ///////////////////////////////////////////////////
  828. int CPPToolTip::GetNextHorizDirection(int nDirection) const
  829. {
  830. switch (nDirection)
  831. {
  832. case PPTOOLTIP_LEFT_TOP:
  833. nDirection = PPTOOLTIP_RIGHT_TOP;
  834. break;
  835. case PPTOOLTIP_RIGHT_TOP:
  836. nDirection = PPTOOLTIP_LEFT_TOP;
  837. break;
  838. case PPTOOLTIP_LEFT_BOTTOM:
  839. nDirection = PPTOOLTIP_RIGHT_BOTTOM;
  840. break;
  841. case PPTOOLTIP_RIGHT_BOTTOM:
  842. nDirection = PPTOOLTIP_LEFT_BOTTOM;
  843. break;
  844. }
  845. return nDirection;
  846. }
  848. ///////////////////////////////////////////////////
  849. // Gets the next vertical direction
  850. //
  851. // Parameters:
  852. // nDirection [in] - the current direction
  853. //
  854. // Return value:
  855. // The next vertical direction
  856. ///////////////////////////////////////////////////
  857. int CPPToolTip::GetNextVertDirection(int nDirection) const
  858. {
  859. switch (nDirection)
  860. {
  861. case PPTOOLTIP_LEFT_TOP:
  862. nDirection = PPTOOLTIP_LEFT_BOTTOM;
  863. break;
  864. case PPTOOLTIP_LEFT_BOTTOM:
  865. nDirection = PPTOOLTIP_LEFT_TOP;
  866. break;
  867. case PPTOOLTIP_RIGHT_TOP:
  868. nDirection = PPTOOLTIP_RIGHT_BOTTOM;
  869. break;
  870. case PPTOOLTIP_RIGHT_BOTTOM:
  871. nDirection = PPTOOLTIP_RIGHT_TOP;
  872. break;
  873. }
  874. return nDirection;
  875. }
  877. BOOL CPPToolTip::TestHorizDirection(int x, int cx, int w_cx, int nDirection, LPRECT rect) const
  878. {
  879. int left,right;
  881. switch (nDirection)
  882. {
  883. case PPTOOLTIP_LEFT_TOP:
  884. case PPTOOLTIP_LEFT_BOTTOM:
  885. right = ((x + (int)m_nSizes[PPTTSZ_MARGIN_ANCHOR]) > w_cx) ? w_cx : (x + m_nSizes[PPTTSZ_MARGIN_ANCHOR]);
  886. left = right - cx;
  887. break;
  888. case PPTOOLTIP_RIGHT_TOP:
  889. case PPTOOLTIP_RIGHT_BOTTOM:
  890. left = (x < (int)m_nSizes[PPTTSZ_MARGIN_ANCHOR]) ? 0 : (x - m_nSizes[PPTTSZ_MARGIN_ANCHOR]);
  891. right = left + cx;
  892. break;
  893. }
  895. BOOL bTestOk = ((left >= 0) && (right <= w_cx)) ? TRUE : FALSE;
  896. if (bTestOk)
  897. {
  898. rect->left = left;
  899. rect->right = right;
  900. }
  902. return bTestOk;
  903. }
  905. BOOL CPPToolTip::TestVertDirection(int y, int cy, int w_cy, int nDirection, LPRECT rect) const
  906. {
  907. int top, bottom;
  909. switch (nDirection)
  910. {
  911. case PPTOOLTIP_LEFT_TOP:
  912. case PPTOOLTIP_RIGHT_TOP:
  913. bottom = y;
  914. top = bottom - cy;
  915. break;
  916. case PPTOOLTIP_LEFT_BOTTOM:
  917. case PPTOOLTIP_RIGHT_BOTTOM:
  918. top = y;
  919. bottom = top + cy;
  920. break;
  921. }
  923. BOOL bTestOk = ((top >= 0) && (bottom <= w_cy)) ? TRUE : FALSE;
  924. if (bTestOk)
  925. {
  926. rect->top = top;
  927. rect->bottom = bottom;
  928. }
  930. return bTestOk;
  931. }
  933. /////////////////////////////////////////////////////////////////
  934. // Gets the system tooltip's logfont
  935. /////////////////////////////////////////////////////////////////
  936. LPLOGFONT CPPToolTip::GetSystemToolTipFont() const
  937. {
  938.     static LOGFONT LogFont;
  940.     NONCLIENTMETRICS ncm;
  941.     ncm.cbSize = sizeof(NONCLIENTMETRICS);
  942.     if (!SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0))
  943.         return FALSE;
  945.     memcpy(&LogFont, &(ncm.lfStatusFont), sizeof(LOGFONT));
  947.     return &LogFont; 
  948. }
  950. /////////////////////////////////////////////////////////////////
  951. // Prints the formating string of the tooltip
  952. //  
  953. // Parameters:
  954. // pDC  - [in] The device context to print the string
  955. //      str  - [in] The formating string for drawing
  956. //      rect         - [in] The rectangle to draws the tooltip
  957. // bEnableAlign - [in] If TRUE align's operators are enables.
  958. //
  959. // Return values:
  960. //      None.
  961. //---------------------------------------------------------------
  962. // Format of string:
  963. //  <b> text </b> - The bold string
  964. //  <i> text </i> - The italic string 
  965. //  <u> text </u> - The underline string
  966. //  <s> text </s> - The strike out string
  967. //
  968. //  <cb=0x123456> text </cb> - The background color (RGB (12,34,56))
  969. //  <ct=0x123456> text </ct> - The text color (RGB (12,34,56))
  970. //
  971. //  <cbi=1> text </cbi> - The index background color(0 - F)
  972. //  <cti=1> text </cti> - The index text color(0 - F)
  973. //
  974. // <al> or <al_l> - sets align to left edge
  975. //  <al_c> - sets align to the center 
  976. //  <al_r> - sets align to the right edge
  977. //
  978. // <hr=100%> - the horizontal line with length 100%
  979. //  <hr=32> - the horizontal line with length 32 pixels.
  980. //
  981. // <a="link"> text </a> - The hyperlink 
  982. //
  983. //  <h=1> text </h> - hot zone (number of zone)
  984. //
  985. // <br[=1]> - new line (numbers of the lines)
  986. //  <t[=1]> - tabulation (number of tabulations)
  987. //
  988. //  <img[=0x0000] [cx=0] [cy=0]>  - draws the image by his name
  989. //  <ilst[=0x0000]>  - draws the image from image list
  990. //  <bmp[=0x0000] mask[=0xFF00FF] [cx=0] [cy=0]> - draws bitmap
  991. //  <icon[=0x0000] [cx=0] [cy=0]>  - draws the icon
  992. ////////////////////////////////////////////////////////////////
  993. CSize CPPToolTip::PrintTitleString(CDC * pDC, CRect rect, CString str, BOOL bCalculate /* = TRUE */)
  994. {
  995. enum{ CMD_NONE = 0,
  996. CMD_BOLD,
  997. CMD_ITALIC,
  998. CMD_STRIKE,
  999. CMD_UNDERLINE,
  1000. CMD_COLOR_TEXT,
  1001. CMD_COLOR_TEXT_INDEX,
  1002. CMD_COLOR_BK,
  1003. CMD_COLOR_BK_INDEX,
  1004. CMD_NEW_LINE,
  1005. CMD_TABULATION,
  1006. CMD_HORZ_LINE,
  1007. CMD_HORZ_LINE_PERCENT,
  1008. CMD_DRAW_IMAGE,
  1009. CMD_DRAW_IMAGE_LIST,
  1010. CMD_DRAW_BITMAP,
  1011. CMD_DRAW_BITMAP_MASK,
  1012. CMD_DRAW_ICON
  1013. };
  1015. enum{ ALIGN_LEFT = 0,
  1016. ALIGN_CENTER,
  1017. ALIGN_RIGHT
  1018. };
  1020. //Clears the length of the lines
  1021. if (bCalculate)
  1022. {
  1023. m_nLengthLines.RemoveAll();
  1024. m_nHeightLines.RemoveAll();
  1025. }
  1027. int nLine = 0;
  1028. int nCmd = CMD_NONE;
  1029. int nAlign = ALIGN_LEFT;
  1030. BOOL bCloseTag = FALSE;
  1032. CSize sz(0, 0);
  1033. CSize szLine (0, 0);
  1034. CSize szIcon (0, 0); //The size of icon
  1036. if (str.IsEmpty())
  1037. return sz;
  1039. CPoint pt = rect.TopLeft();
  1040. CPoint  ptCur = pt;
  1042. // Copies default logfont's structure
  1043. LOGFONT lf;
  1044.     memcpy(&lf, &m_LogFont, sizeof(LOGFONT));
  1046. CFont font;
  1047. font.CreateFontIndirect(&lf);
  1049. CFont * pOldFont = pDC->SelectObject(&font);
  1051. TEXTMETRIC tm;
  1052. pDC->GetTextMetrics(&tm);
  1053. int nHeight = tm.tmHeight; //The height of the font
  1054. int nWidth = tm.tmAveCharWidth; //The width of the font
  1056. CString strTag = _T("");  // Tag's name 
  1057. CString strText = _T(""); // The current text to output
  1058. CString sParam = _T(""); // The text parameter
  1060. UINT nParam = 0, nParam1 = 0;
  1061. int nLineHeight = bCalculate ? nHeight : m_nHeightLines.GetAt(0); //The height of the current line
  1063. CUIntArray percent;
  1064. percent.Add(0);
  1066. int nTemp = 0; //the temporary variable
  1067. BOOL bFirstOutput = TRUE;
  1069. for (int i = 0; i <= str.GetLength(); i++)
  1070. {
  1071. if (i < str.GetLength())
  1072. {
  1073. nCmd = CMD_NONE;
  1074. strText = SearchBeginOfTag(str, i);
  1075. if (strText.IsEmpty())
  1076. {
  1077. //Tag was found
  1078. strTag = GetNameOfTag(str, i);
  1079. bCloseTag = (strTag.GetAt(0) == _T('/')) ? TRUE : FALSE;
  1080. if (bCloseTag)
  1081. strTag = strTag.Right(strTag.GetLength() - 1);
  1083. if (!strTag.CompareNoCase(_T("b")))
  1084. {
  1085. nCmd = CMD_BOLD;
  1086. }
  1087. else if (!strTag.CompareNoCase(_T("i")))
  1088. {
  1089. nCmd = CMD_ITALIC;
  1090. }
  1091. else if (!strTag.CompareNoCase(_T("u")))
  1092. {
  1093. nCmd = CMD_UNDERLINE;
  1094. }
  1095. else if (!strTag.CompareNoCase(_T("s")))
  1096. {
  1097. nCmd = CMD_STRIKE;
  1098. }
  1099. else if (!strTag.CompareNoCase(_T("br")))
  1100. {
  1101. nCmd = CMD_NEW_LINE;
  1102. nParam = GetUIntValue(str, i, 1);
  1103. }
  1104. else if (!strTag.CompareNoCase(_T("t")))
  1105. {
  1106. nCmd = CMD_TABULATION;
  1107. nParam = GetUIntValue(str, i, 1);
  1108. }
  1109. else if (strTag.GetAt(0) == _T('n'))
  1110. {
  1111. nCmd = CMD_NEW_LINE;
  1112. nParam = 1;
  1113. }
  1114. else if (strTag.GetAt(0) == _T('t'))
  1115. {
  1116. nCmd = CMD_TABULATION;
  1117. nParam = 1;
  1118. }
  1119. else if (!strTag.CompareNoCase(_T("ct")))
  1120. {
  1121. nCmd = CMD_COLOR_TEXT;
  1122. nParam = GetUIntValue(str, i, (UINT)m_crColor[PPTOOLTIP_COLOR_FG]);
  1123. }
  1124. else if (!strTag.CompareNoCase(_T("cti")))
  1125. {
  1126. nCmd = CMD_COLOR_TEXT;
  1127. nParam = GetUIntValue(str, i, PPTOOLTIP_COLOR_FG);
  1128. }
  1129. else if (!strTag.CompareNoCase(_T("cb")))
  1130. {
  1131. nCmd = CMD_COLOR_BK;
  1132. nParam = GetUIntValue(str, i, (UINT)m_crColor[PPTOOLTIP_COLOR_BK_BEGIN]);
  1133. }
  1134. else if (!strTag.CompareNoCase(_T("cbi")))
  1135. {
  1136. nCmd = CMD_COLOR_BK_INDEX;
  1137. nParam = GetUIntValue(str, i, PPTOOLTIP_COLOR_BK_BEGIN);
  1138. }
  1139. else if (!strTag.CompareNoCase(_T("al")) || !strTag.CompareNoCase(_T("al_l")))
  1140. {
  1141. nAlign = ALIGN_LEFT;
  1142. }
  1143. else if (!strTag.CompareNoCase(_T("al_c")))
  1144. {
  1145. if (!bCalculate)
  1146. nAlign = ALIGN_CENTER;
  1147. }
  1148. else if (!strTag.CompareNoCase(_T("al_r")))
  1149. {
  1150. if (!bCalculate)
  1151. nAlign = ALIGN_RIGHT;
  1152. }
  1153. else if (!strTag.CompareNoCase(_T("hr")))
  1154. {
  1155. sParam = GetStringValue(str, i);
  1156. if (!sParam.IsEmpty())
  1157. nParam = _tcstoul(sParam, 0, 0);
  1158. else
  1159. nParam = 100;
  1160. nCmd = (sParam.Right(1) == _T("%"))? CMD_HORZ_LINE_PERCENT : CMD_HORZ_LINE;
  1161. }
  1162. else if (!strTag.CompareNoCase(_T("img")))
  1163. {
  1164. nCmd = CMD_DRAW_IMAGE;
  1165. sParam = GetStringValue(str, i);
  1166. szIcon = CSize(0, 0);
  1167. //Gets two param
  1168. for (nTemp = 0; nTemp < 2; nTemp++)
  1169. {
  1170. strTag = GetPropertiesOfTag(str, i);
  1171. if (!strTag.CompareNoCase(_T("cx")))
  1172. szIcon.cx = GetUIntValue(str, i, 0);
  1173. else if (!strTag.CompareNoCase(_T("cy")))
  1174. szIcon.cy = GetUIntValue(str, i, 0);
  1175. }
  1176. }
  1177. else if (!strTag.CompareNoCase(_T("ilst")))
  1178. {
  1179. nCmd = CMD_DRAW_IMAGE_LIST;
  1180. nParam = GetUIntValue(str, i, 0);
  1181. }
  1182. else if (!strTag.CompareNoCase(_T("icon")))
  1183. {
  1184. nCmd = CMD_DRAW_ICON;
  1185. nParam = GetUIntValue(str, i, 0);
  1186. szIcon = CSize(0, 0);
  1187. //Gets two param
  1188. for (nTemp = 0; nTemp < 2; nTemp++)
  1189. {
  1190. strTag = GetPropertiesOfTag(str, i);
  1191. if (!strTag.CompareNoCase(_T("cx")))
  1192. szIcon.cx = GetUIntValue(str, i, 0);
  1193. else if (!strTag.CompareNoCase(_T("cy")))
  1194. szIcon.cy = GetUIntValue(str, i, 0);
  1195. }
  1196. }
  1197. else if (!strTag.CompareNoCase(_T("bmp")))
  1198. {
  1199. nCmd = CMD_DRAW_BITMAP;
  1200. nParam = GetUIntValue(str, i, 0);
  1201. sParam.Empty();
  1202. //Gets three param
  1203. for (nTemp = 0; nTemp < 3; nTemp++)
  1204. {
  1205. strTag = GetPropertiesOfTag(str, i);
  1206. if (!strTag.CompareNoCase(_T("mask")))
  1207. {
  1208. sParam = strTag;
  1209. nParam1 = GetUIntValue(str, i, 0xFF00FF);
  1210. }
  1211. else if (!strTag.CompareNoCase(_T("cx")))
  1212. szIcon.cx = GetUIntValue(str, i, 0);
  1213. else if (!strTag.CompareNoCase(_T("cy")))
  1214. szIcon.cy = GetUIntValue(str, i, 0);
  1215. }
  1216. }
  1217. else nCmd = CMD_NONE;
  1218. SearchEndOfTag(str, i);
  1219. }
  1220. else
  1221. {
  1222. //If text to output is exist
  1223. if (bFirstOutput)
  1224. {
  1225. switch (nAlign)
  1226. {
  1227. case ALIGN_CENTER:
  1228. ptCur.x = pt.x + (rect.Width() - m_nLengthLines.GetAt(nLine)) / 2;
  1229. break;
  1230. case ALIGN_RIGHT:
  1231. ptCur.x = pt.x + rect.Width() - m_nLengthLines.GetAt(nLine);
  1232. break;
  1233. }
  1234. }
  1235. szLine = pDC->GetTextExtent(strText);
  1236. if (bCalculate)
  1237. nLineHeight = max(nLineHeight, szLine.cy);
  1238. else
  1239. pDC->TextOut(ptCur.x, ptCur.y + m_nHeightLines.GetAt(nLine) - nHeight, strText);
  1240. ptCur.x += szLine.cx;
  1241. strText = _T("");
  1242. bFirstOutput = FALSE;
  1243. i--;
  1244. }
  1245. }
  1246. else
  1247. {
  1248. nCmd = CMD_NEW_LINE;
  1249. nParam = 1; 
  1250. }
  1252. //Prepares to first draw in line
  1253. switch (nCmd)
  1254. {
  1255. case CMD_DRAW_IMAGE:
  1256. case CMD_DRAW_IMAGE_LIST:
  1257. case CMD_DRAW_BITMAP:
  1258. case CMD_DRAW_ICON:
  1259. if (bFirstOutput)
  1260. {
  1261. switch (nAlign)
  1262. {
  1263. case ALIGN_CENTER:
  1264. ptCur.x = pt.x + (rect.Width() - m_nLengthLines.GetAt(nLine)) / 2;
  1265. break;
  1266. case ALIGN_RIGHT:
  1267. ptCur.x = pt.x + rect.Width() - m_nLengthLines.GetAt(nLine);
  1268. break;
  1269. }
  1270. bFirstOutput = FALSE;
  1271. }
  1272. break;
  1273. }
  1275. //Executes command
  1276. switch (nCmd)
  1277. {
  1278. case CMD_BOLD:
  1279. //Bold text
  1280. pDC->SelectObject(pOldFont);
  1281. font.DeleteObject();
  1282. lf.lfWeight = m_LogFont.lfWeight;
  1283. if (!bCloseTag)
  1284. {
  1285. lf.lfWeight *= 2;
  1286. if (lf.lfWeight > FW_BLACK)
  1287. lf.lfWeight = FW_BLACK;
  1288. }
  1289. font.CreateFontIndirect(&lf);
  1290. pDC->SelectObject(&font);
  1291. break;
  1292. case CMD_ITALIC:
  1293. //Italic text
  1294. pDC->SelectObject(pOldFont);
  1295. font.DeleteObject();
  1296. lf.lfItalic = bCloseTag ? FALSE : TRUE;
  1297. font.CreateFontIndirect(&lf);
  1298. pDC->SelectObject(&font);
  1299. break;
  1300. case CMD_STRIKE:
  1301. //Strikeout text
  1302. pDC->SelectObject(pOldFont);
  1303. font.DeleteObject();
  1304. lf.lfStrikeOut = bCloseTag ? FALSE : TRUE;
  1305. font.CreateFontIndirect(&lf);
  1306. pDC->SelectObject(&font);
  1307. break;
  1308. case CMD_UNDERLINE:
  1309. //Underline text
  1310. pDC->SelectObject(pOldFont);
  1311. font.DeleteObject();
  1312. lf.lfUnderline = bCloseTag ? FALSE : TRUE;
  1313. font.CreateFontIndirect(&lf);
  1314. pDC->SelectObject(&font);
  1315. break;
  1316. case CMD_COLOR_TEXT:
  1317. //Color of the text
  1318. pDC->SetTextColor((COLORREF)nParam);
  1319. break;
  1320. case CMD_COLOR_TEXT_INDEX:
  1321. //Indexed color of the text
  1322. if (nParam < PPTOOLTIP_MAX_COLORS)
  1323. pDC->SetTextColor(m_crColor[nParam]);
  1324. break;
  1325. case CMD_COLOR_BK:
  1326. //Color of the background
  1327. pDC->SetBkColor((COLORREF)nParam);
  1328. pDC->SetBkMode(bCloseTag ? TRANSPARENT : OPAQUE);
  1329. break;
  1330. case CMD_COLOR_BK_INDEX:
  1331. //Indexed color of the background
  1332. if (nParam < PPTOOLTIP_MAX_COLORS)
  1333. {
  1334. pDC->SetBkColor(m_crColor[nParam]);
  1335. pDC->SetBkMode(bCloseTag ? TRANSPARENT : OPAQUE);
  1336. }
  1337. break;
  1338. case CMD_HORZ_LINE_PERCENT:
  1339. //Horizontal line with percent length
  1340. if (bCalculate)
  1341. {
  1342. percent.SetAt(nLine, percent.GetAt(nLine) + nParam);
  1343. nParam = 0;
  1344. }
  1345. else nParam = ::MulDiv(rect.Width(), nParam, 100);
  1346. case CMD_HORZ_LINE:
  1347. //Horizontal line with absolute length
  1348. //If text to output is exist
  1349. if (!bCalculate)
  1350. DrawHorzLine(pDC, ptCur.x, ptCur.x + nParam, ptCur.y + m_nHeightLines.GetAt(nLine) / 2);
  1351. ptCur.x += nParam;
  1352. break;
  1353. case CMD_DRAW_IMAGE:
  1354. if (!sParam.IsEmpty())
  1355. {
  1356. if (bCalculate)
  1357. {
  1358. szLine = DrawResource(sParam, pDC, ptCur, 0, szIcon, bCalculate);
  1359. nLineHeight = max (nLineHeight, szLine.cy);
  1360. }
  1361. else
  1362. szLine = DrawResource(sParam, pDC, ptCur, m_nHeightLines.GetAt(nLine), szIcon, bCalculate);
  1364. ptCur.x += szLine.cx;
  1365. }
  1366. break;
  1367. case CMD_DRAW_IMAGE_LIST:
  1368. if (m_imgTooltip.m_hImageList != NULL)
  1369. {
  1370. if (bCalculate)
  1371. {
  1372. szLine = DrawIconFromImageList(pDC, ptCur, m_szImage, m_imgTooltip, nParam, bCalculate);
  1373. nLineHeight = max (nLineHeight, szLine.cy);
  1374. }
  1375. else
  1376. {
  1377. szLine = DrawIconFromImageList(pDC, ptCur, m_szImage, m_imgTooltip, nParam, bCalculate);
  1378. }
  1379. // If in one line a few bitmap with different height, then store max height
  1380. ptCur.x += szLine.cx; //m_szImage.cx;
  1381. }
  1382. break;
  1383. case CMD_DRAW_BITMAP:
  1384. if (nParam != 0)
  1385. {
  1386. if (bCalculate)
  1387. {
  1388. szLine = DrawBitmap(pDC, ptCur, 0, nParam, !sParam.IsEmpty(), nParam1, szIcon, bCalculate);
  1389. nLineHeight = max (nLineHeight, szLine.cy);
  1390. }
  1391. else
  1392. {
  1393. szLine = DrawBitmap(pDC, ptCur, m_nHeightLines.GetAt(nLine), nParam, !sParam.IsEmpty(), nParam1, szIcon, bCalculate);
  1394. }
  1395. // If in one line a few bitmap with different height, then store max height
  1396. ptCur.x += szLine.cx;
  1397. }
  1398. case CMD_DRAW_ICON:
  1399. if (nParam != 0)
  1400. {
  1401. if (bCalculate)
  1402. {
  1403. szLine = DrawIcon(pDC, ptCur, 0, nParam, szIcon, bCalculate);
  1404. nLineHeight = max (nLineHeight, szLine.cy);
  1405. }
  1406. else
  1407. {
  1408. szLine = DrawIcon(pDC, ptCur, m_nHeightLines.GetAt(nLine), nParam, szIcon, bCalculate);
  1409. }
  1410. // If in one line a few bitmap with different height, then store max height
  1411. ptCur.x += szLine.cx;
  1412. }
  1413. break;
  1414. case CMD_NEW_LINE:
  1415. //New line
  1416. if (!nParam)
  1417. nParam = 1;
  1418. if (bCalculate)
  1419. {
  1420. sz.cx = max(sz.cx, ptCur.x - pt.x);
  1421. m_nLengthLines.Add(ptCur.x - pt.x); //Adds the real length of the lines
  1422. m_nHeightLines.Add(nLineHeight); //Adds the real height of the lines
  1423. }
  1424. ptCur.y += m_nHeightLines.GetAt(nLine) * nParam;
  1425. nLine ++;
  1426. percent.Add(0);
  1427. bFirstOutput = TRUE;
  1428. ptCur.x = pt.x;
  1429. nLineHeight = nHeight;
  1430. // szLine.cy = nHeight;
  1431. break;
  1432. case CMD_TABULATION:
  1433. //Tabulation
  1434. if (!nParam)
  1435. nParam = 1;
  1436. nParam1 = (ptCur.x - pt.x) % (nWidth * 4);
  1437. if (nParam1)
  1438. {
  1439. //aligns with tab
  1440. ptCur.x += (nWidth * 4) - nParam1;
  1441. nParam --;
  1442. }
  1443. ptCur.x += (nParam * nWidth * 4);
  1444. break;
  1445. }
  1446. }
  1448. //Gets real height of the tooltip
  1449. sz.cy = ptCur.y - pt.y;
  1451. pDC->SelectObject(pOldFont);
  1452. font.DeleteObject();
  1454. //Adds the percent's length to the line's length
  1455. for (i = 0; i < percent.GetSize(); i++)
  1456. {
  1457. if (percent.GetAt(i))
  1458. m_nLengthLines.SetAt(i, m_nLengthLines.GetAt(i) + ::MulDiv(percent.GetAt(i), sz.cx, 100));
  1459. }
  1461. return sz;
  1462. }
  1464. CString CPPToolTip::SearchBeginOfTag(CString & str, int & nIndex)
  1465. {
  1466. CString sText = _T("");
  1467. BOOL bTagFound = FALSE;
  1469. for (nIndex; nIndex < str.GetLength(); nIndex ++)
  1470. {
  1471. switch (str.GetAt(nIndex))
  1472. {
  1473. case _T('r'):
  1474. break;
  1475. case _T('<'):
  1476. nIndex ++;
  1477. if ((nIndex < str.GetLength()) && (str.GetAt(nIndex) != _T('<')))
  1478. {
  1479. if (!sText.IsEmpty())
  1480. nIndex --;
  1481. return sText;
  1482. }
  1483. sText += _T('<');
  1484. break;
  1485. case _T('t'):
  1486. case _T('n'):
  1487. if (!sText.IsEmpty())
  1488. nIndex--;
  1489. return sText;
  1490. default:
  1491. sText += str.GetAt(nIndex);
  1492. break;
  1493. }
  1494. }
  1495. return sText;
  1496. }
  1498. void CPPToolTip::SearchEndOfTag(CString & str, int & nIndex)
  1499. {
  1500. for (nIndex; nIndex < str.GetLength(); nIndex ++)
  1501. {
  1502. switch (str.GetAt(nIndex))
  1503. {
  1504. case _T('>'):
  1505. case _T('n'):
  1506. case _T('t'):
  1507. return;
  1508. }
  1509. }
  1510. }
  1512. CString CPPToolTip::GetNameOfTag(CString & str, int & nIndex)
  1513. {
  1514. CString sText = _T("");
  1516. for (nIndex; nIndex < str.GetLength(); nIndex ++)
  1517. {
  1518. switch (str.GetAt(nIndex))
  1519. {
  1520. case _T('r'): //Pass character
  1521. break;
  1522. case _T('t'): //It is a tab tag
  1523. case _T('n'): //It is a new line tag
  1524. if (sText.IsEmpty())
  1525. {
  1526. sText += str.GetAt(nIndex);
  1527. // nIndex ++;
  1528. return sText;
  1529. }
  1530. break;
  1531. case _T(' '):
  1532. if (!sText.IsEmpty())
  1533. {
  1534. nIndex ++;
  1535. return sText;
  1536. }
  1537. break;
  1538. case _T('>'):
  1539. case _T('='):
  1540. return sText;
  1541. default:
  1542. sText += str.GetAt(nIndex);
  1543. break;
  1544. }
  1545. }
  1546. return sText;
  1547. }
  1549. CString CPPToolTip::GetPropertiesOfTag(CString & str, int & nIndex)
  1550. {
  1551. CString sText = _T("");
  1553. for (nIndex; nIndex < str.GetLength(); nIndex ++)
  1554. {
  1555. switch (str.GetAt(nIndex))
  1556. {
  1557. case _T('r'): //Pass characters
  1558. case _T('t'):
  1559. case _T('n'):
  1560. break;
  1561. case _T(' '):
  1562. if (!sText.IsEmpty())
  1563. {
  1564. nIndex ++;
  1565. return sText;
  1566. }
  1567. break;
  1568. case _T('>'):
  1569. case _T('='):
  1570. return sText;
  1571. default:
  1572. sText += str.GetAt(nIndex);
  1573. break;
  1574. }
  1575. }
  1576. return sText;
  1577. }
  1579. CString CPPToolTip::GetStringValue(CString & str, int & nIndex)
  1580. {
  1581. CString sText = _T("");
  1582. BOOL bValueFound = FALSE;
  1584. for (nIndex; nIndex < str.GetLength(); nIndex ++)
  1585. {
  1586. switch (str.GetAt(nIndex))
  1587. {
  1588. case _T('r'): //Pass character
  1589. case _T('t'): //It is a tab tag
  1590. case _T('n'): //It is a new line tag
  1591. break;
  1592. case _T(' '):
  1593. if (!sText.IsEmpty())
  1594. {
  1595. nIndex ++;
  1596. return sText;
  1597. }
  1598. break;
  1599. case _T('>'):
  1600. return sText;
  1601. case _T('='):
  1602. bValueFound = TRUE;
  1603. break;
  1604. default:
  1605. if (!bValueFound)
  1606. return sText;
  1607. sText += str.GetAt(nIndex);
  1608. break;
  1609. }
  1610. }
  1611. return sText;
  1613. }
  1615. UINT CPPToolTip::GetUIntValue(CString & str, int & nIndex, UINT nDefValue)
  1616. {
  1617. CString sText = GetStringValue(str, nIndex);
  1618. if (!sText.IsEmpty())
  1619. nDefValue = _tcstoul(sText, 0, 0);
  1621. return nDefValue;
  1622. }
  1624. CSize CPPToolTip::DrawResource(CString sName, CDC * pDC, CPoint pt, int nMaxHeight, CSize szResource, BOOL bCalculate)
  1625. {
  1626. CSize sz(0, 0);
  1628. int nIndex = FindIdOfResource(sName);
  1629. if (nIndex < 0)
  1630. return sz;
  1632. PPTOOLTIP_NAME_RES nr = m_arrNameRes.GetAt(nIndex);
  1634. if (nr.nID == 0)
  1635. return sz;
  1637. switch (nr.nTypeRes)
  1638. {
  1639. case TYPE_RES_ICON:
  1640. sz = DrawIcon(pDC, pt, nMaxHeight, nr.nID, szResource, bCalculate);
  1641. break;
  1642. case TYPE_RES_BITMAP:
  1643. sz = DrawBitmap(pDC, pt, nMaxHeight, nr.nID, FALSE, nr.crMask, szResource, bCalculate);
  1644. break;
  1645. case TYPE_RES_MASK_BITMAP:
  1646. sz = DrawBitmap(pDC, pt, nMaxHeight, nr.nID, TRUE, nr.crMask, szResource, bCalculate);
  1647. break;
  1648. }
  1650. return sz;
  1651. }
  1653. CSize CPPToolTip::DrawBitmap(CDC * pDC, CPoint pt, int nMaxHeight, UINT nID, BOOL bUseMask, COLORREF crMask, CSize szBitmap, BOOL bCalculate)
  1654. {
  1655. CSize sz(0, 0);
  1656. HBITMAP hBitmap = GetBitmapFromResources(nID);
  1658. int nRetValue;
  1659. BITMAP csBitmapSize;
  1661. if (hBitmap == NULL)
  1662. return sz;
  1664. // Get bitmap size
  1665. nRetValue = ::GetObject(hBitmap, sizeof(csBitmapSize), &csBitmapSize);
  1666. if (nRetValue == 0)
  1667. return sz;
  1669. sz.cx = (DWORD)csBitmapSize.bmWidth;
  1670. sz.cy = (DWORD)csBitmapSize.bmHeight;
  1672. if (!szBitmap.cy)
  1673. szBitmap.cy = sz.cy;
  1675. if (!szBitmap.cx)
  1676. szBitmap.cx = sz.cx;
  1678. if (bCalculate)
  1679. return szBitmap;
  1681. HDC hSrcDC = ::CreateCompatibleDC(pDC->m_hDC);
  1682. HDC hResDC = ::CreateCompatibleDC(pDC->m_hDC);
  1684. HBITMAP hSrcBitmap = ::CreateCompatibleBitmap(pDC->m_hDC, szBitmap.cx, szBitmap.cy);
  1685. HBITMAP hOldSrcBitmap = (HBITMAP)::SelectObject(hSrcDC, hSrcBitmap);
  1686. HBITMAP hOldResBitmap = (HBITMAP)::SelectObject(hResDC, hBitmap);
  1688. //Scales a bitmap if need
  1689. if ((sz.cx != szBitmap.cx) || (sz.cy != szBitmap.cy))
  1690. ::StretchBlt(hSrcDC, 0, 0, szBitmap.cx, szBitmap.cy, hResDC, 0, 0, sz.cx, sz.cy, SRCCOPY);
  1691. else
  1692. ::BitBlt(hSrcDC, 0, 0, szBitmap.cx, szBitmap.cy, hResDC, 0, 0, SRCCOPY);
  1694. ::SelectObject(hResDC, hOldResBitmap);
  1695. ::DeleteDC(hResDC);
  1696. ::DeleteObject(hOldResBitmap);
  1697. ::DeleteObject(hBitmap);
  1699. pt.y += (nMaxHeight - szBitmap.cy);
  1701. if (bUseMask)
  1702. {
  1703. //Draws a bitmap with mask
  1704. ::SelectObject(hSrcDC, hOldSrcBitmap);
  1705. CImageList img;
  1706. img.Create(szBitmap.cx, szBitmap.cy, ILC_COLOR32 | ILC_MASK, 1, 1);
  1707. img.Add(CBitmap::FromHandle(hSrcBitmap), crMask);
  1708. DrawIconFromImageList(pDC, pt, szBitmap, img, 0, FALSE);
  1709. }
  1710. else
  1711. {
  1712. //Draws a bitmap without mask
  1713. pDC->BitBlt(pt.x, pt.y, szBitmap.cx, szBitmap.cy, CDC::FromHandle(hSrcDC), 0, 0, SRCCOPY);
  1714. ::SelectObject(hSrcDC, hOldSrcBitmap);
  1715. }
  1717. ::DeleteDC(hSrcDC);
  1718. ::DeleteObject(hOldSrcBitmap);
  1719. ::DeleteObject(hSrcBitmap);
  1721. return szBitmap;
  1722. }
  1724. CSize CPPToolTip::DrawIcon(CDC * pDC, CPoint pt, int nMaxHeight, UINT nID, CSize szIcon, BOOL bCalculate)
  1725. {
  1726. CSize sz (0, 0);
  1727. HICON hIcon = GetIconFromResources(nID, szIcon);
  1728. if (hIcon != NULL)
  1729. {
  1730. sz = GetSizeIcon(hIcon);
  1731. if (!bCalculate)
  1732. {
  1733. pt.y += (nMaxHeight - sz.cy);
  1734. pDC->DrawState(pt, sz, hIcon, DSS_NORMAL, (CBrush*)NULL);
  1735. }
  1736. }
  1738. if (hIcon)
  1739. ::DestroyIcon(hIcon);
  1741. return sz;
  1742. }
  1744. CSize CPPToolTip::DrawIconFromImageList(CDC * pDC, CPoint pt, CSize sz, CImageList & img, int nIndex /* = 0 */, BOOL bCalculate /* = TRUE */)
  1745. {
  1746. if (img.GetSafeHandle() == NULL)
  1747. return CSize (0, 0);
  1749. int nCount = img.GetImageCount();
  1750. if (nIndex >= nCount)
  1751. return CSize (0, 0);
  1753. if (bCalculate)
  1754. return sz;
  1756. HICON hIcon = img.ExtractIcon(nIndex);
  1757. pDC->DrawState(pt, sz, hIcon, DSS_NORMAL, (CBrush*)NULL);
  1759. if (hIcon)
  1760. DestroyIcon(hIcon);
  1762. return sz;
  1763. }
  1765. void CPPToolTip::DrawHorzLine(CDC * pDC, int xStart, int xEnd, int y) const
  1766. {
  1767. CPen pen(PS_SOLID, 1, pDC->GetTextColor());
  1768. CPen * penOld = pDC->SelectObject(&pen);
  1769. pDC->MoveTo(xStart, y);
  1770. pDC->LineTo(xEnd, y);
  1771. pDC->SelectObject(penOld);
  1772. pen.DeleteObject();
  1773. }
  1775. void CPPToolTip::FillGradient ( CDC * pDC, CRect rect, 
  1776. COLORREF colorStart, COLORREF colorFinish, 
  1777. BOOL bHorz/* = TRUE*/)
  1778. {
  1779.     // this will make 2^6 = 64 fountain steps
  1780.     int nShift = 6;
  1781.     int nSteps = 1 << nShift;
  1783.     for (int i = 0; i < nSteps; i++)
  1784.     {
  1785.         // do a little alpha blending
  1786.         BYTE bR = (BYTE) ((GetRValue(colorStart) * (nSteps - i) +
  1787.                    GetRValue(colorFinish) * i) >> nShift);
  1788.         BYTE bG = (BYTE) ((GetGValue(colorStart) * (nSteps - i) +
  1789.                    GetGValue(colorFinish) * i) >> nShift);
  1790.         BYTE bB = (BYTE) ((GetBValue(colorStart) * (nSteps - i) +
  1791.                    GetBValue(colorFinish) * i) >> nShift);
  1793. CBrush br (RGB(bR, bG, bB));
  1795.         // then paint with the resulting color
  1796.         CRect r2 = rect;
  1797.         if (!bHorz)
  1798.         {
  1799.             r2.top = rect.top + 
  1800.                 ((i * rect.Height()) >> nShift);
  1801.             r2.bottom = rect.top + 
  1802.                 (((i + 1) * rect.Height()) >> nShift);
  1803.             if (r2.Height() > 0)
  1804.                 pDC->FillRect(r2, &br);
  1805.         }
  1806.         else
  1807.         {
  1808.             r2.left = rect.left + 
  1809.                 ((i * rect.Width()) >> nShift);
  1810.             r2.right = rect.left + 
  1811.                 (((i + 1) * rect.Width()) >> nShift);
  1812.             if (r2.Width() > 0)
  1813.                 pDC->FillRect(r2, &br);
  1814.         }
  1815.     }
  1816. }
  1818. #ifdef PPTOOLTIP_USE_SHADE
  1819. void CPPToolTip::SetShade(CRect rect, UINT shadeID /* = 0 */, BYTE granularity /* = 8 */, 
  1820.   BYTE coloring /* = 0 */, COLORREF color /* = 0 */)
  1821. {
  1822. long sXSize,sYSize,bytes,j,i,k,h;
  1823. BYTE *iDst ,*posDst;
  1825. sYSize= rect.Height(); //rect.bottom-rect.top;
  1826. sXSize= rect.Width(); //rect.right-rect.left ;
  1828. m_dh.Create(max(1,sXSize /*-2*m_FocusRectMargin-1*/ ),1,8); //create the horizontal focus bitmap
  1829. m_dv.Create(1,max(1,sYSize /*-2*m_FocusRectMargin*/),8); //create the vertical focus bitmap
  1831. m_dNormal.Create(sXSize,sYSize,8); //create the default bitmap
  1833. COLORREF hicr = m_pToolInfo.crBegin; //GetSysColor(COLOR_BTNHIGHLIGHT); //get the button base colors
  1834. COLORREF midcr = m_pToolInfo.crMid;  //GetSysColor(COLOR_BTNFACE);
  1835. COLORREF locr = m_pToolInfo.crEnd;   //GetSysColor(COLOR_BTNSHADOW);
  1836. long r,g,b; //build the shaded palette
  1837. for(i=0;i<129;i++){
  1838. r=((128-i)*GetRValue(locr)+i*GetRValue(midcr))/128;
  1839. g=((128-i)*GetGValue(locr)+i*GetGValue(midcr))/128;
  1840. b=((128-i)*GetBValue(locr)+i*GetBValue(midcr))/128;
  1841. m_dNormal.SetPaletteIndex((BYTE)i,(BYTE)r,(BYTE)g,(BYTE)b);
  1842. m_dh.SetPaletteIndex((BYTE)i,(BYTE)r,(BYTE)g,(BYTE)b);
  1843. m_dv.SetPaletteIndex((BYTE)i,(BYTE)r,(BYTE)g,(BYTE)b);
  1844. }
  1845. for(i=1;i<129;i++){
  1846. r=((128-i)*GetRValue(midcr)+i*GetRValue(hicr))/128;
  1847. g=((128-i)*GetGValue(midcr)+i*GetGValue(hicr))/128;
  1848. b=((128-i)*GetBValue(midcr)+i*GetBValue(hicr))/128;
  1849. m_dNormal.SetPaletteIndex((BYTE)(i+127),(BYTE)r,(BYTE)g,(BYTE)b);
  1850. m_dh.SetPaletteIndex((BYTE)(i+127),(BYTE)r,(BYTE)g,(BYTE)b);
  1851. m_dv.SetPaletteIndex((BYTE)(i+127),(BYTE)r,(BYTE)g,(BYTE)b);
  1852. }
  1854. m_dNormal.BlendPalette(color,coloring); //color the palette
  1856. iDst=m_dh.GetBits(); //build the horiz. dotted focus bitmap
  1857. j=(long)m_dh.GetWidth();
  1858. for(i=0;i<j;i++){
  1859. // iDst[i]=64+127*(i%2); //soft
  1860. iDst[i]=255*(i%2); //hard
  1861. }
  1863. iDst=m_dv.GetBits(); //build the vert. dotted focus bitmap
  1864. j=(long)m_dv.GetHeight();
  1865. for(i=0;i<j;i++){
  1866. // *iDst=64+127*(i%2); //soft
  1867. *iDst=255*(i%2); //hard
  1868. iDst+=4;
  1869. }
  1871. bytes = m_dNormal.GetLineWidth();
  1872. iDst = m_dNormal.GetBits();
  1873. posDst =iDst;
  1874. long a,x,y,d,xs,idxmax,idxmin;
  1876. int grainx2=RAND_MAX/(max(1,2*granularity));
  1877. idxmax=255-granularity;
  1878. idxmin=granularity;
  1880. switch (shadeID)
  1881. {
  1882. //----------------------------------------------------
  1883. case PPTOOLTIP_EFFECT_METAL:
  1884. m_dNormal.Clear();
  1885. // create the strokes
  1886. k=40; //stroke granularity
  1887. for(a=0;a<200;a++){
  1888. x=rand()/(RAND_MAX/sXSize); //stroke postion
  1889. y=rand()/(RAND_MAX/sYSize); //stroke position
  1890. xs=rand()/(RAND_MAX/min(sXSize,sYSize))/2; //stroke lenght
  1891. d=rand()/(RAND_MAX/k); //stroke color
  1892. for(i=0;i<xs;i++){
  1893. if (((x-i)>0)&&((y+i)<sYSize))
  1894. m_dNormal.SetPixelIndex(x-i,y+i,(BYTE)d);
  1895. if (((x+i)<sXSize)&&((y-i)>0))
  1896. m_dNormal.SetPixelIndex(sXSize-x+i,y-i,(BYTE)d);
  1897. }
  1898. }
  1899. //blend strokes with SHS_DIAGONAL
  1900. posDst =iDst;
  1901. a=(idxmax-idxmin-k)/2;
  1902. for(i = 0; i < sYSize; i++) {
  1903. for(j = 0; j < sXSize; j++) {
  1904. d=posDst[j]+((a*i)/sYSize+(a*(sXSize-j))/sXSize);
  1905. posDst[j]=(BYTE)d;
  1906. posDst[j]+=rand()/grainx2;
  1907. }
  1908. posDst+=bytes;
  1909. }
  1911. break;
  1912. //----------------------------------------------------
  1913. case PPTOOLTIP_EFFECT_HARDBUMP: // 
  1914. //set horizontal bump
  1915. for(i = 0; i < sYSize; i++) {
  1916. k=(255*i/sYSize)-127;
  1917. k=(k*(k*k)/128)/128;
  1918. k=(k*(128-granularity*2))/128+128;
  1919. for(j = 0; j < sXSize; j++) {
  1920. posDst[j]=(BYTE)k;
  1921. posDst[j]+=rand()/grainx2-granularity;
  1922. }
  1923. posDst+=bytes;
  1924. }
  1925. //set vertical bump
  1926. d=min(16,sXSize/6); //max edge=16
  1927. a=sYSize*sYSize/4;
  1928. posDst =iDst;
  1929. for(i = 0; i < sYSize; i++) {
  1930. y=i-sYSize/2;
  1931. for(j = 0; j < sXSize; j++) {
  1932. x=j-sXSize/2;
  1933. xs=sXSize/2-d+(y*y*d)/a;
  1934. if (x>xs) posDst[j]=idxmin+(BYTE)(((sXSize-j)*128)/d);
  1935. if ((x+xs)<0) posDst[j]=idxmax-(BYTE)((j*128)/d);
  1936. posDst[j]+=rand()/grainx2-granularity;
  1937. }
  1938. posDst+=bytes;
  1939. }
  1940. break;
  1941. //----------------------------------------------------
  1942. case PPTOOLTIP_EFFECT_SOFTBUMP: //
  1943. for(i = 0; i < sYSize; i++) {
  1944. h=(255*i/sYSize)-127;
  1945. for(j = 0; j < sXSize; j++) {
  1946. k=(255*(sXSize-j)/sXSize)-127;
  1947. k=(h*(h*h)/128)/128+(k*(k*k)/128)/128;
  1948. k=k*(128-granularity)/128+128;
  1949. if (k<idxmin) k=idxmin;
  1950. if (k>idxmax) k=idxmax;
  1951. posDst[j]=(BYTE)k;
  1952. posDst[j]+=rand()/grainx2-granularity;
  1953. }
  1954. posDst+=bytes;
  1955. }
  1956. break;
  1957. //----------------------------------------------------
  1958. case PPTOOLTIP_EFFECT_VBUMP: // 
  1959. for(j = 0; j < sXSize; j++) {
  1960. k=(255*(sXSize-j)/sXSize)-127;
  1961. k=(k*(k*k)/128)/128;
  1962. k=(k*(128-granularity))/128+128;
  1963. for(i = 0; i < sYSize; i++) {
  1964. posDst[j+i*bytes]=(BYTE)k;
  1965. posDst[j+i*bytes]+=rand()/grainx2-granularity;
  1966. }
  1967. }
  1968. break;
  1969. //----------------------------------------------------
  1970. case PPTOOLTIP_EFFECT_HBUMP: //
  1971. for(i = 0; i < sYSize; i++) {
  1972. k=(255*i/sYSize)-127;
  1973. k=(k*(k*k)/128)/128;
  1974. k=(k*(128-granularity))/128+128;
  1975. for(j = 0; j < sXSize; j++) {
  1976. posDst[j]=(BYTE)k;
  1977. posDst[j]+=rand()/grainx2-granularity;
  1978. }
  1979. posDst+=bytes;
  1980. }
  1981. break;
  1982. //----------------------------------------------------
  1983. case PPTOOLTIP_EFFECT_DIAGSHADE: //
  1984. a=(idxmax-idxmin)/2;
  1985. for(i = 0; i < sYSize; i++) {
  1986. for(j = 0; j < sXSize; j++) {
  1987. posDst[j]=(BYTE)(idxmin+a*i/sYSize+a*(sXSize-j)/sXSize);
  1988. posDst[j]+=rand()/grainx2-granularity;
  1989. }
  1990. posDst+=bytes;
  1991. }
  1992. break;
  1993. //----------------------------------------------------
  1994. case PPTOOLTIP_EFFECT_HSHADE: //
  1995. a=idxmax-idxmin;
  1996. for(i = 0; i < sYSize; i++) {
  1997. k=a*i/sYSize+idxmin;
  1998. for(j = 0; j < sXSize; j++) {
  1999. posDst[j]=(BYTE)k;
  2000. posDst[j]+=rand()/grainx2-granularity;
  2001. }
  2002. posDst+=bytes;
  2003. }
  2004. break;
  2005. //----------------------------------------------------
  2006. case PPTOOLTIP_EFFECT_VSHADE: //:
  2007. a=idxmax-idxmin;
  2008. for(j = 0; j < sXSize; j++) {
  2009. k=a*(sXSize-j)/sXSize+idxmin;
  2010. for(i = 0; i < sYSize; i++) {
  2011. posDst[j+i*bytes]=(BYTE)k;
  2012. posDst[j+i*bytes]+=rand()/grainx2-granularity;
  2013. }
  2014. }
  2015. break;
  2016. //----------------------------------------------------
  2017. case PPTOOLTIP_EFFECT_NOISE:
  2018. for(i = 0; i < sYSize; i++) {
  2019. for(j = 0; j < sXSize; j++) {
  2020. posDst[j]=128+rand()/grainx2-granularity;
  2021. }
  2022. posDst+=bytes;
  2023. }
  2024. }
  2025. //----------------------------------------------------
  2026. }
  2027. #endif
  2029. HICON CPPToolTip::GetIconFromResources(UINT nID, CSize szIcon /* = CSize(0, 0) */) const
  2030. {
  2031. // Find correct resource handle
  2032. HINSTANCE hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nID), RT_GROUP_ICON);
  2033. // Set icon when the mouse is IN the button
  2034. HICON hIcon = (HICON)::LoadImage(hInstResource, MAKEINTRESOURCE(nID), IMAGE_ICON, szIcon.cx, szIcon.cy, 0);
  2036. return hIcon;
  2037. }
  2039. HBITMAP CPPToolTip::GetBitmapFromResources(UINT nID) const
  2040. {
  2041. // Find correct resource handle
  2042. HINSTANCE hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nID), RT_BITMAP);
  2043. // Load bitmap
  2044. HBITMAP hBitmap = (HBITMAP)::LoadImage(hInstResource, MAKEINTRESOURCE(nID), IMAGE_BITMAP, 0, 0, 0);
  2046. return hBitmap;
  2047. }
  2048. ///////////////////////////////////////////////////////////////////////////////
  2049. ///////////////////////////////////////////////////////////////////////////////
  2050. ///////////////////////////////////////////////////////////////////////////////
  2052. /////////////////////////////////////////////////////////////////////////////
  2053. //  CPPToolTip::SetStyles  (public member function)
  2054. //    Sets the new styles of the control
  2055. //
  2056. //  Parameters :
  2057. // nStyle [in] - new style
  2058. //
  2059. //  Returns :
  2060. // Old styles
  2061. //
  2062. /////////////////////////////////////////////////////////////////////////////
  2063. void CPPToolTip::SetStyles(DWORD nStyles, int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2064. {
  2065. TRACE(_T("CPPToolTip::SetStyles()n"));
  2067. ModifyStyles(nStyles, -1, nIndexTool);
  2068. }  // End of SetStyles
  2070. /////////////////////////////////////////////////////////////////////////////
  2071. //  CPPToolTip::ModifyStyles  (public member function)
  2072. //    Modify the styles of the control
  2073. //
  2074. //  Parameters :
  2075. // nAddStyle  [in] - The styles to add
  2076. // nRemoveStyle [in] - The styles to remove
  2077. //
  2078. //  Returns :
  2079. // Old styles
  2080. //
  2081. /////////////////////////////////////////////////////////////////////////////
  2082. void CPPToolTip::ModifyStyles(DWORD nAddStyles, DWORD nRemoveStyles, int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2083. {
  2084. if (!IsExistTool(nIndexTool))
  2085. {
  2086. m_nStyles &= ~nRemoveStyles;
  2087. m_nStyles |= nAddStyles;
  2088. }
  2089. else
  2090. {
  2091. PPTOOLTIP_INFO ti;
  2092. GetTool(nIndexTool, ti);
  2093. if (!(ti.nMask & PPTOOLTIP_MASK_STYLES))
  2094. ti.nStyles = m_nStyles;
  2095. ti.nStyles &= ~nRemoveStyles;
  2096. ti.nStyles |= nAddStyles;
  2097. ti.nMask |= PPTOOLTIP_MASK_STYLES;
  2098. SetAtTool(nIndexTool, ti);
  2099. }
  2100. }  // End of ModifyStyles
  2102. /////////////////////////////////////////////////////////////////////////////
  2103. //  CPPToolTip::GetStyles (public member function)
  2104. //    Gets the current styles of the control
  2105. //
  2106. //  Parameters :
  2107. //
  2108. //  Returns :
  2109. // Current styles
  2110. //
  2111. /////////////////////////////////////////////////////////////////////////////
  2112. DWORD CPPToolTip::GetStyles(int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2113. {
  2114. TRACE(_T("CPPToolTip::GetStyles()n"));
  2116. if (IsExistTool(nIndexTool))
  2117. {
  2118. PPTOOLTIP_INFO ti;
  2119. GetTool(nIndexTool, ti);
  2120. if (ti.nMask & PPTOOLTIP_MASK_STYLES)
  2121. return ti.nStyles;
  2122. }
  2123. return m_nStyles;
  2124. }  // End of GetStyles
  2126. /////////////////////////////////////////////////////////////////////////////
  2127. //  CPPToolTip::SetDefaultStyles  (public member function)
  2128. //    Sets the new styles of the control
  2129. //
  2130. //  Parameters :
  2131. //
  2132. //  Returns :
  2133. // None
  2134. //
  2135. /////////////////////////////////////////////////////////////////////////////
  2136. void CPPToolTip::SetDefaultStyles(int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2137. {
  2138. TRACE(_T("CPPToolTip::SetDefaultStyles()n"));
  2140. SetStyles(PPTOOLTIP_BALLOON | PPTOOLTIP_ICON_VCENTER_ALIGN, nIndexTool);
  2141. }  // End of SetDefaultStyles
  2144. /////////////////////////////////////////////////////////////////////////////
  2145. //  CPPToolTip::SetColor (public member function)
  2146. //    Set the color
  2147. //
  2148. //  Parameters :
  2149. // nIndex  [in] - index of the color
  2150. // crColor [in] - new color
  2151. //
  2152. //  Returns :
  2153. // None
  2154. //
  2155. /////////////////////////////////////////////////////////////////////////////
  2156. void CPPToolTip::SetColor(int nIndex, COLORREF crColor)
  2157. {
  2158. TRACE (_T("CPPToolTip::SetColor(nIndex = %d)n"), nIndex);
  2160. if (nIndex >= PPTOOLTIP_MAX_COLORS)
  2161. return;
  2163. m_crColor [nIndex] = crColor;
  2164. }  // End of SetColor
  2166. /////////////////////////////////////////////////////////////////////////////
  2167. //  CPPToolTip::GetColor (public member function)
  2168. //    Set the color
  2169. //
  2170. //  Parameters :
  2171. // nIndex  [in] - index of the color
  2172. //
  2173. //  Returns :
  2174. // Current color
  2175. //
  2176. /////////////////////////////////////////////////////////////////////////////
  2177. COLORREF CPPToolTip::GetColor(int nIndex)
  2178. {
  2179. TRACE (_T("CPPToolTip::GetColor(nIndex = %d)n"), nIndex);
  2181. if (nIndex >= PPTOOLTIP_MAX_COLORS)
  2182. nIndex = PPTOOLTIP_COLOR_FG;
  2184. return m_crColor [nIndex];
  2185. }  // End of GetColor
  2187. /////////////////////////////////////////////////////////////////////////////
  2188. //  CPPToolTip::SetDefaultColors (public member function)
  2189. //    Set the color as default
  2190. //
  2191. //  Parameters :
  2192. // None
  2193. //
  2194. //  Returns :
  2195. // None
  2196. //
  2197. /////////////////////////////////////////////////////////////////////////////
  2198. void CPPToolTip::SetDefaultColors()
  2199. {
  2200. TRACE (_T("CPPToolTip::SetDefaultColorsn"));
  2202. SetColor(PPTOOLTIP_COLOR_0, RGB (0, 0, 0));
  2203. SetColor(PPTOOLTIP_COLOR_1, RGB (0, 0, 128));
  2204. SetColor(PPTOOLTIP_COLOR_2, RGB (0, 128, 0));
  2205. SetColor(PPTOOLTIP_COLOR_3, RGB (0, 128, 128));
  2206. SetColor(PPTOOLTIP_COLOR_4, RGB (128, 0, 0));
  2207. SetColor(PPTOOLTIP_COLOR_5, RGB (128, 0, 128));
  2208. SetColor(PPTOOLTIP_COLOR_6, RGB (128, 128, 0));
  2209. SetColor(PPTOOLTIP_COLOR_7, RGB (128, 128, 128));
  2210. SetColor(PPTOOLTIP_COLOR_8, RGB (0, 0, 255));
  2211. SetColor(PPTOOLTIP_COLOR_9, RGB (0, 255, 0));
  2212. SetColor(PPTOOLTIP_COLOR_10, RGB (0, 255, 255));
  2213. SetColor(PPTOOLTIP_COLOR_11, RGB (255, 0, 0));
  2214. SetColor(PPTOOLTIP_COLOR_12, RGB (255, 0, 255));
  2215. SetColor(PPTOOLTIP_COLOR_13, RGB (255, 255, 0));
  2216. SetColor(PPTOOLTIP_COLOR_14, RGB (192, 192, 192));
  2217. SetColor(PPTOOLTIP_COLOR_15, RGB (255, 255, 255));
  2218. SetColor(PPTOOLTIP_COLOR_FG, ::GetSysColor(COLOR_INFOTEXT));
  2219. SetColor(PPTOOLTIP_COLOR_BK_BEGIN, ::GetSysColor(COLOR_INFOBK));
  2220. SetColor(PPTOOLTIP_COLOR_BK_MID, ::GetSysColor(COLOR_INFOBK));
  2221. SetColor(PPTOOLTIP_COLOR_BK_END, ::GetSysColor(COLOR_INFOBK));
  2222. SetColor(PPTOOLTIP_COLOR_LINK, RGB(0, 0, 238));
  2223. SetColor(PPTOOLTIP_COLOR_VISITED, RGB(85, 26, 139));
  2224. SetColor(PPTOOLTIP_COLOR_HOVER, RGB(255, 0, 0));
  2225. SetColor(PPTOOLTIP_COLOR_SHADOW, ::GetSysColor(COLOR_3DSHADOW));
  2226. SetColor(PPTOOLTIP_COLOR_BORDER, ::GetSysColor(COLOR_INFOTEXT));
  2227. }  // End of SetDefaultColors
  2229. /////////////////////////////////////////////////////////////////////////////
  2230. //  CPPToolTip::SetGradientColors (public member function)
  2231. //    Set the gradient colors
  2232. //
  2233. //  Parameters :
  2234. // crStart [in] - start color
  2235. // crEnd [in] - end color
  2236. //
  2237. //  Returns :
  2238. // None
  2239. //
  2240. /////////////////////////////////////////////////////////////////////////////
  2241. void CPPToolTip::SetGradientColors(COLORREF crBegin, COLORREF crMid, COLORREF crEnd, int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2242. {
  2243. TRACE (_T("CPPToolTip::SetGradientColorsn"));
  2244. if (!IsExistTool(nIndexTool))
  2245. {
  2246. SetColor(PPTOOLTIP_COLOR_BK_BEGIN, crBegin);
  2247. SetColor(PPTOOLTIP_COLOR_BK_MID, crMid);
  2248. SetColor(PPTOOLTIP_COLOR_BK_END, crEnd);
  2249. }
  2250. else
  2251. {
  2252. PPTOOLTIP_INFO ti;
  2253. GetTool(nIndexTool, ti);
  2254. ti.crBegin = crBegin;
  2255. ti.crMid = crMid;
  2256. ti.crEnd = crEnd;
  2257. ti.nMask |= PPTOOLTIP_MASK_COLORS;
  2258. SetAtTool(nIndexTool, ti);
  2259. }
  2260. } // End of SetGradientColors
  2262. /////////////////////////////////////////////////////////////////////////////
  2263. //  CPPToolTip::GetGradientColors (public member function)
  2264. //    Set the gradient colors
  2265. //
  2266. //  Parameters :
  2267. // None
  2268. //
  2269. //  Returns :
  2270. // crStart [out] - start color
  2271. // crEnd [out] - end color
  2272. //
  2273. /////////////////////////////////////////////////////////////////////////////
  2274. void CPPToolTip::GetGradientColors(COLORREF & crBegin, COLORREF & crMid, COLORREF & crEnd, int nIndexTool /* = -1 */)
  2275. {
  2276. TRACE (_T("CPPToolTip::GetGradientColorsn"));
  2277. if (IsExistTool(nIndexTool))
  2278. {
  2279. PPTOOLTIP_INFO ti;
  2280. GetTool(nIndexTool, ti);
  2281. if (ti.nMask & PPTOOLTIP_MASK_COLORS)
  2282. {
  2283. crBegin = ti.crBegin;
  2284. crMid = ti.crMid;
  2285. crEnd = ti.crEnd;
  2286. return;
  2287. }
  2288. }
  2289. crBegin = GetColor(PPTOOLTIP_COLOR_BK_BEGIN);
  2290. crMid = GetColor(PPTOOLTIP_COLOR_BK_MID);
  2291. crEnd = GetColor(PPTOOLTIP_COLOR_BK_END);
  2292. } // End of GetGradientColors
  2294. void CPPToolTip::SetMaskTool(int nIndexTool, UINT nMask /* = 0 */)
  2295. {
  2296. ModifyMaskTool(nIndexTool, nMask, -1);
  2297. }
  2299. void CPPToolTip::ModifyMaskTool(int nIndexTool, UINT nAddMask, UINT nRemoveMask)
  2300. {
  2301. if (!IsExistTool(nIndexTool))
  2302. return;
  2303. PPTOOLTIP_INFO ti;
  2304. GetTool(nIndexTool, ti);
  2305. ti.nMask &= ~nRemoveMask;
  2306. ti.nMask |= nAddMask;
  2307. SetAtTool(nIndexTool, ti);
  2308. }
  2310. UINT CPPToolTip::GetMaskTool(int nIndexTool)
  2311. {
  2312. if (!IsExistTool(nIndexTool))
  2313. return 0;
  2314. PPTOOLTIP_INFO ti;
  2315. GetTool(nIndexTool, ti);
  2316. return ti.nMask;
  2317. }
  2319. /////////////////////////////////////////////////////////////////////////////
  2320. //  CPPToolTip::SetEffectBk (public member function)
  2321. //    sets the background's effect
  2322. //
  2323. //  Parameters :
  2324. // nEffect [in]  - the background's effect 
  2325. //
  2326. //  Returns :
  2327. // None 
  2328. //
  2329. /////////////////////////////////////////////////////////////////////////////
  2330. void CPPToolTip::SetEffectBk(UINT nEffect, BYTE nGranularity /* = 2 */, int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2331. {
  2332. TRACE (_T("CPPToolTip::SetEffectBkn"));
  2334. if (!IsExistTool(nIndexTool))
  2335. {
  2336. m_nEffect = nEffect;
  2337. m_nGranularity = nGranularity;
  2338. }
  2339. else
  2340. {
  2341. PPTOOLTIP_INFO ti;
  2342. GetTool(nIndexTool, ti);
  2343. ti.nEffect = nEffect;
  2344. ti.nGranularity = nGranularity;
  2345. ti.nMask |= PPTOOLTIP_MASK_EFFECT;
  2346. SetAtTool(nIndexTool, ti);
  2347. }
  2348. } // End SetEffectBk
  2350. /////////////////////////////////////////////////////////////////////////////
  2351. //  CPPToolTip::GetEffectBk (public member function)
  2352. //    gets the background's effect
  2353. //
  2354. //  Parameters :
  2355. // None 
  2356. //
  2357. //  Returns :
  2358. // the background's effect 
  2359. //
  2360. /////////////////////////////////////////////////////////////////////////////
  2361. UINT CPPToolTip::GetEffectBk(int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2362. {
  2363. BYTE nGranularity = 0;
  2365. return GetEffectBk(nGranularity, nIndexTool);
  2366. } // End SetEffectBk
  2368. /////////////////////////////////////////////////////////////////////////////
  2369. //  CPPToolTip::GetEffectBk (public member function)
  2370. //    gets the background's effect
  2371. //
  2372. //  Parameters :
  2373. // nGranularity [out] - effect's granularity
  2374. //
  2375. //  Returns :
  2376. // the background's effect 
  2377. //
  2378. /////////////////////////////////////////////////////////////////////////////
  2379. UINT CPPToolTip::GetEffectBk(BYTE & nGranularity, int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2380. {
  2381. TRACE (_T("CPPToolTip::GetEffectBkn"));
  2383. if (IsExistTool(nIndexTool))
  2384. {
  2385. PPTOOLTIP_INFO ti;
  2386. GetTool(nIndexTool, ti);
  2387. if (ti.nMask & PPTOOLTIP_MASK_EFFECT)
  2388. {
  2389. nGranularity = ti.nGranularity;
  2390. return ti.nEffect;
  2391. }
  2392. }
  2393. nGranularity = m_nGranularity;
  2394. return m_nEffect;
  2395. } // End SetEffectBk
  2397. /////////////////////////////////////////////////////////////////////
  2398. // CPPToolTip::SetNotify
  2399. // This function sets or removes the notification messages from the control before display.
  2400. //
  2401. // Parameters:
  2402. // bParentNotify [in] - If TRUE the control will be send the notification 
  2403. //    to parent window
  2404. //    Else the notification will not send
  2405. ///////////////////////////////////////////////////////////////////////
  2406. void CPPToolTip::SetNotify(BOOL bParentNotify /* = TRUE */)
  2407. {
  2408. HWND hWnd = NULL;
  2410. if (bParentNotify)
  2411. hWnd = m_pParentWnd->GetSafeHwnd();
  2413. SetNotify(hWnd);
  2414. } //End SetNotify
  2416. /////////////////////////////////////////////////////////////////////
  2417. // CPPToolTip::SetNotify
  2418. // This function sets or removes the notification messages from the control before display.
  2419. //
  2420. // Parameters:
  2421. // hWnd [in] -    If non-NULL the control will be send the notification 
  2422. //    to specified window
  2423. //    Else the notification will not send
  2424. ///////////////////////////////////////////////////////////////////////
  2425. void CPPToolTip::SetNotify(HWND hWnd)
  2426. {
  2427. TRACE(_T("CPPToolTip::SetNotifyn"));
  2429. m_hNotifyWnd = hWnd;
  2430. } //End SetNotify
  2432. /////////////////////////////////////////////////////////////////////
  2433. // CPPToolTip::GetNotify
  2434. // This function determines will be send the notification messages from 
  2435. // the control or not before display.
  2436. //
  2437. // Return value:
  2438. // TRUE if the control will be notified the specified window
  2439. ///////////////////////////////////////////////////////////////////////
  2440. BOOL CPPToolTip::GetNotify()
  2441. {
  2442. TRACE(_T("CPPToolTip::GetNotifyn"));
  2444. return (m_hNotifyWnd != NULL);
  2445. }  //End GetNotify
  2447. /////////////////////////////////////////////////////////////////////
  2448. // CPPToolTip::SetDelayTime
  2449. // Call this function to set the delay time for a tool tip control. 
  2450. // The delay time is the length of time the cursor must remain on a tool 
  2451. // before the tool tip window appears. The default delay time is 500 milliseconds.
  2452. //
  2453. // Parameters:
  2454. //   dwDuration [in]  - Flag that specifies which duration value will be retrieved. 
  2455. // This parameter can be one of the following values:
  2456. //
  2457. // TTDT_AUTOPOP  - Retrieve the length of time the tool tip 
  2458. // window remains visible if the pointer is 
  2459. // stationary within a tool's bounding rectangle. 
  2460. // TTDT_INITIAL  - Retrieve the length of time the pointer 
  2461. // must remain stationary within a tool's bounding 
  2462. // rectangle before the tool tip window appears. 
  2463. // TTDT_RESHOW   - Retrieve the length of time it takes for 
  2464. // subsequent tool tip windows to appear as the 
  2465. // pointer moves from one tool to another.
  2466. //  nTime [in] - The specified delay time, in milliseconds.
  2467. //
  2468. /////////////////////////////////////////////////////////////////////
  2469. void CPPToolTip::SetDelayTime(DWORD dwDuration, UINT nTime)
  2470. {
  2471. switch (dwDuration)
  2472. {
  2473. case TTDT_AUTOPOP:
  2474. m_nTimeAutoPop = nTime;
  2475. break;
  2476. case TTDT_INITIAL :
  2477. m_nTimeInitial = nTime;
  2478. break;
  2479. // case TTDT_RESHOW:
  2480. // m_nTimeReShow = nTime;
  2481. // break;
  2482. }
  2483. } // End SetDelayTime
  2485. /////////////////////////////////////////////////////////////////////
  2486. // CPPToolTip::GetDelayTime
  2487. // Retrieves the initial, pop-up, and reshow durations currently set 
  2488. // for a CPPToolTip control
  2489. //
  2490. // Parameters:
  2491. //   dwDuration [in] - Flag that specifies which duration value will 
  2492. //    be retrieved. This parameter can be one of the 
  2493. //    following values:
  2494. //
  2495. // TTDT_AUTOPOP  - Retrieve the length of time the tool tip 
  2496. // window remains visible if the pointer is 
  2497. // stationary within a tool's bounding rectangle. 
  2498. // TTDT_INITIAL  - Retrieve the length of time the pointer 
  2499. // must remain stationary within a tool's bounding 
  2500. // rectangle before the tool tip window appears. 
  2501. // TTDT_RESHOW   - Retrieve the length of time it takes for 
  2502. // subsequent tool tip windows to appear as the 
  2503. // pointer moves from one tool to another. 
  2504. //
  2505. // Return value:
  2506. // The specified delay time, in milliseconds
  2507. ///////////////////////////////////////////////////////////////////////
  2508. UINT CPPToolTip::GetDelayTime(DWORD dwDuration) const
  2509. {
  2510. UINT nTime = 0;
  2511. switch (dwDuration)
  2512. {
  2513. case TTDT_AUTOPOP:
  2514. nTime = m_nTimeAutoPop;
  2515. break;
  2516. case TTDT_INITIAL:
  2517. nTime = m_nTimeInitial;
  2518. break;
  2519. // case TTDT_RESHOW:
  2520. // nTime = m_nTimeReShow;
  2521. // break;
  2522. }
  2524. return nTime;
  2525. } // End GetDelayTime
  2527. /////////////////////////////////////////////////////////////////////////////
  2528. //  CPPToolTip::SetSize (public member function)
  2529. //    Sets the specified size
  2530. //
  2531. //  Parameters :
  2532. // nSizeIndex  [in] - index of the size
  2533. // nValue [in] - size's value
  2534. //
  2535. //  Returns :
  2536. // None
  2537. //
  2538. /////////////////////////////////////////////////////////////////////////////
  2539. void CPPToolTip::SetSize(int nSizeIndex, UINT nValue)
  2540. {
  2541. TRACE(_T("CPPToolTip::SetSize(nSizeIndex = %d, nValue = %d)n"), nSizeIndex, nValue);
  2542. if (nSizeIndex >= PPTTSZ_MAX_SIZES)
  2543. return;
  2545. m_nSizes [nSizeIndex] = nValue;
  2546. }
  2548. /////////////////////////////////////////////////////////////////////////////
  2549. //  CPPToolTip::GetSize (public member function)
  2550. //    Gets the specified size
  2551. //
  2552. //  Parameters :
  2553. // nSizeIndex  [in] - index of the size
  2554. //
  2555. //  Returns :
  2556. // size's value
  2557. //
  2558. /////////////////////////////////////////////////////////////////////////////
  2559. UINT CPPToolTip::GetSize(int nSizeIndex)
  2560. {
  2561. TRACE(_T("CPPToolTip::GetSize(nSizeIndex = %d)n"), nSizeIndex);
  2562. if (nSizeIndex >= PPTTSZ_MAX_SIZES)
  2563. return 0;
  2565. return m_nSizes [nSizeIndex];
  2566. }
  2568. /////////////////////////////////////////////////////////////////////////////
  2569. //  CPPToolTip::SetDefaultSizes (public member function)
  2570. //    Sets all sizes to default values
  2571. //
  2572. //  Returns :
  2573. // None
  2574. //
  2575. /////////////////////////////////////////////////////////////////////////////
  2576. void CPPToolTip::SetDefaultSizes(BOOL bBalloonSize /* = TRUE */)
  2577. {
  2578. TRACE(_T("CPPToolTip::SetDefaultSizes()n"));
  2580. if (bBalloonSize)
  2581. {
  2582. SetSize(PPTTSZ_ROUNDED_CX, 16);
  2583. SetSize(PPTTSZ_ROUNDED_CY, 16);
  2584. SetSize(PPTTSZ_MARGIN_CX, 12);
  2585. SetSize(PPTTSZ_MARGIN_CY, 12);
  2586. SetSize(PPTTSZ_SHADOW_CX, 4);
  2587. SetSize(PPTTSZ_SHADOW_CY, 4);
  2588. SetSize(PPTTSZ_WIDTH_ANCHOR, 12);
  2589. SetSize(PPTTSZ_HEIGHT_ANCHOR, 16);
  2590. SetSize(PPTTSZ_MARGIN_ANCHOR, 16);
  2591. SetSize(PPTTSZ_BORDER_CX, 1);
  2592. SetSize(PPTTSZ_BORDER_CY, 1);
  2593. }
  2594. else
  2595. {
  2596. SetSize(PPTTSZ_ROUNDED_CX, 0);
  2597. SetSize(PPTTSZ_ROUNDED_CY, 0);
  2598. SetSize(PPTTSZ_MARGIN_CX, 3);
  2599. SetSize(PPTTSZ_MARGIN_CY, 1);
  2600. SetSize(PPTTSZ_SHADOW_CX, 0);
  2601. SetSize(PPTTSZ_SHADOW_CY, 0);
  2602. SetSize(PPTTSZ_WIDTH_ANCHOR, 0);
  2603. SetSize(PPTTSZ_HEIGHT_ANCHOR, 0);
  2604. SetSize(PPTTSZ_MARGIN_ANCHOR, 0);
  2605. SetSize(PPTTSZ_BORDER_CX, 1);
  2606. SetSize(PPTTSZ_BORDER_CY, 1);
  2607. }
  2608. }
  2610. /////////////////////////////////////////////////////////////////////////////
  2611. //  CPPToolTip::SetDirection (public member function)
  2612. //    Sets the tooltip's direction
  2613. //
  2614. //  Parameters :
  2615. // nDirection  [in] - direction of the tooltip
  2616. //
  2617. //  Returns :
  2618. // None
  2619. //
  2620. /////////////////////////////////////////////////////////////////////////////
  2621. void CPPToolTip::SetDirection(UINT nDirection /* = PPTOOLTIP_RIGHT_BOTTOM */, int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2622. {
  2623. TRACE(_T("CPPToolTip::SetDirection(nDirection = %d)n"), nDirection);
  2625. if (nDirection >= PPTOOLTIP_MAX_DIRECTIONS)
  2626. return;
  2628. if (!IsExistTool(nIndexTool))
  2629. {
  2630. m_nDirection = nDirection;
  2631. }
  2632. else
  2633. {
  2634. PPTOOLTIP_INFO ti;
  2635. GetTool(nIndexTool, ti);
  2636. ti.nDirection = nDirection;
  2637. ti.nMask |= PPTOOLTIP_MASK_DIRECTION;
  2638. SetAtTool(nIndexTool, ti);
  2639. }
  2640. }
  2642. /////////////////////////////////////////////////////////////////////////////
  2643. //  CPPToolTip::GetDirection (public member function)
  2644. //    Gets the tooltip's direction
  2645. //
  2646. //  Returns :
  2647. // tooltip's direction
  2648. //
  2649. /////////////////////////////////////////////////////////////////////////////
  2650. UINT CPPToolTip::GetDirection(int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2651. {
  2652. TRACE(_T("CPPToolTip::GetDirection()n"));
  2654. if (IsExistTool(nIndexTool))
  2655. {
  2656. PPTOOLTIP_INFO ti;
  2657. GetTool(nIndexTool, ti);
  2658. if (ti.nMask & PPTOOLTIP_MASK_DIRECTION)
  2659. return ti.nDirection;
  2660. }
  2661. return m_nDirection;
  2662. }
  2664. /////////////////////////////////////////////////////////////////////////////
  2665. //  CPPToolTip::SetBehaviour (public member function)
  2666. //    Sets the tooltip's direction
  2667. //
  2668. //  Parameters :
  2669. // nBehaviour  [in] - direction of the tooltip
  2670. //
  2671. //  Returns :
  2672. // None
  2673. //
  2674. /////////////////////////////////////////////////////////////////////////////
  2676. void CPPToolTip::SetBehaviour(UINT nBehaviour /* = 0 */, int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2677. {
  2678. TRACE(_T("CPPToolTip::SetBehaviour(nBehaviour = 0x%X)n"), nBehaviour);
  2680. if (IsExistTool(nIndexTool))
  2681. {
  2682. PPTOOLTIP_INFO ti;
  2683. GetTool(nIndexTool, ti);
  2684. ti.nBehaviour = nBehaviour;
  2685. ti.nMask |= PPTOOLTIP_MASK_BEHAVIOUR;
  2686. SetAtTool(nIndexTool, ti);
  2687. }
  2688. else m_nBehaviour = nBehaviour;
  2689. }
  2691. /////////////////////////////////////////////////////////////////////////////
  2692. //  CPPToolTip::GetBehaviour (public member function)
  2693. //    Gets the tooltip's direction
  2694. //
  2695. //  Returns :
  2696. // tooltip's direction
  2697. //
  2698. /////////////////////////////////////////////////////////////////////////////
  2699. UINT CPPToolTip::GetBehaviour(int nIndexTool /* = PPTOOLTIP_TOOL_NOEXIST */)
  2700. {
  2701. TRACE(_T("CPPToolTip::GetBehaviour()n"));
  2703. if (IsExistTool(nIndexTool))
  2704. {
  2705. PPTOOLTIP_INFO ti;
  2706. GetTool(nIndexTool, ti);
  2707. if (ti.nMask & PPTOOLTIP_MASK_BEHAVIOUR)
  2708. return ti.nBehaviour;
  2709. }
  2710. return m_nBehaviour;
  2711. }
  2713. /*
  2714. /////////////////////////////////////////////////////////////////////////////
  2715. //  CPPToolTip::SetMultipleShow (public member function)
  2716. //    Sets the multiple show for the tooltip
  2717. //
  2718. //  Parameters :
  2719. // bMultiple [in] - 
  2720. // pWnd [in] - the pointer to the window
  2721. //
  2722. //  Returns :
  2723. // None
  2724. //
  2725. /////////////////////////////////////////////////////////////////////////////
  2726. void CPPToolTip::SetMultipleShow(BOOL bMultiple  = TRUE , CWnd * pWnd  = NULL )
  2727. {
  2728. if (bMultiple)
  2729. ModifyStyles(PPTOOLTIP_MULTIPLE_SHOW, 0, pWnd);
  2730. else
  2731. ModifyStyles(0, PPTOOLTIP_MULTIPLE_SHOW, pWnd);
  2732. } // End of SetMultipleShow
  2734. /////////////////////////////////////////////////////////////////////////////
  2735. //  CPPToolTip::IsMultipleShow (public member function)
  2736. //    
  2737. //
  2738. //  Parameters :
  2739. // pWnd [in] - the pointer to the window
  2740. //
  2741. //  Returns :
  2742. // TRUE if for window sets the multiple show
  2743. //
  2744. /////////////////////////////////////////////////////////////////////////////
  2745. BOOL CPPToolTip::IsMultipleShow(CWnd * pWnd  = NULL )
  2746. {
  2747. return (BOOL)(PPTOOLTIP_MULTIPLE_SHOW & GetStyles(pWnd));
  2748. } // End of IsMultipleShow
  2749. */
  2751. /////////////////////////////////////////////////////////////////////////////
  2752. //  CPPToolTip::SetFont  (public member function)
  2753. //    Sets the new font to the control
  2754. //
  2755. //  Parameters :
  2756. // font [in] - new font
  2757. //
  2758. //  Returns :
  2759. // Nonzero if successful; otherwise 0.
  2760. //
  2761. /////////////////////////////////////////////////////////////////////////////
  2762. BOOL CPPToolTip::SetFont(CFont & font)
  2763. {
  2764. TRACE(_T("CPPToolTip::SetFont()n"));
  2766. LOGFONT lf;
  2767. font.GetLogFont (&lf);
  2769. return SetFont(&lf);
  2770. }  // End of SetFont
  2772. /////////////////////////////////////////////////////////////////////////////
  2773. //  CPPToolTip::SetFont  (public member function)
  2774. //    Sets the new font to the control
  2775. //
  2776. //  Parameters :
  2777. // lf [in] - structure LOGFONT for the new font
  2778. //
  2779. //  Returns :
  2780. // Nonzero if successful; otherwise 0.
  2781. //
  2782. /////////////////////////////////////////////////////////////////////////////
  2783. BOOL CPPToolTip::SetFont(LPLOGFONT lf)
  2784. {
  2785. TRACE(_T("CPPToolTip::SetFont()n"));
  2787. // m_font.DeleteObject();
  2789. // Store font as the global default
  2790.     memcpy(&m_LogFont, lf, sizeof(LOGFONT));
  2792. return TRUE; //m_font.CreateFontIndirect(lf);
  2793. }  // End of SetFont
  2795. /////////////////////////////////////////////////////////////////////////////
  2796. //  CPPToolTip::SetFont  (public member function)
  2797. //    Sets the new font to the control
  2798. //
  2799. //  Parameters :
  2800. // font [in] - new font
  2801. //
  2802. //  Returns :
  2803. // Nonzero if successful; otherwise 0.
  2804. //
  2805. /////////////////////////////////////////////////////////////////////////////
  2806. BOOL CPPToolTip::SetFont(LPCTSTR lpszFaceName, int nSizePoints /* = 8 */,
  2807. BOOL bUnderline /* = FALSE */, BOOL bBold /* = FALSE */,
  2808. BOOL bStrikeOut /* = FALSE */, BOOL bItalic /* = FALSE */)
  2809. {
  2810. TRACE(_T("CPPToolTip::SetFont()n"));
  2812. CDC* pDC = GetDC();
  2813. LOGFONT lf;
  2814. memset (&lf, 0, sizeof(LOGFONT));
  2816. _tcscpy (lf.lfFaceName, lpszFaceName);
  2817. lf.lfHeight = -MulDiv (nSizePoints, GetDeviceCaps (pDC->m_hDC, LOGPIXELSY), 72);
  2818. lf.lfUnderline = bUnderline;
  2819. lf.lfWeight = bBold ? FW_BOLD : FW_NORMAL;
  2820. lf.lfStrikeOut = bStrikeOut;
  2821. lf.lfItalic = bItalic;
  2823. if (pDC)
  2824. ReleaseDC(pDC);
  2826. return SetFont(&lf);
  2827. }  // End of SetFont
  2829. /////////////////////////////////////////////////////////////////////////////
  2830. //  CPPToolTip::SetDefaultFonts  (public member function)
  2831. //    Sets default fonts of the control
  2832. //
  2833. //  Returns :
  2834. // None
  2835. //
  2836. /////////////////////////////////////////////////////////////////////////////
  2837. void CPPToolTip::SetDefaultFont()
  2838. {
  2839. TRACE(_T("CPPToolTip::SetDefaultFont()n"));
  2841. LPLOGFONT lpSysFont = GetSystemToolTipFont();
  2843. SetFont(lpSysFont);
  2844. } // End of SetDefaultFonts
  2846. /////////////////////////////////////////////////////////////////////////////
  2847. //  CPPToolTip::GetFont  (public member function)
  2848. //    Sets the new font to the control
  2849. //
  2850. //  Parameters :
  2851. // font [out] - the current font
  2852. //
  2853. /////////////////////////////////////////////////////////////////////////////
  2854. void CPPToolTip::GetFont(CFont & font)
  2855. {
  2856. font.CreateFontIndirect(&m_LogFont);
  2857. }
  2859. /////////////////////////////////////////////////////////////////////////////
  2860. //  CPPToolTip::GetFont  (public member function)
  2861. //    Sets the new font to the control
  2862. //
  2863. //  Parameters :
  2864. // lf [out] - the current font's structure
  2865. //
  2866. /////////////////////////////////////////////////////////////////////////////
  2867. void CPPToolTip::GetFont(LPLOGFONT lf)
  2868. {
  2869. memcpy(lf, &m_LogFont, sizeof(LOGFONT));
  2870. }
  2872. ///////////////////////////////////////////////////////////////////
  2873. //
  2874. //
  2875. // Parameters:
  2876. // pt [in] - the mouse's coordinates in client coordinates
  2877. //
  2878. // Return values:
  2879. //      CWnd* [out] - the pointer to the window under the mouse. Returns
  2880. //                      NULL if under the mouse no control.
  2881. ///////////////////////////////////////////////////////////////////
  2882. HWND CPPToolTip::GetWndFromPoint(CPoint & pt, BOOL bGetDisabled /* = TRUE */) const
  2883. {
  2884. ASSERT(m_pParentWnd);
  2886.     CPoint point = pt;
  2887. // Find the window under the cursor
  2888.     m_pParentWnd->ClientToScreen(&point);
  2889.     HWND hWnd = ::WindowFromPoint(point);
  2891. // WindowFromPoint misses disabled windows and such - go for a more
  2892.     // comprehensive search in this case.
  2893. UINT nFlags = CWP_ALL;
  2894. if (!bGetDisabled)
  2895. nFlags |= CWP_SKIPDISABLED;
  2896.     if (hWnd == m_pParentWnd->GetSafeHwnd())
  2897.         hWnd = m_pParentWnd->ChildWindowFromPoint(pt, nFlags)->GetSafeHwnd();
  2899.     return hWnd;
  2900. }
  2902. /////////////////////////////////////////////////////////////////////////////
  2903. //  CPPToolTip::AddTool (public member function)
  2904. //    adds or updates the tool
  2905. //
  2906. //  Parameters :
  2907. // pWnd [in] - the pointer to the window
  2908. // nIdText  [in] - the tooltip's text id 
  2909. // nIdIcon  [in] - the icon's identificator 
  2910. //
  2911. //  Returns :
  2912. // None
  2913. //
  2914. /////////////////////////////////////////////////////////////////////////////
  2915. void CPPToolTip::AddTool(CWnd * pWnd, UINT nIdText, HICON hIcon /* = NULL */,
  2916.  LPCRECT lpRectTool /* = NULL */, UINT nIDTool /* = 0 */)
  2917. {
  2918. CString str;
  2919.     str.LoadString(nIdText);
  2920. AddTool(pWnd, str, hIcon, lpRectTool, nIDTool);
  2921. } // End AddTool
  2923. /////////////////////////////////////////////////////////////////////////////
  2924. //  CPPToolTip::AddTool (public member function)
  2925. //    adds or updates the tool
  2926. //
  2927. //  Parameters :
  2928. // pWnd [in] - the pointer to the window
  2929. // nIdText  [in] - the tooltip's text id 
  2930. // nIdIcon  [in] - the icon's identificator 
  2931. //
  2932. //  Returns :
  2933. // None
  2934. //
  2935. /////////////////////////////////////////////////////////////////////////////
  2936. void CPPToolTip::AddTool(CWnd * pWnd, UINT nIdText, UINT nIdIcon, CSize szIcon /* = CSize(0, 0) */,
  2937.  LPCRECT lpRectTool /* = NULL */, UINT nIDTool /* = 0 */)
  2938. {
  2939. CString str;
  2940.     str.LoadString(nIdText);
  2941. AddTool(pWnd, str, nIdIcon, szIcon, lpRectTool, nIDTool);
  2942. } // End AddTool
  2944. /////////////////////////////////////////////////////////////////////////////
  2945. //  CPPToolTip::AddTool (public member function)
  2946. //    adds or updates the tool
  2947. //
  2948. //  Parameters :
  2949. // pWnd [in] - the pointer to the window
  2950. // sTooltipText [in] - the tooltip's text 
  2951. // nIdIcon  [in] - the icon's identificator 
  2952. //
  2953. //  Returns :
  2954. // None
  2955. //
  2956. /////////////////////////////////////////////////////////////////////////////
  2957. void CPPToolTip::AddTool(CWnd * pWnd, CString sTooltipText, UINT nIdIcon, CSize szIcon /* = CSize(0, 0) */,
  2958.  LPCRECT lpRectTool /* = NULL */, UINT nIDTool /* = 0 */)
  2959. {
  2960. HICON hIcon = GetIconFromResources (nIdIcon, szIcon);
  2962. AddTool(pWnd, sTooltipText, hIcon, lpRectTool, nIDTool);
  2963. } // End AddTool
  2965. /////////////////////////////////////////////////////////////////////////////
  2966. //  CPPToolTip::AddTool (public member function)
  2967. //    adds or updates the tool
  2968. //
  2969. //  Parameters :
  2970. // pWnd [in] - the pointer to the window
  2971. // sTooltipText [in] - the tooltip's text 
  2972. // hIcon   [in] - the icon's handle 
  2973. //
  2974. //  Returns :
  2975. // None
  2976. //
  2977. /////////////////////////////////////////////////////////////////////////////
  2978. void CPPToolTip::AddTool(CWnd * pWnd, CString sTooltipText, HICON hIcon /* = NULL */,
  2979.  LPCRECT lpRectTool /* = NULL */, UINT nIDTool /* = 0 */)
  2980. {
  2981. // Store the tool information
  2982. PPTOOLTIP_INFO ti;
  2983. ti.hWnd = pWnd->GetSafeHwnd();
  2984. ti.nIDTool = nIDTool;
  2985. ti.hIcon = hIcon;
  2986. ti.sTooltip = sTooltipText;
  2987. ti.nMask = 0; //All values as default
  2989.     if (lpRectTool)
  2990. ti.rectBounds = lpRectTool;
  2991. else
  2992. ti.rectBounds.SetRectEmpty();
  2994. AddTool(ti);
  2995. } // End AddTool
  2997. /////////////////////////////////////////////////////////////////////////////
  2998. //  CPPToolTip::AddTool (public member function)
  2999. //    adds or updates the tool
  3000. //
  3001. //  Parameters :
  3002. // ti [in] - the tooltip's structure 
  3003. //
  3004. //  Returns :
  3005. // None
  3006. //
  3007. /////////////////////////////////////////////////////////////////////////////
  3008. void CPPToolTip::AddTool(PPTOOLTIP_INFO ti) 
  3009. { 
  3010. ASSERT (ti.hWnd);  
  3011. TRACE (_T("CPPToolTip::AddTool = 0x%Xn"), ti.hWnd); 
  3012. // Get bounding region for tooltip info 
  3013. /*
  3014.     if (ti.rectBounds.IsRectEmpty()) 
  3015.     {  
  3016. CRect rect; 
  3017. CWnd::FromHandle(ti.hWnd)->GetClientRect(&rect); 
  3018. //m_pParentWnd->ScreenToClient(rect); 
  3019. ti.rectBounds = rect; 
  3020.     } 
  3021. */
  3022. int nIndexTool = FindTool(CWnd::FromHandle(ti.hWnd), ti.rectBounds); 
  3023. if (!IsExistTool(nIndexTool)) 
  3024. m_arrTools.Add(ti); 
  3025. else 
  3026. m_arrTools.SetAt(nIndexTool, ti); 
  3027. } // End AddTool
  3029. /////////////////////////////////////////////////////////////////////////////
  3030. //  CPPToolTip::FindTool (public member function)
  3031. //    searches the tool under cursor point
  3032. //
  3033. //  Parameters :
  3034. // pt [in] - cursor point in client coordinates
  3035. //
  3036. //  Returns :
  3037. // < 0  = Not available tool
  3038. //      >= 0 = Index of the found tool
  3039. //
  3040. /////////////////////////////////////////////////////////////////////////////
  3041. int CPPToolTip::FindTool(CPoint & pt) 
  3042. { 
  3043. HWND hWnd = GetWndFromPoint(pt, m_nStyles & PPTOOLTIP_SHOW_DISABLED); 
  3045. PPTOOLTIP_INFO pToolInfo;  
  3046. int nSize = m_arrTools.GetSize(); 
  3047. CPoint ptClient;  
  3048. // Find the window under the cursor 
  3049.     m_pParentWnd->ClientToScreen(&pt); 
  3050.     for (int i = 0; i < nSize; i++) 
  3051.     { 
  3052.         pToolInfo = m_arrTools.GetAt(i); 
  3053.         if (hWnd == pToolInfo.hWnd)  
  3054. { 
  3055. ptClient = pt; 
  3056. ::ScreenToClient(hWnd, &ptClient); 
  3057.    if (pToolInfo.rectBounds.PtInRect(ptClient) || pToolInfo.rectBounds.IsRectEmpty()) 
  3058. {
  3059. return i;  
  3060. }
  3061. }
  3062. }  
  3063. return PPTOOLTIP_TOOL_NOEXIST;
  3064. }
  3066. /////////////////////////////////////////////////////////////////////////////
  3067. //  CPPToolTip::FindTool (public member function)
  3068. //    searches the tool with window's pointer and rectangle
  3069. //
  3070. //  Parameters :
  3071. // pWnd [in] - the pointer to the window
  3072. // lpRect [in] - rectangle of the hot area. Or NULL for any rectangle
  3073. //
  3074. //  Returns :
  3075. // < 0  = Not available tool
  3076. //      >= 0 = Index of the found tool
  3077. //
  3078. /////////////////////////////////////////////////////////////////////////////
  3079. int CPPToolTip::FindTool(CWnd * pWnd, LPCRECT lpRect /* = NULL */)
  3080. {
  3081. HWND hWnd = pWnd->GetSafeHwnd();
  3082. PPTOOLTIP_INFO pToolInfo;
  3083. int nSize = m_arrTools.GetSize();
  3084.     for (int i = 0; i < nSize; i++)
  3085.     {
  3086.         pToolInfo = m_arrTools.GetAt(i);
  3088.         if (hWnd == pToolInfo.hWnd) 
  3089. if ((NULL == lpRect) || (lpRect == pToolInfo.rectBounds))
  3090. return i;
  3091.     }
  3092. return PPTOOLTIP_TOOL_NOEXIST;
  3093. }
  3095. /////////////////////////////////////////////////////////////////////////////
  3096. //  CPPToolTip::FindTool (public member function)
  3097. //    searches the tool with id
  3098. //
  3099. //  Parameters :
  3100. // nIDTool [in] - id of the window
  3101. //
  3102. //  Returns :
  3103. // < 0  = Not available tool
  3104. //      >= 0 = Index of the found tool
  3105. //
  3106. /////////////////////////////////////////////////////////////////////////////
  3107. int CPPToolTip::FindTool(UINT nIDTool)
  3108. {
  3109. PPTOOLTIP_INFO pToolInfo;
  3110. int nSize = m_arrTools.GetSize();
  3111.     for (int i = 0; i < nSize; i++)
  3112.     {
  3113.         pToolInfo = m_arrTools.GetAt(i);
  3115.         if (nIDTool == pToolInfo.nIDTool)
  3116. return i;
  3117.     }
  3118. return PPTOOLTIP_TOOL_NOEXIST;
  3119. }
  3121. /////////////////////////////////////////////////////////////////////////////
  3122. //  CPPToolTip::GetTool (public member function)
  3123. //    gets the tooltip's info
  3124. //
  3125. //  Parameters :
  3126. // nIndexTool [in]  - the index of the tool
  3127. // ti [out] - the tooltip's structure 
  3128. //
  3129. //  Returns :
  3130. // FALSE - tool not found
  3131. //
  3132. /////////////////////////////////////////////////////////////////////////////
  3133. BOOL CPPToolTip::GetTool(int nIndexTool, PPTOOLTIP_INFO & ti)
  3134. {
  3135. if (!IsExistTool(nIndexTool))
  3136. return FALSE;
  3137. ti = m_arrTools.GetAt(nIndexTool);
  3138. return TRUE;
  3139. } // End GetTool
  3141. /////////////////////////////////////////////////////////////////////////////
  3142. //  CPPToolTip::RemoveTool (public member function)
  3143. //    removes the tool
  3144. //
  3145. //  Parameters :
  3146. // pWnd [in]  - the pointer to the window
  3147. //
  3148. //  Returns :
  3149. // None 
  3150. //
  3151. /////////////////////////////////////////////////////////////////////////////
  3152. BOOL CPPToolTip::RemoveTool(int nIndexTool)
  3153. {
  3154. TRACE (_T("CPPToolTip::RemoveTooln"));
  3156. if (!IsExistTool(nIndexTool))
  3157. return FALSE;
  3159. m_arrTools.RemoveAt(nIndexTool);
  3161. return TRUE;
  3162. } // End RemoveTool
  3164. /////////////////////////////////////////////////////////////////////////////
  3165. //  CPPToolTip::RemoveAllTools (public member function)
  3166. //    removes the tool
  3167. //
  3168. //  Parameters :
  3169. // None
  3170. //
  3171. //  Returns :
  3172. // None 
  3173. //
  3174. /////////////////////////////////////////////////////////////////////////////
  3175. void CPPToolTip::RemoveAllTools()
  3176. {
  3177. TRACE (_T("CPPToolTip::RemoveAllToolsn"));
  3179. m_arrTools.RemoveAll();
  3180. } // End RemoveAllTools
  3182. /////////////////////////////////////////////////////////////////////////////
  3183. //  CPPToolTip::IsExistTool (public member function)
  3184. //    removes the tool
  3185. //
  3186. //  Parameters :
  3187. // nIndexTool [in]  - the index of the tool
  3188. //
  3189. //  Returns :
  3190. // TRUE - the tool is exist
  3191. //
  3192. /////////////////////////////////////////////////////////////////////////////
  3193. BOOL CPPToolTip::IsExistTool(int nIndexTool)
  3194. {
  3195. return (BOOL)((nIndexTool < m_arrTools.GetSize()) && (nIndexTool >= 0));
  3196. }
  3198. /////////////////////////////////////////////////////////////////////////////
  3199. //  CPPToolTip::SetAtTool (public member function)
  3200. //    adds or updates the tool
  3201. //
  3202. //  Parameters :
  3203. // nIndexTool [in] - the index of the tool
  3204. // ti [in] - the tooltip's structure 
  3205. //
  3206. //  Returns :
  3207. // None
  3208. //
  3209. /////////////////////////////////////////////////////////////////////////////
  3210. void CPPToolTip::SetAtTool(int nIndexTool, PPTOOLTIP_INFO & ti)
  3211. {
  3212. if (!IsExistTool(nIndexTool))
  3213. return;
  3214. m_arrTools.SetAt(nIndexTool, ti);
  3215. }
  3217. /////////////////////////////////////////////////////////////////////////////
  3218. //  CPPToolTip::ShowHelpTooltip (public member function)
  3219. //    shows the tooltip as help window
  3220. //
  3221. //  Parameters :
  3222. // pt [in] - the point of the tooltip's anchor in client coordinates
  3223. // nIdText  [in] - the tooltip's text id 
  3224. // nIdIcon  [in] - the icon's identificator 
  3225. //
  3226. //  Returns :
  3227. // None
  3228. //
  3229. /////////////////////////////////////////////////////////////////////////////
  3230. void CPPToolTip::ShowHelpTooltip(CPoint & pt, UINT nIdText, HICON hIcon /* = NULL */)
  3231. {
  3232. CString str;
  3233.     str.LoadString(nIdText);
  3234. ShowHelpTooltip(pt, str, hIcon);
  3235. }
  3237. /////////////////////////////////////////////////////////////////////////////
  3238. //  CPPToolTip::ShowHelpTooltip (public member function)
  3239. //    shows the tooltip as help window
  3240. //
  3241. //  Parameters :
  3242. // pt [in] - the point of the tooltip's anchor in client coordinates
  3243. // nIdText  [in] - the tooltip's text id 
  3244. // nIdIcon  [in] - the icon's identificator 
  3245. //
  3246. //  Returns :
  3247. // None
  3248. //
  3249. /////////////////////////////////////////////////////////////////////////////
  3250. void CPPToolTip::ShowHelpTooltip(CPoint & pt, UINT nIdText, UINT nIdIcon)
  3251. {
  3252. CString str;
  3253.     str.LoadString(nIdText);
  3254. ShowHelpTooltip(pt, str, nIdIcon);
  3255. }
  3257. /////////////////////////////////////////////////////////////////////////////
  3258. //  CPPToolTip::ShowHelpTooltip (public member function)
  3259. //    shows the tooltip as help window
  3260. //
  3261. //  Parameters :
  3262. // pt [in] - the point of the tooltip's anchor in client coordinates
  3263. // sTooltipText [in] - the tooltip's text 
  3264. // nIdIcon  [in] - the icon's identificator 
  3265. //
  3266. //  Returns :
  3267. // None
  3268. //
  3269. /////////////////////////////////////////////////////////////////////////////
  3270. void CPPToolTip::ShowHelpTooltip(CPoint & pt, CString sTooltipText, UINT nIdIcon)
  3271. {
  3272. HICON hIcon = GetIconFromResources(nIdIcon);
  3273. ShowHelpTooltip(pt, sTooltipText, hIcon);
  3274. }
  3276. /////////////////////////////////////////////////////////////////////////////
  3277. //  CPPToolTip::ShowHelpTooltip (public member function)
  3278. //    shows the tooltip as help window
  3279. //
  3280. //  Parameters :
  3281. // pt [in] - the point of the tooltip's anchor in client coordinates
  3282. // sTooltipText [in] - the tooltip's text 
  3283. // hIcon   [in] - the icon's handle 
  3284. //
  3285. //  Returns :
  3286. // None
  3287. //
  3288. /////////////////////////////////////////////////////////////////////////////
  3289. void CPPToolTip::ShowHelpTooltip(CPoint & pt, CString sTooltipText, HICON hIcon /* = NULL */)
  3290. {
  3291. PPTOOLTIP_INFO ti;
  3292. ti.hWnd = m_pParentWnd->GetSafeHwnd();
  3293. ti.hIcon = hIcon;
  3294. ti.sTooltip = sTooltipText;
  3295. ti.nMask = 0; //All values as default
  3296. ShowHelpTooltip(pt, ti);
  3297. }
  3299. /////////////////////////////////////////////////////////////////////////////
  3300. //  CPPToolTip::ShowHelpTooltip (public member function)
  3301. //    shows the tooltip as help window
  3302. //
  3303. //  Parameters :
  3304. // pt [in] - the point of the tooltip's anchor in client coordinates
  3305. // ti [in] - the tooltip's structure 
  3306. //
  3307. //  Returns :
  3308. // None
  3309. //
  3310. /////////////////////////////////////////////////////////////////////////////
  3311. void CPPToolTip::ShowHelpTooltip(CPoint & pt, PPTOOLTIP_INFO & ti)
  3312. {
  3313. TRACE(_T("ShowHelpTooltip()n"));
  3314. m_nIndexDisplayWnd = PPTOOLTIP_TOOL_NOEXIST;
  3315. m_nIndexCurrentWnd = PPTOOLTIP_TOOL_HELPER;
  3316. m_pToolInfo = ti;
  3318. m_ptOriginal = pt;
  3319. m_pParentWnd->ClientToScreen(&m_ptOriginal);
  3321. //Start the show timer
  3322. OnTimer(PPTOOLTIP_SHOW);
  3323. }
  3325. /////////////////////////////////////////////////////////////////////////////
  3326. //  CPPToolTip::SetImageList (public member function)
  3327. //    sets the image list to tooltip
  3328. //
  3329. //  Parameters :
  3330. // nIdBitmap [in] - Resource IDs of the bitmap to be associated with the image list
  3331. // cx [in] - Dimensions of each image, in pixels.
  3332. // cy [in] - Dimensions of each image, in pixels.
  3333. // nCount [in] - Number of images that the image list initially contains.
  3334. // crMask [in] - Color used to generate a mask. Each pixel of this color in the 
  3335. //    specified bitmap is changed to black, and the corresponding 
  3336. //    bit in the mask is set to one.
  3337. //  Returns :
  3338. // None
  3339. //
  3340. /////////////////////////////////////////////////////////////////////////////
  3341. void CPPToolTip::SetImageList(UINT nIdBitmap, int cx, int cy, int nCount, COLORREF crMask /* = RGB(255, 0, 255) */)
  3342. {
  3343. // Load bitmap
  3344. HBITMAP hBitmap = GetBitmapFromResources(nIdBitmap);
  3345. SetImageList(hBitmap, cx, cy, nCount, crMask);
  3346. }
  3348. /////////////////////////////////////////////////////////////////////////////
  3349. //  CPPToolTip::SetImageList (public member function)
  3350. //    sets the image list to tooltip
  3351. //
  3352. //  Parameters :
  3353. // hBitmap [in] - Handle of the bitmap to be associated with the image list
  3354. // cx [in] - Dimensions of each image, in pixels.
  3355. // cy [in] - Dimensions of each image, in pixels.
  3356. // nCount [in] - Number of images that the image list initially contains.
  3357. // crMask [in] - Color used to generate a mask. Each pixel of this color in the 
  3358. //    specified bitmap is changed to black, and the corresponding 
  3359. //    bit in the mask is set to one.
  3360. //  Returns :
  3361. // None
  3362. //
  3363. /////////////////////////////////////////////////////////////////////////////
  3364. void CPPToolTip::SetImageList(HBITMAP hBitmap, int cx, int cy, int nCount, COLORREF crMask /* = RGB(255, 0, 255) */)
  3365. {
  3366. if (m_imgTooltip.m_hImageList != NULL)
  3367. m_imgTooltip.DeleteImageList();
  3369. m_imgTooltip.Create(cx, cy, ILC_COLOR32 | ILC_MASK, nCount, 1);
  3370. m_imgTooltip.Add(CBitmap::FromHandle(hBitmap), crMask);
  3372. m_szImage = CSize(cx, cy);
  3373. }
  3375. /////////////////////////////////////////////////////////////////////////////
  3376. //  CPPToolTip::GetImageList (public member function)
  3377. //    gets the image list from tooltip
  3378. //
  3379. //  Parameters :
  3380. // sz    [out] - Dimensions of each image, in pixels.
  3381. //  Returns :
  3382. // A pointer to a CImageList object
  3383. //
  3384. /////////////////////////////////////////////////////////////////////////////
  3385. CImageList * CPPToolTip::GetImageList(CSize & sz)
  3386. {
  3387. sz = m_szImage;
  3388. return &m_imgTooltip;
  3389. }
  3391. /////////////////////////////////////////////////////////////////////////////
  3392. //  CPPToolTip::AddNameOfResource (public member function)
  3393. //    Associates the resource name with him ID
  3394. //
  3395. //  Parameters :
  3396. // sName [in] - A resource name in format string of the tooltip
  3397. // nID [in] - A resource ID associated with name.
  3398. // nTypeRes [in] - A resource type:
  3399. // TYPE_RES_ICON - a resource is a icon
  3400. // TYPE_RES_BITMAP - a resource is a bitmap
  3401. // TYPE_RES_MASK_BITMAP - a resource is a transparent bitmap
  3402. // crMask [in] - Color used to generate a mask. Each pixel of this color in the 
  3403. //    specified bitmap is changed to black, and the corresponding 
  3404. //    bit in the mask is set to one.
  3405. //  Returns :
  3406. // None
  3407. /////////////////////////////////////////////////////////////////////////////
  3408. void CPPToolTip::AddNameOfResource(CString sName, UINT nID, BYTE nTypeRes /* = TYPE_RES_TRAN_BITMAP */, COLORREF crMask /* = RGB(255, 0, 255) */)
  3409. {
  3410. if (sName.IsEmpty() || (nID == 0) || (nTypeRes >= MAX_TYPES_RES))
  3411. return;
  3413. PPTOOLTIP_NAME_RES nr;
  3414. nr.sName = sName;
  3415. nr.nID = nID;
  3416. nr.nTypeRes = nTypeRes;
  3417. nr.crMask = crMask;
  3419. m_arrNameRes.Add(nr);
  3420. }
  3422. /////////////////////////////////////////////////////////////////////////////
  3423. //  CPPToolTip::FindIdOfResource (public member function)
  3424. //    Search the ID resource by his name
  3425. //
  3426. //  Parameters :
  3427. // sName [in] - A resource name in format string of the tooltip
  3428. //  Returns :
  3429. // The array's index with ID resource associated with name or -1 if ID not found
  3430. /////////////////////////////////////////////////////////////////////////////
  3431. int CPPToolTip::FindIdOfResource(CString sName)
  3432. {
  3433. PPTOOLTIP_NAME_RES nr;
  3434. for (int i = 0; i < m_arrNameRes.GetSize(); i++)
  3435. {
  3436. nr = m_arrNameRes.GetAt(i);
  3437. if (!sName.CompareNoCase(nr.sName))
  3438. return i;
  3439. }
  3440. return -1;
  3441. }
  3443. /////////////////////////////////////////////////////////////////////////////
  3444. //  CPPToolTip::FindIdOfResource (public member function)
  3445. //    Search the resource name by his ID
  3446. //
  3447. //  Parameters :
  3448. // nID [in] - A ID resource
  3449. //  Returns :
  3450. // The array's index with resource name associated with ID or -1 if name not found
  3451. /////////////////////////////////////////////////////////////////////////////
  3452. int CPPToolTip::FindNameOfResource(UINT nID)
  3453. {
  3454. PPTOOLTIP_NAME_RES nr;
  3455. for (int i = 0; i < m_arrNameRes.GetSize(); i++)
  3456. {
  3457. nr = m_arrNameRes.GetAt(i);
  3458. if (nr.nID == nID)
  3459. return i;
  3460. }
  3461. return -1;
  3462. }
  3464. /////////////////////////////////////////////////////////////////////////////
  3465. //  CPPToolTip::FindIdOfResource (public member function)
  3466. //    Removes resource name by index of the array
  3467. //
  3468. //  Parameters :
  3469. // nIndex [in] - A The index of the resource name in the array
  3470. //  Returns :
  3471. // None
  3472. /////////////////////////////////////////////////////////////////////////////
  3473. void CPPToolTip::RemoveNameOfResource(int nIndex)
  3474. {
  3475. if (nIndex < m_arrNameRes.GetSize())
  3476. m_arrNameRes.RemoveAt(nIndex);
  3477. }
  3479. /////////////////////////////////////////////////////////////////////////////
  3480. //  CPPToolTip::FindIdOfResource (public member function)
  3481. //    Removes all resource names from the array
  3482. /////////////////////////////////////////////////////////////////////////////
  3483. void CPPToolTip::RemoveAllNamesOfResource()
  3484. {
  3485. m_arrNameRes.RemoveAll();
  3486. }