The Tor Browser / file comparison

comparison: widget/windows/TaskbarTabPreview.cpp

widget/windows/TaskbarTabPreview.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:841512ded4c9
1 /* vim: se cin sw=2 ts=2 et : */
2 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7
8 #include "TaskbarTabPreview.h"
9 #include "nsWindowGfx.h"
10 #include "nsUXThemeData.h"
11 #include "WinUtils.h"
12 #include <nsITaskbarPreviewController.h>
13
14 #define TASKBARPREVIEW_HWNDID L"TaskbarTabPreviewHwnd"
15
16 namespace mozilla {
17 namespace widget {
18
19 NS_IMPL_ISUPPORTS(TaskbarTabPreview, nsITaskbarTabPreview)
20
21 const wchar_t *const kWindowClass = L"MozillaTaskbarPreviewClass";
22
23 TaskbarTabPreview::TaskbarTabPreview(ITaskbarList4 *aTaskbar, nsITaskbarPreviewController *aController, HWND aHWND, nsIDocShell *aShell)
24 : TaskbarPreview(aTaskbar, aController, aHWND, aShell),
25 mProxyWindow(nullptr),
26 mIcon(nullptr),
27 mRegistered(false)
28 {
29 WindowHook &hook = GetWindowHook();
30 hook.AddMonitor(WM_WINDOWPOSCHANGED, MainWindowHook, this);
31 }
32
33 TaskbarTabPreview::~TaskbarTabPreview() {
34 if (mIcon) {
35 ::DestroyIcon(mIcon);
36 mIcon = nullptr;
37 }
38
39 // We need to ensure that proxy window disappears or else Bad Things happen.
40 if (mProxyWindow)
41 Disable();
42
43 NS_ASSERTION(!mProxyWindow, "Taskbar proxy window was not destroyed!");
44
45 if (IsWindowAvailable()) {
46 DetachFromNSWindow();
47 } else {
48 mWnd = nullptr;
49 }
50 }
51
52 nsresult
53 TaskbarTabPreview::ShowActive(bool active) {
54 NS_ASSERTION(mVisible && CanMakeTaskbarCalls(), "ShowActive called on invisible window or before taskbar calls can be made for this window");
55 return FAILED(mTaskbar->SetTabActive(active ? mProxyWindow : nullptr,
56 mWnd, 0)) ? NS_ERROR_FAILURE : NS_OK;
57 }
58
59 HWND &
60 TaskbarTabPreview::PreviewWindow() {
61 return mProxyWindow;
62 }
63
64 nativeWindow
65 TaskbarTabPreview::GetHWND() {
66 return mProxyWindow;
67 }
68
69 void
70 TaskbarTabPreview::EnsureRegistration() {
71 NS_ASSERTION(mVisible && CanMakeTaskbarCalls(), "EnsureRegistration called when it is not safe to do so");
72
73 (void) UpdateTaskbarProperties();
74 }
75
76 NS_IMETHODIMP
77 TaskbarTabPreview::GetTitle(nsAString &aTitle) {
78 aTitle = mTitle;
79 return NS_OK;
80 }
81
82 NS_IMETHODIMP
83 TaskbarTabPreview::SetTitle(const nsAString &aTitle) {
84 mTitle = aTitle;
85 return mVisible ? UpdateTitle() : NS_OK;
86 }
87
88 NS_IMETHODIMP
89 TaskbarTabPreview::SetIcon(imgIContainer *icon) {
90 HICON hIcon = nullptr;
91 if (icon) {
92 nsresult rv;
93 rv = nsWindowGfx::CreateIcon(icon, false, 0, 0,
94 nsWindowGfx::GetIconMetrics(nsWindowGfx::kSmallIcon),
95 &hIcon);
96 NS_ENSURE_SUCCESS(rv, rv);
97 }
98
99 if (mIcon)
100 ::DestroyIcon(mIcon);
101 mIcon = hIcon;
102 mIconImage = icon;
103 return mVisible ? UpdateIcon() : NS_OK;
104 }
105
106 NS_IMETHODIMP
107 TaskbarTabPreview::GetIcon(imgIContainer **icon) {
108 NS_IF_ADDREF(*icon = mIconImage);
109 return NS_OK;
110 }
111
112 NS_IMETHODIMP
113 TaskbarTabPreview::Move(nsITaskbarTabPreview *aNext) {
114 if (aNext == this)
115 return NS_ERROR_INVALID_ARG;
116 mNext = aNext;
117 return CanMakeTaskbarCalls() ? UpdateNext() : NS_OK;
118 }
119
120 nsresult
121 TaskbarTabPreview::UpdateTaskbarProperties() {
122 if (mRegistered)
123 return NS_OK;
124
125 if (FAILED(mTaskbar->RegisterTab(mProxyWindow, mWnd)))
126 return NS_ERROR_FAILURE;
127
128 nsresult rv = UpdateNext();
129 NS_ENSURE_SUCCESS(rv, rv);
130 rv = TaskbarPreview::UpdateTaskbarProperties();
131 mRegistered = true;
132 return rv;
133 }
134
135 LRESULT
136 TaskbarTabPreview::WndProc(UINT nMsg, WPARAM wParam, LPARAM lParam) {
137 nsRefPtr<TaskbarTabPreview> kungFuDeathGrip(this);
138 switch (nMsg) {
139 case WM_CREATE:
140 TaskbarPreview::EnableCustomDrawing(mProxyWindow, true);
141 return 0;
142 case WM_CLOSE:
143 mController->OnClose();
144 return 0;
145 case WM_ACTIVATE:
146 if (LOWORD(wParam) == WA_ACTIVE) {
147 // Activate the tab the user selected then restore the main window,
148 // keeping normal/max window state intact.
149 bool activateWindow;
150 nsresult rv = mController->OnActivate(&activateWindow);
151 if (NS_SUCCEEDED(rv) && activateWindow) {
152 nsWindow* win = WinUtils::GetNSWindowPtr(mWnd);
153 if (win) {
154 nsWindow * parent = win->GetTopLevelWindow(true);
155 if (parent) {
156 parent->Show(true);
157 }
158 }
159 }
160 }
161 return 0;
162 case WM_GETICON:
163 return (LRESULT)mIcon;
164 case WM_SYSCOMMAND:
165 // Send activation events to the top level window and select the proper
166 // tab through the controller.
167 if (wParam == SC_RESTORE || wParam == SC_MAXIMIZE) {
168 bool activateWindow;
169 nsresult rv = mController->OnActivate(&activateWindow);
170 if (NS_SUCCEEDED(rv) && activateWindow) {
171 // Note, restoring an iconic, maximized window here will only
172 // activate the maximized window. This is not a bug, it's default
173 // windows behavior.
174 ::SendMessageW(mWnd, WM_SYSCOMMAND, wParam, lParam);
175 }
176 return 0;
177 }
178 // Forward everything else to the top level window. Do not forward
179 // close since that's intended for the tab. When the preview proxy
180 // closes, we'll close the tab above.
181 return wParam == SC_CLOSE
182 ? ::DefWindowProcW(mProxyWindow, WM_SYSCOMMAND, wParam, lParam)
183 : ::SendMessageW(mWnd, WM_SYSCOMMAND, wParam, lParam);
184 return 0;
185 }
186 return TaskbarPreview::WndProc(nMsg, wParam, lParam);
187 }
188
189 /* static */
190 LRESULT CALLBACK
191 TaskbarTabPreview::GlobalWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam) {
192 TaskbarTabPreview *preview(nullptr);
193 if (nMsg == WM_CREATE) {
194 CREATESTRUCT *cs = reinterpret_cast<CREATESTRUCT*>(lParam);
195 preview = reinterpret_cast<TaskbarTabPreview*>(cs->lpCreateParams);
196 if (!::SetPropW(hWnd, TASKBARPREVIEW_HWNDID, preview))
197 NS_ERROR("Could not associate native window with tab preview");
198 preview->mProxyWindow = hWnd;
199 } else {
200 preview = reinterpret_cast<TaskbarTabPreview*>(::GetPropW(hWnd, TASKBARPREVIEW_HWNDID));
201 if (nMsg == WM_DESTROY)
202 ::RemovePropW(hWnd, TASKBARPREVIEW_HWNDID);
203 }
204
205 if (preview)
206 return preview->WndProc(nMsg, wParam, lParam);
207 return ::DefWindowProcW(hWnd, nMsg, wParam, lParam);
208 }
209
210 nsresult
211 TaskbarTabPreview::Enable() {
212 WNDCLASSW wc;
213 HINSTANCE module = GetModuleHandle(nullptr);
214
215 if (!GetClassInfoW(module, kWindowClass, &wc)) {
216 wc.style = 0;
217 wc.lpfnWndProc = GlobalWndProc;
218 wc.cbClsExtra = 0;
219 wc.cbWndExtra = 0;
220 wc.hInstance = module;
221 wc.hIcon = nullptr;
222 wc.hCursor = nullptr;
223 wc.hbrBackground = (HBRUSH) nullptr;
224 wc.lpszMenuName = (LPCWSTR) nullptr;
225 wc.lpszClassName = kWindowClass;
226 RegisterClassW(&wc);
227 }
228 ::CreateWindowW(kWindowClass, L"TaskbarPreviewWindow",
229 WS_CAPTION | WS_SYSMENU, 0, 0, 200, 60,
230 nullptr, nullptr, module, this);
231 // GlobalWndProc will set mProxyWindow so that WM_CREATE can have a valid HWND
232 if (!mProxyWindow)
233 return NS_ERROR_INVALID_ARG;
234
235 UpdateProxyWindowStyle();
236
237 nsresult rv = TaskbarPreview::Enable();
238 nsresult rvUpdate;
239 rvUpdate = UpdateTitle();
240 if (NS_FAILED(rvUpdate))
241 rv = rvUpdate;
242
243 rvUpdate = UpdateIcon();
244 if (NS_FAILED(rvUpdate))
245 rv = rvUpdate;
246
247 return rv;
248 }
249
250 nsresult
251 TaskbarTabPreview::Disable() {
252 // TaskbarPreview::Disable assumes that mWnd is valid but this method can be
253 // called when it is null iff the nsWindow has already been destroyed and we
254 // are still visible for some reason during object destruction.
255 if (mWnd)
256 TaskbarPreview::Disable();
257
258 if (FAILED(mTaskbar->UnregisterTab(mProxyWindow)))
259 return NS_ERROR_FAILURE;
260 mRegistered = false;
261
262 // TaskbarPreview::WndProc will set mProxyWindow to null
263 if (!DestroyWindow(mProxyWindow))
264 return NS_ERROR_FAILURE;
265 mProxyWindow = nullptr;
266 return NS_OK;
267 }
268
269 void
270 TaskbarTabPreview::DetachFromNSWindow() {
271 (void) SetVisible(false);
272 WindowHook &hook = GetWindowHook();
273 hook.RemoveMonitor(WM_WINDOWPOSCHANGED, MainWindowHook, this);
274
275 TaskbarPreview::DetachFromNSWindow();
276 }
277
278 /* static */
279 bool
280 TaskbarTabPreview::MainWindowHook(void *aContext,
281 HWND hWnd, UINT nMsg,
282 WPARAM wParam, LPARAM lParam,
283 LRESULT *aResult) {
284 if (nMsg == WM_WINDOWPOSCHANGED) {
285 TaskbarTabPreview *preview = reinterpret_cast<TaskbarTabPreview*>(aContext);
286 WINDOWPOS *pos = reinterpret_cast<WINDOWPOS*>(lParam);
287 if (SWP_FRAMECHANGED == (pos->flags & SWP_FRAMECHANGED))
288 preview->UpdateProxyWindowStyle();
289 } else {
290 NS_NOTREACHED("Style changed hook fired on non-style changed message");
291 }
292 return false;
293 }
294
295 void
296 TaskbarTabPreview::UpdateProxyWindowStyle() {
297 if (!mProxyWindow)
298 return;
299
300 DWORD minMaxMask = WS_MINIMIZE | WS_MAXIMIZE;
301 DWORD windowStyle = GetWindowLongW(mWnd, GWL_STYLE);
302
303 DWORD proxyStyle = GetWindowLongW(mProxyWindow, GWL_STYLE);
304 proxyStyle &= ~minMaxMask;
305 proxyStyle |= windowStyle & minMaxMask;
306 SetWindowLongW(mProxyWindow, GWL_STYLE, proxyStyle);
307
308 DWORD exStyle = (WS_MAXIMIZE == (windowStyle & WS_MAXIMIZE)) ? WS_EX_TOOLWINDOW : 0;
309 SetWindowLongW(mProxyWindow, GWL_EXSTYLE, exStyle);
310 }
311
312 nsresult
313 TaskbarTabPreview::UpdateTitle() {
314 NS_ASSERTION(mVisible, "UpdateTitle called on invisible preview");
315
316 if (!::SetWindowTextW(mProxyWindow, mTitle.get()))
317 return NS_ERROR_FAILURE;
318 return NS_OK;
319 }
320
321 nsresult
322 TaskbarTabPreview::UpdateIcon() {
323 NS_ASSERTION(mVisible, "UpdateIcon called on invisible preview");
324
325 ::SendMessageW(mProxyWindow, WM_SETICON, ICON_SMALL, (LPARAM)mIcon);
326
327 return NS_OK;
328 }
329
330 nsresult
331 TaskbarTabPreview::UpdateNext() {
332 NS_ASSERTION(CanMakeTaskbarCalls() && mVisible, "UpdateNext called on invisible tab preview");
333 HWND hNext = nullptr;
334 if (mNext) {
335 bool visible;
336 nsresult rv = mNext->GetVisible(&visible);
337
338 NS_ENSURE_SUCCESS(rv, rv);
339
340 // Can only move next to enabled previews
341 if (!visible)
342 return NS_ERROR_FAILURE;
343
344 hNext = (HWND)mNext->GetHWND();
345
346 // hNext must be registered with the taskbar if the call is to succeed
347 mNext->EnsureRegistration();
348 }
349 if (FAILED(mTaskbar->SetTabOrder(mProxyWindow, hNext)))
350 return NS_ERROR_FAILURE;
351 return NS_OK;
352 }
353
354
355 } // namespace widget
356 } // namespace mozilla
357

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial