dll/win32/shell32/CUserNotification.cpp

   1 /*
   2  * Copyright 2018 Hermes Belusca-Maito
   3  *
   4  * Pass on icon notification messages to the systray implementation
   5  * in the currently running shell.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #include "precomp.h"
  23
  24 #include <mmsystem.h>
  25 #undef PlaySound
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(shell_notify);
  28
  29
  30 /* Use Windows-compatible window callback message */
  31 #define WM_TRAYNOTIFY   (WM_USER + 100)
  32
  33 /* Notification icon ID */
  34 #define ID_NOTIFY_ICON  0
  35
  36 /* Balloon timers */
  37 #define ID_BALLOON_TIMEOUT      1
  38 #define ID_BALLOON_DELAYREMOVE  2
  39 #define ID_BALLOON_QUERYCONT    3
  40 #define ID_BALLOON_SHOWTIME     4
  41
  42 #define BALLOON_DELAYREMOVE_TIMEOUT 250 // milliseconds
  43
  44
  45 CUserNotification::CUserNotification() :
  46     m_hWorkerWnd(NULL),
  47     m_hIcon(NULL),
  48     m_dwInfoFlags(0),
  49     m_uShowTime(15000),
  50     m_uInterval(10000),
  51     m_cRetryCount(-1),
  52     m_uContinuePoolInterval(0),
  53     m_bIsShown(FALSE),
  54     m_hRes(S_OK),
  55     m_pqc(NULL)
  56 {
  57 }
  58
  59 CUserNotification::~CUserNotification()
  60 {
  61     /* If we have a notification window... */
  62     if (m_hWorkerWnd)
  63     {
  64         /* ... remove the notification icon and destroy the window */
  65         RemoveIcon();
  66         ::DestroyWindow(m_hWorkerWnd);
  67         m_hWorkerWnd = NULL;
  68     }
  69
  70     /* Destroy our local icon copy */
  71     if (m_hIcon)
  72         ::DestroyIcon(m_hIcon);
  73 }
  74
  75 VOID CUserNotification::RemoveIcon()
  76 {
  77     NOTIFYICONDATAW nid = {0};
  78
  79     nid.cbSize = NOTIFYICONDATAW_V3_SIZE; // sizeof(nid);
  80     nid.hWnd = m_hWorkerWnd;
  81     nid.uID  = ID_NOTIFY_ICON;
  82
  83     /* Remove the notification icon */
  84     ::Shell_NotifyIconW(NIM_DELETE, &nid);
  85 }
  86
  87 VOID CUserNotification::DelayRemoveIcon(IN HRESULT hRes)
  88 {
  89     /* Set the return value for CUserNotification::Show() and defer icon removal */
  90     m_hRes = hRes;
  91     ::SetTimer(m_hWorkerWnd, ID_BALLOON_DELAYREMOVE,
  92                BALLOON_DELAYREMOVE_TIMEOUT, NULL);
  93 }
  94
  95 VOID CUserNotification::TimeoutIcon()
  96 {
  97     /*
  98      * The balloon timed out, we need to wait before showing it again.
  99      * If we retried too many times, delete the notification icon.
 100      */
 101     if (m_cRetryCount > 0)
 102     {
 103         /* Decrement the retry count */
 104         --m_cRetryCount;
 105
 106         /* Set the timeout interval timer */
 107         ::SetTimer(m_hWorkerWnd, ID_BALLOON_TIMEOUT, m_uInterval, NULL);
 108     }
 109     else
 110     {
 111         /* No other retry: delete the notification icon */
 112         DelayRemoveIcon(HRESULT_FROM_WIN32(ERROR_CANCELLED));
 113     }
 114 }
 115
 116 VOID CUserNotification::SetUpNotifyData(
 117     IN UINT uFlags,
 118     IN OUT PNOTIFYICONDATAW pnid)
 119 {
 120     pnid->cbSize = NOTIFYICONDATAW_V3_SIZE; // sizeof(nid);
 121     pnid->hWnd = m_hWorkerWnd;
 122     pnid->uID  = ID_NOTIFY_ICON;
 123     // pnid->uVersion = NOTIFYICON_VERSION;
 124
 125     if (uFlags & NIF_MESSAGE)
 126     {
 127         pnid->uFlags |= NIF_MESSAGE;
 128         pnid->uCallbackMessage = WM_TRAYNOTIFY;
 129     }
 130
 131     if (uFlags & NIF_ICON)
 132     {
 133         pnid->uFlags |= NIF_ICON;
 134         /* Use a default icon if we do not have one already */
 135         pnid->hIcon = (m_hIcon ? m_hIcon : LoadIcon(NULL, IDI_WINLOGO));
 136     }
 137
 138     if (uFlags & NIF_TIP)
 139     {
 140         pnid->uFlags |= NIF_TIP;
 141         ::StringCchCopyW(pnid->szTip, _countof(pnid->szTip), m_szTip);
 142     }
 143
 144     if (uFlags & NIF_INFO)
 145     {
 146         pnid->uFlags |= NIF_INFO;
 147
 148         // pnid->uTimeout    = m_uShowTime; // NOTE: Deprecated
 149         pnid->dwInfoFlags = m_dwInfoFlags;
 150
 151         ::StringCchCopyW(pnid->szInfo, _countof(pnid->szInfo), m_szInfo);
 152         ::StringCchCopyW(pnid->szInfoTitle, _countof(pnid->szInfoTitle), m_szInfoTitle);
 153     }
 154 }
 155
 156
 157 /* IUserNotification Implementation */
 158
 159 HRESULT STDMETHODCALLTYPE
 160 CUserNotification::SetBalloonInfo(
 161     IN LPCWSTR pszTitle,
 162     IN LPCWSTR pszText,
 163     IN DWORD dwInfoFlags)
 164 {
 165     NOTIFYICONDATAW nid = {0};
 166
 167     m_szInfo      = pszText;
 168     m_szInfoTitle = pszTitle;
 169     m_dwInfoFlags = dwInfoFlags;
 170
 171     /* Update the notification icon if we have one */
 172     if (!m_hWorkerWnd)
 173         return S_OK;
 174
 175     /* Modify the notification icon */
 176     SetUpNotifyData(NIF_INFO, &nid);
 177     if (::Shell_NotifyIconW(NIM_MODIFY, &nid))
 178         return S_OK;
 179     else
 180         return E_FAIL;
 181 }
 182
 183 HRESULT STDMETHODCALLTYPE
 184 CUserNotification::SetBalloonRetry(
 185     IN DWORD dwShowTime,  // Time intervals in milliseconds
 186     IN DWORD dwInterval,
 187     IN UINT cRetryCount)
 188 {
 189     m_uShowTime   = dwShowTime;
 190     m_uInterval   = dwInterval;
 191     m_cRetryCount = cRetryCount;
 192     return S_OK;
 193 }
 194
 195 HRESULT STDMETHODCALLTYPE
 196 CUserNotification::SetIconInfo(
 197     IN HICON hIcon,
 198     IN LPCWSTR pszToolTip)
 199 {
 200     NOTIFYICONDATAW nid = {0};
 201
 202     /* Destroy our local icon copy */
 203     if (m_hIcon)
 204         ::DestroyIcon(m_hIcon);
 205
 206     if (hIcon)
 207     {
 208         /* Copy the icon from the user */
 209         m_hIcon = ::CopyIcon(hIcon);
 210     }
 211     else
 212     {
 213         /* Use the same icon as the one for the balloon if specified */
 214         UINT uIcon = (m_dwInfoFlags & NIIF_ICON_MASK);
 215         LPCWSTR pIcon = NULL;
 216
 217         if (uIcon == NIIF_INFO)
 218             pIcon = IDI_INFORMATION;
 219         else if (uIcon == NIIF_WARNING)
 220             pIcon = IDI_WARNING;
 221         else if (uIcon == NIIF_ERROR)
 222             pIcon = IDI_ERROR;
 223         else if (uIcon == NIIF_USER)
 224             pIcon = NULL;
 225
 226         m_hIcon = (pIcon ? ::LoadIconW(NULL, pIcon) : NULL);
 227     }
 228
 229     m_szTip = pszToolTip;
 230
 231     /* Update the notification icon if we have one */
 232     if (!m_hWorkerWnd)
 233         return S_OK;
 234
 235     /* Modify the notification icon */
 236     SetUpNotifyData(NIF_ICON | NIF_TIP, &nid);
 237     if (::Shell_NotifyIconW(NIM_MODIFY, &nid))
 238         return S_OK;
 239     else
 240         return E_FAIL;
 241 }
 242
 243
 244 LRESULT CALLBACK
 245 CUserNotification::WorkerWndProc(
 246     IN HWND hWnd,
 247     IN UINT uMsg,
 248     IN WPARAM wParam,
 249     IN LPARAM lParam)
 250 {
 251     /* Retrieve the current user notification object stored in the window extra bits */
 252     CUserNotification* pThis = reinterpret_cast<CUserNotification*>(::GetWindowLongPtrW(hWnd, 0));
 253     ASSERT(pThis);
 254     ASSERT(hWnd == pThis->m_hWorkerWnd);
 255
 256     TRACE("Msg = 0x%x\n", uMsg);
 257     switch (uMsg)
 258     {
 259         /*
 260          * We do not receive any WM_(NC)CREATE message since worker windows
 261          * are first created using the default window procedure DefWindowProcW.
 262          * The window procedure is changed only subsequently to the user one.
 263          * We however receive WM_(NC)DESTROY messages.
 264          */
 265         case WM_DESTROY:
 266         {
 267             /* Post a WM_QUIT message only if the Show() method's message loop is running */
 268             if (pThis->m_bIsShown)
 269                 ::PostQuitMessage(0);
 270             return 0;
 271         }
 272
 273         case WM_NCDESTROY:
 274         {
 275             ::SetWindowLongPtrW(hWnd, 0, (LONG_PTR)NULL);
 276             pThis->m_hWorkerWnd = NULL;
 277             return 0;
 278         }
 279
 280         case WM_QUERYENDSESSION:
 281         {
 282             /*
 283              * User session is ending or a shutdown is occurring: perform cleanup.
 284              * Set the return value for CUserNotification::Show() and remove the notification.
 285              */
 286             pThis->m_hRes = HRESULT_FROM_WIN32(ERROR_CANCELLED);
 287             pThis->RemoveIcon();
 288             ::DestroyWindow(pThis->m_hWorkerWnd);
 289             return TRUE;
 290         }
 291
 292         case WM_TIMER:
 293         {
 294             TRACE("WM_TIMER(0x%lx)\n", wParam);
 295
 296             /* Destroy the associated timer */
 297             ::KillTimer(hWnd, (UINT_PTR)wParam);
 298
 299             if (wParam == ID_BALLOON_TIMEOUT)
 300             {
 301                 /* Timeout interval timer expired: display the balloon again */
 302                 NOTIFYICONDATAW nid = {0};
 303                 pThis->SetUpNotifyData(NIF_INFO, &nid);
 304                 ::Shell_NotifyIconW(NIM_MODIFY, &nid);
 305             }
 306             else if (wParam == ID_BALLOON_DELAYREMOVE)
 307             {
 308                 /* Delay-remove timer expired: remove the notification */
 309                 pThis->RemoveIcon();
 310                 ::DestroyWindow(pThis->m_hWorkerWnd);
 311             }
 312             else if (wParam == ID_BALLOON_QUERYCONT)
 313             {
 314                 /*
 315                  * Query-continue timer expired: ask the user whether the
 316                  * notification should continue to be displayed or not.
 317                  */
 318                 if (pThis->m_pqc && pThis->m_pqc->QueryContinue() == S_OK)
 319                 {
 320                     /* The notification can be displayed */
 321                     ::SetTimer(hWnd, ID_BALLOON_QUERYCONT, pThis->m_uContinuePoolInterval, NULL);
 322                 }
 323                 else
 324                 {
 325                     /* The notification should be removed */
 326                     pThis->DelayRemoveIcon(S_FALSE);
 327                 }
 328             }
 329             else if (wParam == ID_BALLOON_SHOWTIME)
 330             {
 331                 /* Show-time timer expired: wait before showing the balloon again */
 332                 pThis->TimeoutIcon();
 333             }
 334             return 0;
 335         }
 336
 337         /*
 338          * Shell User Notification message.
 339          * We use NOTIFYICON_VERSION == 0 or 3 callback version, with:
 340          * wParam == identifier of the taskbar icon in which the event occurred;
 341          * lParam == holds the mouse or keyboard message associated with the event.
 342          */
 343         case WM_TRAYNOTIFY:
 344         {
 345             TRACE("WM_TRAYNOTIFY - wParam = 0x%lx ; lParam = 0x%lx\n", wParam, lParam);
 346             ASSERT(wParam == ID_NOTIFY_ICON);
 347
 348             switch (lParam)
 349             {
 350                 case NIN_BALLOONSHOW:
 351                     TRACE("NIN_BALLOONSHOW\n");
 352                     break;
 353
 354                 case NIN_BALLOONHIDE:
 355                     TRACE("NIN_BALLOONHIDE\n");
 356                     break;
 357
 358                 /* The balloon timed out, or the user closed it by clicking on the 'X' button */
 359                 case NIN_BALLOONTIMEOUT:
 360                 {
 361                     TRACE("NIN_BALLOONTIMEOUT\n");
 362                     pThis->TimeoutIcon();
 363                     break;
 364                 }
 365
 366                 /* The user clicked on the balloon: delete the notification icon */
 367                 case NIN_BALLOONUSERCLICK:
 368                     TRACE("NIN_BALLOONUSERCLICK\n");
 369                     /* Fall back to icon click behaviour */
 370
 371                 /* The user clicked on the notification icon: delete it */
 372                 case WM_LBUTTONDOWN:
 373                 case WM_RBUTTONDOWN:
 374                 {
 375                     pThis->DelayRemoveIcon(S_OK);
 376                     break;
 377                 }
 378
 379                 default:
 380                     break;
 381             }
 382
 383             return 0;
 384         }
 385     }
 386
 387     return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
 388 }
 389
 390
 391 // Blocks until the notification times out.
 392 HRESULT STDMETHODCALLTYPE
 393 CUserNotification::Show(
 394     IN IQueryContinue* pqc,
 395     IN DWORD dwContinuePollInterval)
 396 {
 397     NOTIFYICONDATAW nid = {0};
 398     MSG msg;
 399
 400     /* Create the hidden notification message worker window if we do not have one already */
 401     if (!m_hWorkerWnd)
 402     {
 403         m_hWorkerWnd = ::SHCreateWorkerWindowW(CUserNotification::WorkerWndProc,
 404                                                NULL, 0, 0, NULL, (LONG_PTR)this);
 405         if (!m_hWorkerWnd)
 406         {
 407             FAILED_UNEXPECTEDLY(E_FAIL);
 408             return E_FAIL;
 409         }
 410
 411         /* Add and display the notification icon */
 412         SetUpNotifyData(NIF_MESSAGE | NIF_ICON | NIF_TIP | NIF_INFO, &nid);
 413         if (!::Shell_NotifyIconW(NIM_ADD, &nid))
 414         {
 415             ::DestroyWindow(m_hWorkerWnd);
 416             m_hWorkerWnd = NULL;
 417             return E_FAIL;
 418         }
 419     }
 420
 421     m_hRes = S_OK;
 422
 423     /* Set up the user-continue callback mechanism */
 424     m_pqc = pqc;
 425     if (pqc)
 426     {
 427         m_uContinuePoolInterval = dwContinuePollInterval;
 428         ::SetTimer(m_hWorkerWnd, ID_BALLOON_QUERYCONT, m_uContinuePoolInterval, NULL);
 429     }
 430
 431     /* Control how long the balloon notification is displayed */
 432     if ((nid.uFlags & NIF_INFO) && !*nid.szInfo /* && !*nid.szInfoTitle */)
 433         ::SetTimer(m_hWorkerWnd, ID_BALLOON_SHOWTIME, m_uShowTime, NULL);
 434
 435     /* Dispatch messsages to the worker window */
 436     m_bIsShown = TRUE;
 437     while (::GetMessageW(&msg, NULL, 0, 0))
 438     {
 439         ::TranslateMessage(&msg);
 440         ::DispatchMessageW(&msg);
 441     }
 442     m_bIsShown = FALSE;
 443
 444     /* Reset the user-continue callback mechanism */
 445     if (pqc)
 446     {
 447         ::KillTimer(m_hWorkerWnd, ID_BALLOON_QUERYCONT);
 448         m_uContinuePoolInterval = 0;
 449     }
 450     m_pqc = NULL;
 451
 452     /* Return the notification error code */
 453     return m_hRes;
 454 }
 455
 456 #if 0   // IUserNotification2
 457 // Blocks until the notification times out.
 458 HRESULT STDMETHODCALLTYPE
 459 CUserNotification::Show(
 460     IN IQueryContinue* pqc,
 461     IN DWORD dwContinuePollInterval,
 462     IN IUserNotificationCallback* pSink)
 463 {
 464     return S_OK;
 465 }
 466 #endif
 467
 468 HRESULT STDMETHODCALLTYPE
 469 CUserNotification::PlaySound(
 470     IN LPCWSTR pszSoundName)
 471 {
 472     /* Call the Win32 API - Ignore the PlaySoundW() return value as on Windows */
 473     ::PlaySoundW(pszSoundName,
 474                  NULL,
 475                  SND_ALIAS | SND_APPLICATION |
 476                  SND_NOSTOP | SND_NODEFAULT | SND_ASYNC);
 477     return S_OK;
 478 }