electron/shell/browser/ui/win/taskbar_host.cc
Charles Kerr 60c4c9fec6
chore: remove unused #includes (#42971)
* chore: iwyu buildflags.h

* chore: iwyu dictionary.h

* chore: iwyu arguments.h

* chore: iwyu values.h

* chore: iwyu compiler_specific.h

* chore: iwyu binder_map.h

* chore: iwyu <vector>

* chore: iwyu <set>

* chore: iwyu raw_ptr

* chore: iwyu gfx/canvas.h

* chore: iwyu gfx/color_utils.h

* chore: iwyu base/strings/stringprintf.h

* chore: iwyu base/task/thread_pool.h

* chore: iwyu base/no_destructor.h

* chore: iwyu base/path_service.h

* chore: iwyu base/files/file_pathh

* chore: iwyu base/strings/sys_string_conversions.h

* chore: iwyu base/logging.h

* chore: iwyu base/command_line.h

* chore: iwyu base/files/file_util.h

* chore: iwyu base/files/scoped_file.h

* chore: iwyu base/strings/utf_string_conversions.h

* chore: iwyu base/environment.h

* chore: iwyu base/scoped_observation.h

* chore: iwyu base/strings/string_split.h

* chore: iwyu base/strings/pattern.h

* chore: iwyu base/json/string_escape.h

* chore: iwyu base/json/json_reader.h

* chore: iwyu base/memory/singleton.h

* chore: iwyu base/observer_list.h

* chore: iwyu base/timer/timer.h

* fixup! chore: iwyu values.h

* chore: iwyu shell/browser/browser.h

* chore: iwyu base/stl_util.h

* chore: iwyu base/strings/string_util.h

* chore: iwyu shell/browser/javascript_environment.h

* chore: iwyu base/memory/ref_counted.h

* chore: iwyu base/environment.h

* chore: iwyu content/public/browser/browser_thread.h

* chore: remove unused typedef gin_helper::EventEmitter::ValueArray

* chore: iwyu gin/wrappable.h

* chore: iwyu shell/common/gin_helper/function_template_extensions.h

* chore: iwyu shell/common/gin_converters/login_item_settings_converter.h

* chore: iwyu shell/common/gin_helper/arguments.h

* chore: iwyu ui/gfx/skia_util.h

* chore: iwyu ui/gfx/geometry/rect.h

* chore: iwyu ui/gfx/image/image.h

* chore: iwyu base/strings/strcat.h

* chore: iwyu ui/native_theme/native_theme.h

* fixup! chore: iwyu shell/browser/javascript_environment.h

* fixup! chore: iwyu gfx/canvas.h

* fixup! chore: iwyu content/public/browser/browser_thread.h

* fixup! chore: iwyu ui/native_theme/native_theme.h

* fixup! chore: iwyu ui/native_theme/native_theme.h
2024-07-22 11:31:32 +02:00

272 lines
8.8 KiB
C++

