Changeset 67 for trunk/SystemTray.cpp

Timestamp:

10/18/2007 9:37:01 AM (6 years ago)

Author:

lowjoel

Message:

-Updated the System Tray class
-Make the Scheduler popup menu slightly more meaningful (in terms of text chosen)

File:

• trunk/SystemTray.cpp (modified) (24 diffs)

trunk/SystemTray.cpp

@@ -1 +1 @@
 /////////////////////////////////////////////////////////////////////////////
 // SystemTray.cpp : implementation file
+//
+// MFC VERSION
 //
 // This is a conglomeration of ideas from the MSJ "Webster" application,
@@ -23 +25 @@
 //                          hIcon, nSystemTrayID);
 //
-// Written by Chris Maunder (chrismaunder@codeguru.com)
-// Copyright (c) 1998.
+// Written by Chris Maunder (cmaunder@mail.com)
+// Copyright (c) 1998-2003.
 //
 // Updated: 25 Jul 1998 - Added icon animation, and derived class
@@ -31 +33 @@
 //                        Added API to set default menu item. Code provided
 //                        by Enrico Lelina.
+//
+// Updated: 6 June 1999 - SetIcon can now load non-standard sized icons (Chip Calvert)
+//                        Added "bHidden" parameter when creating icon
+//                        (Thanks to Michael Gombar for these suggestions)
+//                        Restricted tooltip text to 64 characters.
+//
+// Updated: 9 Nov 1999  - Now works in WindowsCE.
+//                        Fix for use in NT services (Thomas Mooney, TeleProc, Inc)
+//                        Added W2K stuff by Michael Dunn
+//
+// Updated: 1 Jan 2000  - Added tray minimisation stuff.
+// 
+// Updated: 21 Sep 2000 - Added GetDoWndAnimation - animation only occurs if the system
+//                        settings allow it (Matthew Ellis). Updated the GetTrayWndRect
+//                        function to include more fallback logic (Matthew Ellis)
+//                        NOTE: Signature of GetTrayWndRect has changed!
+// 
+// Updated: 4 Aug 2003 - Fixed bug that was stopping icon from being recreated when
+//                       Explorer crashed
+//                       Fixed resource leak in SetIcon
+//                       Animate() now checks for empty icon list - Anton Treskunov
+//                       Added the virutal CustomizeMenu() method - Anton Treskunov
+//                       
 //
 // This code may be used in compiled form in any way you desire. This
@@ -41 +66 @@
 //
 // This file is provided "as is" with no expressed or implied warranty.
-// The author accepts no liability if it causes any damage to your
-// computer, causes your pet cat to fall ill, increases baldness or
-// makes you car start emitting strange noises when you start it up.
+// The author accepts no liability for any damage caused through use.
 //
 // Expect bugs.
@@ -54 +77 @@
     
 #include "stdafx.h"
-#include "resource.h"
 #include "SystemTray.h"
 
@@ -63 +85 @@
 #endif
 
+#ifndef _WIN32_WCE  // Use C++ exception handling instead of structured.
+#undef TRY
+#undef CATCH
+#undef END_CATCH
+#define TRY try
+#define CATCH(ex_class, ex_object) catch(ex_class* ex_object)
+#define END_CATCH
+#endif  // _WIN32_WCE
+
+#ifndef _countof
+#define _countof(x) ( sizeof(x) / sizeof(x[0]) )
+#endif
+
 IMPLEMENT_DYNAMIC(CSystemTray, CWnd)
 
-UINT CSystemTray::m_nIDEvent = 4567;
+const UINT CSystemTray::m_nTimerID    = 4567;
+UINT CSystemTray::m_nMaxTooltipLength  = 128;     // This may change...
+const UINT CSystemTray::m_nTaskbarCreatedMsg = ::RegisterWindowMessage(_T("TaskbarCreated"));
+CWnd  CSystemTray::m_wndInvisible;
 
 /////////////////////////////////////////////////////////////////////////////
@@ -75 +113 @@
 }
 
-CSystemTray::CSystemTray(CWnd* pParent, UINT uCallbackMessage, LPCTSTR szToolTip, 
-                         HICON icon, UINT uID)
+CSystemTray::CSystemTray(CWnd* pParent,             // The window that will recieve tray notifications
+                         UINT uCallbackMessage,     // the callback message to send to parent
+                         LPCTSTR szToolTip,         // tray icon tooltip
+                         HICON icon,                // Handle to icon
+                         UINT uID,                  // Identifier of tray icon
+                         BOOL bHidden /*=FALSE*/,   // Hidden on creation?                  
+                         LPCTSTR szBalloonTip /*=NULL*/,    // Ballon tip (w2k only)
+                         LPCTSTR szBalloonTitle /*=NULL*/,  // Balloon tip title (w2k)
+                         DWORD dwBalloonIcon /*=NIIF_NONE*/,// Ballon tip icon (w2k)
+                         UINT uBalloonTimeout /*=10*/)      // Balloon timeout (w2k)
 {
     Initialise();
-    Create(pParent, uCallbackMessage, szToolTip, icon, uID);
+    Create(pParent, uCallbackMessage, szToolTip, icon, uID, bHidden,
+           szBalloonTip, szBalloonTitle, dwBalloonIcon, uBalloonTimeout);
 }
 
