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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPToolTipContext.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：56k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPToolTipContext.cpp：源码内容
  1. // XTPToolTipContext.cpp: implementation of the CXTPToolTipContext class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #if _MSC_VER < 1200
  24. #define _XTP_EXCLUDE_HTML
  25. #else
  26. #include <mshtml.h>
  27. #include <mshtmhst.h>
  28. #endif // !_MSC_VER < 1200
  30. #include "XTPToolTipContext.h"
  31. #include "XTPVC80Helpers.h"
  32. #include "XTPDrawHelpers.h"
  33. #include "XTPColorManager.h"
  34. #include "XTPImageManager.h"
  35. #include "XTPOffice2007Image.h"
  36. #include "XTPSystemHelpers.h"
  37. #include "XTPRichRender.h"
  38. #include "XTPResourceManager.h"
  39. #include "XTPMarkupRender.h"
  41. #ifdef _INC_COMDEF
  42. // Warning "ComDef.h" was included
  43. #endif
  45. #ifdef _DEBUG
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #define new DEBUG_NEW
  49. #endif
  51. #pragma warning (disable : 4097) // typedef-name 'CXTPToolTipContextTipOfficeCtrl' used as synonym for class-name 'CRichEditToolTip'
  53. #define WM_SYSKEYFIRST WM_SYSKEYDOWN
  54. #define WM_SYSKEYLAST WM_SYSDEADCHAR
  56. #define VERSION_IE5             MAKELONG(80, 5)
  58. #define TTS_NOANIMATE           0x10
  59. #define TTS_NOFADE              0x20
  60. #define TTS_BALLOON             0x40
  63. #define CS_DROPSHADOW       0x00020000
  66. #ifndef TTM_SETTITLE
  68. #define TTM_SETTITLEA           (WM_USER + 32)  // wParam = TTI_*, lParam = char* szTitle
  69. #define TTM_SETTITLEW           (WM_USER + 33)  // wParam = TTI_*, lParam = wchar* szTitle
  71. #ifdef UNICODE
  72. #define TTM_SETTITLE            TTM_SETTITLEW
  73. #else
  74. #define TTM_SETTITLE            TTM_SETTITLEA
  75. #endif
  77. #endif
  79. #ifndef WF_TRACKINGTOOLTIPS
  80. #define WF_TRACKINGTOOLTIPS 0x0400
  81. #endif
  83. #define SAFE_DELETEWINDOW(ptr) 
  84. if (ptr) { ptr->DestroyWindow(); delete ptr; ptr = NULL; }
  86. CXTPToolTipContext* CXTPToolTipContext::m_pModuleContext = 0;
  89. IMPLEMENT_DYNAMIC(CXTPToolTipContextToolTip, CWnd)
  91. //////////////////////////////////////////////////////////////////////////
  92. // CXTPToolTipContextToolTip
  94. CXTPToolTipContextToolTip::CXTPToolTipContextToolTip(CXTPToolTipContext* pContext)
  95. : m_pContext(pContext)
  96. {
  97. m_bActive = FALSE;
  98. m_toolVisible.Reset();
  99. m_toolDisabled.Reset();
  100. m_toolDelay.Reset();
  102. m_pIcon = NULL;
  104. m_nDelayTimer = 0;
  105. m_dwLastTip = 0;
  106. m_nDelayInitial = 500;
  107. m_nDelayReshow = 200;
  109. }
  111. void CXTPToolTipContext::SetFont(CFont* pFont)
  112. {
  113. LOGFONT lf;
  114. pFont->GetLogFont(&lf);
  116. SetFontIndirect(&lf);
  117. }
  119. void CXTPToolTipContext::SetFontIndirect(LOGFONT* lpLogFont)
  120. {
  121. if (!lpLogFont)
  122. return;
  124. lpLogFont->lfWeight = FW_NORMAL;
  125. m_fnt.DeleteObject();
  126. m_fnt.CreateFontIndirect(lpLogFont);
  128. lpLogFont->lfWeight = FW_BOLD;
  129. m_fntTitle.DeleteObject();
  130. m_fntTitle.CreateFontIndirect(lpLogFont);
  132. if (m_pToolTip) m_pToolTip->DestroyWindow();
  133. }
  136. CXTPToolTipContextToolTip::~CXTPToolTipContextToolTip()
  137. {
  138. for (int i = 0; i < (int)m_arrTools.GetSize(); i++)
  139. {
  140. delete m_arrTools[i];
  141. }
  142. m_arrTools.RemoveAll();
  143. HookMouseMove(FALSE);
  145. }
  148. BEGIN_MESSAGE_MAP(CXTPToolTipContextToolTip, CWnd)
  149. //{{AFX_MSG_MAP(CXTPToolTipContextToolTip)
  150. ON_MESSAGE(TTM_ADDTOOL, OnAddTool)
  151. ON_MESSAGE(TTM_ACTIVATE, OnActivate)
  152. ON_MESSAGE(TTM_DELTOOL, OnDelTool)
  153. ON_MESSAGE(TTM_RELAYEVENT, OnRelayEvent)
  154. ON_MESSAGE(TTM_SETTITLE, OnSetTitle)
  155. ON_MESSAGE(TTM_UPDATETIPTEXT, OnUpdateTipText)
  156. ON_MESSAGE(TTM_SETDELAYTIME, OnSetDelayTime)
  157. ON_MESSAGE(XTP_TTM_SETIMAGE, OnSetImage)
  158. ON_WM_PAINT()
  159. ON_WM_ERASEBKGND()
  160. ON_WM_NCHITTEST_EX()
  161. ON_WM_MOUSEACTIVATE()
  162. ON_WM_MOUSEMOVE()
  163. ON_WM_TIMER()
  164. ON_WM_DESTROY()
  165. ON_MESSAGE(TTM_WINDOWFROMPOINT, OnWindowFromPoint)
  166. //}}AFX_MSG_MAP
  167. END_MESSAGE_MAP()
  169. /////////////////////////////////////////////////////////////////////////////
  170. // CXTPToolTipContextToolTip message handlers
  171. BOOL CXTPToolTipContextToolTip::Create(CWnd* pParentWnd, DWORD dwStyle)
  172. {
  173. UINT nClassStyle = (dwStyle & XTP_TTS_NOSHADOW ? 0 : CS_DROPSHADOW) | CS_SAVEBITS | CS_OWNDC;
  175. if ((nClassStyle & CS_DROPSHADOW) && !XTPSystemVersion()->IsWinXPOrGreater()) // Windows XP only
  176. {
  177. nClassStyle &= ~CS_DROPSHADOW;
  178. }
  181. BOOL bResult = CWnd::CreateEx(WS_EX_TOOLWINDOW, AfxRegisterWndClass(nClassStyle, AfxGetApp()->LoadStandardCursor(IDC_ARROW)), NULL,
  182. WS_POPUP | dwStyle, // force WS_POPUP
  183. CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  184. pParentWnd->GetSafeHwnd(), NULL, NULL);
  186. if (bResult)
  187. SetOwner(pParentWnd);
  188. return bResult;
  189. }
  191. void CXTPToolTipContextToolTip::OnDestroy()
  192. {
  193. m_toolVisible.Reset();
  194. m_toolDisabled.Reset();
  195. m_toolDelay.Reset();
  197. for (int i = 0; i < (int)m_arrTools.GetSize(); i++)
  198. {
  199. delete m_arrTools[i];
  200. }
  201. m_arrTools.RemoveAll();
  203. m_strTitle.Empty();
  204. m_pIcon = NULL;
  206. Activate(FALSE);
  207. HookMouseMove(FALSE);
  209. CWnd::OnDestroy();
  210. }
  212. LRESULT CXTPToolTipContextToolTip::OnSetImage(WPARAM, LPARAM lParam)
  213. {
  214. m_pIcon = (CXTPImageManagerIcon*)lParam;
  215. return 0;
  216. }
  218. LRESULT CXTPToolTipContextToolTip::OnSetTitle(WPARAM, LPARAM lParam)
  219. {
  220. m_strTitle = (LPCTSTR)lParam;
  221. return 0;
  222. }
  224. LRESULT CXTPToolTipContextToolTip::OnSetDelayTime(WPARAM dwDuration, LPARAM lParam)
  225. {
  226. UINT iTime = LOWORD(lParam);
  228. switch (dwDuration)
  229. {
  230. case TTDT_RESHOW:
  231. m_nDelayReshow = iTime;
  232. break;
  234. case TTDT_INITIAL:
  235. m_nDelayInitial = iTime;
  236. break;
  237. }
  238. return 0;
  239. }
  241. LRESULT CXTPToolTipContextToolTip::OnUpdateTipText(WPARAM, LPARAM lParam)
  242. {
  243. LPTOOLINFO lpToolInfo = LPTOOLINFO(lParam);
  245. for (int i = 0; i < (int)m_arrTools.GetSize(); i++)
  246. {
  247. TOOLITEM* pItem = m_arrTools[i];
  249. if ((pItem->uId == lpToolInfo->uId) && (pItem->hwnd == lpToolInfo->hwnd))
  250. {
  251. pItem->bAutoCaption = (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK);
  252. pItem->strCaption = pItem->bAutoCaption ? _T("") : lpToolInfo->lpszText;
  253. break;
  254. }
  255. }
  257. return 0;
  258. }
  261. LRESULT CXTPToolTipContextToolTip::OnAddTool(WPARAM, LPARAM lParam)
  262. {
  263. return AddTool((LPTOOLINFO)lParam);
  264. }
  266. LRESULT CXTPToolTipContextToolTip::OnActivate(WPARAM wParam, LPARAM)
  267. {
  268. Activate((BOOL)wParam);
  269. return 0;
  270. }
  272. LRESULT CXTPToolTipContextToolTip::OnDelTool(WPARAM, LPARAM lParam)
  273. {
  274. DelTool((LPTOOLINFO)lParam);
  275. return 0;
  276. }
  278. LRESULT CXTPToolTipContextToolTip::OnRelayEvent(WPARAM, LPARAM lParam)
  279. {
  280. RelayEvent((LPMSG)lParam);
  281. return 0;
  282. }
  284. LRESULT CXTPToolTipContextToolTip::OnWindowFromPoint(WPARAM, LPARAM lParam)
  285. {
  286. LPPOINT lpPoint = (LPPOINT)lParam;
  287. HWND hWnd = lpPoint ? ::WindowFromPoint(*lpPoint) : 0;
  289. if ((hWnd != NULL) && (GetWindowLong(hWnd, GWL_STYLE) & WS_CHILD) && (::SendMessage(hWnd, XTP_TTM_WINDOWFROMPOINT, 0, 0) == 1))
  290. {
  291. return (LRESULT)::GetParent(hWnd);
  292. }
  294. return (LRESULT)hWnd;
  295. }
  297. BOOL CXTPToolTipContextToolTip::AddTool(LPTOOLINFO lpToolInfo)
  298. {
  299. ASSERT(lpToolInfo);
  301. if (!lpToolInfo)
  302. return FALSE;
  304. TOOLITEM* pti = new TOOLITEM;
  305. pti->hwnd = lpToolInfo->hwnd;
  306. pti->uFlags = lpToolInfo->uFlags;
  307. pti->uId = lpToolInfo->uId;
  308. pti->rect = lpToolInfo->rect;
  309. pti->bAutoCaption = (lpToolInfo->lpszText == LPSTR_TEXTCALLBACK);
  310. pti->strCaption = pti->bAutoCaption ? _T("") : lpToolInfo->lpszText;
  311. pti->hinst = lpToolInfo->hinst;
  313. pti->rectExclude.SetRectEmpty();
  315. if (lpToolInfo->cbSize == sizeof(XTP_TOOLTIP_TOOLINFO_EX))
  316. {
  317. pti->rectExclude = ((XTP_TOOLTIP_TOOLINFO_EX*)lpToolInfo)->pToolInfo->rcExclude;
  318. }
  321. m_arrTools.Add(pti);
  323. return TRUE;
  324. }
  326. void CXTPToolTipContextToolTip::Activate(BOOL bActivate)
  327. {
  328. m_bActive = bActivate;
  330. if (!bActivate && GetSafeHwnd() && m_nDelayTimer)
  331. {
  332. KillTimer(m_nDelayTimer);
  333. m_nDelayTimer = 0;
  334. m_toolDelay.Reset();
  335. }
  336. if (!bActivate && GetSafeHwnd() && IsWindowVisible())
  337. {
  338. SetVisibleTool(NULL);
  339. }
  340. }
  342. void CXTPToolTipContextToolTip::DelTool(LPTOOLINFO lpToolInfo)
  343. {
  344. ASSERT(lpToolInfo);
  345. if (!lpToolInfo)
  346. return;
  348. for (int i = 0; i < (int)m_arrTools.GetSize(); i++)
  349. {
  350. TOOLITEM* pItem = m_arrTools[i];
  352. if ((pItem->uId == lpToolInfo->uId) && (pItem->hwnd == lpToolInfo->hwnd))
  353. {
  355. if (m_toolVisible.IsEqual(pItem))
  356. SetVisibleTool(0);
  358. if (m_toolDisabled.IsEqual(pItem)) m_toolDisabled.Reset();
  360. if (m_toolDelay.IsEqual(pItem)) m_toolDelay.Reset();
  362. m_arrTools.RemoveAt(i);
  363. delete pItem;
  365. break;
  366. }
  367. }
  369. }
  371. CXTPToolTipContextToolTip::TOOLITEM* CXTPToolTipContextToolTip::FindTool()
  372. {
  373. if (!(GetKeyState(VK_LBUTTON) >= 0 && GetKeyState(VK_RBUTTON) >= 0 &&
  374. GetKeyState(VK_MBUTTON) >= 0))
  375. {
  376. return NULL;
  377. }
  379. CPoint pt;
  380. GetCursorPos(&pt);
  382. for (int i = 0; i < m_arrTools.GetSize(); i++)
  383. {
  384. TOOLITEM* pItem = m_arrTools[i];
  386. if (!::IsWindow(pItem->hwnd))
  387. continue;
  389. CWnd* pWnd = CWnd::FromHandle(pItem->hwnd);
  391. CRect rcTool = pItem->rect;
  393. if (pItem->uFlags & TTF_IDISHWND)
  394. {
  395. pWnd->GetWindowRect(rcTool);
  396. }
  397. else
  398. {
  399. pWnd->ClientToScreen(rcTool);
  400. }
  402. if (rcTool.PtInRect(pt) && ((pItem->uFlags & TTF_IDISHWND) || ((HWND)OnWindowFromPoint(0, (LRESULT)(LPPOINT)&pt) == pItem->hwnd)))
  403. return pItem;
  404. }
  405. return NULL;
  406. }
  408. #ifndef IS_INTRESOURCE
  409. #define IS_INTRESOURCE(x) (((size_t)(x) >> 16) == 0)
  410. #endif
  412. CString CXTPToolTipContextToolTip::GetToolText(TOOLITEM* lpToolInfo)
  413. {
  414. if (lpToolInfo->bAutoCaption)
  415. {
  416. UINT_PTR id = lpToolInfo->uId;
  417. TOOLTIPTEXT tt = {0};
  418. tt.hdr.hwndFrom = m_hWnd;
  419. tt.hdr.idFrom = lpToolInfo->uId;
  420. tt.hdr.code = TTN_NEEDTEXT;
  422. tt.uFlags = lpToolInfo->uFlags;
  423. tt.hinst = NULL;
  425. tt.szText[0] = _T('');
  426. tt.lpszText = tt.szText;
  428. ::SendMessage(lpToolInfo->hwnd, WM_NOTIFY, id, (LPARAM)&tt);
  430. if (IS_INTRESOURCE(tt.lpszText))
  431. {
  432. XTPResourceManager()->LoadLocaleString(tt.hinst, (UINT)(UINT_PTR)tt.lpszText, lpToolInfo->strCaption);
  433. }
  434. else
  435. {
  436. lpToolInfo->strCaption = tt.lpszText;
  437. }
  439. if ((m_pContext->GetControlStyle() & TTS_NOPREFIX) == 0)
  440. {
  441. CXTPDrawHelpers::StripMnemonics(lpToolInfo->strCaption);
  442. }
  444. lpToolInfo->bAutoCaption = FALSE;
  445. }
  447. return lpToolInfo->strCaption;
  448. }
  450. int CXTPToolTipContextToolTip::GetMaxTipWidth() const
  451. {
  452. const int nWidth = m_pContext->GetMaxTipWidth();
  454. if (nWidth == -1)
  455. {
  456. return ::GetSystemMetrics(SM_CXSCREEN);
  457. }
  458. return nWidth;
  459. }
  461. CSize CXTPToolTipContextToolTip::GetToolSize(TOOLITEM* lpToolInfo)
  462. {
  463. CClientDC dc(this);
  465. CFont* pOldFont = dc.SelectObject(&m_pContext->m_fnt);
  467. CString str = GetToolText(lpToolInfo);
  469. if (str.IsEmpty())
  470. return CSize(0);
  472. int nMaxTipWidth = GetMaxTipWidth();
  474. CRect rcMargin = m_pContext->GetMargin();
  475. CSize szMargin(3 + rcMargin.left + rcMargin.right + 3, 3 + rcMargin.top + rcMargin.bottom + 3);
  477. DWORD dwFlags = DT_NOPREFIX | DT_EXPANDTABS;
  479. CRect rc(0, 0, nMaxTipWidth - szMargin.cx, 0);
  480. dc.DrawText(str, rc, dwFlags | DT_CALCRECT | DT_WORDBREAK);
  481. CSize sz = rc.Size();
  483. BOOL bDrawImage = m_pIcon != NULL;
  484. BOOL bDrawTitle = !m_strTitle.IsEmpty();
  485. BOOL bDrawImageTop = TRUE;
  486. CSize szImage(0, 0);
  488. if (bDrawImage)
  489. {
  490. szImage = CSize(m_pIcon->GetWidth(), m_pIcon->GetHeight());
  491. bDrawImageTop = (szImage.cy <= 16);
  493. if (bDrawImageTop)
  494. {
  495. if (!bDrawTitle)
  496. {
  497. sz.cx += szImage.cx + 3;
  498. }
  499. }
  500. else
  501. {
  502. sz.cx += szImage.cx + 5;
  503. }
  504. sz.cy = max(sz.cy, szImage.cy);
  505. }
  507. if (bDrawTitle)
  508. {
  509. CXTPFontDC fntTitle(&dc, &m_pContext->m_fntTitle);
  511. CRect rcTitle(0, 0, nMaxTipWidth - szMargin.cx - 25, 0);
  512. dc.DrawText(m_strTitle, rcTitle, dwFlags | DT_CALCRECT | DT_SINGLELINE);
  514. sz.cy += rcTitle.Height() + 10 + 10;
  515. sz.cx = max(sz.cx + 10 + 15, min(nMaxTipWidth - szMargin.cx, rcTitle.Width() + 4) + (bDrawImage && bDrawImageTop ? szImage.cx + 1: 0));
  517. }
  519. dc.SelectObject(pOldFont);
  521. sz += szMargin;
  523. return sz;
  524. }
  526. HHOOK CXTPToolTipContextToolTip::m_hHookMouse = 0;
  527. CXTPToolTipContextToolTip* CXTPToolTipContextToolTip::m_pWndMonitor = 0;
  529. LRESULT CALLBACK CXTPToolTipContextToolTip::MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
  530. {
  531. if (nCode != HC_ACTION || !m_pWndMonitor || m_pWndMonitor->m_toolVisible.IsEmpty())
  532. return CallNextHookEx(m_hHookMouse, nCode, wParam, lParam);
  534. POINT pt = ((PMOUSEHOOKSTRUCT)lParam)->pt;
  535. HWND hWnd = (HWND)m_pWndMonitor->OnWindowFromPoint(0, (LPARAM)&pt);
  537. if (hWnd != m_pWndMonitor->m_toolVisible.hwnd)
  538. {
  539. MSG msg;
  540. msg.pt = pt;
  541. msg.message = WM_MOUSEMOVE;
  542. m_pWndMonitor->RelayEvent(&msg);
  543. }
  545. return CallNextHookEx(m_hHookMouse, nCode, wParam, lParam);
  546. }
  548. void CXTPToolTipContextToolTip::HookMouseMove(BOOL bSetupHook)
  549. {
  550. if (bSetupHook && m_hHookMouse == 0 && (m_pWndMonitor == NULL))
  551. {
  552. m_hHookMouse = SetWindowsHookEx(WH_MOUSE, MouseProc, 0, GetCurrentThreadId ());
  553. m_pWndMonitor = this;
  554. }
  555. else if (!bSetupHook && m_hHookMouse && (m_pWndMonitor == this))
  556. {
  557. UnhookWindowsHookEx(m_hHookMouse);
  558. m_hHookMouse = 0;
  559. m_pWndMonitor = NULL;
  560. }
  561. }
  563. void CXTPToolTipContextToolTip::EnsureVisible(CRect& rcToolTip)
  564. {
  565. CRect rcWork = XTPMultiMonitor()->GetWorkArea();
  566. int nGap = 4;
  568. if (rcWork.right - nGap < rcToolTip.right)
  569. {
  570. rcToolTip.OffsetRect(- rcToolTip.right + rcWork.right - nGap, 0);
  571. }
  573. if (rcWork.left > rcToolTip.left)
  574. {
  575. rcToolTip.OffsetRect(rcWork.left - rcToolTip.left, 0);
  576. }
  578. if (rcWork.bottom - nGap < rcToolTip.bottom)
  579. {
  580. CPoint pt;
  581. GetCursorPos(&pt);
  582. rcToolTip.OffsetRect(0, pt.y - rcToolTip.bottom - 3);
  583. }
  584. }
  586. int CXTPToolTipContextToolTip::GetCursorHeight() const
  587. {
  588. HCURSOR hCursor = GetCursor();
  590. ICONINFO iconInfo;
  591. if (!GetIconInfo(hCursor, &iconInfo))
  592. return 21;
  594. BITMAP bm;
  595. if (!GetObject(iconInfo.hbmMask, sizeof(BITMAP), &bm))
  596. return 21;
  598. WORD curBits[16 * 8];
  599. memset(&curBits, -1, sizeof(curBits));
  601. if (!GetBitmapBits(iconInfo.hbmMask, sizeof(curBits), curBits))
  602. return 21;
  604. int nBitSize = sizeof(WORD) * 8;
  605. int nCount = MulDiv(bm.bmWidth, bm.bmHeight, nBitSize);
  606. int nXor = 0;
  608. if (!iconInfo.hbmColor)
  609. {
  610. nXor = nCount - 1;
  611. nCount = nCount / 2;
  612. }
  614. if (nCount >= sizeof(curBits)/sizeof(WORD)) nCount = sizeof(curBits)/sizeof(WORD) - 1;
  615. if (nXor >= sizeof(curBits)/sizeof(WORD)) nXor = 0;
  617. int i = nCount - 1;
  619. for (; i >= 0; i--)
  620. {
  621. if (curBits[i] != 0xFFFF || (nXor && (curBits[nXor--] != 0)))
  622. break;
  623. }
  625. if (iconInfo.hbmColor) DeleteObject(iconInfo.hbmColor);
  626. if (iconInfo.hbmMask) DeleteObject(iconInfo.hbmMask);
  628. return MulDiv(i + 1, nBitSize, (int)bm.bmWidth) - (int)iconInfo.yHotspot;
  629. }
  631. void CXTPToolTipContextToolTip::SetRoundRectRegion(CWnd* pWnd)
  632. {
  633. CXTPWindowRect rc(pWnd);
  634. rc.OffsetRect(-rc.TopLeft());
  636. int cx = rc.Width(), cy = rc.Height();
  638. RECT rgn[] =
  639. {
  640. {1, 0, cx - 1, 1}, {0, 1, cx, cy - 1}, {1, cy - 1, cx - 1, cy}
  641. };
  643. int nSizeData = sizeof(RGNDATAHEADER) + sizeof(rgn);
  645. RGNDATA* pRgnData = (RGNDATA*)malloc(nSizeData);
  646. if (!pRgnData)
  647. return;
  648. MEMCPY_S(&pRgnData->Buffer, (void*)&rgn, sizeof(rgn));
  650. pRgnData->rdh.dwSize = sizeof(RGNDATAHEADER);
  651. pRgnData->rdh.iType = RDH_RECTANGLES;
  652. pRgnData->rdh.nCount = sizeof(rgn) / sizeof(RECT);
  653. pRgnData->rdh.nRgnSize = 0;
  654. pRgnData->rdh.rcBound = CRect(0, 0, cx, cy);
  656. CRgn rgnResult;
  657. VERIFY(rgnResult.CreateFromData(NULL, nSizeData, pRgnData));
  659. free(pRgnData);
  661. pWnd->SetWindowRgn((HRGN)rgnResult.Detach(), FALSE);
  662. }
  664. void CXTPToolTipContextToolTip::SetVisibleTool(TOOLITEM* pVisibleTool)
  665. {
  666. if (!m_toolVisible.IsEqual(pVisibleTool))
  667. {
  668. CSize sz(0);
  670. if (pVisibleTool)
  671. {
  672. sz = GetToolSize(pVisibleTool);
  673. if (sz == CSize(0)) pVisibleTool = 0;
  674. }
  676. if (m_hWnd)
  677. {
  678. SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
  679. SetWindowRgn(NULL, FALSE);
  680. }
  682. if (pVisibleTool)
  683. {
  684. CRect rcToolTip(0, 0, 0, 0);
  686. if (!pVisibleTool->rectExclude.IsRectEmpty())
  687. {
  688. CWnd* pWnd = CWnd::FromHandle(pVisibleTool->hwnd);
  689. //CRect rcExclude = pVisibleTool->rectExclude;
  690. //rcToolTip = pVisibleTool->rect;
  691. rcToolTip.SetRect(pVisibleTool->rect.left, pVisibleTool->rectExclude.bottom,
  692. pVisibleTool->rect.left + sz.cx, pVisibleTool->rectExclude.bottom + sz.cy);
  694. pWnd->ClientToScreen(rcToolTip);
  696. }
  697. else
  698. {
  699. CPoint pt;
  700. GetCursorPos(&pt);
  701. int nCursorHeight = GetCursorHeight();
  703. rcToolTip.SetRect(pt.x, pt.y + nCursorHeight, pt.x + sz.cx, pt.y + nCursorHeight + sz.cy);
  705. if (GetWindowLong(pVisibleTool->hwnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL)
  706. {
  707. rcToolTip.OffsetRect(-sz.cx, 0);
  708. }
  709. }
  712. EnsureVisible(rcToolTip);
  714. SetWindowPos(&CWnd::wndTop, rcToolTip.left, rcToolTip.top,
  715. rcToolTip.Width(), rcToolTip.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER);
  717. UINT_PTR id = pVisibleTool->uId;
  718. NMHDR hdr = {0};
  719. hdr.hwndFrom = m_hWnd;
  720. hdr.idFrom = pVisibleTool->uId;
  721. hdr.code = TTN_SHOW;
  722. ::SendMessage(pVisibleTool->hwnd, WM_NOTIFY, id, (LPARAM)&hdr);
  724. if (GetStyle() & XTP_TTS_OFFICE2007FRAME)
  725. {
  726. SetRoundRectRegion(this);
  727. }
  729. SetWindowPos(0, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
  731. Invalidate(FALSE);
  733. HookMouseMove(TRUE);
  735. m_toolDisabled.Reset();
  736. }
  737. else
  738. {
  739. HookMouseMove(FALSE);
  740. m_toolDelay.Reset();
  741. }
  743. m_toolVisible.Assign(pVisibleTool);
  745. m_dwLastTip = GetTickCount();
  747. OnVisibleChanged(pVisibleTool != NULL);
  748. }
  749. }
  751. void CXTPToolTipContextToolTip::RelayEvent(LPMSG lpMsg)
  752. {
  753. if (!m_bActive)
  754. return;
  756. if (!((lpMsg->message >= WM_MOUSEFIRST && lpMsg->message <= WM_MOUSELAST) ||
  757. (lpMsg->message >= WM_NCMOUSEMOVE && lpMsg->message <= WM_NCMBUTTONDBLCLK)))
  758. return;
  760. TOOLITEM* pVisibleTool = FindTool();
  762. if (lpMsg->message == WM_LBUTTONDOWN)
  763. {
  764. if (pVisibleTool)
  765. {
  766. m_toolDisabled = *pVisibleTool;
  767. pVisibleTool = 0;
  768. }
  769. }
  770. if (pVisibleTool && (m_toolDisabled.IsEqual(pVisibleTool)))
  771. {
  772. pVisibleTool = 0;
  773. }
  775. if (m_nDelayTimer && !m_toolDelay.IsEqual(pVisibleTool))
  776. {
  777. KillTimer(m_nDelayTimer);
  778. m_nDelayTimer = 0;
  779. m_toolDelay.Reset();
  780. }
  782. if (pVisibleTool)
  783. {
  784. if (!m_toolVisible.IsEqual(pVisibleTool))
  785. {
  786. if (GetTickCount() - m_dwLastTip < m_nDelayReshow)
  787. {
  788. SetVisibleTool(pVisibleTool);
  789. }
  790. else if (!m_toolDelay.IsEqual(pVisibleTool))
  791. {
  792. m_toolDelay = *pVisibleTool;
  793. m_nDelayTimer = SetTimer(1, m_nDelayInitial, NULL);
  794. }
  795. }
  796. }
  797. else
  798. {
  799. SetVisibleTool(0);
  800. }
  803. }
  805. void CXTPToolTipContextToolTip::DrawEntry(CDC* pDC, TOOLITEM* lpToolInfo, CRect rc)
  806. {
  807. CString str = lpToolInfo->strCaption;
  809. rc.DeflateRect(m_pContext->GetMargin());
  810. rc.DeflateRect(3, 3, 3, 3);
  812. DWORD dwFlags = DT_NOPREFIX | DT_EXPANDTABS;
  813. BOOL bLayoutRTL = lpToolInfo->hwnd && GetWindowLong(lpToolInfo->hwnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL;
  815. if (bLayoutRTL)
  816. {
  817. dwFlags |= DT_RTLREADING | DT_RIGHT;
  818. }
  820. CRect rcTitle(rc.left + 2, rc.top + 2, rc.right - 2, rc.bottom);
  822. BOOL bDrawImage = m_pIcon != NULL;
  823. BOOL bDrawTitle = !m_strTitle.IsEmpty();
  824. BOOL bDrawImageTop = TRUE;
  825. CSize szImage(0, 0);
  827. if (bDrawImage)
  828. {
  829. szImage = CSize(m_pIcon->GetWidth(), m_pIcon->GetHeight());
  830. bDrawImageTop = (szImage.cy <= 16);
  832. if (bDrawImageTop)
  833. {
  834. CPoint ptIcon = bLayoutRTL ? CPoint(rc.right - szImage.cx, rc.top) : rc.TopLeft();
  835. m_pIcon->Draw(pDC, ptIcon);
  837. if (bLayoutRTL)
  838. {
  839. if (bDrawTitle) rcTitle.right -= szImage.cx + 1; else rc.right -= szImage.cx + 3;
  840. }
  841. else
  842. {
  843. if (bDrawTitle) rcTitle.left += szImage.cx + 1; else rc.left += szImage.cx + 3;
  844. }
  845. }
  846. }
  848. if (bDrawTitle)
  849. {
  850. CXTPFontDC fnt(pDC, &m_pContext->m_fntTitle);
  851. pDC->DrawText(m_strTitle, rcTitle, dwFlags | DT_SINGLELINE);
  853. rc.top += pDC->GetTextExtent(m_strTitle).cy;
  855. if (bLayoutRTL)
  856. {
  857. rc.DeflateRect(15, 12, 10, 0);
  858. }
  859. else
  860. {
  861. rc.DeflateRect(10, 12, 15, 0);
  862. }
  863. }
  865. if (bDrawImage && !bDrawImageTop)
  866. {
  867. CPoint ptIcon = bLayoutRTL ? CPoint(rc.right - szImage.cx, rc.top) : rc.TopLeft();
  868. m_pIcon->Draw(pDC, ptIcon);
  869. if (bLayoutRTL) rc.right -= szImage.cx + 5; else rc.left += szImage.cx + 5;
  870. }
  872. pDC->DrawText(str, rc, dwFlags | DT_WORDBREAK);
  873. }
  875. void CXTPToolTipContextToolTip::DrawBackground(CDC* pDC, TOOLITEM* /*lpToolInfo*/, CRect rc)
  876. {
  877. if (GetStyle() & XTP_TTS_OFFICE2007FRAME)
  878. {
  879. COLORREF clrLight = XTPOffice2007Images()->GetImageColor(_T("Window"), _T("TooltipLight"));
  880. COLORREF clrDark = XTPOffice2007Images()->GetImageColor(_T("Window"), _T("TooltipDark"));
  882. if (clrLight == COLORREF_NULL) clrLight = RGB(255, 255, 255);
  883. if (clrDark == COLORREF_NULL) clrDark = RGB(201, 217, 239);
  885. XTPDrawHelpers()->GradientFill(pDC, rc, clrLight, clrDark, FALSE);
  887. CXTPOffice2007Image* pImage = XTPOffice2007Images()->LoadFile(_T("TOOLTIPFRAME"));
  888. if (pImage)
  889. {
  890. pImage->DrawImage(pDC, rc, pImage->GetSource(0, 1), CRect(3, 3, 3, 3), 0xFF00FF);
  891. }
  892. else
  893. {
  894. COLORREF clrBorder = XTPOffice2007Images()->GetImageColor(_T("Window"), _T("TooltipBorder"));
  895. if (clrBorder == COLORREF_NULL) clrBorder = RGB(118, 118, 118);
  896. pDC->Draw3dRect(rc, clrBorder, clrBorder);
  897. }
  898. }
  899. else
  900. {
  901. pDC->FillSolidRect(rc, m_pContext->GetTipBkColor());
  903. if (GetStyle() & XTP_TTS_OFFICEFRAME)
  904. pDC->Draw3dRect(rc, GetSysColor(COLOR_3DFACE), 0);
  905. else
  906. pDC->Draw3dRect(rc, 0, 0);
  907. }
  908. }
  910. void CXTPToolTipContextToolTip::OnPaint()
  911. {
  912. CPaintDC dc(this); // device context for painting
  914. CXTPClientRect rc(this);
  916. DrawBackground(&dc, &m_toolVisible, rc);
  918. COLORREF clrTextColor = m_pContext->GetTipTextColor();
  919. dc.SetBkMode(TRANSPARENT);
  920. dc.SetTextColor(clrTextColor);
  921. CXTPFontDC font(&dc, &m_pContext->m_fnt);
  923. DrawEntry(&dc, &m_toolVisible, rc);
  924. }
  926. BOOL CXTPToolTipContextToolTip::OnEraseBkgnd(CDC* /*pDC*/)
  927. {
  928. return TRUE;
  929. }
  931. LRESULT CXTPToolTipContextToolTip::OnNcHitTest(CPoint /*point*/)
  932. {
  933. return (LRESULT)HTTRANSPARENT;
  934. }
  936. int CXTPToolTipContextToolTip::OnMouseActivate(CWnd* /*pDesktopWnd*/, UINT /*nHitTest*/, UINT /*message*/)
  937. {
  938. return MA_NOACTIVATE;
  939. }
  941. void CXTPToolTipContextToolTip::OnMouseMove(UINT /*nFlags*/, CPoint /*point*/)
  942. {
  943. SetVisibleTool(NULL);
  944. }
  946. void CXTPToolTipContextToolTip::OnTimer(UINT_PTR nIDEvent)
  947. {
  948. if (nIDEvent == m_nDelayTimer)
  949. {
  950. if (!m_toolDelay.IsEmpty())
  951. {
  952. TOOLITEM* pVisibleTool = FindTool();
  954. if (m_toolDelay.IsEqual(pVisibleTool))
  955. {
  956. SetVisibleTool(pVisibleTool);
  957. }
  958. }
  959. KillTimer(m_nDelayTimer);
  960. m_nDelayTimer = 0;
  961. m_toolDelay.Reset();
  962. }
  964. CWnd::OnTimer(nIDEvent);
  965. }
  967. //////////////////////////////////////////////////////////////////////////
  968. // CXTPToolTipContext::CStandardToolTip
  970. class CXTPToolTipContext::CStandardToolTip : public CToolTipCtrl
  971. {
  972. DECLARE_MESSAGE_MAP()
  973. LRESULT OnWindowFromPoint(WPARAM, LPARAM);
  974. };
  976. typedef CXTPToolTipContext::CStandardToolTip CXTPToolTipContextStandardTip;
  978. BEGIN_MESSAGE_MAP(CXTPToolTipContextStandardTip, CToolTipCtrl)
  979. ON_MESSAGE(TTM_WINDOWFROMPOINT, OnWindowFromPoint)
  980. END_MESSAGE_MAP()
  982. LRESULT CXTPToolTipContext::CStandardToolTip::OnWindowFromPoint(WPARAM, LPARAM)
  983. {
  984. HWND hWnd = (HWND)Default();
  987. if ((hWnd != NULL) && (GetWindowLong(hWnd, GWL_STYLE) & WS_CHILD) && (::SendMessage(hWnd, XTP_TTM_WINDOWFROMPOINT, 0, 0) == 1))
  988. {
  989. return (LRESULT)::GetParent(hWnd);
  990. }
  992. return (LRESULT)hWnd;
  993. }
  995. //////////////////////////////////////////////////////////////////////////
  996. // CXTPToolTipContext::CLunaToolTip
  998. class CXTPToolTipContext::CLunaToolTip : public CXTPToolTipContextToolTip
  999. {
  1000. public:
  1001. CLunaToolTip(CXTPToolTipContext* pContext)
  1002. : CXTPToolTipContextToolTip(pContext)
  1003. {
  1005. }
  1007. void DrawBackground(CDC* pDC, TOOLITEM* /*lpToolInfo*/, CRect rc)
  1008. {
  1009. switch (XTPColorManager()->GetCurrentSystemTheme())
  1010. {
  1011. case xtpSystemThemeBlue:
  1012. case xtpSystemThemeRoyale:
  1013. case xtpSystemThemeAero:
  1014. XTPDrawHelpers()->GradientFill(pDC, rc, RGB(255, 212, 151), RGB(255, 242, 200), FALSE);
  1015. pDC->Draw3dRect(rc, RGB(0, 0, 128), RGB(0, 0, 128));
  1016. break;
  1017. case xtpSystemThemeOlive:
  1018. XTPDrawHelpers()->GradientFill(pDC, rc, RGB(255, 212, 151), RGB(255, 242, 200), FALSE);
  1019. pDC->Draw3dRect(rc, RGB(63, 93, 56), RGB(63, 93, 56));
  1020. break;
  1021. case xtpSystemThemeSilver:
  1022. XTPDrawHelpers()->GradientFill(pDC, rc, RGB(255, 212, 151), RGB(255, 242, 200), FALSE);
  1023. pDC->Draw3dRect(rc, RGB(75, 75, 111), RGB(75, 75, 111));
  1024. break;
  1025. default:
  1026. XTPDrawHelpers()->GradientFill(pDC, rc, m_pContext->GetTipBkColor(), RGB(255, 255, 255), FALSE);
  1027. pDC->Draw3dRect(rc, 0, 0);
  1028. }
  1029. }
  1030. };
  1032. //////////////////////////////////////////////////////////////////////////
  1033. // CXTPToolTipContext::CRichEditToolTip
  1035. class CXTPToolTipContext::CRichEditToolTip : public CXTPToolTipContextToolTip
  1036. {
  1037. public:
  1038. CRichEditToolTip(CXTPToolTipContext* pContext)
  1039. : CXTPToolTipContextToolTip(pContext)
  1040. {
  1042. }
  1044. protected:
  1045. virtual void DrawEntry(CDC* pDC, TOOLITEM* lpToolInfo, CRect rc);
  1046. virtual CSize GetToolSize(TOOLITEM* lpToolInfo);
  1048. protected:
  1049. CXTPRichRender m_render;
  1050. };
  1052. CSize CXTPToolTipContext::CRichEditToolTip::GetToolSize(TOOLITEM* lpToolInfo)
  1053. {
  1054. if (!m_render.GetTextService())
  1055. return CSize(0);
  1057. CString sText = GetToolText(lpToolInfo);
  1058. if (sText.IsEmpty())
  1059. return CSize(0);
  1061. CClientDC dc(this);
  1062. CXTPFontDC font(&dc, &m_pContext->m_fnt);
  1064. CHARFORMATW cf;
  1065. ZeroMemory(&cf, sizeof(CHARFORMATW));
  1067. cf.cbSize = sizeof(CHARFORMATW);
  1068. cf.dwMask = CFM_BOLD | CFM_COLOR | CFM_ITALIC | CFM_PROTECTED | CFM_STRIKEOUT | CFM_UNDERLINE;
  1069. cf.crTextColor = m_pContext->GetTipTextColor();
  1071. LOGFONT lf;
  1072. if (m_pContext->GetFont()->GetLogFont(&lf))
  1073. {
  1074. cf.yHeight = -MulDiv(lf.lfHeight, 1440, ::GetDeviceCaps(dc, LOGPIXELSY));
  1075. WCSNCPY_S(cf.szFaceName, XTP_CT2CW(lf.lfFaceName), LF_FACESIZE);
  1076. cf.dwMask |= CFM_FACE | CFM_SIZE;
  1077. }
  1079. m_render.SetText(NULL);
  1080. m_render.SetDefaultCharFormat(&cf);
  1081. m_render.SetText(sText);
  1083. CRect rcMargin = m_pContext->GetMargin();
  1084. CSize szMargin(3 + rcMargin.left + rcMargin.right + 3, 3 + rcMargin.top + rcMargin.bottom + 3);
  1086. CSize size = m_render.GetTextExtent(&dc, GetMaxTipWidth() - szMargin.cx);
  1088. size += szMargin;
  1090. return size;
  1091. }
  1093. void CXTPToolTipContext::CRichEditToolTip::DrawEntry(CDC* pDC, TOOLITEM* /*lpToolInfo*/, CRect rc)
  1094. {
  1095. rc.DeflateRect(m_pContext->GetMargin());
  1096. rc.DeflateRect(3, 3, 3, 3);
  1098. m_render.DrawText(pDC, rc);
  1099. }
  1101. class CXTPToolTipContext::CMarkupToolTip : public CXTPToolTipContextToolTip
  1102. {
  1103. public:
  1104. CMarkupToolTip(CXTPToolTipContext* pContext)
  1105. : CXTPToolTipContextToolTip(pContext)
  1106. {
  1107. m_pUIElement = NULL;
  1108. m_pMarkupContext = XTPMarkupCreateContext();
  1109. }
  1111. ~CMarkupToolTip()
  1112. {
  1113. XTPMarkupReleaseElement(m_pUIElement);
  1114. XTPMarkupReleaseContext(m_pMarkupContext);
  1115. }
  1117. protected:
  1118. virtual void DrawEntry(CDC* pDC, TOOLITEM* lpToolInfo, CRect rc);
  1119. virtual CSize GetToolSize(TOOLITEM* lpToolInfo);
  1121. protected:
  1122. CXTPMarkupUIElement* m_pUIElement;
  1123. CXTPMarkupContext* m_pMarkupContext;
  1124. };
  1126. CSize CXTPToolTipContext::CMarkupToolTip::GetToolSize(TOOLITEM* lpToolInfo)
  1127. {
  1128. XTPMarkupReleaseElement(m_pUIElement);
  1130. CString sText = GetToolText(lpToolInfo);
  1131. if (sText.IsEmpty())
  1132. return CSize(0);
  1134. XTPMarkupSetDefaultFont(m_pMarkupContext, (HFONT)m_pContext->GetFont()->GetSafeHandle(), m_pContext->GetTipTextColor());
  1136. m_pUIElement = XTPMarkupParseText(m_pMarkupContext, sText);
  1138. if (!m_pUIElement)
  1139. {
  1140. return CXTPToolTipContextToolTip::GetToolSize(lpToolInfo);
  1141. }
  1143. CRect rcMargin = m_pContext->GetMargin();
  1144. CSize szMargin(3 + rcMargin.left + rcMargin.right + 3, 3 + rcMargin.top + rcMargin.bottom + 3);
  1146. CSize size = XTPMarkupMeasureElement(m_pUIElement, GetMaxTipWidth() - szMargin.cx);
  1148. size += szMargin;
  1150. return size;
  1151. }
  1153. void CXTPToolTipContext::CMarkupToolTip::DrawEntry(CDC* pDC, TOOLITEM* lpToolInfo, CRect rc)
  1154. {
  1155. if (m_pUIElement)
  1156. {
  1157. CRect rcMargin = m_pContext->GetMargin();
  1159. CRect rcText(rc);
  1160. rcText.DeflateRect(3 + rcMargin.left, 3 + rcMargin.top, rcMargin.right + 3, rcMargin.bottom + 3);
  1162. XTPMarkupRenderElement(m_pUIElement, pDC->GetSafeHdc(), rcText);
  1163. }
  1164. else
  1165. {
  1166. CXTPToolTipContextToolTip::DrawEntry(pDC, lpToolInfo, rc);
  1167. }
  1168. }
  1170. #ifndef _XTP_EXCLUDE_HTML
  1172. //////////////////////////////////////////////////////////////////////////
  1173. // CXTPToolTipContext::CHTMLToolTip
  1175. class CXTPToolTipContext::CHTMLToolTip : public CXTPToolTipContextToolTip
  1176. {
  1177. public:
  1178. CHTMLToolTip(CXTPToolTipContext* pContext);
  1179. ~CHTMLToolTip();
  1181. protected:
  1182. virtual void DrawEntry(CDC* pDC, TOOLITEM* lpToolInfo, CRect rc);
  1183. virtual CSize GetToolSize(TOOLITEM* lpToolInfo);
  1184. virtual void OnVisibleChanged(BOOL bVisble);
  1186. protected:
  1187. DECLARE_INTERFACE_MAP()
  1189. BEGIN_INTERFACE_PART(OleClientSite, IOleClientSite)
  1190. STDMETHOD(SaveObject)( void) { return E_NOTIMPL;}
  1191. STDMETHOD (GetMoniker)(
  1192. /* [in] */ DWORD /*dwAssign*/,
  1193. /* [in] */ DWORD /*dwWhichMoniker*/,
  1194. /* [out] */ IMoniker ** /*ppmk*/) { return E_NOTIMPL;}
  1195. STDMETHOD(GetContainer)(
  1196. /* [out] */ IOleContainer ** /*ppContainer*/) { return E_NOTIMPL;}
  1197. STDMETHOD(ShowObject)( void) { return E_NOTIMPL;}
  1198. STDMETHOD(OnShowWindow)(
  1199. /* [in] */ BOOL /*fShow*/) { return E_NOTIMPL;}
  1200. STDMETHOD(RequestNewObjectLayout)( void) { return E_NOTIMPL;}
  1201. END_INTERFACE_PART(OleClientSite)
  1203. BEGIN_INTERFACE_PART(DocHostUIHandler, IDocHostUIHandler)
  1204. STDMETHOD(ShowContextMenu)(/* [in] */ DWORD dwID,
  1205. /* [in] */ POINT __RPC_FAR *ppt,
  1206. /* [in] */ IUnknown __RPC_FAR *pcmdtReserved,
  1207. /* [in] */ IDispatch __RPC_FAR *pdispReserved);
  1208. STDMETHOD(GetHostInfo)(
  1209. /* [out][in] */ DOCHOSTUIINFO __RPC_FAR *pInfo);
  1210. STDMETHOD(ShowUI)(
  1211. /* [in] */ DWORD dwID,
  1212. /* [in] */ IOleInPlaceActiveObject __RPC_FAR *pActiveObject,
  1213. /* [in] */ IOleCommandTarget __RPC_FAR *pCommandTarget,
  1214. /* [in] */ IOleInPlaceFrame __RPC_FAR *pFrame,
  1215. /* [in] */ IOleInPlaceUIWindow __RPC_FAR *pDoc);
  1216. STDMETHOD(HideUI)(void);
  1217. STDMETHOD(UpdateUI)(void);
  1218. STDMETHOD(EnableModeless)(/* [in] */ BOOL fEnable);
  1219. STDMETHOD(OnDocWindowActivate)(/* [in] */ BOOL fEnable);
  1220. STDMETHOD(OnFrameWindowActivate)(/* [in] */ BOOL fEnable);
  1221. STDMETHOD(ResizeBorder)(
  1222. /* [in] */ LPCRECT prcBorder,
  1223. /* [in] */ IOleInPlaceUIWindow __RPC_FAR *pUIWindow,
  1224. /* [in] */ BOOL fRameWindow);
  1225. STDMETHOD(TranslateAccelerator)(
  1226. /* [in] */ LPMSG lpMsg,
  1227. /* [in] */ const GUID __RPC_FAR *pguidCmdGroup,
  1228. /* [in] */ DWORD nCmdID);
  1229. STDMETHOD(GetOptionKeyPath)(
  1230. /* [out] */ LPOLESTR __RPC_FAR *pchKey,
  1231. /* [in] */ DWORD dw);
  1232. STDMETHOD(GetDropTarget)(
  1233. /* [in] */ IDropTarget __RPC_FAR *pDropTarget,
  1234. /* [out] */ IDropTarget __RPC_FAR *__RPC_FAR *ppDropTarget);
  1235. STDMETHOD(GetExternal)(
  1236. /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppDispatch);
  1237. STDMETHOD(TranslateUrl)(
  1238. /* [in] */ DWORD dwTranslate,
  1239. /* [in] */ OLECHAR __RPC_FAR *pchURLIn,
  1240. /* [out] */ OLECHAR __RPC_FAR *__RPC_FAR *ppchURLOut);
  1241. STDMETHOD(FilterDataObject)(
  1242. /* [in] */ IDataObject __RPC_FAR *pDO,
  1243. /* [out] */ IDataObject __RPC_FAR *__RPC_FAR *ppDORet);
  1244. END_INTERFACE_PART(DocHostUIHandler)
  1247. protected:
  1248. CBitmap m_bmpScreen;
  1249. CWnd m_wndBrowser;
  1250. IWebBrowser2* m_pBrowserApp;
  1251. };
  1254. //////////////////////////////////////////////////////////////////////////
  1255. // CWebBrowserSite
  1257. BEGIN_INTERFACE_MAP(CXTPToolTipContext::CHTMLToolTip, CWnd)
  1258. INTERFACE_PART(CXTPToolTipContext::CHTMLToolTip, IID_IOleClientSite, OleClientSite)
  1259. INTERFACE_PART(CXTPToolTipContext::CHTMLToolTip, IID_IDocHostUIHandler, DocHostUIHandler)
  1260. END_INTERFACE_MAP()
  1262. #define IMPLEMENT_INTERFACE_PART(theClass, localClass)
  1263. STDMETHODIMP_(ULONG) theClass::X##localClass::AddRef()
  1264. {
  1265. METHOD_PROLOGUE(theClass, localClass)
  1266. return pThis->ExternalAddRef();
  1267. }
  1268. STDMETHODIMP_(ULONG) theClass::X##localClass::Release()
  1269. {
  1270. METHOD_PROLOGUE(theClass, localClass)
  1271. return pThis->ExternalRelease();
  1272. }
  1273. STDMETHODIMP theClass::X##localClass::QueryInterface(REFIID riid, void **ppvObj)
  1274. {
  1275. METHOD_PROLOGUE(theClass, localClass)
  1276. HRESULT hr = (HRESULT)pThis->ExternalQueryInterface(&riid, ppvObj);
  1277. return hr;
  1278. }
  1280. IMPLEMENT_INTERFACE_PART(CXTPToolTipContext::CHTMLToolTip, OleClientSite)
  1282. IMPLEMENT_INTERFACE_PART(CXTPToolTipContext::CHTMLToolTip, DocHostUIHandler)
  1284. STDMETHODIMP CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::GetHostInfo( DOCHOSTUIINFO* pInfo )
  1285. {
  1286. pInfo->dwFlags = 0x40000 | DOCHOSTUIFLAG_NO3DBORDER;
  1287. pInfo->dwFlags |= DOCHOSTUIFLAG_DIALOG;
  1288. pInfo->dwFlags |= DOCHOSTUIFLAG_SCROLL_NO;
  1289. pInfo->dwDoubleClick = DOCHOSTUIDBLCLK_DEFAULT;
  1290. return S_OK;
  1291. }
  1293. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::ShowUI(
  1294. DWORD /*dwID*/,
  1295. IOleInPlaceActiveObject * /*pActiveObject*/,
  1296. IOleCommandTarget * /*pCommandTarget*/,
  1297. IOleInPlaceFrame * /*pFrame*/,
  1298. IOleInPlaceUIWindow * /*pDoc*/)
  1299. {
  1300. return S_OK;
  1301. }
  1303. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::HideUI(void)
  1304. {
  1305. return S_OK;
  1306. }
  1308. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::UpdateUI(void)
  1309. {
  1310. return S_OK;
  1311. }
  1313. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::EnableModeless(BOOL /*fEnable*/)
  1314. {
  1315. return E_NOTIMPL;
  1316. }
  1318. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::OnDocWindowActivate(BOOL /*fActivate*/)
  1319. {
  1320. return E_NOTIMPL;
  1321. }
  1323. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::OnFrameWindowActivate(BOOL /*fActivate*/)
  1324. {
  1325. return E_NOTIMPL;
  1326. }
  1328. STDMETHODIMP CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::ResizeBorder(
  1329. LPCRECT /*prcBorder*/,
  1330. IOleInPlaceUIWindow* /*pUIWindow*/,
  1331. BOOL /*fRameWindow*/)
  1332. {
  1333. return E_NOTIMPL;
  1334. }
  1336. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::ShowContextMenu(
  1337. DWORD /*dwID*/,
  1338. POINT* /*pptPosition*/,
  1339. IUnknown* /*pCommandTarget*/,
  1340. IDispatch* /*pDispatchObjectHit*/)
  1341. {
  1342. return S_OK;
  1343. }
  1345. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::TranslateAccelerator(LPMSG /*lpMsg*/,
  1346. /* [in] */ const GUID __RPC_FAR* /*pguidCmdGroup*/,
  1347. /* [in] */ DWORD /*nCmdID*/)
  1348. {
  1349. return S_FALSE;
  1350. }
  1352. STDMETHODIMP  CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::GetOptionKeyPath(BSTR* /*pbstrKey*/, DWORD)
  1353. {
  1354. return E_NOTIMPL;
  1355. }
  1357. STDMETHODIMP CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::GetDropTarget(
  1358. /* [in] */ IDropTarget __RPC_FAR* /*pDropTarget*/,
  1359. /* [out] */ IDropTarget __RPC_FAR *__RPC_FAR* /*ppDropTarget*/)
  1360. {
  1361. return E_NOTIMPL;
  1362. }
  1364. STDMETHODIMP CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::GetExternal(
  1365. /* [out] */ IDispatch __RPC_FAR *__RPC_FAR* /*ppDispatch*/)
  1366. {
  1367. return E_NOTIMPL;
  1368. }
  1370. STDMETHODIMP CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::TranslateUrl(
  1371. /* [in] */ DWORD /*dwTranslate*/,
  1372. /* [in] */ OLECHAR __RPC_FAR* /*pchURLIn*/,
  1373. /* [out] */ OLECHAR __RPC_FAR *__RPC_FAR* /*ppchURLOut*/)
  1374. {
  1375. return E_NOTIMPL;
  1376. }
  1378. STDMETHODIMP CXTPToolTipContext::CHTMLToolTip::XDocHostUIHandler::FilterDataObject(
  1379. /* [in] */ IDataObject __RPC_FAR* /*pDO*/,
  1380. /* [out] */ IDataObject __RPC_FAR *__RPC_FAR* /*ppDORet*/)
  1381. {
  1382. return E_NOTIMPL;
  1383. }
  1385. CXTPToolTipContext::CHTMLToolTip::CHTMLToolTip(CXTPToolTipContext* pContext)
  1386. : CXTPToolTipContextToolTip(pContext)
  1387. {
  1388. AfxEnableControlContainer();
  1389. m_pBrowserApp = 0;
  1390. }
  1392. CXTPToolTipContext::CHTMLToolTip::~CHTMLToolTip()
  1393. {
  1394. SAFE_RELEASE(m_pBrowserApp);
  1395. }
  1397. CSize CXTPToolTipContext::CHTMLToolTip::GetToolSize(TOOLITEM* lpToolInfo)
  1398. {
  1399. m_bmpScreen.DeleteObject();
  1401. if (m_wndBrowser.GetSafeHwnd() == 0)
  1402. {
  1403. // create the control window
  1404. // AFX_IDW_PANE_FIRST is a safe but arbitrary ID
  1405. if (!m_wndBrowser.CreateControl(CLSID_WebBrowser, 0,
  1406. WS_VISIBLE | WS_CHILD, CRect(0, 0, 200, 200), this, AFX_IDW_PANE_FIRST))
  1407. {
  1408. return 0;
  1409. }
  1411. LPUNKNOWN lpUnk = m_wndBrowser.GetControlUnknown();
  1412. HRESULT hr = lpUnk->QueryInterface(IID_IWebBrowser2, (void**) &m_pBrowserApp);
  1413. if (!SUCCEEDED(hr) || !m_pBrowserApp)
  1414. {
  1415. m_pBrowserApp = NULL;
  1416. m_wndBrowser.DestroyWindow();
  1417. return 0;
  1418. }
  1420. IOleObject* spOleObj = NULL;
  1422. m_pBrowserApp->QueryInterface(IID_IOleObject, (void**)&spOleObj);
  1423. if (spOleObj)
  1424. {
  1425. spOleObj->SetClientSite((IOleClientSite*)GetInterface(&IID_IOleClientSite));
  1426. spOleObj->Release();
  1427. }
  1429. CString strFaceName = _T("Arial");
  1430. int nFontSize = 11;
  1432. LOGFONT lf;
  1433. if (m_pContext->GetFont()->GetLogFont(&lf))
  1434. {
  1435. strFaceName = lf.lfFaceName;
  1436. nFontSize = lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight;
  1437. }
  1439. CString strBackColor; COLORREF clrBack = m_pContext->GetTipBkColor();
  1440. strBackColor.Format(_T("#%0.2x%0.2x%0.2x"), GetRValue(clrBack), GetGValue(clrBack), GetBValue(clrBack));
  1442. CString strBody;
  1443. strBody.Format(
  1444. _T("about:<head><style> body {font-family:%s; font-size:%i;}")
  1445. _T("table {font-family:%s; font-size:%i;}</style></head>")
  1446. _T("<body topmargin=0 leftmargin=0 bottommargin=0 rightmargin=0 bgColor=%s></body>"),
  1447. (LPCTSTR)strFaceName, nFontSize, (LPCTSTR)strFaceName, nFontSize, (LPCTSTR)strBackColor);
  1449. COleVariant varEmpty;
  1450. BSTR bstrBody = strBody.AllocSysString();
  1451. m_pBrowserApp->Navigate(bstrBody,
  1452. (VARIANT*)&varEmpty,
  1453. (VARIANT*)&varEmpty,
  1454. (VARIANT*)&varEmpty,
  1455. (VARIANT*)&varEmpty);
  1456. SysFreeString(bstrBody);
  1458. READYSTATE rs;
  1459. do
  1460. {
  1461. AfxGetApp()->PumpMessage();
  1462. m_pBrowserApp->get_ReadyState (&rs);
  1463. }
  1464. while (rs != READYSTATE_COMPLETE);
  1465. }
  1467. CString strText = GetToolText(lpToolInfo);
  1469. if (strText.IsEmpty())
  1470. return CSize(0);
  1472. IDispatch* lpDocument = NULL;
  1473. m_pBrowserApp->get_Document(&lpDocument);
  1475. if (lpDocument == 0)
  1476. return 0;
  1478. // Verify that what we get is a pointer to a IHTMLDocument2
  1479. // interface. To be sure, let's query for
  1480. // the IHTMLDocument2 interface (through smart pointers)
  1481. IHTMLDocument2* lpHTML = NULL;
  1482. lpDocument->QueryInterface(IID_IHTMLDocument2, (void**)&lpHTML);
  1483. if (lpHTML == 0)
  1484. {
  1485. lpDocument->Release();
  1486. return 0;
  1487. }
  1489. // The previous step is sufficient to keep Explorer aside
  1490. // without an explicit check against the loader module
  1492. // Extract the source code of the document
  1493. IHTMLElement* lpBody = NULL;
  1495. // Get the BODY object
  1496. HRESULT hr = lpHTML->get_body(&lpBody);
  1497. if (FAILED(hr) || (lpBody == 0))
  1498. {
  1499. lpHTML->Release();
  1500. lpDocument->Release();
  1501. return 0;
  1502. }
  1504. BSTR bstrText = strText.AllocSysString();
  1505. lpBody->put_innerHTML(bstrText);
  1506. SysFreeString(bstrText);
  1508. m_wndBrowser.MoveWindow(0, 0, 650, 200);
  1511. IHTMLTextContainer* lpHTMLContainer = NULL;
  1512. lpBody->QueryInterface(IID_IHTMLTextContainer, (void**)&lpHTMLContainer);
  1514. if (lpHTMLContainer == 0)
  1515. {
  1516. lpBody->Release();
  1517. lpHTML->Release();
  1518. lpDocument->Release();
  1519. return 0;
  1520. }
  1522. long nScrollHeight, nScrollWidth;
  1523. lpHTMLContainer->get_scrollHeight(&nScrollHeight);
  1525. int nBestWidth = m_pContext->GetMaxTipWidth();
  1526. int nBestHeight = nScrollHeight;
  1528. int cxFirst = 0;
  1529. int cxLast = nBestWidth * 2;
  1531. do
  1532. {
  1533. // Taking a guess
  1534. int cx = (cxFirst + cxLast) / 2;
  1536. m_wndBrowser.MoveWindow(0, 0, cx, nScrollHeight);
  1538. lpHTMLContainer->get_scrollHeight(&nScrollHeight);
  1539. lpHTMLContainer->get_scrollWidth(&nScrollWidth);
  1541. if (nScrollWidth > cx && nScrollHeight <= nBestHeight)
  1542. {
  1543. nBestWidth = nScrollWidth;
  1544. break;
  1545. }
  1547. if (nScrollHeight > nBestHeight)
  1548. {
  1549. // If the control required a larger height, then
  1550. // it's too narrow.
  1551. cxFirst = cx + 1;
  1552. }
  1553. else
  1554. {
  1555. // If the control didn't required a larger height,
  1556. // then it's too wide.
  1557. cxLast = cx - 1;
  1558. nBestWidth = cx;
  1559. }
  1560. }
  1561. while (cxFirst <= cxLast);
  1563. m_wndBrowser.MoveWindow(0, 0, nBestWidth, nBestHeight);
  1565. CSize sz(nBestWidth, nBestHeight);
  1566. CRect rcMargin = m_pContext->GetMargin();
  1568. #if 0
  1569. if (sz.cx > 0 && sz.cy > 0)
  1570. {
  1571. CWindowDC dcPaint(this);
  1573. CDC dc;
  1574. dc.CreateCompatibleDC(&dcPaint);
  1575. m_bmpScreen.CreateCompatibleBitmap(&dcPaint, sz.cx, sz.cy);
  1577. CBitmap* pOldBitmap = dc.SelectObject(&m_bmpScreen);
  1579. dc.FillSolidRect(0, 0, sz.cx, sz.cy, m_pContext->GetTipBkColor());
  1580. m_wndBrowser.SendMessage(WM_PRINT, (WPARAM)dc.GetSafeHdc(), PRF_CLIENT | PRF_CHILDREN);
  1582. dc.SelectObject(pOldBitmap);
  1583. }
  1584. m_wndBrowser.MoveWindow(0, 0, 0, 0);
  1585. #else
  1586. m_wndBrowser.MoveWindow(3 + rcMargin.left, 3 + rcMargin.top, nBestWidth, nBestHeight);
  1587. #endif
  1589. CSize szMargin(3 + rcMargin.left + rcMargin.right + 3, 3 + rcMargin.top + rcMargin.bottom + 3);
  1590. sz += szMargin;
  1593. lpHTMLContainer->Release();
  1594. lpBody->Release();
  1595. lpHTML->Release();
  1596. lpDocument->Release();
  1598. return sz;
  1599. }
  1601. void CXTPToolTipContext::CHTMLToolTip::DrawEntry(CDC* pDC, TOOLITEM* /*lpToolInfo*/, CRect rc)
  1602. {
  1603. rc.DeflateRect(m_pContext->GetMargin());
  1604. rc.DeflateRect(3, 3, 3, 3);
  1606. if (m_bmpScreen.GetSafeHandle())
  1607. {
  1608. pDC->DrawState(rc.TopLeft(), CSize(0, 0), &m_bmpScreen, DSS_NORMAL, 0);
  1609. }
  1610. }
  1612. void CXTPToolTipContext::CHTMLToolTip::OnVisibleChanged(BOOL bVisble)
  1613. {
  1614. if (!bVisble)
  1615. {
  1616. m_bmpScreen.DeleteObject();
  1617. }
  1618. }
  1620. #endif // _XTP_EXCLUDE_HTML
  1623. //////////////////////////////////////////////////////////////////////
  1624. // Construction/Destruction
  1625. //////////////////////////////////////////////////////////////////////
  1627. CXTPToolTipContext::CXTPToolTipContext()
  1628. {
  1629. m_pToolTip = 0;
  1630. m_bShowTitleAndDescription = FALSE;
  1631. m_bShowImage = FALSE;
  1632. m_nImageSize = ICON_BIG;
  1633. m_nImageBase = 0;
  1634. m_toolStyle = xtpToolTipStandard;
  1635. m_nMaxTipWidth = ::GetSystemMetrics(SM_CXSCREEN) / 2;
  1636. ZeroMemory(&m_lastInfo, sizeof(m_lastInfo));
  1638. m_dwComCtlVersion = XTPSystemVersion()->GetComCtlVersion();
  1640. m_clrTipTextColor = m_clrTipBkColor = COLORREF_NULL;
  1641. m_nIconTitle = TTI_INFO;
  1642. m_dwStyle = TTS_NOPREFIX;
  1643. m_rcMargin.SetRect(0, 0, 0, 0);
  1645. m_nDelayAutoPop = m_nDelayInitial = m_nDelayReshow = -1;
  1648. NONCLIENTMETRICS ncm;
  1649. ::ZeroMemory(&ncm, sizeof(NONCLIENTMETRICS));
  1651. ncm.cbSize = sizeof(NONCLIENTMETRICS);
  1652. VERIFY(::SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
  1653. sizeof(NONCLIENTMETRICS), &ncm, 0));
  1655. ncm.lfStatusFont.lfWeight = FW_NORMAL;
  1656. m_fnt.CreateFontIndirect(&ncm.lfStatusFont);
  1658. ncm.lfStatusFont.lfWeight = FW_BOLD;
  1659. m_fntTitle.CreateFontIndirect(&ncm.lfStatusFont);
  1662. }
  1664. CXTPToolTipContext::~CXTPToolTipContext()
  1665. {
  1666. SAFE_DELETEWINDOW(m_pToolTip);
  1668. if (m_pModuleContext == this)
  1669. {
  1670. m_pModuleContext = 0;
  1671. }
  1673. }
  1675. BOOL CXTPToolTipContext::IsBalloonStyleSupported() const
  1676. {
  1677. return m_dwComCtlVersion >= VERSION_IE5;
  1678. }
  1680. void CXTPToolTipContext::ShowTitleAndDescription(BOOL bShowTitleAndDescription, int nIconTitle)
  1681. {
  1682. m_bShowTitleAndDescription = bShowTitleAndDescription;
  1683. m_nIconTitle = nIconTitle;
  1684. }
  1686. void CXTPToolTipContext::ShowImage(BOOL bShowImage, int nImageBase, int nImageSize)
  1687. {
  1688. m_bShowImage = bShowImage;
  1689. m_nImageBase = nImageBase;
  1690. m_nImageSize = nImageSize;
  1692. SAFE_DELETEWINDOW(m_pToolTip);
  1693. }
  1695. void CXTPToolTipContext::FillInToolInfo(TOOLINFO* pTI, HWND hWnd, CRect rect, INT_PTR nHit, const CString& strToolTip)
  1696. {
  1697. #if _MSC_VER < 1200 // MFC 5.0
  1698. if (pTI != NULL && pTI->cbSize >= sizeof(TOOLINFO))
  1699. #else
  1700. if (pTI != NULL && pTI->cbSize >= sizeof(XTP_TOOLTIP_TOOLINFO))
  1701. #endif
  1702. {
  1703. pTI->hwnd = hWnd;
  1704. pTI->rect = rect;
  1705. pTI->uId = nHit;
  1706. pTI->lpszText = (LPTSTR) ::calloc(strToolTip.GetLength() + 1, sizeof(TCHAR));
  1707. if (pTI->lpszText != NULL) STRCPY_S(pTI->lpszText, strToolTip.GetLength() + 1, (LPCTSTR)strToolTip);
  1708. }
  1709. }
  1711. void CXTPToolTipContext::FillInToolInfo(TOOLINFO* pTI, HWND hWnd, CRect rect, INT_PTR nHit,
  1712. const CString& strToolTip, const CString& strTitle, const CString& strDescription, CXTPImageManager* pImageManager)
  1713. {
  1714. FillInToolInfo(pTI, hWnd, rect, nHit, strToolTip);
  1716. if (pTI != NULL && pTI->cbSize == sizeof(XTP_TOOLTIP_TOOLINFO_EX))
  1717. {
  1718. XTP_TOOLTIP_CONTEXT* ptc = ((XTP_TOOLTIP_TOOLINFO_EX*)pTI)->pToolInfo;
  1719. if (!ptc)
  1720. return;
  1722. if (!strDescription.IsEmpty() && !strTitle.IsEmpty())
  1723. {
  1724. ptc->lpszDescription = (LPTSTR)::calloc(strDescription.GetLength() + 1, sizeof(TCHAR));
  1725. if (ptc->lpszDescription != NULL) STRCPY_S(ptc->lpszDescription, strDescription.GetLength() + 1, (LPCTSTR)strDescription);
  1727. ptc->lpszTitle = (LPTSTR)::calloc(strTitle.GetLength() + 1, sizeof(TCHAR));
  1728. if (ptc->lpszTitle != NULL) STRCPY_S(ptc->lpszTitle, strTitle.GetLength() + 1, (LPCTSTR)strTitle);
  1729. }
  1731. ptc->pImageManager = pImageManager;
  1732. }
  1733. }
  1736. void CXTPToolTipContext::SetMargin(LPCRECT lprc)
  1737. {
  1738. if (lprc)
  1739. {
  1740. m_rcMargin = *lprc;
  1741. if (m_pToolTip) m_pToolTip->DestroyWindow();
  1742. }
  1743. }
  1745. void CXTPToolTipContext::SetStyle(XTPToolTipStyle toolStyle)
  1746. {
  1747. if (m_toolStyle != toolStyle && (toolStyle != xtpToolTipBalloon || IsBalloonStyleSupported()))
  1748. {
  1749. m_toolStyle = toolStyle;
  1750. SAFE_DELETEWINDOW(m_pToolTip);
  1752. ModifyToolTipStyle(XTP_TTS_OFFICEFRAME | XTP_TTS_NOSHADOW, m_toolStyle == xtpToolTipOffice ? XTP_TTS_OFFICEFRAME | XTP_TTS_NOSHADOW : 0);
  1753. ModifyToolTipStyle(XTP_TTS_OFFICE2007FRAME, m_toolStyle == xtpToolTipOffice2007 ? XTP_TTS_OFFICE2007FRAME : 0);
  1754. }
  1755. }
  1757. XTPToolTipStyle CXTPToolTipContext::GetStyle() const
  1758. {
  1759. return m_toolStyle;
  1760. }
  1763. void CXTPToolTipContext::SetMaxTipWidth(int iWidth)
  1764. {
  1765. m_nMaxTipWidth = iWidth;
  1766. if (m_pToolTip) m_pToolTip->DestroyWindow();
  1767. }
  1769. int CXTPToolTipContext::GetMaxTipWidth() const
  1770. {
  1771. return m_nMaxTipWidth;
  1772. }
  1774. COLORREF CXTPToolTipContext::GetTipBkColor() const
  1775. {
  1776. return m_clrTipBkColor != COLORREF_NULL ? m_clrTipBkColor :GetXtremeColor(COLOR_INFOBK);
  1777. }
  1779. void CXTPToolTipContext::SetTipBkColor(COLORREF clr)
  1780. {
  1781. m_clrTipBkColor = clr;
  1782. if (m_pToolTip) m_pToolTip->DestroyWindow();
  1783. }
  1786. void CXTPToolTipContext::ModifyToolTipStyle(DWORD dwRemove, DWORD dwAdd)
  1787. {
  1788. DWORD dwStyle = (m_dwStyle & ~dwRemove) | dwAdd;
  1790. if (m_dwStyle != dwStyle)
  1791. {
  1792. m_dwStyle = dwStyle;
  1793. SAFE_DELETEWINDOW(m_pToolTip);
  1794. }
  1795. }
  1797. COLORREF CXTPToolTipContext::GetTipTextColor() const
  1798. {
  1799. return m_clrTipTextColor != COLORREF_NULL ? m_clrTipTextColor :
  1800. m_dwStyle & XTP_TTS_OFFICE2007FRAME ?  RGB(76, 76, 76) : GetXtremeColor(COLOR_INFOTEXT);
  1801. }
  1803. void CXTPToolTipContext::SetTipTextColor(COLORREF clr)
  1804. {
  1805. m_clrTipTextColor = clr;
  1806. if (m_pToolTip) m_pToolTip->DestroyWindow();
  1807. }
  1809. void CXTPToolTipContext::SetDelayTime(DWORD dwDuration, int iTime)
  1810. {
  1811. switch (dwDuration)
  1812. {
  1813. case TTDT_RESHOW:
  1814. m_nDelayReshow = iTime;
  1815. break;
  1817. case TTDT_INITIAL:
  1818. m_nDelayInitial = iTime;
  1819. break;
  1821. case TTDT_AUTOPOP:
  1822. m_nDelayAutoPop = iTime;
  1823. break;
  1825. default:
  1826. ASSERT(FALSE);
  1828. }
  1829. if (m_pToolTip) m_pToolTip->DestroyWindow();
  1830. }
  1833. void CXTPToolTipContext::RelayToolTipMessage(CWnd* pToolTip, MSG* pMsg)
  1834. {
  1835. // transate the message based on TTM_WINDOWFROMPOINT
  1836. MSG msg = *pMsg;
  1837. msg.hwnd = (HWND)pToolTip->SendMessage(TTM_WINDOWFROMPOINT, 0, (LPARAM)&msg.pt);
  1838. CPoint pt = pMsg->pt;
  1839. if (msg.message >= WM_MOUSEFIRST && msg.message <= WM_MOUSELAST)
  1840. ::ScreenToClient(msg.hwnd, &pt);
  1841. msg.lParam = MAKELONG(pt.x, pt.y);
  1843. // relay mouse event before deleting old tool
  1844. pToolTip->SendMessage(TTM_RELAYEVENT, 0, (LPARAM)&msg);
  1845. }
  1848. void CXTPToolTipContext::FilterToolTipMessage(CWnd* pWndHost, UINT message, WPARAM wParam, LPARAM lParam)
  1849. {
  1850. MSG msg;
  1851. msg.wParam = wParam;
  1852. msg.lParam = lParam;
  1853. msg.message = message;
  1854. msg.hwnd = pWndHost->m_hWnd;
  1855. GetCursorPos(&msg.pt);
  1857. FilterToolTipMessage(pWndHost, &msg);
  1858. }
  1860. void CXTPToolTipContext::FilterToolTipMessage(CWnd* pWndHost, MSG* pMsg)
  1861. {
  1862. FilterToolTipMessageHelper(pWndHost, pMsg, TRUE);
  1863. }
  1866. void PASCAL CXTPToolTipContext::FilterToolTipMessageStatic(MSG* pMsg, CWnd* pWnd)
  1867. {
  1868. if (m_pModuleContext)
  1869. {
  1870. m_pModuleContext->FilterToolTipMessageHelper(pWnd, pMsg, FALSE);
  1871. }
  1872. else
  1873. {
  1874. pWnd->FilterToolTipMessage(pMsg);
  1875. }
  1876. }
  1878. void CXTPToolTipContext::SetModuleToolTipContext()
  1879. {
  1880. AFX_MODULE_STATE* pModuleState = _AFX_CMDTARGET_GETSTATE();
  1881. pModuleState->m_pfnFilterToolTipMessage = &CXTPToolTipContext::FilterToolTipMessageStatic;
  1882. m_pModuleContext = this;
  1883. }
  1885. CWnd* CXTPToolTipContext::CreateToolTip(CWnd* /*pOwner*/)
  1886. {
  1887. switch (m_toolStyle)
  1888. {
  1889. case xtpToolTipOffice:
  1890. return new CXTPToolTipContextToolTip(this);
  1892. case xtpToolTipRTF:
  1893. return new CRichEditToolTip(this);
  1895. case xtpToolTipLuna:
  1896. return new CLunaToolTip(this);
  1898. case xtpToolTipOffice2007:
  1899. return new CXTPToolTipContextToolTip(this);
  1901. #ifndef _XTP_EXCLUDE_HTML
  1902. case xtpToolTipHTML:
  1903. return new CHTMLToolTip(this);
  1904. #endif
  1906. case xtpToolTipMarkup:
  1907. return new CMarkupToolTip(this);
  1908. }
  1910. return new CStandardToolTip();
  1911. }
  1913. void CXTPToolTipContext::SetToolTipCtrl(CXTPToolTipContextToolTip* pToolTipCtrl)
  1914. {
  1915. SAFE_DELETEWINDOW(m_pToolTip);
  1916. m_pToolTip = pToolTipCtrl;
  1917. }
  1919. void CXTPToolTipContext::CancelToolTips()
  1920. {
  1921. if (m_pToolTip->GetSafeHwnd() != NULL)
  1922. m_pToolTip->SendMessage(TTM_ACTIVATE, FALSE);
  1923. }
  1925. INT_PTR CXTPToolTipContext::OnToolHitTest(CWnd* pWnd, CPoint point, TOOLINFO* pToolInfo)
  1926. {
  1927. return pWnd->OnToolHitTest(point, pToolInfo);
  1928. }
  1930. void CXTPToolTipContext::FilterToolTipMessageHelper(CWnd* pWndHost, MSG* pMsg, BOOL bIgnoreFlags)
  1931. {
  1932. // this CWnd has tooltips enabled
  1933. UINT message = pMsg->message;
  1934. if ((message == WM_MOUSEMOVE || message == WM_NCMOUSEMOVE || message == WM_MOUSELEAVE ||
  1935. message == WM_LBUTTONUP || message == WM_RBUTTONUP ||
  1936. message == WM_MBUTTONUP) &&
  1937. (GetKeyState(VK_LBUTTON) >= 0 && GetKeyState(VK_RBUTTON) >= 0 &&
  1938. GetKeyState(VK_MBUTTON) >= 0))
  1939. {
  1940. if (!bIgnoreFlags)
  1941. {
  1942. // make sure that tooltips are not already being handled
  1943. CWnd* pWnd = CWnd::FromHandle(pMsg->hwnd);
  1944. while (pWnd != NULL && !(pWnd->m_nFlags & (WF_TOOLTIPS | WF_TRACKINGTOOLTIPS)))
  1945. {
  1946. pWnd = pWnd->GetParent();
  1947. }
  1948. if (pWnd != pWndHost)
  1949. {
  1950. return;
  1951. }
  1952. }
  1954. BOOL bTopParentActive = CXTPDrawHelpers::IsTopParentActive(pWndHost->GetSafeHwnd());
  1956. if (m_pToolTip->GetSafeHwnd() && m_pToolTip->IsWindowVisible() && !bTopParentActive)
  1957. {
  1958. m_pToolTip->SendMessage(TTM_ACTIVATE, FALSE);
  1959. return;
  1960. }
  1963. CWnd* pOwner = pWndHost->GetParentOwner();
  1965. if (m_pToolTip != NULL && m_pToolTip->GetOwner() != pOwner)
  1966. {
  1967. m_pToolTip->DestroyWindow();
  1968. }
  1970. if (m_pToolTip == NULL || m_pToolTip->GetSafeHwnd() == NULL)
  1971. {
  1972. if (m_pToolTip == NULL)
  1973. {
  1974. m_pToolTip = CreateToolTip(pOwner);
  1975. }
  1977. if (!m_pToolTip)
  1978. return;
  1980. if (!m_pToolTip->GetSafeHwnd())
  1981. {
  1982. if (DYNAMIC_DOWNCAST(CXTPToolTipContextToolTip, m_pToolTip))
  1983. {
  1984. ((CXTPToolTipContextToolTip*)m_pToolTip)->Create(pOwner, m_dwStyle | TTS_ALWAYSTIP | TTS_NOPREFIX);
  1985. }
  1986. else if (DYNAMIC_DOWNCAST(CToolTipCtrl, m_pToolTip))
  1987. {
  1988. ((CToolTipCtrl*)m_pToolTip)->Create(pOwner, m_dwStyle | TTS_ALWAYSTIP | TTS_NOPREFIX | (m_toolStyle == xtpToolTipBalloon ? TTS_BALLOON : 0));
  1989. }
  1990. else
  1991. {
  1992. ASSERT(FALSE);
  1993. return;
  1994. }
  1995. }
  1997. if (!m_pToolTip->GetSafeHwnd())
  1998. return;
  2000. m_pToolTip->SetFont(&m_fnt);
  2002. m_pToolTip->SendMessage(TTM_SETMAXTIPWIDTH, 0, m_nMaxTipWidth);
  2003. m_pToolTip->SendMessage(TTM_SETMARGIN, 0, (LPARAM)(LPRECT)&m_rcMargin);
  2005. if (m_clrTipBkColor != COLORREF_NULL)
  2006. m_pToolTip->SendMessage(TTM_SETTIPBKCOLOR, m_clrTipBkColor);
  2008. if (m_clrTipTextColor != COLORREF_NULL)
  2009. m_pToolTip->SendMessage(TTM_SETTIPTEXTCOLOR, m_clrTipTextColor);
  2011. if (m_nDelayReshow != -1)
  2012. m_pToolTip->SendMessage(TTM_SETDELAYTIME, TTDT_RESHOW, MAKELPARAM(m_nDelayReshow, 0));
  2014. if (m_nDelayInitial != -1)
  2015. m_pToolTip->SendMessage(TTM_SETDELAYTIME, TTDT_INITIAL, MAKELPARAM(m_nDelayInitial, 0));
  2017. if (m_nDelayAutoPop != -1)
  2018. m_pToolTip->SendMessage(TTM_SETDELAYTIME, TTDT_AUTOPOP, MAKELPARAM(m_nDelayAutoPop, 0));
  2020. m_pToolTip->SendMessage(TTM_ACTIVATE, FALSE);
  2021. }
  2023. CWnd* pToolTip = m_pToolTip;
  2025. ASSERT_VALID(pToolTip);
  2026. ASSERT(::IsWindow(pToolTip->m_hWnd));
  2028. XTP_TOOLTIP_CONTEXT tc;
  2029. ZeroMemory(&tc, sizeof(tc));
  2031. // determine which tool was hit
  2032. CPoint point = pMsg->pt;
  2033. ::ScreenToClient(pWndHost->m_hWnd, &point);
  2035. XTP_TOOLTIP_TOOLINFO_EX tiHit;
  2036. memset(&tiHit, 0, sizeof(XTP_TOOLTIP_TOOLINFO_EX));
  2038. tiHit.cbSize = m_bShowTitleAndDescription || m_bShowImage ? sizeof(XTP_TOOLTIP_TOOLINFO_EX) : sizeof(XTP_TOOLTIP_TOOLINFO);
  2039. tiHit.pToolInfo = &tc;
  2040. INT_PTR nHit = OnToolHitTest(pWndHost, point, (TOOLINFO*)&tiHit);
  2042. if (m_bShowTitleAndDescription && tc.lpszDescription &&
  2043. tc.lpszTitle && (_tcscmp(tc.lpszDescription, tc.lpszTitle) == 0))
  2044. {
  2045. free(tc.lpszDescription);
  2046. tc.lpszDescription = 0;
  2047. }
  2049. if ((m_dwStyle & TTS_NOPREFIX) == 0)
  2050. {
  2051. CXTPDrawHelpers::StripMnemonics(tiHit.lpszText);
  2052. CXTPDrawHelpers::StripMnemonics(tiHit.pToolInfo->lpszTitle);
  2053. }
  2056. // build new toolinfo and if different than current, register it
  2057. BOOL bTipInfoChanged = m_lastInfo.uId != tiHit.uId || m_lastInfo.hwnd != tiHit.hwnd;
  2059. if (bTipInfoChanged || CRect(m_lastInfo.rect) != CRect(tiHit.rect))
  2060. {
  2061. if (m_lastInfo.cbSize >= sizeof(XTP_TOOLTIP_TOOLINFO) && !bTipInfoChanged)
  2062. pToolTip->SendMessage(TTM_DELTOOL, 0, (LPARAM)&m_lastInfo);
  2064. if (nHit != -1)
  2065. {
  2066. // add new tool and activate the tip
  2067. XTP_TOOLTIP_TOOLINFO_EX ti = tiHit;
  2068. ti.uFlags &= ~(TTF_NOTBUTTON | TTF_ALWAYSTIP);
  2070. VERIFY(pToolTip->SendMessage(TTM_ADDTOOL, 0, (LPARAM)&ti));
  2072. if ((m_toolStyle != xtpToolTipRTF && m_toolStyle != xtpToolTipHTML && m_toolStyle != xtpToolTipMarkup) && ((m_dwComCtlVersion >= VERSION_IE5) || (m_toolStyle != xtpToolTipStandard)))
  2073. {
  2074. if (m_bShowTitleAndDescription && tc.lpszDescription && tc.lpszTitle)
  2075. {
  2076. pToolTip->SendMessage(TTM_SETTITLE, m_nIconTitle, (LPARAM)(LPCTSTR)tc.lpszTitle);
  2078. ti.lpszText = tc.lpszDescription;
  2079. pToolTip->SendMessage(TTM_UPDATETIPTEXT, 0, (LPARAM)&ti);
  2080. }
  2081. else
  2082. {
  2083. pToolTip->SendMessage(TTM_SETTITLE, 0, 0);
  2084. }
  2085. }
  2087. if (m_bShowImage)
  2088. {
  2089. CXTPImageManagerIcon* pIcon = NULL;
  2090. pIcon =  tc.pImageManager ? tc.pImageManager->GetImage(UINT(m_nImageBase + nHit), m_nImageSize) : 0;
  2091. if (pIcon)
  2092. {
  2093. pToolTip->SendMessage(XTP_TTM_SETIMAGE, 0, (LPARAM)pIcon);
  2094. }
  2095. else
  2096. {
  2097. pToolTip->SendMessage(XTP_TTM_SETIMAGE, 0, NULL);
  2098. }
  2099. }
  2101. if ((tiHit.uFlags & TTF_ALWAYSTIP) || bTopParentActive)
  2102. {
  2103. // allow the tooltip to popup when it should
  2104. pToolTip->SendMessage(TTM_ACTIVATE, TRUE);
  2106. // bring the tooltip window above other popup windows
  2107. ::SetWindowPos(pToolTip->m_hWnd, HWND_TOP, 0, 0, 0, 0,
  2108. SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOOWNERZORDER);
  2109. }
  2110. }
  2111. else
  2112. {
  2113. pToolTip->SendMessage(TTM_ACTIVATE, FALSE);
  2114. }
  2116. // relay mouse event before deleting old tool
  2117. RelayToolTipMessage(pToolTip, pMsg);
  2119. //// now safe to delete the old tool
  2120. if (m_lastInfo.cbSize >= sizeof(XTP_TOOLTIP_TOOLINFO) && bTipInfoChanged)
  2121. pToolTip->SendMessage(TTM_DELTOOL, 0, (LPARAM)&m_lastInfo);
  2123. m_lastInfo = tiHit;
  2124. }
  2125. else
  2126. {
  2127. // relay mouse events through the tooltip
  2128. if (nHit != -1)
  2129. RelayToolTipMessage(pToolTip, pMsg);
  2130. }
  2132. if ((tiHit.lpszText != LPSTR_TEXTCALLBACK) && (tiHit.hinst == 0))
  2133. free(tiHit.lpszText);
  2135. if (tc.lpszDescription  != 0)
  2136. free(tc.lpszDescription);
  2138. if (tc.lpszTitle != 0)
  2139. free(tc.lpszTitle);
  2140. }
  2141. else
  2142. {
  2143. if (!bIgnoreFlags)
  2144. {
  2145. // make sure that tooltips are not already being handled
  2146. CWnd* pWnd = CWnd::FromHandle(pMsg->hwnd);
  2147. while (pWnd != NULL && pWnd != pWndHost && !(pWnd->m_nFlags & (WF_TOOLTIPS | WF_TRACKINGTOOLTIPS)))
  2148. {
  2149. pWnd = pWnd->GetParent();
  2150. }
  2151. if (pWnd != pWndHost)
  2152. return;
  2153. }
  2155. BOOL bKeys = (message >= WM_KEYFIRST && message <= WM_KEYLAST) ||
  2156. (message >= WM_SYSKEYFIRST && message <= WM_SYSKEYLAST);
  2157. if ((bKeys ||
  2158. (message == WM_LBUTTONDOWN || message == WM_LBUTTONDBLCLK) ||
  2159. (message == WM_RBUTTONDOWN || message == WM_RBUTTONDBLCLK) ||
  2160. (message == WM_MBUTTONDOWN || message == WM_MBUTTONDBLCLK) ||
  2161. (message == WM_NCLBUTTONDOWN || message == WM_NCLBUTTONDBLCLK) ||
  2162. (message == WM_NCRBUTTONDOWN || message == WM_NCRBUTTONDBLCLK) ||
  2163. (message == WM_NCMBUTTONDOWN || message == WM_NCMBUTTONDBLCLK)))
  2164. {
  2165. CancelToolTips();
  2166. }
  2167. }
  2168. }