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

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

对话框与窗口

开发平台：

Visual C++

XTTrayIcon.cpp：源码内容
  1. // XTTrayIcon.cpp : implementation of the CXTTrayIcon class.
  2. //
  3. // This file is a part of the XTREME CONTROLS 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"
  22. #include "Common/XTPVC80Helpers.h"
  23. #include "Common/XTPSystemHelpers.h"
  25. #include "XTDefines.h"
  26. #include "XTUtil.h"
  27. #include "XTTrayIcon.h"
  29. #ifdef _DEBUG
  30. #undef THIS_FILE
  31. static char THIS_FILE[] = __FILE__;
  32. #define new DEBUG_NEW
  33. #endif
  35. const UINT XT_WM_TASKBARCREATED = ::RegisterWindowMessage(_T("TaskbarCreated"));
  37. #ifndef IDANI_CAPTION
  38. #define IDANI_CAPTION               3
  39. #endif//IDANI_CAPTION
  41. /////////////////////////////////////////////////////////////////////////////
  42. // CXTTrayIcon
  44. CXTTrayIcon::CXTTrayIcon()
  45. {
  46. SetDefaultValues();
  47. }
  49. CXTTrayIcon::~CXTTrayIcon()
  50. {
  51. RemoveIcon();
  52. DestroyWindow();
  53. RemoveAnimationIcons();
  54. }
  56. BEGIN_MESSAGE_MAP(CXTTrayIcon, CWnd)
  57. //{{AFX_MSG_MAP(CXTTrayIcon)
  58. ON_WM_TIMER()
  59. ON_WM_SETTINGCHANGE()
  60. //}}AFX_MSG_MAP
  61. ON_REGISTERED_MESSAGE(XT_WM_TASKBARCREATED, OnTaskbarCreated)
  62. END_MESSAGE_MAP()
  64. /////////////////////////////////////////////////////////////////////////////
  65. // CXTTrayIcon initialization
  67. void CXTTrayIcon::SetDefaultValues()
  68. {
  69. ::ZeroMemory(&m_niData, sizeof(NOTIFYICONDATAEX));
  71. // Default initialization for the NOTIFYICONDATA base struct.
  73. m_niData.cbSize = sizeof(NOTIFYICONDATAEX);
  74. m_niData.hWnd = NULL;
  75. m_niData.uID = 0;
  76. m_niData.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
  77. m_niData.uCallbackMessage = TIN_XT_TRAYICON;
  78. m_niData.hIcon = NULL;
  79. m_niData.szTip[0] = 0;
  81. // Initialize the remaining member data.
  83. m_iMaxTipSize = 64;
  84. m_nIconID = 0;
  85. m_strToolTip = _T("");
  86. m_nIDEvent = 1001;
  87. m_nCounter = 0;
  88. m_uDefMenuItemID = 0;
  89. m_bDefMenuItemByPos = true;
  90. m_bHidden = true;
  91. m_bRemoved = true;
  92. m_bShowPending = false;
  93. m_hWndNotify = NULL;
  94. m_hIcon = NULL;
  95. }
  97. BOOL CXTTrayIcon::IsShellVersion5() const
  98. {
  99. static BOOL bVersion5 = -1;
  101. if (bVersion5 != -1)
  102. return bVersion5;
  104. CXTPModuleHandle hShell(_T("shell32.dll"));
  105. bVersion5 = HIWORD(hShell.GetVersion()) >= 5;
  107. return bVersion5;
  108. }
  110. BOOL CXTTrayIcon::ShellNotify(DWORD dwMessage)
  111. {
  112. return ::Shell_NotifyIcon(dwMessage, (PNOTIFYICONDATA)&m_niData);
  113. }
  115. /////////////////////////////////////////////////////////////////////////////
  116. // CXTTrayIcon notification window initialization
  118. bool CXTTrayIcon::SetNotificationWnd(CWnd* pWndNotify)
  119. {
  120. ASSERT_VALID(pWndNotify);
  122. // Make sure Notification window is valid
  123. if (!pWndNotify || !::IsWindow(pWndNotify->GetSafeHwnd()))
  124. {
  125. return false;
  126. }
  128. // assign values
  129. m_niData.hWnd = pWndNotify->GetSafeHwnd();
  130. m_niData.uFlags = 0;
  132. if (!ShellNotify(NIM_MODIFY))
  133. {
  134. return false;
  135. }
  137. return true;
  138. }
  140. CWnd* CXTTrayIcon::GetNotificationWnd()
  141. {
  142. return CWnd::FromHandle(m_niData.hWnd);
  143. }
  145. /////////////////////////////////////////////////////////////////////////////
  146. // CXTTrayIcon notification message handling
  148. bool CXTTrayIcon::SetCallbackMessage(UINT uNewCallbackMessage)
  149. {
  150. // Make sure we avoid conflict with other messages
  151. ASSERT(m_niData.uCallbackMessage >= WM_APP);
  153. m_niData.uCallbackMessage = uNewCallbackMessage;
  154. m_niData.uFlags = NIF_MESSAGE;
  156. if (!ShellNotify(NIM_MODIFY))
  157. {
  158. return false;
  159. }
  161. return true;
  162. }
  164. UINT CXTTrayIcon::GetCallbackMessage()
  165. {
  166. return m_niData.uCallbackMessage;
  167. }
  169. /////////////////////////////////////////////////////////////////////////////
  170. // CXTTrayIcon icon initialization
  172. bool CXTTrayIcon::SetIcon(HICON hIcon)
  173. {
  174. // check to see if this icon was already set.
  175. if (m_niData.hIcon == hIcon)
  176. {
  177. return true;
  178. }
  180. m_niData.uFlags = NIF_ICON;
  181. m_niData.hIcon = hIcon;
  183. if (m_bHidden)
  184. {
  185. return true;
  186. }
  188. if (!ShellNotify(NIM_MODIFY))
  189. {
  190. return false;
  191. }
  193. return true;
  194. }
  196. bool CXTTrayIcon::SetIcon(LPCTSTR lpszIconName)
  197. {
  198. int cx = ::GetSystemMetrics(SM_CXSMICON);
  199. int cy = ::GetSystemMetrics(SM_CYSMICON);
  201. m_hIcon = (HICON)::LoadImage(AfxGetResourceHandle(),
  202. lpszIconName, IMAGE_ICON, cx, cy, LR_DEFAULTCOLOR);
  204. return SetIcon(m_hIcon);
  205. }
  207. bool CXTTrayIcon::SetIcon(UINT nIDResource)
  208. {
  209. return SetIcon(MAKEINTRESOURCE(nIDResource));
  210. }
  212. void CXTTrayIcon::RemoveAnimationIcons()
  213. {
  214. while (!m_arTrayIcons.IsEmpty())
  215. {
  216. TRAYICONDATA ti = m_arTrayIcons.RemoveHead();
  217. ::DestroyIcon(ti.hIcon);
  218. }
  219. }
  221. bool CXTTrayIcon::SetAnimationIcons(const UINT* lpIDArray, int nIDCount, const CString* lpStrTipArray/*= NULL*/)
  222. {
  223. RemoveAnimationIcons();
  225. int cx = ::GetSystemMetrics(SM_CXSMICON);
  226. int cy = ::GetSystemMetrics(SM_CYSMICON);
  228. int iIcon;
  229. for (iIcon = 0; iIcon < nIDCount; ++iIcon)
  230. {
  231. TRAYICONDATA ti;
  233. if (lpStrTipArray != NULL)
  234. ti.strToolTip = lpStrTipArray[ iIcon ];
  236. ti.hIcon = (HICON)::LoadImage(AfxGetResourceHandle(),
  237. MAKEINTRESOURCE(lpIDArray[ iIcon ]), IMAGE_ICON, cx, cy, LR_DEFAULTCOLOR);
  239. if (ti.hIcon == NULL)
  240. {
  241. return false;
  242. }
  244. m_arTrayIcons.AddTail(ti);
  245. }
  247. return true;
  248. }
  250. HICON CXTTrayIcon::GetIcon() const
  251. {
  252. return m_niData.hIcon;
  253. }
  255. /////////////////////////////////////////////////////////////////////////////
  256. // CXTTrayIcon tooltip initialization
  260. bool CXTTrayIcon::SetTooltipText(LPCTSTR lpszTipText)
  261. {
  262. m_strToolTip = lpszTipText;
  264. if (m_strToolTip.GetLength() >= (int)m_iMaxTipSize)
  265. m_strToolTip = m_strToolTip.Left((int)m_iMaxTipSize-1);
  267. return SetShellTooltip(m_strToolTip);
  268. }
  270. bool CXTTrayIcon::SetShellTooltip(LPCTSTR lpszTipText)
  271. {
  272. ASSERT(AfxIsValidString(lpszTipText));
  273. ASSERT(_tcslen(lpszTipText) < m_iMaxTipSize);
  275. m_niData.uFlags = NIF_TIP;
  276. STRNCPY_S(m_niData.szTip, _countof(m_niData.szTip), lpszTipText, m_iMaxTipSize-1);
  278. if (m_bHidden)
  279. {
  280. return true;
  281. }
  283. if (!ShellNotify(NIM_MODIFY))
  284. {
  285. return false;
  286. }
  288. return true;
  289. }
  291. bool CXTTrayIcon::SetTooltipText(UINT nTipText)
  292. {
  293. CString strTipText;
  294. if (!strTipText.LoadString(nTipText))
  295. {
  296. return false;
  297. }
  299. return SetTooltipText(strTipText);
  300. }
  302. CString CXTTrayIcon::GetTooltipText() const
  303. {
  304. return m_strToolTip;
  305. }
  307. /////////////////////////////////////////////////////////////////////////////
  308. // CXTTrayIcon manipulation
  310. bool CXTTrayIcon::AddIcon()
  311. {
  312. if (!m_bRemoved)
  313. {
  314. RemoveIcon();
  315. }
  317. m_niData.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
  318. if (!ShellNotify(NIM_ADD))
  319. {
  320. m_bShowPending = true;
  321. return false;
  322. }
  324. m_bRemoved = m_bHidden = false;
  326. return true;
  327. }
  329. bool CXTTrayIcon::RemoveIcon()
  330. {
  331. m_bShowPending = false;
  333. if (m_bRemoved)
  334. {
  335. return true;
  336. }
  338. m_niData.uFlags = 0;
  339. if (!ShellNotify(NIM_DELETE))
  340. {
  341. return false;
  342. }
  344. m_bRemoved = m_bHidden = true;
  346. return true;
  347. }
  349. bool CXTTrayIcon::HideIcon()
  350. {
  351. if (m_bRemoved || m_bHidden)
  352. {
  353. return true;
  354. }
  356. if (IsShellVersion5())
  357. {
  358. m_niData.uFlags = NIF_STATE;
  359. m_niData.dwState = NIS_HIDDEN;
  360. m_niData.dwStateMask = NIS_HIDDEN;
  362. if (!ShellNotify(NIM_MODIFY))
  363. {
  364. m_bHidden = false;
  365. }
  366. else
  367. {
  368. m_bHidden = true;
  369. }
  371. return m_bHidden;
  372. }
  374. return RemoveIcon();
  375. }
  377. bool CXTTrayIcon::ShowIcon()
  378. {
  379. if (m_bRemoved)
  380. return AddIcon();
  382. if (!m_bHidden)
  383. return TRUE;
  385. if (IsShellVersion5())
  386. {
  387. m_niData.uFlags = NIF_STATE;
  388. m_niData.dwState = 0;
  389. m_niData.dwStateMask = NIS_HIDDEN;
  391. if (!ShellNotify(NIM_MODIFY))
  392. return false;
  394. m_bRemoved = m_bHidden = false;
  395. return true;
  396. }
  398. return AddIcon();
  399. }
  401. /////////////////////////////////////////////////////////////////////////////
  402. // CXTTrayIcon menu initialization
  404. bool CXTTrayIcon::SetDefaultMenuItem(UINT uItem, bool bByPos)
  405. {
  406. // if the values already exist, return true.
  407. if ((m_uDefMenuItemID == uItem) && (m_bDefMenuItemByPos == bByPos))
  408. {
  409. return true;
  410. }
  412. m_uDefMenuItemID = uItem;
  413. m_bDefMenuItemByPos = bByPos;
  415. // verify that we can load the menu defined by uID.
  416. CMenu menu;
  417. if (!menu.LoadMenu(m_niData.uID))
  418. {
  419. return false;
  420. }
  422. // see if we can access the submenu
  423. CMenu* pSubMenu = menu.GetSubMenu(0);
  424. if (!pSubMenu)
  425. {
  426. return false;
  427. }
  429. // check to see if we can set the submenu for the popup.  This is just a check to ensure
  430. // that everything has been correctly set.
  431. if (!::SetMenuDefaultItem(pSubMenu->m_hMenu, m_uDefMenuItemID, m_bDefMenuItemByPos))
  432. {
  433. return false;
  434. }
  436. return true;
  437. }
  439. void CXTTrayIcon::GetDefaultMenuItem(UINT& uItem, bool& bByPos)
  440. {
  441. uItem = m_uDefMenuItemID;
  442. bByPos = m_bDefMenuItemByPos;
  443. }
  445. /////////////////////////////////////////////////////////////////////////////
  446. // CXTTrayIcon message handlers
  448. void CXTTrayIcon::OnTimer(UINT_PTR nIDEvent)
  449. {
  450. // Update the tray icon and tooltip text.
  451. if (nIDEvent == m_nIDEvent)
  452. {
  453. POSITION pos = m_arTrayIcons.FindIndex(m_nCounter);
  454. if (pos != NULL)
  455. {
  456. TRAYICONDATA& ti = m_arTrayIcons.GetAt(pos);
  458. if (!ti.strToolTip.IsEmpty())
  459. {
  460. SetShellTooltip(ti.strToolTip);
  461. }
  462. else
  463. {
  464. SetShellTooltip(m_strToolTip);
  465. }
  467. if (ti.hIcon != NULL)
  468. {
  469. SetIcon(ti.hIcon);
  470. }
  471. }
  473. m_nCounter = (m_nCounter + 1) % (int)m_arTrayIcons.GetCount();
  474. }
  475. }
  477. bool CXTTrayIcon::Create(
  478. LPCTSTR lpszCaption,
  479. CWnd* pParentWnd,
  480. UINT nIconID,
  481. UINT uMenuID/*= 0*/,
  482. UINT uDefMenuItemID/*= 0*/,
  483. bool bDefMenuItemByPos/*= false*/)
  484. {
  485. ASSERT(pParentWnd); // must be valid.
  486. if (!pParentWnd)
  487. return false;
  489. m_nIconID = nIconID;
  490. m_strToolTip = lpszCaption;
  491. m_hWndNotify = pParentWnd->GetSafeHwnd();
  493. m_iMaxTipSize = _countof(m_niData.szTip) - 1;
  495. // Set the tray icon and tooltip text
  496. SetIcon(m_nIconID);
  497. SetTooltipText(m_strToolTip);
  499. // Create an invisible window
  500. CWnd::CreateEx(0, AfxRegisterWndClass(0), _T(""), WS_POPUP, 0, 0, 0, 0, NULL, 0);
  502. m_niData.hWnd = m_hWnd;
  503. m_niData.uID = uMenuID;
  504. m_uDefMenuItemID = uDefMenuItemID;
  505. m_bDefMenuItemByPos = bDefMenuItemByPos;
  507. m_uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
  509. return AddIcon();
  510. }
  512. bool CXTTrayIcon::ShowBalloonTip(LPCTSTR lpszInfo, LPCTSTR lpszInfoTitle/*= NULL*/, DWORD dwInfoFlags/*= NIIF_NONE*/, UINT uTimeout/*= 10*/)
  513. {
  514. bool bResult = false;
  516. if (IsShellVersion5() && lpszInfo)
  517. {
  518. // The balloon tooltip text can be up to 255 chars long.
  519. ASSERT(AfxIsValidString(lpszInfo));
  520. ASSERT(lstrlen(lpszInfo) < 256);
  522. // The balloon title text can be up to 63 chars long.
  523. if (lpszInfoTitle)
  524. {
  525. ASSERT(AfxIsValidString(lpszInfoTitle));
  526. ASSERT(lstrlen(lpszInfoTitle) < 64);
  527. }
  529. // dwInfoFlags must be valid.
  530. ASSERT(NIIF_NONE == dwInfoFlags ||
  531. NIIF_INFO == dwInfoFlags ||
  532. NIIF_WARNING == dwInfoFlags ||
  533. NIIF_ERROR == dwInfoFlags);
  535. // The timeout must be between 10 and 30 seconds.
  536. ASSERT(uTimeout >= 10 && uTimeout <= 30);
  538. m_niData.uFlags |= NIF_INFO;
  540. STRNCPY_S(m_niData.szInfo, _countof(m_niData.szInfo), lpszInfo, 255);
  542. if (lpszInfoTitle)
  543. {
  544. STRNCPY_S(m_niData.szInfoTitle, _countof(m_niData.szInfoTitle), lpszInfoTitle, 63);
  545. }
  546. else
  547. {
  548. m_niData.szInfoTitle[0] = _T('');
  549. }
  551. m_niData.uTimeout = (uTimeout * 1000); // convert time to millisecs
  552. m_niData.dwInfoFlags = dwInfoFlags;
  554. if (ShellNotify(NIM_MODIFY))
  555. {
  556. bResult = true;
  557. }
  559. // Zero out the balloon text string so that later operations won't redisplay
  560. // the balloon.
  561. m_niData.szInfo[0] = _T('');
  562. }
  564. return bResult;
  565. }
  567. void CXTTrayIcon::StartAnimation(UINT uElapse/*= 500*/)
  568. {
  569. CWnd::SetTimer(m_nIDEvent, uElapse, NULL);
  570. }
  572. void CXTTrayIcon::StopAnimation()
  573. {
  574. CWnd::KillTimer(m_nIDEvent);
  576. SetShellTooltip(m_strToolTip);
  577. SetIcon(m_nIconID);
  578. }
  580. LRESULT CXTTrayIcon::OnTrayNotification(WPARAM wParam, LPARAM lParam)
  581. {
  582. // Return quickly if its not for this tray icon
  583. if (wParam != m_niData.uID)
  584. {
  585. return 0L;
  586. }
  588. if (m_hWndNotify == NULL)
  589. {
  590. return 0L;
  591. }
  593. // Check to see if our notification window has already handled this
  594. // message, if so then return success.
  595. if (::SendMessage(m_hWndNotify, TIN_XT_TRAYICON, wParam, lParam))
  596. {
  597. return 1;
  598. }
  600. switch (LOWORD(lParam))
  601. {
  603. // Sent when the balloon is shown (balloons are queued).
  604. case NIN_BALLOONSHOW:
  605. break;
  607. // Sent when the balloon disappears-for example, when the
  608. // icon is deleted. This message is not sent if the balloon
  609. // is dismissed because of a timeout or a mouse click.
  610. case NIN_BALLOONHIDE:
  611. break;
  613. // Sent when the balloon is dismissed because of a timeout.
  614. case NIN_BALLOONTIMEOUT:
  615. break;
  617. // Sent when the balloon is dismissed because of a mouse click.
  618. case NIN_BALLOONUSERCLICK:
  619. break;
  621. // The version 5.0 Shell sends the associated application a NIN_SELECT message
  622. // if a user selects a notify icon with the mouse and activates it with the ENTER key
  624. case NIN_SELECT:
  625. // intentional fall thru...
  627. // The version 5.0 Shell sends the associated application a NIN_KEYSELECT message
  628. // if a user selects a notify icon with the keyboard and activates it with the space bar or ENTER key
  630. case NIN_KEYSELECT:
  631. // intentional fall thru...
  633. // The version 5.0 Shell sends the associated application a WM_CONTEXTMENU
  634. // If a user requests a notify icon's shortcut menu with the keyboard
  635. case WM_CONTEXTMENU:
  636. // intentional fall thru...
  638. case WM_RBUTTONUP:
  639. {
  640. CMenu menu;
  641. if (!menu.LoadMenu(m_niData.uID))
  642. {
  643. return 0;
  644. }
  646. CMenu* pSubMenu = menu.GetSubMenu(0);
  647. if (pSubMenu == NULL)
  648. {
  649. return 0;
  650. }
  652. // Make chosen menu item the default (bold font)
  653. ::SetMenuDefaultItem(pSubMenu->m_hMenu,
  654. m_uDefMenuItemID, m_bDefMenuItemByPos);
  656. // Display the menu at the current mouse location. There's a "bug"
  657. // (Microsoft calls it a feature) in Windows 95 that requires calling
  658. // SetForegroundWindow. To find out more, search for Q135788 in MSDN.
  659. //
  660. CPoint pos;
  661. GetCursorPos(&pos);
  662. ::SetForegroundWindow(m_hWndNotify);
  664. ::TrackPopupMenu(pSubMenu->m_hMenu, 0, pos.x, pos.y,
  665. 0, m_hWndNotify, NULL);
  667. ::PostMessage(m_hWndNotify, WM_NULL, 0, 0);
  669. menu.DestroyMenu();
  671. ShellNotify(NIM_SETFOCUS);
  672. }
  673. break;
  675. case WM_LBUTTONDBLCLK:
  676. {
  677. // double click received, the default action is to execute default menu item
  678. ::SetForegroundWindow(m_hWndNotify);
  680. UINT uItem;
  681. if (m_bDefMenuItemByPos)
  682. {
  683. CMenu menu;
  684. if (!menu.LoadMenu(m_niData.uID))
  685. {
  686. return 0;
  687. }
  689. CMenu* pSubMenu = menu.GetSubMenu(0);
  690. if (pSubMenu == NULL)
  691. {
  692. return 0;
  693. }
  695. uItem = pSubMenu->GetMenuItemID(m_uDefMenuItemID);
  697. menu.DestroyMenu();
  698. }
  699. else
  700. {
  701. uItem = m_uDefMenuItemID;
  702. }
  704. ::SendMessage(m_hWndNotify, WM_COMMAND, uItem, 0);
  705. }
  706. }
  708. return 1;
  709. }
  711. LRESULT CXTTrayIcon::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  712. {
  713. if (message == m_niData.uCallbackMessage)
  714. {
  715. return OnTrayNotification(wParam, lParam);
  716. }
  718. return CWnd::WindowProc(message, wParam, lParam);
  719. }
  721. // This is called whenever the taskbar is created (eg after explorer crashes
  722. // and restarts. Please note that the WM_TASKBARCREATED message is only passed
  723. // to TOP LEVEL windows (like WM_QUERYNEWPALETTE)
  725. LRESULT CXTTrayIcon::OnTaskbarCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
  726. {
  727. InstallIconPending();
  728. return 0L;
  729. }
  731. void CXTTrayIcon::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
  732. {
  733. CWnd::OnSettingChange(uFlags, lpszSection);
  735. if (uFlags == SPI_SETWORKAREA && m_bShowPending)
  736. {
  737. InstallIconPending();
  738. }
  739. }
  741. void CXTTrayIcon::InstallIconPending()
  742. {
  743. // Is the icon display pending, and it's not been set as "hidden"?
  744. if (m_bRemoved || m_bHidden)
  745. {
  746. return;
  747. }
  749. // Reset the flags to what was used at creation
  750. m_niData.uFlags = m_uFlags;
  752. // Try and recreate the icon
  753. m_bShowPending = (ShellNotify(NIM_ADD) == FALSE);
  754. }
  756. /////////////////////////////////////////////////////////////////////////////
  757. // CXTTrayIcon minimize and restore helper functions
  759. BOOL CALLBACK CXTTrayIcon::FindTrayWnd(HWND hWnd, LPARAM lParam)
  760. {
  761. TCHAR szClassName[256];
  762. ::GetClassName(hWnd, szClassName, 255);
  764. // Did we find the main system tray ? If so, then get its size and keep going
  765. if (_tcscmp(szClassName, _T("TrayNotifyWnd")) == 0)
  766. {
  767. CRect *pRect = (CRect*) lParam;
  768. ::GetWindowRect(hWnd, pRect);
  769. return TRUE;
  770. }
  772. // Did we find the System Clock ? If so, then adjust the size of the rectangle
  773. // we have and quit (clock will be found after the system tray)
  774. if (_tcscmp(szClassName, _T("TrayClockWClass")) == 0)
  775. {
  776. CRect *pRect = (CRect*)lParam;
  777. CRect rectClock;
  778. ::GetWindowRect(hWnd, rectClock);
  780. // if clock is above system tray adjust accordingly
  781. if (rectClock.bottom < pRect->bottom-5)    // 10 = random fudge factor.
  782. {
  783. pRect->top = rectClock.bottom;
  784. }
  785. else
  786. {
  787. pRect->right = rectClock.left;
  788. }
  790. return FALSE;
  791. }
  793. return TRUE;
  794. }
  796. bool CXTTrayIcon::GetTrayWindowRect(CRect& rect)
  797. {
  798. int cx = 150;
  799. int cy = 30;
  801. HWND hWndTray = ::FindWindow(_T("Shell_TrayWnd"), NULL);
  802. if (hWndTray)
  803. {
  804. ::GetWindowRect(hWndTray, &rect);
  805. ::EnumChildWindows(hWndTray, FindTrayWnd, (LPARAM)&rect);
  806. return true;
  807. }
  809. // OK, we failed to get the rect from the quick hack. Either explorer isn't
  810. // running or it's a new version of the shell with the window class names
  811. // changed (how dare Microsoft change these undocumented class names!) So, we
  812. // try to find out what side of the screen the taskbar is connected to. We
  813. // know that the system tray is either on the right or the bottom of the
  814. // taskbar, so we can make a good guess at where to minimize to
  816. APPBARDATA ad;
  817. ::ZeroMemory(&ad, sizeof(APPBARDATA));
  818. ad.cbSize = sizeof(ad);
  820. if (::SHAppBarMessage(ABM_GETTASKBARPOS, &ad))
  821. {
  822. // We know the edge the taskbar is connected to, so guess the rect of the
  823. // system tray. Use various fudge factor to make it look good
  825. switch (ad.uEdge)
  826. {
  827. case ABE_LEFT:
  828. case ABE_RIGHT:
  829. // We want to minimize to the bottom of the taskbar
  830. rect.top = ad.rc.bottom-100;
  831. rect.bottom = ad.rc.bottom-16;
  832. rect.left = ad.rc.left;
  833. rect.right = ad.rc.right;
  834. break;
  836. case ABE_TOP:
  837. case ABE_BOTTOM:
  838. // We want to minimize to the right of the taskbar
  839. rect.top = ad.rc.top;
  840. rect.bottom = ad.rc.bottom;
  841. rect.left = ad.rc.right-100;
  842. rect.right = ad.rc.right-16;
  843. break;
  844. }
  846. return true;
  847. }
  849. // Blimey, we really aren't in luck. It's possible that a third party shell
  850. // is running instead of explorer. This shell might provide support for the
  851. // system tray, by providing a Shell_TrayWnd window (which receives the
  852. // messages for the icons) So, look for a Shell_TrayWnd window and work out
  853. // the rect from that. Remember that explorer's taskbar is the Shell_TrayWnd,
  854. // and stretches either the width or the height of the screen. We can't rely
  855. // on the 3rd party shell's Shell_TrayWnd doing the same, in fact, we can't
  856. // rely on it being any size. The best we can do is just blindly use the
  857. // window rect, perhaps limiting the width and height to, say 150 square.
  858. // Note that if the 3rd party shell supports the same configuration as
  859. // explorer (the icons hosted in NotifyTrayWnd, which is a child window of
  860. // Shell_TrayWnd), we would already have caught it above
  862. if (hWndTray)
  863. {
  864. ::GetWindowRect(hWndTray, &rect);
  866. if (rect.right - rect.left > cx)
  867. {
  868. rect.left = rect.right - cx;
  869. }
  870. if (rect.bottom - rect.top > cy)
  871. {
  872. rect.top = rect.bottom - cy;
  873. }
  875. return true;
  876. }
  878. // OK. Haven't found a thing. Provide a default rect based on the current work
  879. // area
  880. if (::SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0))
  881. {
  882. rect.left = rect.right - cx;
  883. rect.top = rect.bottom - cy;
  884. return true;
  885. }
  887. return false;
  888. }
  890. bool CXTTrayIcon::CanAnimate() const
  891. {
  892. ANIMATIONINFO ai;
  893. ::ZeroMemory(&ai, sizeof(ANIMATIONINFO));
  894. ai.cbSize = sizeof(ANIMATIONINFO);
  896. ::SystemParametersInfo(SPI_GETANIMATION,
  897. sizeof(ANIMATIONINFO), &ai, 0);
  899. return ai.iMinAnimate ? true : false;
  900. }
  902. /////////////////////////////////////////////////////////////////////////////
  903. // CXTTrayIcon minimize and restore functions
  905. bool CXTTrayIcon::CreateMinimizeWnd(CWnd* pWndApp)
  906. {
  907. // Create the minimize window
  908. if (!::IsWindow(m_wndMinimize.m_hWnd))
  909. {
  910. if (!m_wndMinimize.CreateEx(0, AfxRegisterWndClass(0), _T(""), WS_POPUP,
  911. CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, 0))
  912. {
  913. return false;
  914. }
  915. }
  917. pWndApp->SetParent(&m_wndMinimize);
  918. return true;
  919. }
  921. void CXTTrayIcon::MinimizeToTray(CWnd* pWndApp)
  922. {
  923. if (CanAnimate())
  924. {
  925. CRect rectFrom, rectTo;
  927. pWndApp->GetWindowRect(rectFrom);
  928. GetTrayWindowRect(rectTo);
  930. ::DrawAnimatedRects(pWndApp->m_hWnd,
  931. IDANI_CAPTION, rectFrom, rectTo);
  932. }
  934. CreateMinimizeWnd(pWndApp);
  935. pWndApp->ShowWindow(SW_HIDE);
  936. }
  938. void CXTTrayIcon::MaximizeFromTray(CWnd* pWndApp)
  939. {
  940. if (CanAnimate())
  941. {
  942. CRect rectTo;
  943. pWndApp->GetWindowRect(rectTo);
  945. CRect rectFrom;
  946. GetTrayWindowRect(rectFrom);
  948. pWndApp->SetParent(NULL);
  949. ::DrawAnimatedRects(pWndApp->m_hWnd,
  950. IDANI_CAPTION, rectFrom, rectTo);
  951. }
  952. else
  953. {
  954. pWndApp->SetParent(NULL);
  955. }
  957. pWndApp->SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
  959. // Move focus away and back again to ensure taskbar icon is recreated
  960. if (::IsWindow(m_wndMinimize.m_hWnd))
  961. {
  962. m_wndMinimize.SetActiveWindow();
  963. }
  965. pWndApp->SetActiveWindow();
  966. pWndApp->SetForegroundWindow();
  967. }