programs/explorer/systray.c

   1 /*
   2  * Copyright (C) 2004 Mike Hearn, for CodeWeavers
   3  * Copyright (C) 2005 Robert Shearman
   4  * Copyright (C) 2008 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22
  23 #define UNICODE
  24 #define NONAMELESSUNION
  25 #define _WIN32_IE 0x500
  26 #include <windows.h>
  27 #include <commctrl.h>
  28
  29 #include <wine/debug.h>
  30 #include <wine/list.h>
  31
  32 #include "explorer_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(systray);
  35
  36 #define IS_OPTION_FALSE(ch) \
  37     ((ch) == 'n' || (ch) == 'N' || (ch) == 'f' || (ch) == 'F' || (ch) == '0')
  38
  39 struct notify_data  /* platform-independent format for NOTIFYICONDATA */
  40 {
  41     LONG  hWnd;
  42     UINT  uID;
  43     UINT  uFlags;
  44     UINT  uCallbackMessage;
  45     WCHAR szTip[128];
  46     DWORD dwState;
  47     DWORD dwStateMask;
  48     WCHAR szInfo[256];
  49     union {
  50         UINT uTimeout;
  51         UINT uVersion;
  52     } u;
  53     WCHAR szInfoTitle[64];
  54     DWORD dwInfoFlags;
  55     GUID  guidItem;
  56     /* data for the icon bitmap */
  57     UINT width;
  58     UINT height;
  59     UINT planes;
  60     UINT bpp;
  61 };
  62
  63 static int (CDECL *wine_notify_icon)(DWORD,NOTIFYICONDATAW *);
  64
  65 /* an individual systray icon, unpacked from the NOTIFYICONDATA and always in unicode */
  66 struct icon
  67 {
  68     struct list    entry;
  69     HICON          image;    /* the image to render */
  70     HWND           owner;    /* the HWND passed in to the Shell_NotifyIcon call */
  71     HWND           tooltip;  /* Icon tooltip */
  72     UINT           id;       /* the unique id given by the app */
  73     UINT           callback_message;
  74     int            display;  /* index in display list, or -1 if hidden */
  75     WCHAR          tiptext[128]; /* Tooltip text. If empty => tooltip disabled */
  76 };
  77
  78 static struct list icon_list = LIST_INIT( icon_list );
  79 static HWND tray_window;
  80
  81 static unsigned int alloc_displayed;
  82 static unsigned int nb_displayed;
  83 static struct icon **displayed;  /* array of currently displayed icons */
  84
  85 static BOOL hide_systray;
  86 static int icon_cx, icon_cy;
  87
  88 #define MIN_DISPLAYED 8
  89 #define ICON_BORDER  2
  90
  91 /* Retrieves icon record by owner window and ID */
  92 static struct icon *get_icon(HWND owner, UINT id)
  93 {
  94     struct icon *this;
  95
  96     /* search for the icon */
  97     LIST_FOR_EACH_ENTRY( this, &icon_list, struct icon, entry )
  98         if ((this->id == id) && (this->owner == owner)) return this;
  99
 100     return NULL;
 101 }
 102
 103 /* compute the size of the tray window */
 104 static SIZE get_window_size(void)
 105 {
 106     SIZE size;
 107     RECT rect;
 108
 109     rect.left = 0;
 110     rect.top = 0;
 111     rect.right = icon_cx * max( nb_displayed, MIN_DISPLAYED );
 112     rect.bottom = icon_cy;
 113     AdjustWindowRect( &rect, WS_CAPTION, FALSE );
 114     size.cx = rect.right - rect.left;
 115     size.cy = rect.bottom - rect.top;
 116     return size;
 117 }
 118
 119 /* Creates tooltip window for icon. */
 120 static void create_tooltip(struct icon *icon)
 121 {
 122     TTTOOLINFOW ti;
 123     static BOOL tooltips_initialized = FALSE;
 124
 125     /* Register tooltip classes if this is the first icon */
 126     if (!tooltips_initialized)
 127     {
 128         INITCOMMONCONTROLSEX init_tooltip;
 129
 130         init_tooltip.dwSize = sizeof(INITCOMMONCONTROLSEX);
 131         init_tooltip.dwICC = ICC_TAB_CLASSES;
 132
 133         InitCommonControlsEx(&init_tooltip);
 134         tooltips_initialized = TRUE;
 135     }
 136
 137     icon->tooltip = CreateWindowExW(WS_EX_TOPMOST, TOOLTIPS_CLASSW, NULL,
 138                                    WS_POPUP | TTS_ALWAYSTIP,
 139                                    CW_USEDEFAULT, CW_USEDEFAULT,
 140                                    CW_USEDEFAULT, CW_USEDEFAULT,
 141                                    tray_window, NULL, NULL, NULL);
 142
 143     ZeroMemory(&ti, sizeof(ti));
 144     ti.cbSize = sizeof(TTTOOLINFOW);
 145     ti.hwnd = tray_window;
 146     ti.lpszText = icon->tiptext;
 147     if (icon->display != -1)
 148     {
 149         ti.rect.left = icon_cx * icon->display;
 150         ti.rect.right = icon_cx * (icon->display + 1);
 151         ti.rect.top = 0;
 152         ti.rect.bottom = icon_cy;
 153     }
 154     SendMessageW(icon->tooltip, TTM_ADDTOOLW, 0, (LPARAM)&ti);
 155 }
 156
 157 /* Synchronize tooltip text with tooltip window */
 158 static void update_tooltip_text(struct icon *icon)
 159 {
 160     TTTOOLINFOW ti;
 161
 162     ZeroMemory(&ti, sizeof(ti));
 163     ti.cbSize = sizeof(TTTOOLINFOW);
 164     ti.hwnd = tray_window;
 165     ti.lpszText = icon->tiptext;
 166
 167     SendMessageW(icon->tooltip, TTM_UPDATETIPTEXTW, 0, (LPARAM)&ti);
 168 }
 169
 170 /* synchronize tooltip position with tooltip window */
 171 static void update_tooltip_position( struct icon *icon )
 172 {
 173     TTTOOLINFOW ti;
 174
 175     ZeroMemory(&ti, sizeof(ti));
 176     ti.cbSize = sizeof(TTTOOLINFOW);
 177     ti.hwnd = tray_window;
 178     if (icon->display != -1)
 179     {
 180         ti.rect.left = icon_cx * icon->display;
 181         ti.rect.right = icon_cx * (icon->display + 1);
 182         ti.rect.top = 0;
 183         ti.rect.bottom = icon_cy;
 184     }
 185     SendMessageW( icon->tooltip, TTM_NEWTOOLRECTW, 0, (LPARAM)&ti );
 186 }
 187
 188 /* find the icon located at a certain point in the tray window */
 189 static struct icon *icon_from_point( int x, int y )
 190 {
 191     if (y < 0 || y >= icon_cy) return NULL;
 192     if (x < 0 || x >= icon_cx * nb_displayed) return NULL;
 193     return displayed[x / icon_cx];
 194 }
 195
 196 /* invalidate the portion of the tray window that contains the specified icons */
 197 static void invalidate_icons( unsigned int start, unsigned int end )
 198 {
 199     RECT rect;
 200
 201     rect.left = start * icon_cx;
 202     rect.top  = 0;
 203     rect.right = (end + 1) * icon_cx;
 204     rect.bottom = icon_cy;
 205     InvalidateRect( tray_window, &rect, TRUE );
 206 }
 207
 208 /* make an icon visible */
 209 static BOOL show_icon(struct icon *icon)
 210 {
 211     WINE_TRACE("id=0x%x, hwnd=%p\n", icon->id, icon->owner);
 212
 213     if (icon->display != -1) return TRUE;  /* already displayed */
 214
 215     if (nb_displayed >= alloc_displayed)
 216     {
 217         unsigned int new_count = max( alloc_displayed * 2, 32 );
 218         struct icon **ptr;
 219         if (displayed) ptr = HeapReAlloc( GetProcessHeap(), 0, displayed, new_count * sizeof(*ptr) );
 220         else ptr = HeapAlloc( GetProcessHeap(), 0, new_count * sizeof(*ptr) );
 221         if (!ptr) return FALSE;
 222         displayed = ptr;
 223         alloc_displayed = new_count;
 224     }
 225
 226     icon->display = nb_displayed;
 227     displayed[nb_displayed++] = icon;
 228     update_tooltip_position( icon );
 229     invalidate_icons( nb_displayed-1, nb_displayed-1 );
 230
 231     if (nb_displayed > MIN_DISPLAYED)
 232     {
 233         SIZE size = get_window_size();
 234         SetWindowPos( tray_window, 0, 0, 0, size.cx, size.cy, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE );
 235     }
 236     else if (nb_displayed == 1)
 237     {
 238         if (!hide_systray) ShowWindow( tray_window, SW_SHOWNA );
 239     }
 240
 241     create_tooltip(icon);
 242     return TRUE;
 243 }
 244
 245 /* make an icon invisible */
 246 static BOOL hide_icon(struct icon *icon)
 247 {
 248     unsigned int i;
 249
 250     WINE_TRACE("id=0x%x, hwnd=%p\n", icon->id, icon->owner);
 251
 252     if (icon->display == -1) return TRUE;  /* already hidden */
 253
 254     assert( nb_displayed );
 255     for (i = icon->display; i < nb_displayed - 1; i++)
 256     {
 257         displayed[i] = displayed[i + 1];
 258         displayed[i]->display = i;
 259         update_tooltip_position( displayed[i] );
 260     }
 261     nb_displayed--;
 262     invalidate_icons( icon->display, nb_displayed );
 263     icon->display = -1;
 264
 265     if (nb_displayed >= MIN_DISPLAYED)
 266     {
 267         SIZE size = get_window_size();
 268         SetWindowPos( tray_window, 0, 0, 0, size.cx, size.cy, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE );
 269     }
 270     else if (!nb_displayed)
 271     {
 272         ShowWindow( tray_window, SW_HIDE );
 273     }
 274
 275     update_tooltip_position( icon );
 276     return TRUE;
 277 }
 278
 279 /* Modifies an existing icon record */
 280 static BOOL modify_icon( struct icon *icon, NOTIFYICONDATAW *nid )
 281 {
 282     WINE_TRACE("id=0x%x, hwnd=%p\n", nid->uID, nid->hWnd);
 283
 284     /* demarshal the request from the NID */
 285     if (!icon)
 286     {
 287         WINE_WARN("Invalid icon ID (0x%x) for HWND %p\n", nid->uID, nid->hWnd);
 288         return FALSE;
 289     }
 290
 291     if ((nid->uFlags & NIF_STATE) && (nid->dwStateMask & NIS_HIDDEN))
 292     {
 293         if (nid->dwState & NIS_HIDDEN) hide_icon( icon );
 294         else show_icon( icon );
 295     }
 296
 297     if (nid->uFlags & NIF_ICON)
 298     {
 299         if (icon->image) DestroyIcon(icon->image);
 300         icon->image = CopyIcon(nid->hIcon);
 301         if (icon->display != -1) invalidate_icons( icon->display, icon->display );
 302     }
 303
 304     if (nid->uFlags & NIF_MESSAGE)
 305     {
 306         icon->callback_message = nid->uCallbackMessage;
 307     }
 308     if (nid->uFlags & NIF_TIP)
 309     {
 310         lstrcpynW(icon->tiptext, nid->szTip, sizeof(icon->tiptext)/sizeof(WCHAR));
 311         if (icon->display != -1) update_tooltip_text(icon);
 312     }
 313     if (nid->uFlags & NIF_INFO && nid->cbSize >= NOTIFYICONDATAA_V2_SIZE)
 314     {
 315         WINE_FIXME("balloon tip title %s, message %s\n", wine_dbgstr_w(nid->szInfoTitle), wine_dbgstr_w(nid->szInfo));
 316     }
 317     return TRUE;
 318 }
 319
 320 /* Adds a new icon record to the list */
 321 static BOOL add_icon(NOTIFYICONDATAW *nid)
 322 {
 323     struct icon  *icon;
 324
 325     WINE_TRACE("id=0x%x, hwnd=%p\n", nid->uID, nid->hWnd);
 326
 327     if ((icon = get_icon(nid->hWnd, nid->uID)))
 328     {
 329         WINE_WARN("duplicate tray icon add, buggy app?\n");
 330         return FALSE;
 331     }
 332
 333     if (!(icon = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*icon))))
 334     {
 335         WINE_ERR("out of memory\n");
 336         return FALSE;
 337     }
 338
 339     ZeroMemory(icon, sizeof(struct icon));
 340     icon->id     = nid->uID;
 341     icon->owner  = nid->hWnd;
 342     icon->display = -1;
 343
 344     list_add_tail(&icon_list, &icon->entry);
 345
 346     modify_icon( icon, nid );
 347     /* show icon, unless hidden state was explicitly specified */
 348     if (!((nid->uFlags & NIF_STATE) && (nid->dwStateMask & NIS_HIDDEN))) show_icon( icon );
 349     return TRUE;
 350 }
 351
 352 /* Deletes tray icon window and icon record */
 353 static BOOL delete_icon(struct icon *icon)
 354 {
 355     hide_icon(icon);
 356     list_remove(&icon->entry);
 357     DestroyIcon(icon->image);
 358     HeapFree(GetProcessHeap(), 0, icon);
 359     return TRUE;
 360 }
 361
 362 /* cleanup icons belonging to windows that have been destroyed */
 363 static void cleanup_destroyed_windows(void)
 364 {
 365     struct icon *icon, *next;
 366
 367     LIST_FOR_EACH_ENTRY_SAFE( icon, next, &icon_list, struct icon, entry )
 368         if (!IsWindow( icon->owner )) delete_icon( icon );
 369 }
 370
 371 static BOOL handle_incoming(HWND hwndSource, COPYDATASTRUCT *cds)
 372 {
 373     struct icon *icon = NULL;
 374     const struct notify_data *data;
 375     NOTIFYICONDATAW nid;
 376     int ret = FALSE;
 377
 378     if (cds->cbData < sizeof(*data)) return FALSE;
 379     data = cds->lpData;
 380
 381     nid.cbSize           = sizeof(nid);
 382     nid.hWnd             = LongToHandle( data->hWnd );
 383     nid.uID              = data->uID;
 384     nid.uFlags           = data->uFlags;
 385     nid.uCallbackMessage = data->uCallbackMessage;
 386     nid.hIcon            = 0;
 387     nid.dwState          = data->dwState;
 388     nid.dwStateMask      = data->dwStateMask;
 389     nid.u.uTimeout       = data->u.uTimeout;
 390     nid.dwInfoFlags      = data->dwInfoFlags;
 391     nid.guidItem         = data->guidItem;
 392     lstrcpyW( nid.szTip, data->szTip );
 393     lstrcpyW( nid.szInfo, data->szInfo );
 394     lstrcpyW( nid.szInfoTitle, data->szInfoTitle );
 395     nid.hBalloonIcon     = 0;
 396
 397     /* FIXME: if statement only needed because we don't support interprocess
 398      * icon handles */
 399     if ((nid.uFlags & NIF_ICON) && cds->cbData > sizeof(*data))
 400     {
 401         LONG cbMaskBits;
 402         LONG cbColourBits;
 403         const char *buffer = (const char *)(data + 1);
 404
 405         cbMaskBits = (data->width * data->height + 15) / 16 * 2;
 406         cbColourBits = (data->planes * data->width * data->height * data->bpp + 15) / 16 * 2;
 407
 408         if (cds->cbData < sizeof(*data) + cbMaskBits + cbColourBits)
 409         {
 410             WINE_ERR("buffer underflow\n");
 411             return FALSE;
 412         }
 413         nid.hIcon = CreateIcon(NULL, data->width, data->height, data->planes, data->bpp,
 414                                buffer, buffer + cbMaskBits);
 415     }
 416
 417     /* try forward to x11drv first */
 418     if (cds->dwData == NIM_ADD || !(icon = get_icon( nid.hWnd, nid.uID )))
 419     {
 420         if (wine_notify_icon && ((ret = wine_notify_icon( cds->dwData, &nid )) != -1))
 421         {
 422             if (nid.hIcon) DestroyIcon( nid.hIcon );
 423             return ret;
 424         }
 425         ret = FALSE;
 426     }
 427
 428     switch (cds->dwData)
 429     {
 430     case NIM_ADD:
 431         ret = add_icon(&nid);
 432         break;
 433     case NIM_DELETE:
 434         if (icon) ret = delete_icon( icon );
 435         break;
 436     case NIM_MODIFY:
 437         if (icon) ret = modify_icon( icon, &nid );
 438         break;
 439     default:
 440         WINE_FIXME("unhandled tray message: %ld\n", cds->dwData);
 441         break;
 442     }
 443
 444     if (nid.hIcon) DestroyIcon( nid.hIcon );
 445     return ret;
 446 }
 447
 448 static void do_hide_systray(void)
 449 {
 450     SetWindowPos( tray_window, 0,
 451                   GetSystemMetrics(SM_XVIRTUALSCREEN) + GetSystemMetrics(SM_CXVIRTUALSCREEN),
 452                   GetSystemMetrics(SM_YVIRTUALSCREEN) + GetSystemMetrics(SM_CYVIRTUALSCREEN),
 453                   0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
 454 }
 455
 456 static LRESULT WINAPI tray_wndproc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 457 {
 458     switch (msg)
 459     {
 460     case WM_COPYDATA:
 461         return handle_incoming((HWND)wparam, (COPYDATASTRUCT *)lparam);
 462
 463     case WM_DISPLAYCHANGE:
 464         if (hide_systray) do_hide_systray();
 465         break;
 466
 467     case WM_TIMER:
 468         cleanup_destroyed_windows();
 469         break;
 470
 471     case WM_PAINT:
 472         {
 473             unsigned int i;
 474             PAINTSTRUCT ps;
 475             HDC hdc;
 476
 477             hdc = BeginPaint( hwnd, &ps );
 478             for (i = ps.rcPaint.left / icon_cx;
 479                  (i < (ps.rcPaint.right + icon_cx - 1) / icon_cx) && (i < nb_displayed);
 480                  i++)
 481             {
 482                 DrawIconEx( hdc, i * icon_cx + ICON_BORDER, ICON_BORDER, displayed[i]->image,
 483                             icon_cx - 2*ICON_BORDER, icon_cy - 2*ICON_BORDER,
 484                             0, 0, DI_DEFAULTSIZE|DI_NORMAL);
 485             }
 486             EndPaint( hwnd, &ps );
 487             break;
 488         }
 489
 490     case WM_MOUSEMOVE:
 491     case WM_LBUTTONDOWN:
 492     case WM_LBUTTONUP:
 493     case WM_RBUTTONDOWN:
 494     case WM_RBUTTONUP:
 495     case WM_MBUTTONDOWN:
 496     case WM_MBUTTONUP:
 497     case WM_LBUTTONDBLCLK:
 498     case WM_RBUTTONDBLCLK:
 499     case WM_MBUTTONDBLCLK:
 500         {
 501             MSG message;
 502             struct icon *icon = icon_from_point( (short)LOWORD(lparam), (short)HIWORD(lparam) );
 503             if (!icon) break;
 504
 505             /* notify the owner hwnd of the message */
 506             WINE_TRACE("relaying 0x%x\n", msg);
 507
 508             message.hwnd = hwnd;
 509             message.message = msg;
 510             message.wParam = wparam;
 511             message.lParam = lparam;
 512             SendMessageW( icon->tooltip, TTM_RELAYEVENT, 0, (LPARAM)&message );
 513
 514             if (!PostMessageW( icon->owner, icon->callback_message, (WPARAM) icon->id, (LPARAM) msg ) &&
 515                 GetLastError() == ERROR_INVALID_WINDOW_HANDLE)
 516             {
 517                 WINE_WARN("application window was destroyed without removing "
 518                           "notification icon, removing automatically\n");
 519                 delete_icon( icon );
 520             }
 521             break;
 522         }
 523
 524     case WM_CLOSE:
 525         /* don't destroy the tray window, just hide it */
 526         ShowWindow( hwnd, SW_HIDE );
 527         return 0;
 528
 529     default:
 530         return DefWindowProcW( hwnd, msg, wparam, lparam );
 531     }
 532     return 0;
 533 }
 534
 535 static BOOL is_systray_hidden(void)
 536 {
 537     const WCHAR show_systray_keyname[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
 538                                           'X','1','1',' ','D','r','i','v','e','r',0};
 539     const WCHAR show_systray_valuename[] = {'S','h','o','w','S','y','s','t','r','a','y',0};
 540     HKEY hkey;
 541     BOOL ret = FALSE;
 542
 543     /* @@ Wine registry key: HKCU\Software\Wine\X11 Driver */
 544     if (RegOpenKeyW(HKEY_CURRENT_USER, show_systray_keyname, &hkey) == ERROR_SUCCESS)
 545     {
 546         WCHAR value[10];
 547         DWORD type, size = sizeof(value);
 548         if (RegQueryValueExW(hkey, show_systray_valuename, 0, &type, (LPBYTE)&value, &size) == ERROR_SUCCESS)
 549         {
 550             ret = IS_OPTION_FALSE(value[0]);
 551         }
 552         RegCloseKey(hkey);
 553     }
 554     return ret;
 555 }
 556
 557 /* this function creates the listener window */
 558 void initialize_systray(void)
 559 {
 560     HMODULE x11drv;
 561     SIZE size;
 562     WNDCLASSEXW class;
 563     static const WCHAR classname[] = {'S','h','e','l','l','_','T','r','a','y','W','n','d',0};
 564     static const WCHAR winname[] = {'W','i','n','e',' ','S','y','s','t','e','m',' ','T','r','a','y',0};
 565
 566     if ((x11drv = GetModuleHandleA( "winex11.drv" )))
 567         wine_notify_icon = (void *)GetProcAddress( x11drv, "wine_notify_icon" );
 568
 569     icon_cx = GetSystemMetrics( SM_CXSMICON ) + 2*ICON_BORDER;
 570     icon_cy = GetSystemMetrics( SM_CYSMICON ) + 2*ICON_BORDER;
 571     hide_systray = is_systray_hidden();
 572
 573     /* register the systray listener window class */
 574     ZeroMemory(&class, sizeof(class));
 575     class.cbSize        = sizeof(class);
 576     class.style         = CS_DBLCLKS;
 577     class.lpfnWndProc   = tray_wndproc;
 578     class.hInstance     = NULL;
 579     class.hIcon         = LoadIconW(0, (LPCWSTR)IDI_WINLOGO);
 580     class.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
 581     class.hbrBackground = (HBRUSH) COLOR_WINDOW;
 582     class.lpszClassName = (WCHAR *) &classname;
 583
 584     if (!RegisterClassExW(&class))
 585     {
 586         WINE_ERR("Could not register SysTray window class\n");
 587         return;
 588     }
 589
 590     size = get_window_size();
 591     tray_window = CreateWindowW( classname, winname, WS_OVERLAPPED | WS_CAPTION,
 592                                  CW_USEDEFAULT, CW_USEDEFAULT, size.cx, size.cy, 0, 0, 0, 0 );
 593     if (!tray_window)
 594     {
 595         WINE_ERR("Could not create tray window\n");
 596         return;
 597     }
 598
 599     if (hide_systray) do_hide_systray();
 600
 601     SetTimer( tray_window, 1, 2000, NULL );
 602 }