/* 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 "TaskbarTabPreview.h" #include "nsWindowGfx.h" #include "nsUXThemeData.h" #include "WinUtils.h" #include <nsITaskbarPreviewController.h> #define TASKBARPREVIEW_HWNDID L"TaskbarTabPreviewHwnd" namespace mozilla { namespace widget { NS_IMPL_ISUPPORTS(TaskbarTabPreview, nsITaskbarTabPreview) const wchar_t *const kWindowClass = L"MozillaTaskbarPreviewClass"; TaskbarTabPreview::TaskbarTabPreview(ITaskbarList4 *aTaskbar, nsITaskbarPreviewController *aController, HWND aHWND, nsIDocShell *aShell) : TaskbarPreview(aTaskbar, aController, aHWND, aShell), mProxyWindow(nullptr), mIcon(nullptr), mRegistered(false) { WindowHook &hook = GetWindowHook(); hook.AddMonitor(WM_WINDOWPOSCHANGED, MainWindowHook, this); } TaskbarTabPreview::~TaskbarTabPreview() { if (mIcon) { ::DestroyIcon(mIcon); mIcon = nullptr; } // We need to ensure that proxy window disappears or else Bad Things happen. if (mProxyWindow) Disable(); NS_ASSERTION(!mProxyWindow, "Taskbar proxy window was not destroyed!"); if (IsWindowAvailable()) { DetachFromNSWindow(); } else { mWnd = nullptr; } } nsresult TaskbarTabPreview::ShowActive(bool active) { NS_ASSERTION(mVisible && CanMakeTaskbarCalls(), "ShowActive called on invisible window or before taskbar calls can be made for this window"); return FAILED(mTaskbar->SetTabActive(active ? mProxyWindow : nullptr, mWnd, 0)) ? NS_ERROR_FAILURE : NS_OK; } HWND & TaskbarTabPreview::PreviewWindow() { return mProxyWindow; } nativeWindow TaskbarTabPreview::GetHWND() { return mProxyWindow; } void TaskbarTabPreview::EnsureRegistration() { NS_ASSERTION(mVisible && CanMakeTaskbarCalls(), "EnsureRegistration called when it is not safe to do so"); (void) UpdateTaskbarProperties(); } NS_IMETHODIMP TaskbarTabPreview::GetTitle(nsAString &aTitle) { aTitle = mTitle; return NS_OK; } NS_IMETHODIMP TaskbarTabPreview::SetTitle(const nsAString &aTitle) { mTitle = aTitle; return mVisible ? UpdateTitle() : NS_OK; } NS_IMETHODIMP TaskbarTabPreview::SetIcon(imgIContainer *icon) { HICON hIcon = nullptr; if (icon) { nsresult rv; rv = nsWindowGfx::CreateIcon(icon, false, 0, 0, nsWindowGfx::GetIconMetrics(nsWindowGfx::kSmallIcon), &hIcon); NS_ENSURE_SUCCESS(rv, rv); } if (mIcon) ::DestroyIcon(mIcon); mIcon = hIcon; mIconImage = icon; return mVisible ? UpdateIcon() : NS_OK; } NS_IMETHODIMP TaskbarTabPreview::GetIcon(imgIContainer **icon) { NS_IF_ADDREF(*icon = mIconImage); return NS_OK; } NS_IMETHODIMP TaskbarTabPreview::Move(nsITaskbarTabPreview *aNext) { if (aNext == this) return NS_ERROR_INVALID_ARG; mNext = aNext; return CanMakeTaskbarCalls() ? UpdateNext() : NS_OK; } nsresult TaskbarTabPreview::UpdateTaskbarProperties() { if (mRegistered) return NS_OK; if (FAILED(mTaskbar->RegisterTab(mProxyWindow, mWnd))) return NS_ERROR_FAILURE; nsresult rv = UpdateNext(); NS_ENSURE_SUCCESS(rv, rv); rv = TaskbarPreview::UpdateTaskbarProperties(); mRegistered = true; return rv; } LRESULT TaskbarTabPreview::WndProc(UINT nMsg, WPARAM wParam, LPARAM lParam) { RefPtr<TaskbarTabPreview> kungFuDeathGrip(this); switch (nMsg) { case WM_CREATE: TaskbarPreview::EnableCustomDrawing(mProxyWindow, true); return 0; case WM_CLOSE: mController->OnClose(); return 0; case WM_ACTIVATE: if (LOWORD(wParam) == WA_ACTIVE) { // Activate the tab the user selected then restore the main window, // keeping normal/max window state intact. bool activateWindow; nsresult rv = mController->OnActivate(&activateWindow); if (NS_SUCCEEDED(rv) && activateWindow) { nsWindow* win = WinUtils::GetNSWindowPtr(mWnd); if (win) { nsWindow * parent = win->GetTopLevelWindow(true); if (parent) { parent->Show(true); } } } } return 0; case WM_GETICON: return (LRESULT)mIcon; case WM_SYSCOMMAND: // Send activation events to the top level window and select the proper // tab through the controller. if (wParam == SC_RESTORE || wParam == SC_MAXIMIZE) { bool activateWindow; nsresult rv = mController->OnActivate(&activateWindow); if (NS_SUCCEEDED(rv) && activateWindow) { // Note, restoring an iconic, maximized window here will only // activate the maximized window. This is not a bug, it's default // windows behavior. ::SendMessageW(mWnd, WM_SYSCOMMAND, wParam, lParam); } return 0; } // Forward everything else to the top level window. Do not forward // close since that's intended for the tab. When the preview proxy // closes, we'll close the tab above. return wParam == SC_CLOSE ? ::DefWindowProcW(mProxyWindow, WM_SYSCOMMAND, wParam, lParam) : ::SendMessageW(mWnd, WM_SYSCOMMAND, wParam, lParam); return 0; } return TaskbarPreview::WndProc(nMsg, wParam, lParam); } /* static */ LRESULT CALLBACK TaskbarTabPreview::GlobalWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam) { TaskbarTabPreview *preview(nullptr); if (nMsg == WM_CREATE) { CREATESTRUCT *cs = reinterpret_cast<CREATESTRUCT*>(lParam); preview = reinterpret_cast<TaskbarTabPreview*>(cs->lpCreateParams); if (!::SetPropW(hWnd, TASKBARPREVIEW_HWNDID, preview)) NS_ERROR("Could not associate native window with tab preview"); preview->mProxyWindow = hWnd; } else { preview = reinterpret_cast<TaskbarTabPreview*>(::GetPropW(hWnd, TASKBARPREVIEW_HWNDID)); if (nMsg == WM_DESTROY) ::RemovePropW(hWnd, TASKBARPREVIEW_HWNDID); } if (preview) return preview->WndProc(nMsg, wParam, lParam); return ::DefWindowProcW(hWnd, nMsg, wParam, lParam); } nsresult TaskbarTabPreview::Enable() { WNDCLASSW wc; HINSTANCE module = GetModuleHandle(nullptr); if (!GetClassInfoW(module, kWindowClass, &wc)) { wc.style = 0; wc.lpfnWndProc = GlobalWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = module; wc.hIcon = nullptr; wc.hCursor = nullptr; wc.hbrBackground = (HBRUSH) nullptr; wc.lpszMenuName = (LPCWSTR) nullptr; wc.lpszClassName = kWindowClass; RegisterClassW(&wc); } ::CreateWindowW(kWindowClass, L"TaskbarPreviewWindow", WS_CAPTION | WS_SYSMENU, 0, 0, 200, 60, nullptr, nullptr, module, this); // GlobalWndProc will set mProxyWindow so that WM_CREATE can have a valid HWND if (!mProxyWindow) return NS_ERROR_INVALID_ARG; UpdateProxyWindowStyle(); nsresult rv = TaskbarPreview::Enable(); nsresult rvUpdate; rvUpdate = UpdateTitle(); if (NS_FAILED(rvUpdate)) rv = rvUpdate; rvUpdate = UpdateIcon(); if (NS_FAILED(rvUpdate)) rv = rvUpdate; return rv; } nsresult TaskbarTabPreview::Disable() { // TaskbarPreview::Disable assumes that mWnd is valid but this method can be // called when it is null iff the nsWindow has already been destroyed and we // are still visible for some reason during object destruction. if (mWnd) TaskbarPreview::Disable(); if (FAILED(mTaskbar->UnregisterTab(mProxyWindow))) return NS_ERROR_FAILURE; mRegistered = false; // TaskbarPreview::WndProc will set mProxyWindow to null if (!DestroyWindow(mProxyWindow)) return NS_ERROR_FAILURE; mProxyWindow = nullptr; return NS_OK; } void TaskbarTabPreview::DetachFromNSWindow() { (void) SetVisible(false); WindowHook &hook = GetWindowHook(); hook.RemoveMonitor(WM_WINDOWPOSCHANGED, MainWindowHook, this); TaskbarPreview::DetachFromNSWindow(); } /* static */ bool TaskbarTabPreview::MainWindowHook(void *aContext, HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam, LRESULT *aResult) { if (nMsg == WM_WINDOWPOSCHANGED) { TaskbarTabPreview *preview = reinterpret_cast<TaskbarTabPreview*>(aContext); WINDOWPOS *pos = reinterpret_cast<WINDOWPOS*>(lParam); if (SWP_FRAMECHANGED == (pos->flags & SWP_FRAMECHANGED)) preview->UpdateProxyWindowStyle(); } else { NS_NOTREACHED("Style changed hook fired on non-style changed message"); } return false; } void TaskbarTabPreview::UpdateProxyWindowStyle() { if (!mProxyWindow) return; DWORD minMaxMask = WS_MINIMIZE | WS_MAXIMIZE; DWORD windowStyle = GetWindowLongW(mWnd, GWL_STYLE); DWORD proxyStyle = GetWindowLongW(mProxyWindow, GWL_STYLE); proxyStyle &= ~minMaxMask; proxyStyle |= windowStyle & minMaxMask; SetWindowLongW(mProxyWindow, GWL_STYLE, proxyStyle); DWORD exStyle = (WS_MAXIMIZE == (windowStyle & WS_MAXIMIZE)) ? WS_EX_TOOLWINDOW : 0; SetWindowLongW(mProxyWindow, GWL_EXSTYLE, exStyle); } nsresult TaskbarTabPreview::UpdateTitle() { NS_ASSERTION(mVisible, "UpdateTitle called on invisible preview"); if (!::SetWindowTextW(mProxyWindow, mTitle.get())) return NS_ERROR_FAILURE; return NS_OK; } nsresult TaskbarTabPreview::UpdateIcon() { NS_ASSERTION(mVisible, "UpdateIcon called on invisible preview"); ::SendMessageW(mProxyWindow, WM_SETICON, ICON_SMALL, (LPARAM)mIcon); return NS_OK; } nsresult TaskbarTabPreview::UpdateNext() { NS_ASSERTION(CanMakeTaskbarCalls() && mVisible, "UpdateNext called on invisible tab preview"); HWND hNext = nullptr; if (mNext) { bool visible; nsresult rv = mNext->GetVisible(&visible); NS_ENSURE_SUCCESS(rv, rv); // Can only move next to enabled previews if (!visible) return NS_ERROR_FAILURE; hNext = (HWND)mNext->GetHWND(); // hNext must be registered with the taskbar if the call is to succeed mNext->EnsureRegistration(); } if (FAILED(mTaskbar->SetTabOrder(mProxyWindow, hNext))) return NS_ERROR_FAILURE; return NS_OK; } } // namespace widget } // namespace mozilla