@@ -85 +132 @@
 {
     memset(&m_tnd, 0, sizeof(m_tnd));
-    m_bEnabled   = FALSE;
-    m_bHidden    = FALSE;
+
+    m_bEnabled = FALSE;
+    m_bHidden  = TRUE;
+    m_bRemoved = TRUE;
+
+    m_DefaultMenuItemID    = 0;
+    m_DefaultMenuItemByPos = TRUE;
+
+    m_bShowIconPending = FALSE;
+
     m_uIDTimer   = 0;
     m_hSavedIcon = NULL;
-    m_DefaultMenuItemID = 0;
-    m_DefaultMenuItemByPos = TRUE;
-}
-
-#pragma warning(disable : 4706)
+
+    m_pTargetWnd = NULL;
+    m_uCreationFlags = 0;
+
+#ifdef SYSTEMTRAY_USEW2K
+    OSVERSIONINFO os = { sizeof(os) };
+    GetVersionEx(&os);
+    m_bWin2K = ( VER_PLATFORM_WIN32_NT == os.dwPlatformId && os.dwMajorVersion >= 5 );
+#else
+    m_bWin2K = FALSE;
+#endif
+}
+
+// update by Michael Dunn, November 1999
+//
+//  New version of Create() that handles new features in Win 2K.
+//
+// Changes:
+//  szTip: Same as old, but can be 128 characters instead of 64.
+//  szBalloonTip: Text for a balloon tooltip that is shown when the icon
+//                is first added to the tray.  Pass "" if you don't want
+//                a balloon.
+//  szBalloonTitle: Title text for the balloon tooltip.  This text is shown
+//                  in bold above the szBalloonTip text.  Pass "" if you
+//                  don't want a title.
+//  dwBalloonIcon: Specifies which icon will appear in the balloon.  Legal
+//                 values are:
+//                     NIIF_NONE: No icon
+//                     NIIF_INFO: Information
+//                     NIIF_WARNING: Exclamation
+//                     NIIF_ERROR: Critical error (red circle with X)
+//  uBalloonTimeout: Number of seconds for the balloon to remain visible.
+//                   Must be between 10 and 30 inclusive.
+
 BOOL CSystemTray::Create(CWnd* pParent, UINT uCallbackMessage, LPCTSTR szToolTip, 
-                         HICON icon, UINT uID, BOOL bInitialShow /*=TRUE*/)
-{
+                         HICON icon, UINT uID, BOOL bHidden /*=FALSE*/,
+                         LPCTSTR szBalloonTip /*=NULL*/, 
+                         LPCTSTR szBalloonTitle /*=NULL*/,  
+                         DWORD dwBalloonIcon /*=NIIF_NONE*/,
+                         UINT uBalloonTimeout /*=10*/)
+{
+#ifdef _WIN32_WCE
+    m_bEnabled = TRUE;
+#else
     // this is only for Windows 95 (or higher)
-    VERIFY(m_bEnabled = ( GetVersion() & 0xff ) >= 4);
-    if (!m_bEnabled) return FALSE;
-
-    // Make sure Notification window is valid (not needed - CJM)
-    // VERIFY(m_bEnabled = (pParent && ::IsWindow(pParent->GetSafeHwnd())));
-    // if (!m_bEnabled) return FALSE;
+    m_bEnabled = (GetVersion() & 0xff) >= 4;
+    if (!m_bEnabled) 
+    {
+        ASSERT(FALSE);
+        return FALSE;
+    }
+#endif
+
+    m_nMaxTooltipLength = _countof(m_tnd.szTip);
     
     // Make sure we avoid conflict with other messages
-    ASSERT(uCallbackMessage >= WM_USER);
-
-    // Tray only supports tooltip text up to 64 characters
-    ASSERT(_tcslen(szToolTip) <= 64);
+    ASSERT(uCallbackMessage >= WM_APP);
+
+    // Tray only supports tooltip text up to m_nMaxTooltipLength) characters
+    ASSERT(AfxIsValidString(szToolTip));
+    ASSERT(_tcslen(szToolTip) <= m_nMaxTooltipLength);
 
     // Create an invisible window
-    CWnd::CreateEx(0, AfxRegisterWndClass(0), _T(""), WS_POPUP, 0,0,10,10, NULL, 0);
+    CWnd::CreateEx(0, AfxRegisterWndClass(0), _T(""), WS_POPUP, 0,0,0,0, NULL, 0);
 
     // load up the NOTIFYICONDATA structure
@@ -121 +216 @@
     m_tnd.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
     m_tnd.uCallbackMessage = uCallbackMessage;
-    _tcsncpy(m_tnd.szTip, szToolTip, 64);
-
-    if (bInitialShow)
-    {
-        // Set the tray icon
-        VERIFY(m_bEnabled = Shell_NotifyIcon(NIM_ADD, &m_tnd));
-        return m_bEnabled;
-    }
-    else
-    {
-        m_bHidden = TRUE;
-        return TRUE;
-    }
-}
-#pragma warning(default : 4706)
+    _tcsncpy(m_tnd.szTip, szToolTip, m_nMaxTooltipLength-1);
+
+#ifdef SYSTEMTRAY_USEW2K
+    if (m_bWin2K && szBalloonTip)
+    {
+        // The balloon tooltip text can be up to 255 chars long.
+        ASSERT(AfxIsValidString(szBalloonTip));
+        ASSERT(lstrlen(szBalloonTip) < 256);
+
+        // The balloon title text can be up to 63 chars long.
+        if (szBalloonTitle)
+        {
+            ASSERT(AfxIsValidString(szBalloonTitle));
+            ASSERT(lstrlen(szBalloonTitle) < 64);
+        }
+
+        // dwBalloonIcon must be valid.
+        ASSERT(NIIF_NONE == dwBalloonIcon    || NIIF_INFO == dwBalloonIcon ||
+               NIIF_WARNING == dwBalloonIcon || NIIF_ERROR == dwBalloonIcon);
+
+        // The timeout must be between 10 and 30 seconds.
+        ASSERT(uBalloonTimeout >= 10 && uBalloonTimeout <= 30);
+
+        m_tnd.uFlags |= NIF_INFO;
+
+        _tcsncpy(m_tnd.szInfo, szBalloonTip, 255);
+        if (szBalloonTitle)
+            _tcsncpy(m_tnd.szInfoTitle, szBalloonTitle, 63);
+        else
+            m_tnd.szInfoTitle[0] = _T('\0');
+        m_tnd.uTimeout    = uBalloonTimeout * 1000; // convert time to ms
+        m_tnd.dwInfoFlags = dwBalloonIcon;
+    }
+#endif
+
+    m_bHidden = bHidden;
+
+#ifdef SYSTEMTRAY_USEW2K
+    if (m_bWin2K && m_bHidden)
+    {
+        m_tnd.uFlags = NIF_STATE;
+        m_tnd.dwState = NIS_HIDDEN;
+        m_tnd.dwStateMask = NIS_HIDDEN;
+    }
+#endif
+
+    m_uCreationFlags = m_tnd.uFlags;    // Store in case we need to recreate in OnTaskBarCreate
+
+    BOOL bResult = TRUE;
+    if (!m_bHidden || m_bWin2K)
+    {
+        bResult = Shell_NotifyIcon(NIM_ADD, &m_tnd);
+        m_bShowIconPending = m_bHidden = m_bRemoved = !bResult;
+    }
+    
+#ifdef SYSTEMTRAY_USEW2K    
+    if (m_bWin2K && szBalloonTip)
+    {
+        // Zero out the balloon text string so that later operations won't redisplay
+        // the balloon.
+        m_tnd.szInfo[0] = _T('\0');
+    }
+#endif
+
+    return bResult;
+}
 
 CSystemTray::~CSystemTray()