// Copyright (c) 2015 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/taskbar_host.h"
#include <objbase.h>
#include <string>
#include "base/strings/utf_string_conversions.h"
#include "base/win/scoped_gdi_object.h"
#include "shell/browser/native_window.h"
#include "skia/ext/image_operations.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkRRect.h"
#include "ui/display/win/screen_win.h"
#include "ui/gfx/icon_util.h"
namespace electron {
namespace {
// From MSDN:
// https://msdn.microsoft.com/en-us/library/windows/desktop/dd378460(v=vs.85).aspx#thumbbars
// The thumbnail toolbar has a maximum of seven buttons due to the limited room.
const size_t kMaxButtonsCount = 7;
// The base id of Thumbar button.
const int kButtonIdBase = 40001;
bool GetThumbarButtonFlags(const std::vector<std::string>& flags,
THUMBBUTTONFLAGS* out) {
THUMBBUTTONFLAGS result = THBF_ENABLED; // THBF_ENABLED == 0
for (const auto& flag : flags) {
if (flag == "disabled")
result |= THBF_DISABLED;
else if (flag == "dismissonclick")
result |= THBF_DISMISSONCLICK;
else if (flag == "nobackground")
result |= THBF_NOBACKGROUND;
else if (flag == "hidden")
result |= THBF_HIDDEN;
else if (flag == "noninteractive")
result |= THBF_NONINTERACTIVE;
else
return false;
}
*out = result;
return true;
}
} // namespace
TaskbarHost::ThumbarButton::ThumbarButton() = default;
TaskbarHost::ThumbarButton::ThumbarButton(const TaskbarHost::ThumbarButton&) =
default;
TaskbarHost::ThumbarButton::~ThumbarButton() = default;
TaskbarHost::TaskbarHost() = default;
TaskbarHost::~TaskbarHost() = default;
bool TaskbarHost::SetThumbarButtons(HWND window,
const std::vector<ThumbarButton>& buttons) {
if (buttons.size() > kMaxButtonsCount || !InitializeTaskbar())
return false;
callback_map_.clear();
// The number of buttons in thumbar can not be changed once it is created,
// so we have to claim kMaxButtonsCount buttons initially in case users add
// more buttons later.
base::win::ScopedHICON icons[kMaxButtonsCount] = {};
THUMBBUTTON thumb_buttons[kMaxButtonsCount] = {};
for (size_t i = 0; i < kMaxButtonsCount; ++i) {
THUMBBUTTON& thumb_button = thumb_buttons[i];
// Set ID.
thumb_button.iId = kButtonIdBase + i;
thumb_button.dwMask = THB_FLAGS;
if (i >= buttons.size()) {
// This button is used to occupy the place in toolbar, and it does not
// show.
thumb_button.dwFlags = THBF_HIDDEN;
continue;
}
// This button is user's button.
const ThumbarButton& button = buttons[i];
// Generate flags.
thumb_button.dwFlags = THBF_ENABLED;
if (!GetThumbarButtonFlags(button.flags, &thumb_button.dwFlags))
return false;
// Set icon.
if (!button.icon.IsEmpty()) {
thumb_button.dwMask |= THB_ICON;
icons[i] = IconUtil::CreateHICONFromSkBitmap(button.icon.AsBitmap());
thumb_button.hIcon = icons[i].get();
}
// Set tooltip.
if (!button.tooltip.empty()) {
thumb_button.dwMask |= THB_TOOLTIP;
wcsncpy_s(thumb_button.szTip, base::UTF8ToWide(button.tooltip).c_str(),
_TRUNCATE);
}
// Save callback.
callback_map_[thumb_button.iId] = button.clicked_callback;
}
// Finally add them to taskbar.
HRESULT r;
if (thumbar_buttons_added_) {
r = taskbar_->ThumbBarUpdateButtons(window, kMaxButtonsCount,
thumb_buttons);
} else {
r = taskbar_->ThumbBarAddButtons(window, kMaxButtonsCount, thumb_buttons);
}
thumbar_buttons_added_ = true;
last_buttons_ = buttons;
return SUCCEEDED(r);
}
void TaskbarHost::RestoreThumbarButtons(HWND window) {
if (thumbar_buttons_added_) {
thumbar_buttons_added_ = false;
SetThumbarButtons(window, last_buttons_);
}
}
bool TaskbarHost::SetProgressBar(HWND window,
double value,
const NativeWindow::ProgressState state) {
if (!InitializeTaskbar())
return false;
bool success;
if (value > 1.0 || state == NativeWindow::ProgressState::kIndeterminate) {
success = SUCCEEDED(taskbar_->SetProgressState(window, TBPF_INDETERMINATE));
} else if (value < 0 || state == NativeWindow::ProgressState::kNone) {
success = SUCCEEDED(taskbar_->SetProgressState(window, TBPF_NOPROGRESS));
} else {
// Unless SetProgressState set a blocking state (TBPF_ERROR, TBPF_PAUSED)
// for the window, a call to SetProgressValue assumes the TBPF_NORMAL
// state even if it is not explicitly set.
// SetProgressValue overrides and clears the TBPF_INDETERMINATE state.
if (state == NativeWindow::ProgressState::kError) {
success = SUCCEEDED(taskbar_->SetProgressState(window, TBPF_ERROR));
} else if (state == NativeWindow::ProgressState::kPaused) {
success = SUCCEEDED(taskbar_->SetProgressState(window, TBPF_PAUSED));
} else {
success = SUCCEEDED(taskbar_->SetProgressState(window, TBPF_NORMAL));
}
if (success) {
int val = static_cast<int>(value * 100);
success = SUCCEEDED(taskbar_->SetProgressValue(window, val, 100));
}
}
return success;
}
// Adapted from SetOverlayIcon in
// chrome/browser/taskbar/taskbar_decorator_win.cc.
bool TaskbarHost::SetOverlayIcon(HWND window,
const SkBitmap& bitmap,
const std::string& text) {
if (!InitializeTaskbar())
return false;
base::win::ScopedGDIObject<HICON> icon;
if (!bitmap.isNull()) {
DCHECK_GE(bitmap.width(), bitmap.height());
constexpr int kOverlayIconSize = 16;
// Maintain aspect ratio on resize, but prefer more square.
// (We used to round down here, but rounding up produces nicer results.)
const int resized_height =
base::ClampCeil(kOverlayIconSize *
(static_cast<float>(bitmap.height()) / bitmap.width()));
DCHECK_GE(kOverlayIconSize, resized_height);
// Since the target size is so small, we use our best resizer.
SkBitmap sk_icon = skia::ImageOperations::Resize(
bitmap, skia::ImageOperations::RESIZE_LANCZOS3, kOverlayIconSize,
resized_height);
// Paint the resized icon onto a 16x16 canvas otherwise Windows will badly
// hammer it to 16x16. We'll use a circular clip to be consistent with the
// way profile icons are rendered in the profile switcher.
SkBitmap offscreen_bitmap;
offscreen_bitmap.allocN32Pixels(kOverlayIconSize, kOverlayIconSize);
SkCanvas offscreen_canvas(offscreen_bitmap, SkSurfaceProps{});
offscreen_canvas.clear(SK_ColorTRANSPARENT);
static const SkRRect overlay_icon_clip =
SkRRect::MakeOval(SkRect::MakeWH(kOverlayIconSize, kOverlayIconSize));
offscreen_canvas.clipRRect(overlay_icon_clip, true);
// Note: the original code used kOverlayIconSize - resized_height, but in
// order to center the icon in the circle clip area, we're going to center
// it in the paintable region instead, rounding up to the closest pixel to
// avoid smearing.
const int y_offset = std::ceilf((kOverlayIconSize - resized_height) / 2.0f);
offscreen_canvas.drawImage(sk_icon.asImage(), 0, y_offset);
icon = IconUtil::CreateHICONFromSkBitmap(offscreen_bitmap);
if (!icon.is_valid())
return false;
}
return SUCCEEDED(taskbar_->SetOverlayIcon(window, icon.get(),
base::UTF8ToWide(text).c_str()));
}
bool TaskbarHost::SetThumbnailClip(HWND window, const gfx::Rect& region) {
if (!InitializeTaskbar())
return false;
if (region.IsEmpty()) {
return SUCCEEDED(taskbar_->SetThumbnailClip(window, nullptr));
} else {
RECT rect =
display::win::ScreenWin::DIPToScreenRect(window, region).ToRECT();
return SUCCEEDED(taskbar_->SetThumbnailClip(window, &rect));
}
}
bool TaskbarHost::SetThumbnailToolTip(HWND window, const std::string& tooltip) {
if (!InitializeTaskbar())
return false;
return SUCCEEDED(
taskbar_->SetThumbnailTooltip(window, base::UTF8ToWide(tooltip).c_str()));
}
bool TaskbarHost::HandleThumbarButtonEvent(int button_id) {
const auto iter = callback_map_.find(button_id);
if (iter != std::end(callback_map_)) {
auto callback = iter->second;
if (!callback.is_null())
callback.Run();
return true;
}
return false;
}
bool TaskbarHost::InitializeTaskbar() {
if (taskbar_)
return true;
if (FAILED(::CoCreateInstance(CLSID_TaskbarList, nullptr,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&taskbar_))) ||
FAILED(taskbar_->HrInit())) {
taskbar_.Reset();
return false;
} else {
return true;
}
}
} // namespace electron