Source code

Revision control

Other Tools

/* vim: se cin sw=2 ts=2 et : */
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "TaskbarPreview.h"
#include <nsITaskbarPreviewController.h>
#include <windows.h>
#include <nsError.h>
#include <nsCOMPtr.h>
#include <nsIWidget.h>
#include <nsServiceManagerUtils.h>
#include "nsUXThemeData.h"
#include "nsWindow.h"
#include "nsAppShell.h"
#include "TaskbarPreviewButton.h"
#include "WinUtils.h"
#include "mozilla/dom/HTMLCanvasElement.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/DataSurfaceHelpers.h"
#include "mozilla/StaticPrefs_layout.h"
#include "mozilla/Telemetry.h"
// Defined in dwmapi in a header that needs a higher numbered _WINNT #define
#ifndef DWM_SIT_DISPLAYFRAME
# define DWM_SIT_DISPLAYFRAME 0x1
#endif
namespace mozilla {
namespace widget {
///////////////////////////////////////////////////////////////////////////////
// TaskbarPreview
TaskbarPreview::TaskbarPreview(ITaskbarList4* aTaskbar,
nsITaskbarPreviewController* aController,
HWND aHWND, nsIDocShell* aShell)
: mTaskbar(aTaskbar),
mController(aController),
mWnd(aHWND),
mVisible(false),
mDocShell(do_GetWeakReference(aShell)) {}
TaskbarPreview::~TaskbarPreview() {
// Avoid dangling pointer
if (sActivePreview == this) sActivePreview = nullptr;
// Our subclass should have invoked DetachFromNSWindow already.
NS_ASSERTION(
!mWnd,
"TaskbarPreview::DetachFromNSWindow was not called before destruction");
// Make sure to release before potentially uninitializing COM
mTaskbar = nullptr;
::CoUninitialize();
}
nsresult TaskbarPreview::Init() {
// TaskbarPreview may outlive the WinTaskbar that created it
if (FAILED(::CoInitialize(nullptr))) {
return NS_ERROR_NOT_INITIALIZED;
}
WindowHook* hook = GetWindowHook();
if (!hook) {
return NS_ERROR_NOT_AVAILABLE;
}
return hook->AddMonitor(WM_DESTROY, MainWindowHook, this);
}
NS_IMETHODIMP
TaskbarPreview::SetController(nsITaskbarPreviewController* aController) {
NS_ENSURE_ARG(aController);
mController = aController;
return NS_OK;
}
NS_IMETHODIMP
TaskbarPreview::GetController(nsITaskbarPreviewController** aController) {
NS_ADDREF(*aController = mController);
return NS_OK;
}
NS_IMETHODIMP
TaskbarPreview::GetTooltip(nsAString& aTooltip) {
aTooltip = mTooltip;
return NS_OK;
}
NS_IMETHODIMP
TaskbarPreview::SetTooltip(const nsAString& aTooltip) {
mTooltip = aTooltip;
return CanMakeTaskbarCalls() ? UpdateTooltip() : NS_OK;
}
NS_IMETHODIMP
TaskbarPreview::SetVisible(bool visible) {
if (mVisible == visible) return NS_OK;
mVisible = visible;
// If the nsWindow has already been destroyed but the caller is still trying
// to use it then just pretend that everything succeeded. The caller doesn't
// actually have a way to detect this since it's the same case as when we
// CanMakeTaskbarCalls returns false.
if (!IsWindowAvailable()) return NS_OK;
return visible ? Enable() : Disable();
}
NS_IMETHODIMP
TaskbarPreview::GetVisible(bool* visible) {
*visible = mVisible;
return NS_OK;
}
NS_IMETHODIMP
TaskbarPreview::SetActive(bool active) {
if (active)
sActivePreview = this;
else if (sActivePreview == this)
sActivePreview = nullptr;
return CanMakeTaskbarCalls() ? ShowActive(active) : NS_OK;
}
NS_IMETHODIMP
TaskbarPreview::GetActive(bool* active) {
*active = sActivePreview == this;
return NS_OK;
}
NS_IMETHODIMP
TaskbarPreview::Invalidate() {
if (!mVisible) return NS_OK;
// DWM Composition is required for previews
if (!gfxWindowsPlatform::GetPlatform()->DwmCompositionEnabled()) return NS_OK;
HWND previewWindow = PreviewWindow();
return FAILED(DwmInvalidateIconicBitmaps(previewWindow)) ? NS_ERROR_FAILURE
: NS_OK;
}
nsresult TaskbarPreview::UpdateTaskbarProperties() {
nsresult rv = UpdateTooltip();
// If we are the active preview and our window is the active window, restore
// our active state - otherwise some other non-preview window is now active
// and should be displayed as so.
if (sActivePreview == this) {
if (mWnd == ::GetActiveWindow()) {
nsresult rvActive = ShowActive(true);
if (NS_FAILED(rvActive)) rv = rvActive;
} else {
sActivePreview = nullptr;
}
}
return rv;
}
nsresult TaskbarPreview::Enable() {
nsresult rv = NS_OK;
if (CanMakeTaskbarCalls()) {
rv = UpdateTaskbarProperties();
} else if (IsWindowAvailable()) {
WindowHook* hook = GetWindowHook();
MOZ_ASSERT(hook,
"IsWindowAvailable() should have eliminated the null case.");
hook->AddMonitor(nsAppShell::GetTaskbarButtonCreatedMessage(),
MainWindowHook, this);
}
return rv;
}
nsresult TaskbarPreview::Disable() {
if (!IsWindowAvailable()) {
// Window is already destroyed
return NS_OK;
}
WindowHook* hook = GetWindowHook();
MOZ_ASSERT(hook, "IsWindowAvailable() should have eliminated the null case.");
(void)hook->RemoveMonitor(nsAppShell::GetTaskbarButtonCreatedMessage(),
MainWindowHook, this);
return NS_OK;
}
bool TaskbarPreview::IsWindowAvailable() const {
if (mWnd) {
nsWindow* win = WinUtils::GetNSWindowPtr(mWnd);
if (win && !win->Destroyed()) {
return true;
}
}
return false;
}
void TaskbarPreview::DetachFromNSWindow() {
if (WindowHook* hook = GetWindowHook()) {
hook->RemoveMonitor(WM_DESTROY, MainWindowHook, this);
}
mWnd = nullptr;
}
LRESULT
TaskbarPreview::WndProc(UINT nMsg, WPARAM wParam, LPARAM lParam) {
switch (nMsg) {
case WM_DWMSENDICONICTHUMBNAIL: {
uint32_t width = HIWORD(lParam);
uint32_t height = LOWORD(lParam);
float aspectRatio = width / float(height);
nsresult rv;
float preferredAspectRatio;
rv = mController->GetThumbnailAspectRatio(&preferredAspectRatio);
if (NS_FAILED(rv)) break;
uint32_t thumbnailWidth = width;
uint32_t thumbnailHeight = height;
if (aspectRatio > preferredAspectRatio) {
thumbnailWidth = uint32_t(thumbnailHeight * preferredAspectRatio);
} else {
thumbnailHeight = uint32_t(thumbnailWidth / preferredAspectRatio);
}
DrawBitmap(thumbnailWidth, thumbnailHeight, false);
} break;
case WM_DWMSENDICONICLIVEPREVIEWBITMAP: {
uint32_t width, height;
nsresult rv;
rv = mController->GetWidth(&width);
if (NS_FAILED(rv)) break;
rv = mController->GetHeight(&height);
if (NS_FAILED(rv)) break;
double scale = StaticPrefs::layout_css_devPixelsPerPx();
if (scale <= 0.0) {
scale = WinUtils::LogToPhysFactor(PreviewWindow());
}
DrawBitmap(NSToIntRound(scale * width), NSToIntRound(scale * height),
true);
} break;
}
return ::DefWindowProcW(PreviewWindow(), nMsg, wParam, lParam);
}
bool TaskbarPreview::CanMakeTaskbarCalls() {
// If the nsWindow has already been destroyed and we know it but our caller
// clearly doesn't so we can't make any calls.
if (!mWnd) return false;
// Certain functions like SetTabOrder seem to require a visible window. During
// window close, the window seems to be hidden before being destroyed.
if (!::IsWindowVisible(mWnd)) return false;
if (mVisible) {
nsWindow* window = WinUtils::GetNSWindowPtr(mWnd);
NS_ASSERTION(window, "Could not get nsWindow from HWND");
return window ? window->HasTaskbarIconBeenCreated() : false;
}
return false;
}
WindowHook* TaskbarPreview::GetWindowHook() {
nsWindow* window = WinUtils::GetNSWindowPtr(mWnd);
NS_ASSERTION(window, "Cannot use taskbar previews in an embedded context!");
return window ? &window->GetWindowHook() : nullptr;
}
void TaskbarPreview::EnableCustomDrawing(HWND aHWND, bool aEnable) {
BOOL enabled = aEnable;
DwmSetWindowAttribute(aHWND, DWMWA_FORCE_ICONIC_REPRESENTATION, &enabled,
sizeof(enabled));
DwmSetWindowAttribute(aHWND, DWMWA_HAS_ICONIC_BITMAP, &enabled,
sizeof(enabled));
}
nsresult TaskbarPreview::UpdateTooltip() {
NS_ASSERTION(CanMakeTaskbarCalls() && mVisible,
"UpdateTooltip called on invisible tab preview");
if (FAILED(mTaskbar->SetThumbnailTooltip(PreviewWindow(), mTooltip.get())))
return NS_ERROR_FAILURE;
return NS_OK;
}
void TaskbarPreview::DrawBitmap(uint32_t width, uint32_t height,
bool isPreview) {
nsresult rv;
nsCOMPtr<nsITaskbarPreviewCallback> callback =
do_CreateInstance("@mozilla.org/widget/taskbar-preview-callback;1", &rv);
if (NS_FAILED(rv)) {
return;
}
((TaskbarPreviewCallback*)callback.get())->SetPreview(this);
if (isPreview) {
((TaskbarPreviewCallback*)callback.get())->SetIsPreview();
mController->RequestPreview(callback);
} else {
mController->RequestThumbnail(callback, width, height);
}
}
///////////////////////////////////////////////////////////////////////////////
// TaskbarPreviewCallback
NS_IMPL_ISUPPORTS(TaskbarPreviewCallback, nsITaskbarPreviewCallback)
/* void done (in nsISupports aCanvas, in boolean aDrawBorder); */
NS_IMETHODIMP
TaskbarPreviewCallback::Done(nsISupports* aCanvas, bool aDrawBorder) {
// We create and destroy TaskbarTabPreviews from front end code in response
// to TabOpen and TabClose events. Each TaskbarTabPreview creates and owns a
// proxy HWND which it hands to Windows as a tab identifier. When a tab
// closes, TaskbarTabPreview Disable() method is called by front end, which
// destroys the proxy window and clears mProxyWindow which is the HWND
// returned from PreviewWindow(). So, since this is async, we should check to
// be sure the tab is still alive before doing all this gfx work and making
// dwm calls. To accomplish this we check the result of PreviewWindow().
if (!aCanvas || !mPreview || !mPreview->PreviewWindow() ||
!mPreview->IsWindowAvailable()) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIContent> content(do_QueryInterface(aCanvas));
auto canvas = dom::HTMLCanvasElement::FromNodeOrNull(content);
if (!canvas) {
return NS_ERROR_FAILURE;
}
RefPtr<gfx::SourceSurface> source = canvas->GetSurfaceSnapshot();
if (!source) {
return NS_ERROR_FAILURE;
}
RefPtr<gfxWindowsSurface> target = new gfxWindowsSurface(
source->GetSize(), gfx::SurfaceFormat::A8R8G8B8_UINT32);
if (!target) {
return NS_ERROR_FAILURE;
}
RefPtr<gfx::DataSourceSurface> srcSurface = source->GetDataSurface();
RefPtr<gfxImageSurface> imageSurface = target->GetAsImageSurface();
if (!srcSurface || !imageSurface) {
return NS_ERROR_FAILURE;
}
gfx::DataSourceSurface::MappedSurface sourceMap;
srcSurface->Map(gfx::DataSourceSurface::READ, &sourceMap);
mozilla::gfx::CopySurfaceDataToPackedArray(
sourceMap.mData, imageSurface->Data(), srcSurface->GetSize(),
sourceMap.mStride, BytesPerPixel(srcSurface->GetFormat()));
srcSurface->Unmap();
HDC hDC = target->GetDC();
HBITMAP hBitmap = (HBITMAP)GetCurrentObject(hDC, OBJ_BITMAP);
DWORD flags = aDrawBorder ? DWM_SIT_DISPLAYFRAME : 0;
POINT pptClient = {0, 0};
HRESULT hr;
if (!mIsThumbnail) {
hr = DwmSetIconicLivePreviewBitmap(mPreview->PreviewWindow(), hBitmap,
&pptClient, flags);
} else {
hr = DwmSetIconicThumbnail(mPreview->PreviewWindow(), hBitmap, flags);
}
MOZ_ASSERT(SUCCEEDED(hr));
(void)hr;
return NS_OK;
}
/* static */
bool TaskbarPreview::MainWindowHook(void* aContext, HWND hWnd, UINT nMsg,
WPARAM wParam, LPARAM lParam,
LRESULT* aResult) {
NS_ASSERTION(nMsg == nsAppShell::GetTaskbarButtonCreatedMessage() ||
nMsg == WM_DESTROY,
"Window hook proc called with wrong message");
NS_ASSERTION(aContext, "Null context in MainWindowHook");
if (!aContext) return false;
TaskbarPreview* preview = reinterpret_cast<TaskbarPreview*>(aContext);
if (nMsg == WM_DESTROY) {
// nsWindow is being destroyed
// We can't really do anything at this point including removing hooks
return false;
} else {
nsWindow* window = WinUtils::GetNSWindowPtr(preview->mWnd);
if (window) {
window->SetHasTaskbarIconBeenCreated();
if (preview->mVisible) preview->UpdateTaskbarProperties();
}
}
return false;
}
TaskbarPreview* TaskbarPreview::sActivePreview = nullptr;
} // namespace widget
} // namespace mozilla