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

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

对话框与窗口

开发平台：

Visual C++

XTPMiniToolBar.cpp：源码内容
  1. // XTPMiniToolBar.cpp : implementation of the CXTPMiniToolBar class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS 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. #include "Common/XTPDrawHelpers.h"
  25. #include "XTPPaintManager.h"
  26. #include "XTPMouseManager.h"
  27. #include "XTPCommandBars.h"
  28. #include "XTPKeyboardManager.h"
  29. #include "XTPMiniToolBar.h"
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  39. #ifndef LWA_ALPHA
  40. #define LWA_ALPHA               0x00000002
  41. #endif
  42. #ifndef WS_EX_LAYERED
  43. #define WS_EX_LAYERED           0x00080000
  44. #endif
  46. /////////////////////////////////////////////////////////////////////////////
  47. // CXTPMiniToolBar
  49. IMPLEMENT_XTP_COMMANDBAR(CXTPMiniToolBar, CXTPPopupToolBar);
  51. CXTPMiniToolBar::CXTPMiniToolBar()
  52. {
  53. m_pfnSetLayeredWindowAttributes = NULL;
  54. m_pfnUpdateLayeredWindow = NULL;
  56. HMODULE hLib = GetModuleHandle(_T("USER32"));
  57. if (hLib)
  58. {
  59. m_pfnSetLayeredWindowAttributes = (PFNSETLAYEREDWINDOWATTRIBUTES) ::GetProcAddress(hLib, "SetLayeredWindowAttributes");
  60. m_pfnUpdateLayeredWindow = (LPFNUPDATELAYEREDWINDOW) GetProcAddress(hLib, "UpdateLayeredWindow");
  61. }
  63. m_bActivated = FALSE;
  64. m_bTracking = FALSE;
  65. m_nOpacity = 0;
  66. m_pContextMenu = FALSE;
  67. m_bTrackOnHover = FALSE;
  69. m_rcBorders = CRect(2, 2, 2, 2);
  70. m_nWrapMargin = 3;
  71. }
  73. CXTPMiniToolBar::~CXTPMiniToolBar()
  74. {
  76. }
  78. void CXTPMiniToolBar::UpdateOpacity()
  79. {
  80. CXTPWindowRect rc(this);
  81. CPoint pt;
  82. GetCursorPos(&pt);
  84. int x = pt.x < rc.left ? rc.left - pt.x : pt.x > rc.right ? pt.x - rc.right : 0;
  85. int y = pt.y < rc.top ? rc.top - pt.y : pt.y > rc.bottom ? pt.y - rc.bottom : 0;
  87. int nLen = max(x, y);
  88. int nOpacity = 0;
  90. if (m_nPopuped != -1 || m_pContextMenu || IsTrackingMode() || nLen == 0)
  91. {
  92. nLen = 0;
  93. nOpacity = 255;
  94. }
  95. else if (!m_bActivated)
  96. {
  97. if (nLen < 17) nOpacity = 17 + (16 - nLen) * 14;
  98. }
  99. else
  100. {
  101. if (nLen < 90) nOpacity = MulDiv(255, 90 - nLen, 90);
  102. }
  104. if ((m_nOpacity != nOpacity))
  105. {
  106. m_nOpacity = nOpacity;
  108. if (m_pfnSetLayeredWindowAttributes)
  109. {
  110. m_pfnSetLayeredWindowAttributes(m_hWnd, 0x00, (BYTE)nOpacity, LWA_ALPHA);
  111. }
  112. else
  113. {
  114. SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | (nOpacity > 20 ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
  115. }
  117. CXTPShadowManager* pShadowManager = GetPaintManager()->GetShadowManager();
  119. POSITION pos = pShadowManager->GetHeadPosition(this);
  120. while (pos)
  121. {
  122. CWnd* pShadow = pShadowManager->GetNext(pos);
  124. if (m_pfnUpdateLayeredWindow)
  125. {
  126. BLENDFUNCTION bf;
  127. bf.BlendOp = AC_SRC_OVER;
  128. bf.BlendFlags = 0;
  129. bf.SourceConstantAlpha = (BYTE)nOpacity;
  130. bf.AlphaFormat = 0x01;
  131. m_pfnUpdateLayeredWindow(pShadow->GetSafeHwnd(), (HDC)0, 0, 0, 0, 0, 0, &bf, 0x02);
  132. }
  133. else
  134. {
  135. pShadow->SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | (nOpacity > 20 ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
  136. }
  137. }
  138. }
  140. if (m_nOpacity == 255)
  141. {
  142. m_bActivated = TRUE;
  143. }
  145. if (nLen > (m_bActivated ? 180 : 110))
  146. {
  147. m_bTracking = FALSE;
  148. }
  149. }
  151. void CXTPMiniToolBar::Animate()
  152. {
  153. GetPaintManager()->SetCommandBarRegion(this);
  155. if (m_pfnSetLayeredWindowAttributes != 0)
  156. {
  157. ModifyStyleEx(0, WS_EX_LAYERED);
  158. }
  159. }
  161. BOOL CXTPMiniToolBar::TrackMiniBar(UINT nFlags, int x, int y)
  162. {
  163. CXTPMouseManager* pMouseManager = XTPMouseManager();
  165. m_bActivated = FALSE;
  166. m_bTracking = TRUE;
  168. m_popupFlags = xtpPopupUp;
  169. m_nOpacity = 0;
  171. CWnd* pWnd = GetSite();
  173. if (pWnd && pWnd->GetExStyle() & (WS_EX_LAYOUTRTL | WS_EX_RIGHT))
  174. nFlags |= TPM_RIGHTALIGN;
  176. m_bExecOnRButton = nFlags & TPM_RIGHTBUTTON;
  177. m_popupFlags = (nFlags & TPM_RIGHTALIGN) ? xtpPopupLeft | xtpPopupUp : xtpPopupUp;
  179. pMouseManager->SendTrackLost();
  180. ReleaseCapture();
  182. if (!Popup(x, y, CRect(0, 0, 0, 0)))
  183. {
  184. return FALSE;
  185. }
  187. InternalAddRef();
  189. SetTrackingMode(FALSE);
  191. UpdateOpacity();
  193. PumpMessage();
  195. DestroyWindow();
  197. InternalRelease();
  199. return TRUE;
  200. }
  202. BOOL CXTPMiniToolBar::TrackPopupMenu(CXTPPopupBar* pPopup, UINT nFlags, int x, int y)
  203. {
  204. ASSERT(pPopup);
  205. if (!pPopup)
  206. {
  207. return FALSE;
  208. }
  210. m_bActivated = TRUE;
  211. m_bTracking = TRUE;
  212. m_nOpacity = 0;
  213. m_popupFlags = xtpPopupUp;
  215. CWnd* pWnd = GetSite();
  217. if (pWnd && pWnd->GetExStyle() & (WS_EX_LAYOUTRTL | WS_EX_RIGHT))
  218. nFlags |= TPM_RIGHTALIGN;
  220. UINT nReturn = TRUE;
  221. pPopup->m_pReturnCmd = NULL;
  223. if (nFlags & TPM_RETURNCMD)
  224. {
  225. pPopup->m_pReturnCmd = &nReturn;
  226. nReturn = 0;
  227. }
  229. m_bExecOnRButton = nFlags & TPM_RIGHTBUTTON;
  231. pPopup->m_bIgnoreUpdateHandler = nFlags & TPM_NONOTIFY;
  232. pPopup->m_bExecOnRButton = nFlags & TPM_RIGHTBUTTON;
  234. if (nFlags & TPM_RIGHTALIGN)
  235. {
  236. SetPopupFlags(xtpPopupLeft | xtpPopupUp);
  237. pPopup->SetPopupFlags(xtpPopupLeft | xtpPopupDown);
  238. }
  239. else
  240. {
  241. SetPopupFlags(xtpPopupUp);
  242. pPopup->SetPopupFlags(xtpPopupDown);
  243. }
  245. CXTPMouseManager* pMouseManager = XTPMouseManager();
  247. pMouseManager->SendTrackLost();
  248. ReleaseCapture();
  250. pMouseManager->IgnoreLButtonUp();
  252. if (!Create())
  253. return FALSE;
  255. if (!pPopup->Create())
  256. return FALSE;
  258. int nPopupWidth = pPopup->GetWidth();
  259. int nMiniBarWidth = GetWidth();
  261. CSize szMiniBar = CalcDynamicLayout(0, 0);
  262. CSize szPopupBar = pPopup->CalcDynamicLayout(0, 0);
  264. CPoint ptPopup(x, y);
  265. CRect rc = pPopup->CalculatePopupRect(ptPopup, szPopupBar);
  267. int nWidth = max(szMiniBar.cx, szPopupBar.cx);
  268. int nTop = rc.top - 15;
  270. if (!Popup(x, nTop, CRect(0, 0, 0, 0)))
  271. {
  272. return FALSE;
  273. }
  275. m_pContextMenu = pPopup;
  277. UpdateOpacity();
  278. UpdateWindow();
  280. pPopup->SetWidth(nWidth);
  281. SetWidth(nWidth);
  283. if (!pPopup->Popup(x, y, CRect(0, 0, 0, 0)))
  284. {
  285. m_pContextMenu = NULL;
  286. return FALSE;
  287. }
  289. InternalAddRef();
  291. PumpMessage();
  293. SetWidth(nMiniBarWidth);
  294. pPopup->SetWidth(nPopupWidth);
  296. m_pContextMenu = NULL;
  298. DestroyWindow();
  299. InternalRelease();
  302. return nReturn;
  303. }
  305. BOOL CXTPMiniToolBar::OnHookKeyDown(UINT nChar, LPARAM lParam)
  306. {
  307. if (m_pContextMenu)
  308. return FALSE;
  310. return CXTPPopupToolBar::OnHookKeyDown(nChar, lParam);
  311. }
  313. BOOL CXTPMiniToolBar::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  314. {
  315. return CXTPCommandBar::SetTrackingMode(bMode, bSelectFirst, bKeyboard);
  316. }
  318. BOOL CXTPMiniToolBar::CursorInWindow() const
  319. {
  320. CPoint pt;
  321. GetCursorPos(&pt);
  323. if (CXTPWindowRect(this).PtInRect(pt))
  324. return TRUE;
  326. CXTPCommandBar* pCommandBar = XTPMouseManager()->HitTest(pt);
  327. if (!pCommandBar)
  328. return FALSE;
  330. return pCommandBar->GetRootParent() == (CXTPCommandBar*)this;
  331. }
  333. int CXTPMiniToolBar::OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  334. {
  335. if (m_bTracking)
  336. {
  337. if (nMessage == WM_ENABLE || nMessage == WM_ACTIVATEAPP)
  338. {
  339. ShowWindow(SW_HIDE);
  340. m_bTracking = FALSE;
  341. }
  342. }
  344. return CXTPPopupToolBar::OnHookMessage(hWnd, nMessage, wParam, lParam, lResult);
  345. }
  347. void CXTPMiniToolBar::PumpMessage()
  348. {
  349. HWND hwndSite = GetSite()->m_hWnd;
  350. CWinThread* pThread = AfxGetThread();
  352. XTPHookManager()->SetHook(hwndSite, this);
  354. while (m_bTracking)
  355. {
  357. MSG msg;
  358. if (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
  359. {
  360. if (!m_bTracking)
  361. break;
  363. if (!m_pContextMenu)
  364. {
  365. if (msg.message == WM_MOUSEMOVE)
  366. {
  367. UpdateOpacity();
  368. }
  370. if ((msg.message == WM_KEYDOWN || msg.message == WM_CHAR
  371. || msg.message == WM_SYSKEYDOWN || msg.message == WM_MOUSEWHEEL) && !IsTrackingMode())
  372. {
  373. m_bTracking = FALSE;
  374. }
  376. if (msg.message == WM_CLOSE || msg.message == WM_SYSCOMMAND)
  377. {
  378. m_bTracking = FALSE;
  379. }
  381. if ((msg.message == WM_LBUTTONDOWN || msg.message == WM_RBUTTONDOWN || msg.message == WM_MBUTTONDOWN ||
  382. msg.message == WM_NCLBUTTONDOWN || msg.message == WM_NCRBUTTONDOWN) && !CursorInWindow())
  383. {
  384. m_bTracking = FALSE;
  385. }
  386. }
  387. else
  388. {
  389. if (msg.message == WM_LBUTTONDOWN || msg.message == WM_RBUTTONDOWN || msg.message == WM_MBUTTONDOWN ||
  390. msg.message == WM_NCLBUTTONDOWN || msg.message == WM_NCRBUTTONDOWN)
  391. {
  392. if (!CursorInWindow())
  393. {
  394. CPoint point;
  395. GetCursorPos(&point);
  397. if (XTPMouseManager()->HitTest(point) == 0)
  398. m_bTracking = FALSE;
  399. }
  400. else
  401. {
  402. m_pContextMenu->SetTrackingMode(FALSE);
  403. m_pContextMenu = NULL;
  404. SetTrackingMode(FALSE);
  405. }
  406. }
  407. }
  409. if (msg.message == WM_ACTIVATE || msg.message == WM_ACTIVATEAPP || msg.message == WM_CAPTURECHANGED)
  410. {
  411. m_bTracking = FALSE;
  412. }
  414. if (m_pContextMenu && !m_pContextMenu->IsTrackingMode())
  415. {
  416. ShowWindow(SW_HIDE);
  417. m_bTracking = FALSE;
  418. }
  420. if (!m_bTracking)
  421. break;
  423. if (!::GetMessage(&msg, NULL, 0, 0))
  424. break;
  426. if (m_pContextMenu && !m_pContextMenu->IsTrackingMode())
  427. {
  428. m_bTracking = FALSE;
  429. }
  431. if (!m_bTracking)
  432. {
  433. ::PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam);
  434. break;
  435. }
  437. if (msg.message != WM_KICKIDLE && !AfxGetThread()->PreTranslateMessage(&msg))
  438. {
  439. // process this message
  440. ::TranslateMessage(&msg);
  441. ::DispatchMessage(&msg);
  442. }
  444. pThread->OnIdle(-1);
  445. OnIdleUpdateCmdUI(TRUE, 0L);
  447. }
  448. else
  449. {
  450. WaitMessage();
  451. }
  452. }
  454. XTPHookManager()->RemoveHook(hwndSite, this);
  455. }
  457. CXTPMiniToolBar* CXTPMiniToolBar::CreateMiniToolBar(CXTPCommandBars* pCommandBars)
  458. {
  459. CXTPMiniToolBar* pMiniToolBar = new CXTPMiniToolBar();
  460. pMiniToolBar->SetCommandBars(pCommandBars);
  461. return pMiniToolBar;
  462. }
  464. INT_PTR CXTPMiniToolBar::OnToolHitTest(CPoint /*point*/, TOOLINFO* /*pTI*/) const
  465. {
  466. return -1; // No Tips.
  467. }
  469. BEGIN_MESSAGE_MAP(CXTPMiniToolBar, CXTPPopupToolBar)
  470. //{{AFX_MSG_MAP(CXTPMiniToolBar)
  471. //}}AFX_MSG_MAP
  472. END_MESSAGE_MAP()
  475. /////////////////////////////////////////////////////////////////////////////
  476. // CXTPMiniToolBar message handlers