@@ -147 +293 @@
 // CSystemTray icon manipulation
 
-void CSystemTray::MoveToRight()
-{
-    HideIcon();
-    ShowIcon();
-}
-
-void CSystemTray::RemoveIcon()
-{
-    if (!m_bEnabled) return;
+//////////////////////////////////////////////////////////////////////////
+//
+// Function:    SetFocus()
+//
+// Description:
+//  Sets the focus to the tray icon.  Microsoft's Win 2K UI guidelines
+//  say you should do this after the user dismisses the icon's context
+//  menu.
+//
+// Input:
+//  Nothing.
+//
+// Returns:
+//  Nothing.
+//
+//////////////////////////////////////////////////////////////////////////
+// Added by Michael Dunn, November, 1999
+//////////////////////////////////////////////////////////////////////////
+
+void CSystemTray::SetFocus()
+{
+#ifdef SYSTEMTRAY_USEW2K
+    Shell_NotifyIcon ( NIM_SETFOCUS, &m_tnd );
+#endif
+}
+
+BOOL CSystemTray::MoveToRight()
+{
+    RemoveIcon();
+    return AddIcon();
+}
+
+BOOL CSystemTray::AddIcon()
+{
+    if (!m_bRemoved)
+        RemoveIcon();
+
+    if (m_bEnabled)
+    {
+        m_tnd.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
+        if (!Shell_NotifyIcon(NIM_ADD, &m_tnd))
+            m_bShowIconPending = TRUE;
+        else
+            m_bRemoved = m_bHidden = FALSE;
+    }
+    return (m_bRemoved == FALSE);
+}
+
+BOOL CSystemTray::RemoveIcon()
+{
+    m_bShowIconPending = FALSE;
+
+    if (!m_bEnabled || m_bRemoved)
+        return TRUE;
 
     m_tnd.uFlags = 0;
-    Shell_NotifyIcon(NIM_DELETE, &m_tnd);
-    m_bEnabled = FALSE;
-}
-
-void CSystemTray::HideIcon()
-{
-    if (m_bEnabled && !m_bHidden) {
-        m_tnd.uFlags = NIF_ICON;
-        Shell_NotifyIcon (NIM_DELETE, &m_tnd);
-        m_bHidden = TRUE;
-    }
-}
-
-void CSystemTray::ShowIcon()
-{
-    if (m_bEnabled && m_bHidden) {
-        m_tnd.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
-        Shell_NotifyIcon(NIM_ADD, &m_tnd);
+    if (Shell_NotifyIcon(NIM_DELETE, &m_tnd))
+        m_bRemoved = m_bHidden = TRUE;
+
+    return (m_bRemoved == TRUE);
+}
+
+BOOL CSystemTray::HideIcon()
+{
+    if (!m_bEnabled || m_bRemoved || m_bHidden)
+        return TRUE;
+
+#ifdef SYSTEMTRAY_USEW2K
+    if (m_bWin2K)
+    {
+        m_tnd.uFlags = NIF_STATE;
+        m_tnd.dwState = NIS_HIDDEN;
+        m_tnd.dwStateMask = NIS_HIDDEN;
+
+        m_bHidden = Shell_NotifyIcon( NIM_MODIFY, &m_tnd);
+    }
+    else
+#endif
+        RemoveIcon();
+
+    return (m_bHidden == TRUE);
+}
+
+BOOL CSystemTray::ShowIcon()
+{
+    if (m_bRemoved)
+        return AddIcon();
+
+    if (!m_bHidden)
+        return TRUE;
+
+#ifdef SYSTEMTRAY_USEW2K
+    if (m_bWin2K)
+    {
+        m_tnd.uFlags = NIF_STATE;
+        m_tnd.dwState = 0;
+        m_tnd.dwStateMask = NIS_HIDDEN;
+        Shell_NotifyIcon ( NIM_MODIFY, &m_tnd );
         m_bHidden = FALSE;
     }
+    else
+#endif
+        AddIcon();
+
+    return (m_bHidden == FALSE);
 }
 
 BOOL CSystemTray::SetIcon(HICON hIcon)
 {
-    if (!m_bEnabled) return FALSE;
-    if (m_tnd.hIcon == hIcon) return TRUE;
+    if (!m_bEnabled)
+        return FALSE;
 
     m_tnd.uFlags = NIF_ICON;
     m_tnd.hIcon = hIcon;
 
-    return Shell_NotifyIcon(NIM_MODIFY, &m_tnd);
+    if (m_bHidden)
+        return TRUE;
+    else
+        return Shell_NotifyIcon(NIM_MODIFY, &m_tnd);
 }
 
 BOOL CSystemTray::SetIcon(LPCTSTR lpszIconName)
 {
-    HICON hIcon = AfxGetApp()->LoadIcon(lpszIconName);
+    HICON hIcon = (HICON) ::LoadImage(AfxGetResourceHandle(), 
+                                      lpszIconName,
+                                      IMAGE_ICON, 
+                                      0, 0,
+                                      LR_DEFAULTCOLOR);
+    if (!hIcon)
+        return FALSE;
+
+    BOOL bSuccess = SetIcon(hIcon);
+    ::DestroyIcon(hIcon);
+
+    return bSuccess;
+}
+
+BOOL CSystemTray::SetIcon(UINT nIDResource)
+{
+    return SetIcon(MAKEINTRESOURCE(nIDResource));
+}
+
+BOOL CSystemTray::SetStandardIcon(LPCTSTR lpIconName)
+{
+    HICON hIcon = LoadIcon(NULL, lpIconName);
 
     return SetIcon(hIcon);
 }
 
-BOOL CSystemTray::SetIcon(UINT nIDResource)
-{
-    HICON hIcon = AfxGetApp()->LoadIcon(nIDResource);
-
-    return SetIcon(hIcon);
-}
-
-BOOL CSystemTray::SetStandardIcon(LPCTSTR lpIconName)
-{
-    HICON hIcon = LoadIcon(NULL, lpIconName);
-
-    return SetIcon(hIcon);
-}
-
 BOOL CSystemTray::SetStandardIcon(UINT nIDResource)
 {
-    HICON hIcon = LoadIcon(NULL, MAKEINTRESOURCE(nIDResource));
-
-    return SetIcon(hIcon);
+    return SetStandardIcon(MAKEINTRESOURCE(nIDResource));
 }
  
@@ -226 +454 @@
 BOOL CSystemTray::SetIconList(UINT uFirstIconID, UINT uLastIconID) 
 {
-    if (uFirstIconID > uLastIconID)
-        return FALSE;
-
-//    UINT uIconArraySize = uLastIconID - uFirstIconID + 1;
-    const CWinApp * pApp = AfxGetApp();
-    ASSERT(pApp != 0);
+    if (uFirstIconID > uLastIconID)
+        return FALSE;
+
+    const CWinApp* pApp = AfxGetApp();
+    if (!pApp)
+    {
+        ASSERT(FALSE);
+        return FALSE;
+    }
 
     m_IconList.RemoveAll();
-    try {
-        for (UINT i = uFirstIconID; i <= uLastIconID; i++)
-            m_IconList.Add(pApp->LoadIcon(i));
-    }
-    catch (CException *e)
-    {
-        REPORT_ERROR(e);
+    TRY {
+        for (UINT i = uFirstIconID; i <= uLastIconID; i++)
+            m_IconList.Add(pApp->LoadIcon(i));
+    }
+    CATCH(CMemoryException, e)
+    {
+        e->ReportError();
         e->Delete();
         m_IconList.RemoveAll();
         return FALSE;
     }
+    END_CATCH
 
     return TRUE;
@@ -253 +485 @@
     m_IconList.RemoveAll();
 
-    try {
-        for (UINT i = 0; i <= nNumIcons; i++)
-            m_IconList.Add(pHIconList[i]);
-    }
-    catch (CException *e)
-    {
-        REPORT_ERROR(e);
+    TRY {
+        for (UINT i = 0; i < nNumIcons; i++)
+            m_IconList.Add(pHIconList[i]);
+    }
+    CATCH (CMemoryException, e)
+    {
+        e->ReportError();
         e->Delete();
         m_IconList.RemoveAll();
         return FALSE;
     }
+    END_CATCH
 
     return TRUE;
@@ -270 +503 @@
 BOOL CSystemTray::Animate(UINT nDelayMilliSeconds, int nNumSeconds /*=-1*/)
 {
+    if (m_IconList.IsEmpty())
+        return FALSE;
+
     StopAnimation();
 
     m_nCurrentIcon = 0;
-    m_StartTime = GetTimeTimeZoneBased();
+    m_StartTime = COleDateTime::GetCurrentTime();
     m_nAnimationPeriod = nNumSeconds;
     m_hSavedIcon = GetIcon();
 
-    // Setup a timer for the animation
-    m_uIDTimer = SetTimer(m_nIDEvent, nDelayMilliSeconds, NULL);
+    // Setup a timer for the animation
+    m_uIDTimer = SetTimer(m_nTimerID, nDelayMilliSeconds, NULL);
 
     return (m_uIDTimer != 0);
@@ -300 +536 @@
 
     if (m_uIDTimer)
-        bResult = KillTimer(m_uIDTimer);
+        bResult = KillTimer(m_uIDTimer);
     m_uIDTimer = 0;
 
@@ -315 +551 @@
 BOOL CSystemTray::SetTooltipText(LPCTSTR pszTip)
 {
-    if (!m_bEnabled) return FALSE;
+    ASSERT(AfxIsValidString(pszTip)); // (md)
+    ASSERT(_tcslen(pszTip) < m_nMaxTooltipLength);
+
+    if (!m_bEnabled) 
+        return FALSE;
 
     m_tnd.uFlags = NIF_TIP;
-    _tcsncpy(m_tnd.szTip, pszTip, 64);
-
-    return Shell_NotifyIcon(NIM_MODIFY, &m_tnd);
+    _tcsncpy(m_tnd.szTip, pszTip, m_nMaxTooltipLength-1);
+
+    if (m_bHidden)
+        return TRUE;
+    else
+        return Shell_NotifyIcon(NIM_MODIFY, &m_tnd);
 }
 
@@ -326 +569 @@
 {
     CString strText;
-
-    try
-    {
-        VERIFY(strText.LoadString(nID));
-    }
-    catch (...)
-    {
-        strText.Empty();
-    }
+    VERIFY(strText.LoadString(nID));
 
     return SetTooltipText(strText);
@@ -349 +584 @@
 
 /////////////////////////////////////////////////////////////////////////////
+// CSystemTray support for Win 2K features.
+
+//////////////////////////////////////////////////////////////////////////
+//
+// Function:    ShowBalloon
+//
+// Description:
+//  Shows a balloon tooltip over the tray icon.
+//
+// Input:
+//  szText: [in] Text for the balloon tooltip.
+//  szTitle: [in] Title for the balloon.  This text is shown in bold above
+//           the tooltip text (szText).  Pass "" if you don't want a title.
+//  dwIcon: [in] Specifies an icon to appear in the balloon.  Legal values are:
+//                 NIIF_NONE: No icon
+//                 NIIF_INFO: Information
+//                 NIIF_WARNING: Exclamation
+//                 NIIF_ERROR: Critical error (red circle with X)
+//  uTimeout: [in] Number of seconds for the balloon to remain visible.  Can
+//            be between 10 and 30 inclusive.
+//
+// Returns:
+//  TRUE if successful, FALSE if not.
+//
+//////////////////////////////////////////////////////////////////////////
+// Added by Michael Dunn, November 1999
+//////////////////////////////////////////////////////////////////////////
+
+BOOL CSystemTray::ShowBalloon(LPCTSTR szText,
+                              LPCTSTR szTitle  /*=NULL*/,
+                              DWORD   dwIcon   /*=NIIF_NONE*/,
+                              UINT    uTimeout /*=10*/ )
+{
+#ifndef SYSTEMTRAY_USEW2K
+    return FALSE;
+#else
+    // Bail out if we're not on Win 2K.
+    if (!m_bWin2K)
+        return FALSE;
+
+    // Verify input parameters.
+
+    // The balloon tooltip text can be up to 255 chars long.
+    ASSERT(AfxIsValidString(szText));
+    ASSERT(lstrlen(szText) < 256);
+
+    // The balloon title text can be up to 63 chars long.
+    if (szTitle)
+    {
+        ASSERT(AfxIsValidString( szTitle));
+        ASSERT(lstrlen(szTitle) < 64);
+    }
+
+    // dwBalloonIcon must be valid.
+    ASSERT(NIIF_NONE == dwIcon    || NIIF_INFO == dwIcon ||
+           NIIF_WARNING == dwIcon || NIIF_ERROR == dwIcon);
+
+    // The timeout must be between 10 and 30 seconds.
+    ASSERT(uTimeout >= 10 && uTimeout <= 30);
+
+
+    m_tnd.uFlags = NIF_INFO;
+    _tcsncpy(m_tnd.szInfo, szText, 256);
+    if (szTitle)
+        _tcsncpy(m_tnd.szInfoTitle, szTitle, 64);
+    else
+        m_tnd.szInfoTitle[0] = _T('\0');
+    m_tnd.dwInfoFlags = dwIcon;
+    m_tnd.uTimeout = uTimeout * 1000;   // convert time to ms
+
+    BOOL bSuccess = Shell_NotifyIcon (NIM_MODIFY, &m_tnd);
+
+    // Zero out the balloon text string so that later operations won't redisplay
+    // the balloon.
+    m_tnd.szInfo[0] = _T('\0');
+
+    return bSuccess;
+#endif
+}
+
+/////////////////////////////////////////////////////////////////////////////
 // CSystemTray notification window stuff
 
 BOOL CSystemTray::SetNotificationWnd(CWnd* pWnd)
 {
-    if (!m_bEnabled) return FALSE;
+    if (!m_bEnabled) 
+        return FALSE;
 
     // Make sure Notification window is valid
-    ASSERT(pWnd && ::IsWindow(pWnd->GetSafeHwnd()));
+    if (!pWnd || !::IsWindow(pWnd->GetSafeHwnd()))
+    {
+        ASSERT(FALSE);
+        return FALSE;
+    }
 
     m_tnd.hWnd = pWnd->GetSafeHwnd();
     m_tnd.uFlags = 0;
 
-    return Shell_NotifyIcon(NIM_MODIFY, &m_tnd);
+    if (m_bHidden)
+        return TRUE;
+    else
+        return Shell_NotifyIcon(NIM_MODIFY, &m_tnd);
 }
 
@@ -367 +691 @@
 {
     return CWnd::FromHandle(m_tnd.hWnd);
+}
+
+// Hatr added
+
+// Hatr added
+
+// Change or retrive the window to send menu commands to
+BOOL CSystemTray::SetTargetWnd(CWnd* pTargetWnd)
+{
+    m_pTargetWnd = pTargetWnd;
+    return TRUE;
+} // CSystemTray::SetTargetWnd()
+
+CWnd* CSystemTray::GetTargetWnd() const
+{
+    if (m_pTargetWnd)
+        return m_pTargetWnd;
+    else
+        return AfxGetMainWnd();
+} // CSystemTray::GetTargetWnd()
+
+/////////////////////////////////////////////////////////////////////////////
+// CSystemTray notification message stuff
+
+BOOL CSystemTray::SetCallbackMessage(UINT uCallbackMessage)
+{
+    if (!m_bEnabled)
+        return FALSE;
+
+    // Make sure we avoid conflict with other messages
+    ASSERT(uCallbackMessage >= WM_APP);
+
+    m_tnd.uCallbackMessage = uCallbackMessage;
+    m_tnd.uFlags = NIF_MESSAGE;
+
+    if (m_bHidden)
+        return TRUE;
+    else
+        return Shell_NotifyIcon(NIM_MODIFY, &m_tnd);
+}
+
+UINT CSystemTray::GetCallbackMessage() const
+{
+    return m_tnd.uCallbackMessage;
 }
 
@@ -374 +742 @@
 BOOL CSystemTray::SetMenuDefaultItem(UINT uItem, BOOL bByPos)
 {
+#ifdef _WIN32_WCE
+    return FALSE;
+#else
     if ((m_DefaultMenuItemID == uItem) && (m_DefaultMenuItemByPos == bByPos)) 
         return TRUE;
@@ -382 +753 @@
     CMenu menu, *pSubMenu;
 
-    if (!menu.LoadMenu(m_tnd.uID)) return FALSE;
+    if (!menu.LoadMenu(m_tnd.uID))
+        return FALSE;
 
     pSubMenu = menu.GetSubMenu(0);
-    if (!pSubMenu) return FALSE;
+    if (!pSubMenu)
+        return FALSE;
 
     ::SetMenuDefaultItem(pSubMenu->m_hMenu, m_DefaultMenuItemID, m_DefaultMenuItemByPos);
 
-    menu.DestroyMenu();
-
     return TRUE;
+#endif
 }
 
@@ -404 +776 @@
 
 BEGIN_MESSAGE_MAP(CSystemTray, CWnd)
-    //{{AFX_MSG_MAP(CSystemTray)
-    ON_WM_TIMER()
-    //}}AFX_MSG_MAP
+    //{{AFX_MSG_MAP(CSystemTray)
+    ON_WM_TIMER()
+    //}}AFX_MSG_MAP
+#ifndef _WIN32_WCE
+    ON_WM_SETTINGCHANGE()
+#endif
+    ON_REGISTERED_MESSAGE(CSystemTray::m_nTaskbarCreatedMsg, OnTaskbarCreated)
 END_MESSAGE_MAP()
 
 void CSystemTray::OnTimer(UINT_PTR nIDEvent) 
 {
-    UNUSED(nIDEvent);
-    ASSERT(nIDEvent == m_nIDEvent);
-
-    COleDateTime CurrentTime = GetTimeTimeZoneBased();
+    if (nIDEvent != m_uIDTimer)
+    {
+        ASSERT(FALSE);
+        return;
+    }
+
+    COleDateTime CurrentTime = COleDateTime::GetCurrentTime();
     COleDateTimeSpan period = CurrentTime - m_StartTime;
+
     if (m_nAnimationPeriod > 0 && m_nAnimationPeriod < period.GetTotalSeconds())
     {
@@ -425 +805 @@
 }
 
-void CSystemTray::DeleteItem(UINT uItem)
-{
-    m_ItemsToDelete.Add(uItem);
-}
-
-void CSystemTray::CheckItem(UINT uItem)
-{
-    m_ItemsToCheck.Add(uItem);
-}
-
-void CSystemTray::DisableItem(UINT uItem)
-{
-    m_ItemsToDisable.Add(uItem);
-}
-
-void CSystemTray::CleanCheckList()
-{
-    m_ItemsToCheck.RemoveAll();
-}
-
-void CSystemTray::CleanDisableList()
-{
-    m_ItemsToDisable.RemoveAll();
-}
-
-void CSystemTray::CleanDeleteList()
-{
-    m_ItemsToDelete.RemoveAll();
-}
+// This is called whenever the taskbar is created (eg after explorer crashes
+// and restarts. Please note that the WM_TASKBARCREATED message is only passed
+// to TOP LEVEL windows (like WM_QUERYNEWPALETTE)
+LRESULT CSystemTray::OnTaskbarCreated(WPARAM /*wParam*/, LPARAM /*lParam*/) 
+{
+    m_bShowIconPending = TRUE; // !m_bHidden;
+    InstallIconPending();
+
+    return 0L;
+}
+
+#ifndef _WIN32_WCE
+void CSystemTray::OnSettingChange(UINT uFlags, LPCTSTR lpszSection) 
+{
+    CWnd::OnSettingChange(uFlags, lpszSection);
+
+    if (uFlags == SPI_SETWORKAREA)
+    {
+        m_bShowIconPending = !m_bHidden;
+        InstallIconPending();   
+    }
+}
+#endif
 
 LRESULT CSystemTray::OnTrayNotification(WPARAM wParam, LPARAM lParam) 
@@ -459 +833 @@
     //Return quickly if its not for this tray icon
     if (wParam != m_tnd.uID)
-        return(0L);
+        return 0L;
 
     CMenu menu, *pSubMenu;
-    CWnd* pTarget = AfxGetMainWnd();
-
-    // sanity check - st@iki.fi
-    if (!IsWindow(pTarget->GetSafeHwnd()))
-        return(0);
+    CWnd *pTargetWnd = GetTargetWnd();
+    if (!pTargetWnd)
+        return 0L;
 
     // Clicking with right button brings up a context menu
+#if defined(_WIN32_WCE) //&& _WIN32_WCE < 211
+    BOOL bAltPressed = ((GetKeyState(VK_MENU) & (1 << (sizeof(SHORT)*8-1))) != 0);
+    if (LOWORD(lParam) == WM_LBUTTONUP && bAltPressed)
+#else
     if (LOWORD(lParam) == WM_RBUTTONUP)
+#endif
     {    
-        if (!menu.LoadMenu(m_tnd.uID)) return(0);
+        if (!menu.LoadMenu(m_tnd.uID))
+            return 0;
         
         pSubMenu = menu.GetSubMenu(0);
-        if (!pSubMenu) return(0);
-
+        if (!pSubMenu)
+            return 0;
+
+#ifndef _WIN32_WCE
         // Make chosen menu item the default (bold font)
         ::SetMenuDefaultItem(pSubMenu->m_hMenu, m_DefaultMenuItemID, m_DefaultMenuItemByPos);
-
-        // Delete unwanted items
-        UINT uIndex, uSize = m_ItemsToDelete.GetSize();
-        for (uIndex = 0; uIndex < uSize; uIndex++)
-            pSubMenu->DeleteMenu(m_ItemsToDelete[uIndex], MF_BYCOMMAND);
-
-        // Check items
-        uSize = m_ItemsToCheck.GetSize();
-        for (uIndex = 0; uIndex < uSize; uIndex++)
-            pSubMenu->CheckMenuItem(m_ItemsToCheck[uIndex], MF_BYCOMMAND | MF_CHECKED);
-
-        // Disable items
-        uSize = m_ItemsToDisable.GetSize();
-        for (uIndex = 0; uIndex < uSize; uIndex++)
-            pSubMenu->EnableMenuItem(m_ItemsToDisable[uIndex], MF_DISABLED | MF_GRAYED | MF_BYCOMMAND);
+#endif
+
+        CustomizeMenu(pSubMenu);
 
         // Display and track the popup menu
         CPoint pos;
+#ifdef _WIN32_WCE
+        pos = CPoint(GetMessagePos());
+#else
         GetCursorPos(&pos);
-
-        pTarget->SetForegroundWindow();  
+#endif
+
+        pTargetWnd->SetForegroundWindow(); 
+        
+#ifndef _WIN32_WCE
         ::TrackPopupMenu(pSubMenu->m_hMenu, 0, pos.x, pos.y, 0, 
-                         pTarget->GetSafeHwnd(), NULL);
+                         pTargetWnd->GetSafeHwnd(), NULL);
+#else
+        pSubMenu->TrackPopupMenu(TPM_LEFTALIGN, pos.x, pos.y, pTargetWnd, NULL);
+#endif
 
         // BUGFIX: See "PRB: Menus for Notification Icons Don't Work Correctly"
-        pTarget->PostMessage(WM_NULL, 0, 0);
+        pTargetWnd->PostMessage(WM_NULL, 0, 0);
 
         menu.DestroyMenu();
     } 
+#if defined(_WIN32_WCE) //&& _WIN32_WCE < 211
+    if (LOWORD(lParam) == WM_LBUTTONDBLCLK && bAltPressed)
+#else
     else if (LOWORD(lParam) == WM_LBUTTONDBLCLK) 
+#endif
     {
         // double click received, the default action is to execute default menu item
-        pTarget->SetForegroundWindow();  
+        pTargetWnd->SetForegroundWindow();  
 
         UINT uItem;
         if (m_DefaultMenuItemByPos)
         {
-            if (!menu.LoadMenu(m_tnd.uID)) return(0);
+            if (!menu.LoadMenu(m_tnd.uID))
+                return 0;
+            
             pSubMenu = menu.GetSubMenu(0);
-            if (!pSubMenu) return(0);
-
+            if (!pSubMenu)
+                return 0;
+            
             uItem = pSubMenu->GetMenuItemID(m_DefaultMenuItemID);
+
+            menu.DestroyMenu();
         }
         else
             uItem = m_DefaultMenuItemID;
         
-        pTarget->SendMessage(WM_COMMAND, uItem, 0);
-
-        menu.DestroyMenu();
-    }
-
-    return(1);
+        pTargetWnd->PostMessage(WM_COMMAND, uItem, 0);
+    }
+
+    return 1;
 }
 
@@ -536 +920 @@
     if (message == m_tnd.uCallbackMessage)
         return OnTrayNotification(wParam, lParam);
+    
+    return CWnd::WindowProc(message, wParam, lParam);
+}
+
+void CSystemTray::InstallIconPending()
+{
+    // Is the icon display pending, and it's not been set as "hidden"?
+    if (!m_bShowIconPending || m_bHidden)
+        return;
+
+    // Reset the flags to what was used at creation
+    m_tnd.uFlags = m_uCreationFlags;
+
+    // Try and recreate the icon
+    m_bHidden = !Shell_NotifyIcon(NIM_ADD, &m_tnd);
+
+    // If it's STILL hidden, then have another go next time...
+    m_bShowIconPending = m_bHidden;
+
+    ASSERT(m_bHidden == FALSE);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// For minimising/maximising from system tray
+
+BOOL CALLBACK FindTrayWnd(HWND hwnd, LPARAM lParam)
+{
+    TCHAR szClassName[256];
+    GetClassName(hwnd, szClassName, 255);
+
+    // Did we find the Main System Tray? If so, then get its size and keep going
+    if (_tcscmp(szClassName, _T("TrayNotifyWnd")) == 0)
+    {
+        CRect *pRect = (CRect*) lParam;
+        ::GetWindowRect(hwnd, pRect);
+        return TRUE;
+    }
+
+    // Did we find the System Clock? If so, then adjust the size of the rectangle
+    // we have and quit (clock will be found after the system tray)
+    if (_tcscmp(szClassName, _T("TrayClockWClass")) == 0)
+    {
+        CRect *pRect = (CRect*) lParam;
+        CRect rectClock;
+        ::GetWindowRect(hwnd, rectClock);
+        // if clock is above system tray adjust accordingly
+        if (rectClock.bottom < pRect->bottom-5) // 10 = random fudge factor.
+            pRect->top = rectClock.bottom;
+        else
+            pRect->right = rectClock.left;
+        return FALSE;
+    }
+ 
+    return TRUE;
+}
+ 
+#ifndef _WIN32_WCE
+// enhanced version by Matthew Ellis <m.t.ellis@bigfoot.com>
+void CSystemTray::GetTrayWndRect(LPRECT lprect)
+{
+#define DEFAULT_RECT_WIDTH 150
+#define DEFAULT_RECT_HEIGHT 30
+
+    HWND hShellTrayWnd = ::FindWindow(_T("Shell_TrayWnd"), NULL);
+    if (hShellTrayWnd)
+    {
+        ::GetWindowRect(hShellTrayWnd, lprect);
+        EnumChildWindows(hShellTrayWnd, FindTrayWnd, (LPARAM)lprect);
+        return;
+    }
+    // OK, we failed to get the rect from the quick hack. Either explorer isn't
+    // running or it's a new version of the shell with the window class names
+    // changed (how dare Microsoft change these undocumented class names!) So, we
+    // try to find out what side of the screen the taskbar is connected to. We
+    // know that the system tray is either on the right or the bottom of the
+    // taskbar, so we can make a good guess at where to minimize to
+    APPBARDATA appBarData;
+    appBarData.cbSize=sizeof(appBarData);
+    if (SHAppBarMessage(ABM_GETTASKBARPOS,&appBarData))
+    {
+        // We know the edge the taskbar is connected to, so guess the rect of the
+        // system tray. Use various fudge factor to make it look good
+        switch(appBarData.uEdge)
+        {
+        case ABE_LEFT:
+        case ABE_RIGHT:
+            // We want to minimize to the bottom of the taskbar
+            lprect->top    = appBarData.rc.bottom-100;
+            lprect->bottom = appBarData.rc.bottom-16;
+            lprect->left   = appBarData.rc.left;
+            lprect->right  = appBarData.rc.right;
+            break;
+            
+        case ABE_TOP:
+        case ABE_BOTTOM:
+            // We want to minimize to the right of the taskbar
+            lprect->top    = appBarData.rc.top;
+            lprect->bottom = appBarData.rc.bottom;
+            lprect->left   = appBarData.rc.right-100;
+            lprect->right  = appBarData.rc.right-16;
+            break;
+        }
+        return;
+    }
     
-    return CWnd::WindowProc(message, wParam, lParam);
-}
+    // Blimey, we really aren't in luck. It's possible that a third party shell
+    // is running instead of explorer. This shell might provide support for the
+    // system tray, by providing a Shell_TrayWnd window (which receives the
+    // messages for the icons) So, look for a Shell_TrayWnd window and work out
+    // the rect from that. Remember that explorer's taskbar is the Shell_TrayWnd,
+    // and stretches either the width or the height of the screen. We can't rely
+    // on the 3rd party shell's Shell_TrayWnd doing the same, in fact, we can't
+    // rely on it being any size. The best we can do is just blindly use the
+    // window rect, perhaps limiting the width and height to, say 150 square.
+    // Note that if the 3rd party shell supports the same configuraion as
+    // explorer (the icons hosted in NotifyTrayWnd, which is a child window of
+    // Shell_TrayWnd), we would already have caught it above
+    if (hShellTrayWnd)
+    {
+        ::GetWindowRect(hShellTrayWnd, lprect);
+        if (lprect->right - lprect->left > DEFAULT_RECT_WIDTH)
+            lprect->left = lprect->right - DEFAULT_RECT_WIDTH;
+        if (lprect->bottom - lprect->top > DEFAULT_RECT_HEIGHT)
+            lprect->top = lprect->bottom - DEFAULT_RECT_HEIGHT;
+        
+        return;
+    }
+    
+    // OK. Haven't found a thing. Provide a default rect based on the current work
+    // area
+    SystemParametersInfo(SPI_GETWORKAREA,0, lprect, 0);
+    lprect->left = lprect->right - DEFAULT_RECT_WIDTH;
+    lprect->top  = lprect->bottom - DEFAULT_RECT_HEIGHT;
+}
+
+// Check to see if the animation has been disabled (Matthew Ellis <m.t.ellis@bigfoot.com>)
+BOOL CSystemTray::GetDoWndAnimation()
+{
+  ANIMATIONINFO ai;
+
+  ai.cbSize=sizeof(ai);
+  SystemParametersInfo(SPI_GETANIMATION,sizeof(ai),&ai,0);
+
+  return ai.iMinAnimate?TRUE:FALSE;
+}
+#endif
+
+BOOL CSystemTray::RemoveTaskbarIcon(CWnd* pWnd)
+{
+    LPCTSTR pstrOwnerClass = AfxRegisterWndClass(0);
+
+    // Create static invisible window
+    if (!::IsWindow(m_wndInvisible.m_hWnd))
+    {
+        if (!m_wndInvisible.CreateEx(0, pstrOwnerClass, _T(""), WS_POPUP,
+                CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+                NULL, 0))
+            return FALSE;
+    }
+
+    pWnd->SetParent(&m_wndInvisible);
+
+    return TRUE;
+}
+
+void CSystemTray::MinimiseToTray(CWnd* pWnd, BOOL bForceAnimation /*= FALSE*/)
+{
+#ifndef _WIN32_WCE
+    if (bForceAnimation || GetDoWndAnimation())
+    {
+        CRect rectFrom, rectTo;
+
+        pWnd->GetWindowRect(rectFrom);
+        GetTrayWndRect(rectTo);
+
+        ::DrawAnimatedRects(pWnd->m_hWnd, IDANI_CAPTION, rectFrom, rectTo);
+    }
+
+    RemoveTaskbarIcon(pWnd);
+    pWnd->ModifyStyle(WS_VISIBLE, 0);
+#endif
+}
+
+void CSystemTray::MaximiseFromTray(CWnd* pWnd, BOOL bForceAnimation /*= TRUE*/)
+{
+#ifndef _WIN32_WCE
+    if (bForceAnimation || GetDoWndAnimation())
+    {
+        CRect rectTo;
+        pWnd->GetWindowRect(rectTo);
+
+        CRect rectFrom;
+        GetTrayWndRect(rectFrom);
+
+        pWnd->SetParent(NULL);
+        ::DrawAnimatedRects(pWnd->m_hWnd, IDANI_CAPTION, rectFrom, rectTo);
+    }
+    else
+        pWnd->SetParent(NULL);
+
+    pWnd->ModifyStyle(0, WS_VISIBLE);
+    pWnd->RedrawWindow(NULL, NULL, RDW_UPDATENOW | RDW_ALLCHILDREN | RDW_FRAME |
+                                   RDW_INVALIDATE | RDW_ERASE);
+
+    // Move focus away and back again to ensure taskbar icon is recreated
+    if (::IsWindow(m_wndInvisible.m_hWnd))
+        m_wndInvisible.SetActiveWindow();
+    pWnd->SetActiveWindow();
+    pWnd->SetForegroundWindow();
+#endif
+}