a0d983e4b5* feat: allow macOS tray to maintain position * refactor: just use guid * test: fixup tests * docs: clarify UUID format
337 lines
11 KiB
C++
337 lines
11 KiB
C++
// Copyright (c) 2014 GitHub, Inc.
|
|
// Use of this source code is governed by the MIT license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "shell/browser/ui/win/notify_icon_host.h"
|
|
|
|
#include <commctrl.h>
|
|
#include <winuser.h>
|
|
|
|
#include "base/functional/bind.h"
|
|
#include "base/logging.h"
|
|
#include "base/memory/weak_ptr.h"
|
|
#include "base/timer/timer.h"
|
|
#include "base/win/win_util.h"
|
|
#include "base/win/windows_types.h"
|
|
#include "base/win/wrapped_window_proc.h"
|
|
#include "content/public/browser/browser_thread.h"
|
|
#include "shell/browser/ui/win/notify_icon.h"
|
|
#include "ui/display/screen.h"
|
|
#include "ui/events/event_constants.h"
|
|
#include "ui/events/win/system_event_state_lookup.h"
|
|
#include "ui/gfx/win/hwnd_util.h"
|
|
|
|
namespace electron {
|
|
|
|
namespace {
|
|
|
|
const UINT kNotifyIconMessage = WM_APP + 1;
|
|
|
|
// |kBaseIconId| is 2 to avoid conflicts with plugins that hard-code id 1.
|
|
const UINT kBaseIconId = 2;
|
|
|
|
const wchar_t kNotifyIconHostWindowClass[] = L"Electron_NotifyIconHostWindow";
|
|
|
|
constexpr unsigned int kMouseLeaveCheckFrequency = 250;
|
|
|
|
bool IsWinPressed() {
|
|
return ((::GetKeyState(VK_LWIN) & 0x8000) == 0x8000) ||
|
|
((::GetKeyState(VK_RWIN) & 0x8000) == 0x8000);
|
|
}
|
|
|
|
int GetKeyboardModifiers() {
|
|
int modifiers = ui::EF_NONE;
|
|
if (ui::win::IsShiftPressed())
|
|
modifiers |= ui::EF_SHIFT_DOWN;
|
|
if (ui::win::IsCtrlPressed())
|
|
modifiers |= ui::EF_CONTROL_DOWN;
|
|
if (ui::win::IsAltPressed())
|
|
modifiers |= ui::EF_ALT_DOWN;
|
|
if (IsWinPressed())
|
|
modifiers |= ui::EF_COMMAND_DOWN;
|
|
return modifiers;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// Helper class used to detect mouse entered and mouse exited events based on
|
|
// mouse move event.
|
|
class NotifyIconHost::MouseEnteredExitedDetector {
|
|
public:
|
|
MouseEnteredExitedDetector() = default;
|
|
~MouseEnteredExitedDetector() = default;
|
|
|
|
// disallow copy
|
|
MouseEnteredExitedDetector(const MouseEnteredExitedDetector&) = delete;
|
|
MouseEnteredExitedDetector& operator=(const MouseEnteredExitedDetector&) =
|
|
delete;
|
|
|
|
// disallow move
|
|
MouseEnteredExitedDetector(MouseEnteredExitedDetector&&) = delete;
|
|
MouseEnteredExitedDetector& operator=(MouseEnteredExitedDetector&&) = delete;
|
|
|
|
void MouseMoveEvent(raw_ptr<NotifyIcon> icon) {
|
|
if (!icon)
|
|
return;
|
|
|
|
// If cursor is out of icon then skip this move event.
|
|
if (!IsCursorOverIcon(icon))
|
|
return;
|
|
|
|
// If user moved cursor to other icon then send mouse exited event for
|
|
// old icon.
|
|
if (current_mouse_entered_ &&
|
|
current_mouse_entered_->icon_id() != icon->icon_id()) {
|
|
SendExitedEvent();
|
|
}
|
|
|
|
// If timer is running then cursor is already over icon and
|
|
// CheckCursorPositionOverIcon will be repeatedly checking when to send
|
|
// mouse exited event.
|
|
if (mouse_exit_timer_.IsRunning())
|
|
return;
|
|
|
|
SendEnteredEvent(icon);
|
|
|
|
// Start repeatedly checking when to send mouse exited event.
|
|
StartObservingIcon(icon);
|
|
}
|
|
|
|
void IconRemoved(raw_ptr<NotifyIcon> icon) {
|
|
if (current_mouse_entered_ &&
|
|
current_mouse_entered_->icon_id() == icon->icon_id()) {
|
|
SendExitedEvent();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void SendEnteredEvent(raw_ptr<NotifyIcon> icon) {
|
|
content::GetUIThreadTaskRunner({})->PostTask(
|
|
FROM_HERE, base::BindOnce(&NotifyIcon::HandleMouseEntered,
|
|
icon->GetWeakPtr(), GetKeyboardModifiers()));
|
|
}
|
|
|
|
void SendExitedEvent() {
|
|
mouse_exit_timer_.Stop();
|
|
content::GetUIThreadTaskRunner({})->PostTask(
|
|
FROM_HERE, base::BindOnce(&NotifyIcon::HandleMouseExited,
|
|
std::move(current_mouse_entered_),
|
|
GetKeyboardModifiers()));
|
|
}
|
|
|
|
bool IsCursorOverIcon(raw_ptr<NotifyIcon> icon) {
|
|
gfx::Point cursor_pos =
|
|
display::Screen::GetScreen()->GetCursorScreenPoint();
|
|
return icon->GetBounds().Contains(cursor_pos);
|
|
}
|
|
|
|
void CheckCursorPositionOverIcon() {
|
|
if (!current_mouse_entered_ ||
|
|
IsCursorOverIcon(current_mouse_entered_.get()))
|
|
return;
|
|
|
|
SendExitedEvent();
|
|
}
|
|
|
|
void StartObservingIcon(raw_ptr<NotifyIcon> icon) {
|
|
current_mouse_entered_ = icon->GetWeakPtr();
|
|
mouse_exit_timer_.Start(
|
|
FROM_HERE, base::Milliseconds(kMouseLeaveCheckFrequency),
|
|
base::BindRepeating(
|
|
&MouseEnteredExitedDetector::CheckCursorPositionOverIcon,
|
|
weak_factory_.GetWeakPtr()));
|
|
}
|
|
|
|
// Timer used to check if cursor is still over the icon.
|
|
base::MetronomeTimer mouse_exit_timer_;
|
|
|
|
// Weak pointer to icon over which cursor is hovering.
|
|
base::WeakPtr<NotifyIcon> current_mouse_entered_;
|
|
|
|
base::WeakPtrFactory<MouseEnteredExitedDetector> weak_factory_{this};
|
|
};
|
|
|
|
NotifyIconHost::NotifyIconHost() {
|
|
// Register our window class
|
|
WNDCLASSEX window_class;
|
|
base::win::InitializeWindowClass(
|
|
kNotifyIconHostWindowClass,
|
|
&base::win::WrappedWindowProc<NotifyIconHost::WndProcStatic>, 0, 0, 0,
|
|
nullptr, nullptr, nullptr, nullptr, nullptr, &window_class);
|
|
instance_ = window_class.hInstance;
|
|
atom_ = RegisterClassEx(&window_class);
|
|
CHECK(atom_);
|
|
|
|
// If the taskbar is re-created after we start up, we have to rebuild all of
|
|
// our icons.
|
|
taskbar_created_message_ = RegisterWindowMessage(TEXT("TaskbarCreated"));
|
|
|
|
// Create an offscreen window for handling messages for the status icons. We
|
|
// create a hidden WS_POPUP window instead of an HWND_MESSAGE window, because
|
|
// only top-level windows such as popups can receive broadcast messages like
|
|
// "TaskbarCreated".
|
|
window_ = CreateWindow(MAKEINTATOM(atom_), 0, WS_POPUP, 0, 0, 0, 0, 0, 0,
|
|
instance_, 0);
|
|
gfx::CheckWindowCreated(window_, ::GetLastError());
|
|
gfx::SetWindowUserData(window_, this);
|
|
|
|
mouse_entered_exited_detector_ =
|
|
std::make_unique<MouseEnteredExitedDetector>();
|
|
}
|
|
|
|
NotifyIconHost::~NotifyIconHost() {
|
|
if (window_)
|
|
DestroyWindow(window_);
|
|
|
|
if (atom_)
|
|
UnregisterClass(MAKEINTATOM(atom_), instance_);
|
|
|
|
for (NotifyIcon* ptr : notify_icons_)
|
|
delete ptr;
|
|
}
|
|
|
|
NotifyIcon* NotifyIconHost::CreateNotifyIcon(std::optional<base::Uuid> guid) {
|
|
std::string guid_str =
|
|
guid.has_value() ? guid.value().AsLowercaseString() : "";
|
|
UUID uid = GUID_NULL;
|
|
if (!guid_str.empty()) {
|
|
if (guid_str[0] == '{' && guid_str[guid_str.length() - 1] == '}') {
|
|
guid_str = guid_str.substr(1, guid_str.length() - 2);
|
|
}
|
|
|
|
unsigned char* uid_cstr = (unsigned char*)guid_str.c_str();
|
|
RPC_STATUS result = UuidFromStringA(uid_cstr, &uid);
|
|
if (result != RPC_S_INVALID_STRING_UUID) {
|
|
for (NotifyIcons::const_iterator i(notify_icons_.begin());
|
|
i != notify_icons_.end(); ++i) {
|
|
auto* current_win_icon = static_cast<NotifyIcon*>(*i);
|
|
if (current_win_icon->guid() == uid) {
|
|
LOG(WARNING)
|
|
<< "Guid already in use. Existing tray entry will be replaced.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
auto* notify_icon =
|
|
new NotifyIcon(this, NextIconId(), window_, kNotifyIconMessage,
|
|
uid == GUID_NULL ? GUID_DEFAULT : uid);
|
|
|
|
notify_icons_.push_back(notify_icon);
|
|
return notify_icon;
|
|
}
|
|
|
|
void NotifyIconHost::Remove(NotifyIcon* icon) {
|
|
const auto i = std::ranges::find(notify_icons_, icon);
|
|
|
|
if (i == notify_icons_.end()) {
|
|
NOTREACHED();
|
|
}
|
|
|
|
mouse_entered_exited_detector_->IconRemoved(*i);
|
|
|
|
notify_icons_.erase(i);
|
|
}
|
|
|
|
LRESULT CALLBACK NotifyIconHost::WndProcStatic(HWND hwnd,
|
|
UINT message,
|
|
WPARAM wparam,
|
|
LPARAM lparam) {
|
|
auto* msg_wnd =
|
|
reinterpret_cast<NotifyIconHost*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
|
|
if (msg_wnd)
|
|
return msg_wnd->WndProc(hwnd, message, wparam, lparam);
|
|
else
|
|
return ::DefWindowProc(hwnd, message, wparam, lparam);
|
|
}
|
|
|
|
LRESULT CALLBACK NotifyIconHost::WndProc(HWND hwnd,
|
|
UINT message,
|
|
WPARAM wparam,
|
|
LPARAM lparam) {
|
|
if (message == taskbar_created_message_) {
|
|
// We need to reset all of our icons because the taskbar went away.
|
|
std::ranges::for_each(notify_icons_, [](auto* icon) { icon->ResetIcon(); });
|
|
return TRUE;
|
|
} else if (message == kNotifyIconMessage) {
|
|
NotifyIcon* win_icon = nullptr;
|
|
|
|
// Find the selected status icon.
|
|
for (NotifyIcons::const_iterator i(notify_icons_.begin());
|
|
i != notify_icons_.end(); ++i) {
|
|
auto* current_win_icon = static_cast<NotifyIcon*>(*i);
|
|
if (current_win_icon->icon_id() == wparam) {
|
|
win_icon = current_win_icon;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// It is possible for this procedure to be called with an obsolete icon
|
|
// id. In that case we should just return early before handling any
|
|
// actions.
|
|
if (!win_icon)
|
|
return TRUE;
|
|
|
|
// We use a WeakPtr factory for NotifyIcons here so
|
|
// that the callback is aware if the NotifyIcon gets
|
|
// garbage-collected. This occurs when the tray gets
|
|
// GC'd, and the BALLOON events below will not emit.
|
|
base::WeakPtr<NotifyIcon> win_icon_weak = win_icon->GetWeakPtr();
|
|
|
|
switch (lparam) {
|
|
case NIN_BALLOONSHOW:
|
|
content::GetUIThreadTaskRunner({})->PostTask(
|
|
FROM_HERE,
|
|
base::BindOnce(&NotifyIcon::NotifyBalloonShow, win_icon_weak));
|
|
return TRUE;
|
|
|
|
case NIN_BALLOONUSERCLICK:
|
|
content::GetUIThreadTaskRunner({})->PostTask(
|
|
FROM_HERE,
|
|
base::BindOnce(&NotifyIcon::NotifyBalloonClicked, win_icon_weak));
|
|
return TRUE;
|
|
|
|
case NIN_BALLOONTIMEOUT:
|
|
content::GetUIThreadTaskRunner({})->PostTask(
|
|
FROM_HERE,
|
|
base::BindOnce(&NotifyIcon::NotifyBalloonClosed, win_icon_weak));
|
|
return TRUE;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_LBUTTONDBLCLK:
|
|
case WM_RBUTTONDBLCLK:
|
|
case WM_MBUTTONDBLCLK:
|
|
case WM_CONTEXTMENU:
|
|
// Walk our icons, find which one was clicked on, and invoke its
|
|
// HandleClickEvent() method.
|
|
content::GetUIThreadTaskRunner({})->PostTask(
|
|
FROM_HERE,
|
|
base::BindOnce(
|
|
&NotifyIcon::HandleClickEvent, win_icon_weak,
|
|
GetKeyboardModifiers(),
|
|
(lparam == WM_LBUTTONDOWN || lparam == WM_LBUTTONDBLCLK),
|
|
(lparam == WM_LBUTTONDBLCLK || lparam == WM_RBUTTONDBLCLK),
|
|
(lparam == WM_MBUTTONDOWN || lparam == WM_MBUTTONDBLCLK)));
|
|
|
|
return TRUE;
|
|
|
|
case WM_MOUSEMOVE:
|
|
mouse_entered_exited_detector_->MouseMoveEvent(win_icon);
|
|
|
|
content::GetUIThreadTaskRunner({})->PostTask(
|
|
FROM_HERE, base::BindOnce(&NotifyIcon::HandleMouseMoveEvent,
|
|
win_icon_weak, GetKeyboardModifiers()));
|
|
return TRUE;
|
|
}
|
|
}
|
|
return ::DefWindowProc(hwnd, message, wparam, lparam);
|
|
}
|
|
|
|
UINT NotifyIconHost::NextIconId() {
|
|
UINT icon_id = next_icon_id_++;
|
|
return kBaseIconId + icon_id;
|
|
}
|
|
|
|
} // namespace electron
|