| blob | ac8f44cd9becdc3df59b0c0563549e31f9d0ff49 |
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:set ts=2 sts=2 sw=2 et cin: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 /*
8 * nsWindow - Native window management and event handling.
9 *
10 * nsWindow is organized into a set of major blocks and
11 * block subsections. The layout is as follows:
12 *
13 * Includes
14 * Variables
15 * nsIWidget impl.
16 * nsIWidget methods and utilities
17 * nsSwitchToUIThread impl.
18 * nsSwitchToUIThread methods and utilities
19 * Moz events
20 * Event initialization
21 * Event dispatching
22 * Native events
23 * Wndproc(s)
24 * Event processing
25 * OnEvent event handlers
26 * IME management and accessibility
27 * Transparency
28 * Popup hook handling
29 * Misc. utilities
30 * Child window impl.
31 *
32 * Search for "BLOCK:" to find major blocks.
33 * Search for "SECTION:" to find specific sections.
34 *
35 * Blocks should be split out into separate files if they
36 * become unmanageable.
37 *
38 * Notable related sources:
39 *
40 * nsWindowDefs.h - Definitions, macros, structs, enums
41 * and general setup.
42 * nsWindowDbg.h/.cpp - Debug related code and directives.
43 * nsWindowGfx.h/.cpp - Graphics and painting.
44 *
45 */
47 /**************************************************************
48 **************************************************************
49 **
50 ** BLOCK: Includes
51 **
52 ** Include headers.
53 **
54 **************************************************************
55 **************************************************************/
77 #include <algorithm>
78 #include <limits>
86 #include <shellapi.h>
87 #include <windows.h>
88 #include <wtsapi32.h>
89 #include <process.h>
90 #include <commctrl.h>
91 #include <dbt.h>
92 #include <unknwn.h>
93 #include <psapi.h>
94 #include <rpc.h>
95 #include <propvarutil.h>
96 #include <propkey.h>
176 #include <zmouse.h>
177 #include <richedit.h>
179 #ifdef ACCESSIBILITY
180 # ifdef DEBUG
182 # endif
185 # include <uiautomation.h>
186 # include <winuser.h>
192 # if !defined(WINABLEAPI)
193 # include <winable.h>
195 #endif
210 #include <d3d11.h>
212 // ERROR from wingdi.h (below) gets undefined by some code.
213 // #define ERROR 0
214 // #define RGN_ERROR ERROR
215 #define ERROR 0
217 #if !defined(SM_CONVERTIBLESLATEMODE)
218 # define SM_CONVERTIBLESLATEMODE 0x2003
219 #endif
241 /**************************************************************
242 **************************************************************
243 **
244 ** BLOCK: Variables
245 **
246 ** nsWindow Class static initializations and global variables.
247 **
248 **************************************************************
249 **************************************************************/
251 /**************************************************************
252 *
253 * SECTION: nsWindow statics
254 *
255 **************************************************************/
266 // Urgent-message reentrancy depth for the static `WindowProc` callback.
267 //
268 // Three unfortunate facts collide:
269 //
270 // 𝛼) Some messages must be processed promptly. If not, Windows will leave the
271 // receiving window in an intermediate, and potentially unusable, state until
272 // the WindowProc invocation that is handling it returns.
273 //
274 // 𝛽) Some messages have indefinitely long processing time. These are mostly
275 // messages which may cause us to enter a nested modal loop (via
276 // `SpinEventLoopUntil` or similar).
277 //
278 // 𝛾) Sometimes, messages skip the queue entirely. Our `WindowProc` may be
279 // reentrantly reinvoked from the kernel while we're blocking _on_ the
280 // kernel, even briefly, during processing of other messages. (Relevant
281 // search term: `KeUserModeCallback`.)
282 //
283 // The nightmare scenario, then, is that during processing of an 𝛼-message, we
284 // briefly become blocked (e.g., by calling `::SendMessageW()`), and the kernel
285 // takes that opportunity to use 𝛾 to hand us a 𝛽-message. (Concretely, see
286 // bug 1842170.)
287 //
288 // There is little we can do to prevent the first half of this scenario. 𝛼) and
289 // 𝛾) are effectively immutable facts of Windows, and we sometimes legitimately
290 // need to make blocking calls to process 𝛼-messages. (We may not even be aware
291 // that we're making such calls, if they're undocumented implementation details
292 // of another API.)
293 //
294 // In an ideal world, WindowProc would always return promptly (or at least in
295 // bounded time), and 𝛽-messages would not _per se_ exist; long-running modal
296 // states would instead be implemented in async fashion. In practice, that's far
297 // easier said than done -- replacing existing uses of `SpinEventLoopUntil` _et
298 // al._ with asynchronous mechanisms is a collection of mostly-unrelated cross-
299 // cutting architectural tasks, each of potentially unbounded scope. For now,
300 // and for the foreseeable future, we're stuck with them.
301 //
302 // We therefore simply punt. More specifically: if a known 𝛽-message jumps the
303 // queue to come in while we're in the middle of processing a known 𝛼-message,
304 // we:
305 // * properly queue the message for processing later;
306 // * respond to the 𝛽-message as though we actually had processed it; and
307 // * just hope that it can wait until we get around to it.
308 //
309 // The word "known" requires a bit of justification. There is no canonical set
310 // of 𝛼-messages, nor is the set of 𝛽-messages fixed (or even demarcable). We
311 // can't safely assume that all messages are 𝛼-messages, as that could cause
312 // 𝛽-messages to be arbitrarily and surprisingly delayed whenever any nested
313 // event loop is active. We also can't assume all messages are 𝛽-messages,
314 // since one 𝛼-message jumping the queue while processing another 𝛼-message is
315 // part of normal and required operation for windowed Windows applications.
316 //
317 // So we simply add messages to those sets as we identify them. (Or, preferably,
318 // rework the 𝛽-message's handling to make it no longer 𝛽. But see above.)
319 //
320 // ---
321 //
322 // The actual value of `sDepth` is the number of active invocations of
323 // `WindowProc` that are processing known 𝛼-messages.
326 // Hook Data Members for Dropdowns. sProcessHook Tells the
327 // hook methods whether they should be processing the hook
328 // messages.
337 // Used to prevent dispatching mouse events that do not originate from user
338 // input.
349 }
351 // Global event hook for window cloaking. Never deregistered.
352 // - `Nothing` if not yet set.
353 // - `Some(nullptr)` if no attempt should be made to set it.
368 // There's already one inflight with this timestamp. Don't
369 // send a duplicate.
371 }
377 }
382 // The SKEWFIX message is stale; we've sent a new one since then.
383 // Ignore this one.
385 }
390 }
395 HWND mWnd;
396 };
403 /**************************************************************
404 *
405 * SECTION: globals variables
406 *
407 **************************************************************/
416 // General purpose user32.dll hook object
419 // When the client area is extended out into the default window frame area,
420 // this is the minimum amount of space along the edge of resizable windows
421 // we will always display a resize cursor in, regardless of the underlying
422 // content.
425 // Getting this object from the window server can be expensive. Keep it
426 // around, also get it off the main thread. (See bug 1640852)
430 // We should never really try to accelerate windows bigger than this. In some
431 // cases this might lead to no D3D9 acceleration where we could have had it
432 // but D3D9 does not reliably report when it supports bigger windows. 8192
433 // is as safe as we can get, we know at least D3D10 hardware always supports
434 // this, other hardware we expect to report correctly in D3D9.
435 #define MAX_ACCELERATED_DIMENSION 8192
437 // On window open (as well as after), Windows has an unfortunate habit of
438 // sending rather a lot of WM_NCHITTEST messages. Because we have to do point
439 // to DOM target conversions for these, we cache responses for a given
440 // coordinate this many milliseconds:
441 #define HITTEST_CACHE_LIFETIME_MS 50
443 #if defined(ACCESSIBILITY)
447 /**
448 * Windows touchscreen code works by setting a global WH_GETMESSAGE hook and
449 * injecting tiptsf.dll. The touchscreen process then posts registered messages
450 * to our main thread. The tiptsf hook picks up those registered messages and
451 * uses them as commands, some of which call into UIA, which then calls into
452 * MSAA, which then sends WM_GETOBJECT to us.
453 *
454 * We can get ahead of this by installing our own thread-local WH_GETMESSAGE
455 * hook. Since thread-local hooks are called ahead of global hooks, we will
456 * see these registered messages before tiptsf does. At this point we can then
457 * raise a flag that blocks a11y before invoking CallNextHookEx which will then
458 * invoke the global tiptsf hook. Then when we see WM_GETOBJECT, we check the
459 * flag by calling TIPMessageHandler::IsA11yBlocked().
460 *
461 * For Windows 8, we also hook tiptsf!ProcessCaretEvents, which is an a11y hook
462 * function that also calls into UIA.
463 */
469 }
470 }
475 }
479 }
484 }
487 }
493 // Registered messages used by tiptsf
511 }
512 }
519 }
521 }
526 }
529 }
530 };
537 }
544 A11yInstantiationBlocker block;
546 }
547 }
550 }
555 PDWORD_PTR aMsgResult) {
556 // We don't want to handle this unless the message is a WM_GETOBJECT that we
557 // want to block, and the aHwnd is a nsWindow that belongs to the current
558 // (i.e., main) thread.
564 }
566 // In this case we want to fake the result that would happen if we had
567 // decided not to handle WM_GETOBJECT in our WndProc. We hand the message
568 // off to DefWindowProc to accomplish this.
573 }
576 sSendMessageTimeoutWStub;
579 HHOOK mHook;
582 };
594 // This task will get the VirtualDesktopManager from the generic thread pool
595 // since doing this on the main thread on startup causes performance issues.
596 //
597 // See bug 1640852.
598 //
599 // This should be fine and should not require any locking, as when the main
600 // thread will access it, if it races with this function it will either find
601 // it to be null or to have a valid value.
607 #ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
611 }
612 #endif
621 }
625 }
626 };
628 // Ground-truth query: does Windows claim the window is cloaked right now?
630 DWORD cloakedState;
638 }
641 }
645 /**************************************************************
646 **************************************************************
647 **
648 ** BLOCK: nsIWidget impl.
649 **
650 ** nsIWidget interface implementation, broken down into
651 ** sections.
652 **
653 **************************************************************
654 **************************************************************/
656 /**************************************************************
657 *
658 * SECTION: nsWindow construction and destruction
659 *
660 **************************************************************/
677 }
679 // Global initialization
681 // Global app registration id for Win7 and up. See
682 // WinTaskbar.cpp for details.
683 // MSIX packages explicitly do not support setting the appid from within
684 // the app, as it is set in the package manifest instead.
687 }
690 }
691 #if defined(ACCESSIBILITY)
696 }
699 // Init theme data
704 sInstanceCount++;
705 }
710 // If the widget was released without calling Destroy() then the native window
711 // still exists, and we need to destroy it. Destroy() will early-return if it
712 // was already called. In any case it is important to call it before
713 // destroying mPresentLock (cf. 1156182).
716 // Free app icon resources. This must happen after `OnDestroy` (see bug
717 // 708033).
722 sInstanceCount--;
724 // Global shutdown
727 sCurrentCursor = {};
732 }
733 }
736 }
738 /**************************************************************
739 *
740 * SECTION: nsIWidget::Create, nsIWidget::Destroy
741 *
742 * Creating and destroying windows for this widget.
743 *
744 **************************************************************/
746 // Allow Derived classes to modify the height that is passed
747 // when the window is created or resized.
751 LRESULT popupHandlingResult;
753 // We need to consume the event after using it to roll up the popup(s).
755 }
758 // Give the swipe tracker a first pass at the event. If a new pan gesture
759 // has been started since the beginning of the swipe, the swipe tracker
760 // will know to ignore the event.
761 nsEventStatus status =
765 }
766 }
768 APZEventResult result;
771 }
774 }
785 }
788 }
793 }
798 }
805 }
811 }
818 }
825 }
826 }
832 }
833 }
835 // Create the proper widget
839 // Historical note: there was once some belief and/or intent that nsWindows
840 // could be created on arbitrary threads, and this may still be reflected in
841 // some comments.
857 // Ensure that the toolkit is created.
862 HWND parent;
868 mParent =
870 }
884 }
886 // Make sure CreateWindowEx succeeds at creating a toplevel window
889 // See if the caller wants to explictly set clip children and clip siblings
894 }
897 }
898 }
902 // Take specific actions when creating the first top-level window
914 errorString);
915 }
918 "The skeleton UI window style should match the expected "
921 "The skeleton UI window extended style should match the "
925 "The skeleton UI window should be created on the same thread as "
929 // If we successfully consumed the pre-XUL skeleton UI, just update
930 // our internal state to match what is currently being displayed.
935 // These match the margins set in browser-tabsintitlebar.js with
936 // default prefs on Windows. Bug 1673092 tracks lining this up with
937 // that more correctly instead of hard-coding it.
940 // Reset the WNDPROC for this window and its whole class, as we had
941 // to use our own WNDPROC when creating the the skeleton UI window.
948 }
949 }
952 mWnd =
956 }
961 }
966 // C++03 lambda approximation until P2173R1 is available (-std=c++2b)
971 DWORD idEventThread,
972 DWORD dwmsEventTime) {
975 }
976 };
988 err));
989 }
990 }
995 // Although permanent Private Browsing mode is indeed Private Browsing,
996 // we choose to make it look like regular Firefox in terms of the icon
997 // it uses (which also means we shouldn't use the Private Browsing
998 // AUMID).
1003 PROPVARIANT pv;
1004 nsAutoString aumid;
1005 // make sure we're using the private browsing AUMID so that taskbar
1006 // grouping works properly
1012 }
1015 }
1016 }
1021 }
1022 }
1026 // If mDefaultScale is set before mWnd has been set, it will have the scale of
1027 // the primary monitor, rather than the monitor that the window is actually
1028 // on. For non-popup windows this gets corrected by the WM_DPICHANGED message
1029 // which resets mDefaultScale, but for popup windows we don't reset
1030 // mDefaultScale on that message. In order to ensure that popup windows
1031 // spawned on a non-primary monitor end up with the correct scale, we reset
1032 // mDefaultScale here so that it gets recomputed using the correct monitor now
1033 // that we have a mWnd.
1040 }
1046 }
1051 }
1055 // Ugly Thinkpad Driver Hack (Bugs 507222 and 594977)
1056 //
1057 // We create two zero-sized windows as descendants of the top-level window,
1058 // like so:
1059 //
1060 // Top-level window (MozillaWindowClass)
1061 // FAKETRACKPOINTSCROLLCONTAINER (MozillaWindowClass)
1062 // FAKETRACKPOINTSCROLLABLE (MozillaWindowClass)
1063 //
1064 // We need to have the middle window, otherwise the Trackpoint driver
1065 // will fail to deliver scroll messages. WM_MOUSEWHEEL messages are
1066 // sent to the FAKETRACKPOINTSCROLLABLE, which then propagate up the
1067 // window hierarchy until they are handled by nsWindow::WindowProc.
1068 // WM_HSCROLL messages are also sent to the FAKETRACKPOINTSCROLLABLE,
1069 // but these do not propagate automatically, so we have the window
1070 // procedure pretend that they were dispatched to the top-level window
1071 // instead.
1072 //
1073 // The FAKETRACKPOINTSCROLLABLE needs to have the specific window styles it
1074 // is given below so that it catches the Trackpoint driver's heuristics.
1083 // Give the FAKETRACKPOINTSCROLLABLE window a specific ID so that
1084 // WindowProcInternal can distinguish it from the top-level window
1085 // easily.
1088 // Make FAKETRACKPOINTSCROLLABLE use nsWindow::WindowProc, and store the
1089 // old window procedure in its "user data".
1093 }
1095 // We will start receiving native events after associating with our native
1096 // window. We will also become the output of WinUtils::GetNSWindowPtr for that
1097 // window.
1100 }
1102 // Starting with Windows XP, a process always runs within a terminal services
1103 // session. In order to play nicely with RDP, fast user switching, and the
1104 // lock screen, we should be handling WM_WTSSESSION_CHANGE. We must register
1105 // our HWND in order to receive this message.
1118 }
1119 }
1124 }
1133 }
1134 }
1136 // Close this nsWindow
1138 // WM_DESTROY has already fired, avoid calling it twice
1141 // Don't destroy windows that have file pickers open, we'll tear these down
1142 // later once the picker is closed.
1146 // During the destruction of all of our children, make sure we don't get
1147 // deleted.
1152 /**
1153 * On windows the LayerManagerOGL destructor wants the widget to be around for
1154 * cleanup. It also would like to have the HWND intact, so we nullptr it here.
1155 */
1161 // The DestroyWindow function destroys the specified window. The function
1162 // sends WM_DESTROY and WM_NCDESTROY messages to the window to deactivate it
1163 // and remove the keyboard focus from it. The function also destroys the
1164 // window's menu, flushes the thread message queue, destroys timers, removes
1165 // clipboard ownership, and breaks the clipboard viewer chain (if the window
1166 // is at the top of the viewer chain).
1167 //
1168 // If the specified window is a parent or owner window, DestroyWindow
1169 // automatically destroys the associated child or owned windows when it
1170 // destroys the parent or owner window. The function first destroys child or
1171 // owned windows, and then it destroys the parent or owner window.
1174 // Our windows can be subclassed which may prevent us receiving WM_DESTROY. If
1175 // OnDestroy() didn't get called, call it now.
1177 MSGResult msgResult;
1180 }
1181 }
1183 /**************************************************************
1184 *
1185 * SECTION: Window class utilities
1186 *
1187 * Utilities for calculating the proper window class name for
1188 * Create window.
1189 *
1190 **************************************************************/
1192 /* static */
1195 WNDCLASSW wc;
1197 // already registered
1199 }
1214 // For older versions of Win32 (i.e., not XP), the registration may
1215 // fail with aExtraStyle, so we have to re-register without it.
1218 }
1220 }
1224 /* static */
1236 }
1237 }();
1239 }
1241 /**************************************************************
1242 *
1243 * SECTION: Window styles utilities
1244 *
1245 * Return the proper windows styles and extended styles.
1246 *
1247 **************************************************************/
1257 }
1260 }
1264 }
1267 }
1269 // Looks like getting rid of the system menu also does away with the close
1270 // box. So, we only get rid of the system menu and the close box if you
1271 // want neither. How does the Windows "Dialog" window class get just
1272 // closebox and no sysmenu? Who knows.
1274 }
1277 }
1280 }
1283 }
1285 }
1287 // Return nsWindow styles
1289 DWORD style;
1300 }
1316 }
1324 }
1325 }
1329 }
1331 // Return nsWindow extended styles
1340 }
1342 }
1347 }
1352 }
1354 }
1356 /**************************************************************
1357 *
1358 * SECTION: Native window association utilities
1359 *
1360 * Used in Create and Destroy. A nsWindow can associate with its
1361 * underlying native window mWnd. Once a native window is
1362 * associated with a nsWindow, its native events will be handled
1363 * by the static member function nsWindow::WindowProc. Moreover,
1364 * the association will be registered in the WinUtils association
1365 * list, that is, calling WinUtils::GetNSWindowPtr on the native
1366 * window will return the associated nsWindow. This is used in
1367 * nsWindow::WindowProc to correctly dispatch native events to
1368 * the handler methods defined in nsWindow, even though it is a
1369 * static member function.
1370 *
1371 * After dissociation, the native events of the native window will
1372 * no longer be handled by nsWindow::WindowProc, and will thus not
1373 * be dispatched to the nsWindow native event handler methods.
1374 * Moreover, the association will no longer be registered in the
1375 * WinUtils association list, so calling WinUtils::GetNSWindowPtr
1376 * on the native window will return nullptr.
1377 *
1378 **************************************************************/
1384 }
1386 // Connect the this pointer to the native window handle.
1387 // This should be done before SetWindowLongPtrW, because nsWindow::WindowProc
1388 // uses WinUtils::GetNSWindowPtr internally.
1398 }
1402 }
1407 }
1417 }
1419 /**************************************************************
1420 *
1421 * SECTION: nsIWidget::SetParent, nsIWidget::GetParent
1422 *
1423 * Set or clear the parent widgets using window properties, and
1424 * handles calculating native parent handles.
1425 *
1426 **************************************************************/
1428 // Get and set parent widgets
1434 }
1442 }
1444 // If we have no parent, SetParent should return the desktop.
1447 }
1448 }
1456 }
1462 }
1463 }
1468 }
1471 }
1473 }
1478 }
1485 }
1487 }
1492 }
1494 }
1499 }
1503 }
1507 // Must use a flag instead of mWindowType to tell if the window is the
1508 // owned by the topmost widget, because a child window can be embedded
1509 // inside a HWND which is not associated with a nsIWidget.
1511 }
1513 // If this widget has already been destroyed, pretend we have no parent.
1514 // This corresponds to code in Destroy which removes the destroyed
1515 // widget from its parent's child list.
1518 // aIncludeOwner set to true implies walking the parent chain to retrieve the
1519 // root owner. aIncludeOwner set to false implies the search will stop at the
1520 // true parent (default).
1526 else
1532 // If the widget is in the process of being destroyed then
1533 // do NOT return it
1536 }
1537 }
1538 }
1539 }
1542 }
1544 /**************************************************************
1545 *
1546 * SECTION: nsIWidget::Show
1547 *
1548 * Hide or show this component.
1549 *
1550 **************************************************************/
1554 // The first time we decide to actually show the window is when we decide
1555 // that we've taken over the window from the skeleton UI, and we should
1556 // no longer treat resizes / moves specially.
1558 #if defined(ACCESSIBILITY)
1559 // If our HWND has focus and the a11y engine hasn't started yet, fire a
1560 // focus win event. Windows already did this when the skeleton UI appeared,
1561 // but a11y wouldn't have been able to start at that point even if a client
1562 // responded. Firing this now gives clients the chance to respond with
1563 // WM_GETOBJECT, which will trigger the a11y engine. We don't want to do
1564 // this if the a11y engine has already started because it has probably
1565 // already fired focus on a descendant.
1568 }
1570 }
1574 // WS_EX_COMPOSITED conflicts with the WS_EX_LAYERED style and causes
1575 // some popup menus to become invisible.
1579 }
1580 }
1585 // Set the status now so that anyone asking during ShowWindow or
1586 // SetWindowPos would get the correct answer.
1592 // speed up the initial paint after show for
1593 // top level windows:
1596 // Set the cursor before showing the window to avoid the default wait
1597 // cursor.
1615 // Don't flicker the window if we're restoring session
1618 }
1619 }
1621 }
1626 }
1629 }
1632 // ensure popups are the topmost of the TOPMOST
1633 // layer. Remember not to set the SWP_NOZORDER
1634 // flag as that might allow the taskbar to overlap
1635 // the popup.
1639 // PopupLevel::Top popups should be above all else. All other
1640 // types should be placed in front of their owner, without
1641 // changing the owner's z-level relative to other windows.
1648 }
1651 }
1657 }
1658 }
1660 // Clear contents to avoid ghosting of old content if we display
1661 // this window again.
1665 }
1666 }
1672 SWP_NOACTIVATE);
1673 }
1674 }
1675 }
1681 }
1682 }
1686 }
1687 }
1689 /**************************************************************
1690 *
1691 * SECTION: nsIWidget::IsVisible
1692 *
1693 * Returns the visibility state.
1694 *
1695 **************************************************************/
1697 // Return true if the component is visible, false otherwise.
1698 //
1699 // This does not take cloaking into account.
1702 /**************************************************************
1703 *
1704 * SECTION: Touch and APZ-related functions
1705 *
1706 **************************************************************/
1712 }
1718 }
1720 }
1727 }
1728 }
1730 /**************************************************************
1731 *
1732 * SECTION: nsIWidget::SetInputRegion
1733 *
1734 * Sets whether the window should ignore mouse events.
1735 *
1736 **************************************************************/
1739 }
1741 /**************************************************************
1742 *
1743 * SECTION: nsIWidget::Move, nsIWidget::Resize, nsIWidget::Size
1744 *
1745 * Repositioning and sizing a window.
1746 *
1747 **************************************************************/
1757 }
1760 // We can't make ThebesLayers bigger than this anyway.. no point it letting
1761 // a window grow bigger as we won't be able to draw content there in
1762 // general.
1765 }
1770 }
1776 }
1781 }
1784 }
1787 }
1790 }
1792 }
1794 // Move this component
1799 }
1801 // for top-level windows only, convert coordinates from desktop pixels
1802 // (the "parent" coordinate space) to the window's device pixel space
1808 // Check to see if window needs to be moved first
1809 // to avoid a costly call to SetWindowPos. This check
1810 // can not be moved to the calling code in nsView, because
1811 // some platforms do not position child windows correctly
1813 // Only perform this check for non-popup windows, since the positioning can
1814 // in fact change even when the x/y do not. We always need to perform the
1815 // check. See bug #97805 for details.
1817 // Nothing to do, since it is already positioned correctly.
1819 }
1824 #ifdef DEBUG
1825 // complain if a window is moved offscreen (legal, but potentially
1826 // worrisome)
1828 // Make sure this window is actually on the screen before we move it
1829 // XXX: Needs multiple monitor support
1833 RECT workArea;
1835 // no annoying assertions. just mention the issue.
1839 }
1840 }
1842 }
1843 }
1844 #endif
1846 // Normally, when the skeleton UI is disabled, we resize+move the window
1847 // before showing it in order to ensure that it restores to the correct
1848 // position when the user un-maximizes it. However, when we are using the
1849 // skeleton UI, this results in the skeleton UI window being moved around
1850 // undesirably before being locked back into the maximized position. To
1851 // avoid this, we simply set the placement to restore to via
1852 // SetWindowPlacement. It's a little bit more of a dance, though, since we
1853 // need to convert the workspace coords that SetWindowPlacement uses to the
1854 // screen space coordinates we normally use with SetWindowPos.
1862 }
1883 }
1884 }
1887 }
1888 }
1890 // Resize this component
1892 // for top-level windows only, convert coordinates from desktop pixels
1893 // (the "parent" coordinate space) to the window's device pixel space
1904 }
1908 // Avoid unnecessary resizing calls
1912 }
1914 }
1916 // Set cached value for lightweight and printing
1921 }
1924 // Refer to the comment above a similar check in nsWindow::Move
1938 }
1948 }
1949 }
1952 }
1955 }
1957 // Resize this component
1960 // for top-level windows only, convert coordinates from desktop pixels
1961 // (the "parent" coordinate space) to the window's device pixel space
1975 }
1979 // Avoid unnecessary resizing calls
1983 }
1985 }
1987 // Set cached value for lightweight and printing
1991 // Refer to the comment above a similar check in nsWindow::Move
1999 }
2016 }
2025 }
2028 // If we have a fullscreen transition window, we need to make
2029 // it topmost again, otherwise the taskbar may be raised by
2030 // the system unexpectedly when we leave fullscreen state.
2033 }
2034 }
2037 }
2040 }
2042 /**************************************************************
2043 *
2044 * SECTION: Window Z-order and state.
2045 *
2046 * nsIWidget::PlaceBehind, nsIWidget::SetSizeMode,
2047 * nsIWidget::ConstrainPosition
2048 *
2049 * Z-order, positioning, restore, minimize, and maximize.
2050 *
2051 **************************************************************/
2053 // Position the window behind the given window
2065 // Can't place the window to top so place it behind the foreground window
2066 // (as long as it is not topmost)
2073 }
2076 }
2079 WINDOWPLACEMENT pl;
2083 }
2085 // Maximize, minimize or restore the window.
2087 // If we are still displaying a maximized pre-XUL skeleton UI, ignore the
2088 // noise of sizemode changes. Once we have "shown" the window for the first
2089 // time (called nsWindow::Show(true), even though the window is already
2090 // technically displayed), we will again accept sizemode changes.
2093 }
2096 }
2104 }
2106 GUID desktop;
2110 }
2116 }
2117 }
2120 // If we have a value cached, use that, but also make sure it is
2121 // scheduled to be updated. If we don't yet have a value, get
2122 // one synchronously.
2129 }
2132 }
2145 }
2147 }
2149 #ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
2153 }
2154 #endif
2157 };
2161 }
2165 }
2171 }
2173 GUID desktop;
2180 }
2181 }
2182 }
2188 }
2190 // Constrain a potential move to fit onscreen
2191 // Position (aX, aY) is specified in Windows screen (logical) pixels,
2192 // except when using per-monitor DPI, in which case it's device pixels.
2199 // We need to use the window size in the kind of pixels used for window-
2200 // manipulation APIs.
2206 /* get our playing field. use the current screen, or failing that
2207 for any reason, use device caps for the default screen. */
2208 RECT screenRect;
2214 }
2221 // For normalized windows, use the desktop work area.
2225 }
2227 // For full screen windows, use the desktop.
2231 }
2232 }
2247 }
2249 /**************************************************************
2250 *
2251 * SECTION: nsIWidget::Enable, nsIWidget::IsEnabled
2252 *
2253 * Enabling and disabling the widget.
2254 *
2255 **************************************************************/
2257 // Enable/disable this component
2261 }
2262 }
2264 // Return the current enable state
2268 }
2270 /**************************************************************
2271 *
2272 * SECTION: nsIWidget::SetFocus
2273 *
2274 * Give the focus to this widget.
2275 *
2276 **************************************************************/
2280 #ifdef WINSTATE_DEBUG_OUTPUT
2287 }
2288 #endif
2289 // Uniconify, if necessary
2293 }
2295 }
2296 }
2298 /**************************************************************
2299 *
2300 * SECTION: Bounds
2301 *
2302 * GetBounds, GetClientBounds, GetScreenBounds,
2303 * GetRestoredBounds, GetClientOffset, SetNonClientMargins
2304 *
2305 * Bound calculations.
2306 *
2307 **************************************************************/
2309 // Return the window's full dimensions in screen coordinates.
2310 // If the window has a parent, converts the origin to an offset
2311 // of the parent's screen origin.
2315 }
2317 RECT r;
2320 LayoutDeviceIntRect rect;
2322 // assign size
2325 // popup window bounds' are in screen coordinates, not relative to parent
2326 // window
2330 }
2332 // chrome on parent:
2333 // ___ 5,5 (chrome start)
2334 // | ____ 10,10 (client start)
2335 // | | ____ 20,20 (child start)
2336 // | | |
2337 // 20,20 - 5,5 = 15,15 (??)
2338 // minus GetClientOffset:
2339 // 15,15 - 5,5 = 10,10
2340 //
2341 // no chrome on parent:
2342 // ______ 10,10 (win start)
2343 // | ____ 20,20 (child start)
2344 // | |
2345 // 20,20 - 10,10 = 10,10
2346 //
2347 // walking the chain:
2348 // ___ 5,5 (chrome start)
2349 // | ___ 10,10 (client start)
2350 // | | ___ 20,20 (child start)
2351 // | | | __ 30,30 (child start)
2352 // | | | |
2353 // 30,30 - 20,20 = 10,10 (offset from second child to first)
2354 // 20,20 - 5,5 = 15,15 + 10,10 = 25,25 (??)
2355 // minus GetClientOffset:
2356 // 25,25 - 5,5 = 20,20 (offset from second child to parent client)
2358 // convert coordinates if parent exists
2361 RECT pr;
2365 // adjust for chrome
2371 }
2372 }
2378 }
2381 }
2383 // Get this component dimension
2387 }
2389 RECT r;
2394 }
2397 LayoutDeviceIntRect rect;
2401 }
2403 // Like GetBounds, but don't offset by the parent
2407 }
2409 RECT r;
2413 }
2419 }
2422 }
2431 }
2439 }
2441 // Return the x,y offset of the client area from the origin of the window. If
2442 // the window is borderless returns (0,0).
2446 }
2448 RECT r1;
2453 }
2456 // This will trigger a frame changed event, triggering
2457 // nc calc size and a sizemode gecko event.
2462 // If hidden, just send the frame changed event for now.
2465 }
2467 // Send a gecko size event to trigger reflow.
2472 // Invalidate and update
2474 }
2476 #define DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 19
2477 #define DWMWA_USE_IMMERSIVE_DARK_MODE 20
2486 }
2489 LayoutDeviceIntMargin nonClientOffset;
2491 // We're dealing with a "normal" window (not maximized, minimized, or
2492 // fullscreen), so process `mNonClientMargins` and set `mNonClientOffset`
2493 // accordingly.
2494 //
2495 // Setting `mNonClientOffset` to 0 has the effect of leaving the default
2496 // frame intact. Setting it to a value greater than 0 reduces the frame
2497 // size by that amount.
2505 }
2514 }
2522 }
2530 }
2532 }
2534 /**
2535 * Called when the window layout changes: full screen mode transitions,
2536 * theme changes, and composition changes. Calculates the new non-client
2537 * margins and fires off a frame changed event, which triggers an nc calc
2538 * size windows event, kicking the changes in.
2539 *
2540 * The offsets calculated here are based on the value of `mNonClientMargins`
2541 * which is specified in the "chromemargins" attribute of the window. For
2542 * each margin, the value specified has the following meaning:
2543 * -1 - leave the default frame in place
2544 * 0 - remove the frame
2545 * >0 - frame size equals min(0, (default frame size - margin value))
2546 *
2547 * This function calculates and populates `mNonClientOffset`.
2548 * In our processing of `WM_NCCALCSIZE`, the frame size will be calculated
2549 * as (default frame size - offset). For example, if the left frame should
2550 * be 1 pixel narrower than the default frame size, `mNonClientOffset.left`
2551 * will equal 1.
2552 *
2553 * For maximized, fullscreen, and minimized windows, the values stored in
2554 * `mNonClientMargins` are ignored, and special processing takes place.
2555 *
2556 * For non-glass windows, we only allow frames to be their default size
2557 * or removed entirely.
2558 */
2562 }
2572 // mCaptionHeight is the default size of the NC area at
2573 // the top of the window. If the window has a caption,
2574 // the size is calculated as the sum of:
2575 // SM_CYFRAME - The thickness of the sizing border
2576 // around a resizable window
2577 // SM_CXPADDEDBORDER - The amount of border padding
2578 // for captioned windows
2579 // SM_CYCAPTION - The height of the caption area
2580 //
2581 // If the window does not have a caption, mCaptionHeight will be equal to
2582 // `WinUtils::GetSystemMetricsForDpi(SM_CYFRAME, dpi)`
2583 mCaptionHeight =
2589 // mHorResizeMargin is the size of the default NC areas on the
2590 // left and right sides of our window. It is calculated as
2591 // the sum of:
2592 // SM_CXFRAME - The thickness of the sizing border
2593 // SM_CXPADDEDBORDER - The amount of border padding
2594 // for captioned windows
2595 //
2596 // If the window does not have a caption, mHorResizeMargin will be equal to
2597 // `WinUtils::GetSystemMetricsForDpi(SM_CXFRAME, dpi)`
2598 mHorResizeMargin =
2603 // mVertResizeMargin is the size of the default NC area at the
2604 // bottom of the window. It is calculated as the sum of:
2605 // SM_CYFRAME - The thickness of the sizing border
2606 // SM_CXPADDEDBORDER - The amount of border padding
2607 // for captioned windows.
2608 //
2609 // If the window does not have a caption, mVertResizeMargin will be equal to
2610 // `WinUtils::GetSystemMetricsForDpi(SM_CYFRAME, dpi)`
2611 mVertResizeMargin =
2615 }
2618 // Use default frame size for minimized windows
2624 // Remove the default frame from the top of our fullscreen window. This
2625 // makes the whole caption part of our client area, allowing us to draw
2626 // in the whole caption area. Additionally remove the default frame from
2627 // the left, right, and bottom.
2633 // We make the entire frame part of the client area. We leave the default
2634 // frame sizes for left, right and bottom since Windows will automagically
2635 // position the edges "offscreen" for maximized windows.
2655 }
2657 // When we are drawing the non-client region, we need
2658 // to clear the portion of the NC region that is exposed by the
2659 // hidden taskbar. As above, we clear the bottom of the NC region
2660 // when the taskbar is at the top of the screen.
2663 }
2666 }
2669 // Force a reflow of content based on the new client
2670 // dimensions.
2672 }
2675 }
2680 }
2686 }
2689 // Request for a reset
2694 // Force a reflow of content based on the new client
2695 // dimensions.
2698 }
2703 }
2710 }
2713 }
2720 }
2723 // +-+-----------------------+-+
2724 // | | app non-client chrome | |
2725 // | +-----------------------+ |
2726 // | | app client chrome | | }
2727 // | +-----------------------+ | }
2728 // | | app content | | } area we don't want to invalidate
2729 // | +-----------------------+ | }
2730 // | | app client chrome | | }
2731 // | +-----------------------+ |
2732 // +---------------------------+ <
2733 // ^ ^ windows non-client chrome
2734 // client area = app *
2735 RECT rect;
2740 // Subtract app client chrome and app content leaving
2741 // windows non-client chrome and app non-client chrome
2742 // in winRgn.
2753 // triggers ncpaint and paint events for the two areas
2756 }
2758 /**************************************************************
2759 *
2760 * SECTION: nsIWidget::SetBackgroundColor
2761 *
2762 * Sets the window background paint color.
2763 *
2764 **************************************************************/
2772 }
2773 }
2775 /**************************************************************
2776 *
2777 * SECTION: nsIWidget::SetCursor
2778 *
2779 * SetCursor and related utilities for manging cursor state.
2780 *
2781 **************************************************************/
2783 // Set this component cursor
2863 // XXX not 100% appropriate perhaps
2884 }
2885 }
2888 CSSToLayoutDeviceScale aScale) {
2891 }
2895 // Reject cursors greater than 128 pixels in either direction, to prevent
2896 // spoofing.
2897 // XXX ideally we should rescale. Also, we could modify the API to
2898 // allow trusted content to set larger cursors.
2901 }
2903 LayoutDeviceIntSize layoutSize =
2905 LayoutDeviceIntPoint hotspot =
2907 HCURSOR cursor;
2912 }
2915 }
2924 // Cursors in windows are global, so even if our mUpdateCursor flag is
2925 // false we always need to make sure the Windows cursor is up-to-date,
2926 // since stuff like native drag and drop / resizers code can mutate it
2927 // outside of this method.
2930 }
2936 }
2944 }
2950 }
2954 }
2959 }
2961 /**************************************************************
2962 *
2963 * SECTION: nsIWidget::Get/SetTransparencyMode
2964 *
2965 * Manage the transparency mode of the window containing this
2966 * widget. Only works for popup and dialog windows when the
2967 * Desktop Window Manager compositor is not enabled.
2968 *
2969 **************************************************************/
2973 }
2981 }
2984 }
2986 /**************************************************************
2987 *
2988 * SECTION: nsIWidget::UpdateWindowDraggingRegion
2989 *
2990 * For setting the draggable titlebar region from CSS
2991 * with -moz-window-dragging: drag.
2992 *
2993 **************************************************************/
2998 }
3000 /**************************************************************
3001 *
3002 * SECTION: nsIWidget::HideWindowChrome
3003 *
3004 * Show or hide window chrome.
3005 *
3006 **************************************************************/
3013 }
3017 // Data manipulation: styles + ex-styles, and bitmasking operations thereupon.
3022 }
3025 }
3028 }
3030 // Compute a style-set which matches `zero` where the bits of `this` are 0
3031 // and `one` where the bits of `this` are 1.
3035 }
3037 // The dual of `merge`, above: returns a pair [zero, one] satisfying
3038 // `a.merge(a.split(b)...) == b`. (Or its equivalent in valid C++.)
3042 }
3043 };
3045 // Get styles from an HWND.
3049 };
3054 };
3056 // Get styles from *this.
3060 });
3061 };
3065 };
3067 // The mask describing the "chrome" which this function is supposed to remove
3068 // (or restore, as the case may be). Other style-flags will be left untouched.
3072 WS_EX_STATICEDGE};
3074 // The desired style-flagset for fullscreen windows. (This happens to be all
3075 // zeroes, but we don't need to rely on that.)
3086 // if there's nothing to "restore" it to, just use what's there now
3091 }
3092 }
3096 }
3098 /**************************************************************
3099 *
3100 * SECTION: nsWindow::Invalidate
3101 *
3102 * Invalidate an area of the client for painting.
3103 *
3104 **************************************************************/
3106 // Invalidate this component visible area
3111 }
3113 #ifdef WIDGET_DEBUG_OUTPUT
3120 }
3123 }
3126 }
3129 }
3131 // Invalidate this component visible area
3134 #ifdef WIDGET_DEBUG_OUTPUT
3138 RECT rect;
3146 }
3147 }
3150 WPARAM wParam,
3151 LPARAM lParam) {
3159 }
3161 // The message sender should have added ref for us.
3165 }
3171 }
3173 }
3176 LayoutDeviceIntRect mBounds;
3177 HANDLE mSemaphore;
3178 HANDLE mThread;
3179 HWND mWnd;
3187 }
3190 }
3191 }
3192 };
3195 // Initialize window class
3198 WNDCLASSW wc = {};
3205 }
3213 }
3215 // Since AnimateWindow blocks the thread of the transition window,
3216 // we need to hide the cursor for that window, otherwise the system
3217 // would show the busy pointer to the user.
3227 // The initialization data may no longer be valid
3228 // after we release the semaphore.
3231 MSG msg;
3235 }
3239 }
3243 NS_DECL_ISUPPORTS
3247 "FullscreenTransitionData "
3249 }
3256 "FullscreenTransitionData "
3259 }
3260 };
3264 /* virtual */
3266 FullscreenTransitionInitData initData;
3274 // Create a semaphore for synchronizing the window handle which will
3275 // be created by the transition thread and used by the main thread for
3276 // posting the transition messages.
3283 }
3284 }
3287 }
3295 }
3297 /* virtual */
3308 }
3310 /* virtual */
3313 "CleanupFullscreenTransition "
3317 }
3320 // The "DWM resize hack", aka the "fullscreen resize hack", is a workaround
3321 // for DWM's occasional and not-entirely-predictable failure to update its
3322 // internal state when the client area of a window changes without changing
3323 // the window size. The effect of this is that DWM will clip the content of
3324 // the window to its former client area.
3325 //
3326 // It is not known under what circumstances the bug will trigger. Windows 11
3327 // is known to be required, but many Windows 11 machines do not exhibit the
3328 // issue. Even machines that _do_ exhibit it will sometimes not do so when
3329 // apparently-irrelevant changes are made to the configuration. (See bug
3330 // 1763981.)
3331 //
3332 // The bug is triggered by Firefox when a maximized window (which has window
3333 // decorations) becomes fullscreen (which doesn't). To work around this, if we
3334 // think it may occur, we "flicker-resize" the relevant window -- that is, we
3335 // reduce its height by 1px, then restore it. This causes DWM to acquire the
3336 // new client-area metrics.
3337 //
3338 // Note that, in particular, this bug will not occur when using a separate
3339 // compositor window, as our compositor windows never have any nonclient area.
3340 //
3341 // This is admittedly a sledgehammer where a screwdriver should suffice.
3343 // ---------------------------------------------------------------------------
3345 // Regardless of preferences or heuristics, only apply the hack if this is the
3346 // first time we've entered fullscreen across the entire Firefox session.
3347 // (Subsequent transitions to fullscreen, even with different windows, don't
3348 // appear to induce the bug.)
3349 {
3350 // (main thread only; `atomic` not needed)
3356 }
3359 }
3361 // Check whether to try to apply the DWM resize hack, based on the override
3362 // pref and/or some internal heuristics.
3363 {
3365 // The bug has only been seen under Windows 11. (At time of writing, this
3366 // is the latest version of Windows.)
3369 }
3372 // This should never happen...
3374 // ... so if it does, we are in uncharted territory: don't apply the hack.
3377 }
3379 // The bug doesn't occur when we're using a separate compositor window
3380 // (since the compositor window always comprises exactly its client area,
3381 // with no non-client border).
3384 }
3386 // Otherwise, apply the hack.
3388 };
3390 // Figure out whether or not we should perform the hack, and -- arguably
3391 // more importantly -- log that decision.
3399 };
3407 }
3408 }();
3412 }
3413 }
3415 // The DWM bug is believed to involve a race condition: some users have
3416 // reported that setting a custom theme or adding unused command-line
3417 // parameters sometimes causes the bug to vanish.
3418 //
3419 // Out of an abundance of caution, we therefore apply the hack in a later
3420 // event, rather than inline.
3429 }
3431 RECT origRect;
3436 }
3446 });
3457 }));
3458 }
3463 // HACK: Potentially flicker-resize the window, to force DWM to get the right
3464 // client-area information.
3467 }
3469 // Hide chrome and reposition window. Note this will also cache dimensions for
3470 // restoration, so it should only be called once per fullscreen request.
3471 //
3472 // Don't do this when minimized, since our bounds make no sense then, nor when
3473 // coming back from that state.
3479 }
3481 // Possibly notify the taskbar that we have changed our fullscreen mode.
3483 }
3488 }
3490 /**************************************************************
3491 *
3492 * SECTION: Native data storage
3493 *
3494 * nsIWidget::GetNativeData
3495 * nsIWidget::FreeNativeData
3496 *
3497 * Set or clear native data based on a constant.
3498 *
3499 **************************************************************/
3501 // Return some native data according to aDataType
3515 }
3517 }
3525 }
3528 }
3530 // Free some native data according to aDataType
3539 }
3540 }
3542 /**************************************************************
3543 *
3544 * SECTION: nsIWidget::SetTitle
3545 *
3546 * Set the main windows title text.
3547 *
3548 **************************************************************/
3556 }
3558 /**************************************************************
3559 *
3560 * SECTION: nsIWidget::SetIcon
3561 *
3562 * Set the main windows icon.
3563 *
3564 **************************************************************/
3567 HICON icon =
3571 }
3574 }
3581 }
3584 }
3587 // Assume the given string is a local identifier for an icon file.
3593 nsAutoString iconPath;
3596 // XXX this should use MZLU (see bug 239279)
3600 HICON bigIcon =
3604 HICON smallIcon =
3611 }
3612 #ifdef DEBUG_SetIcon
3618 }
3619 #endif
3622 }
3623 #ifdef DEBUG_SetIcon
3629 }
3630 #endif
3631 }
3634 HICON bigIcon =
3637 }
3640 HICON smallIcon =
3643 }
3645 /**************************************************************
3646 *
3647 * SECTION: nsIWidget::WidgetToScreenOffset
3648 *
3649 * Return this widget's origin in screen coordinates.
3650 *
3651 **************************************************************/
3654 POINT point;
3659 }
3664 }
3668 }
3670 // Just use a dummy 200x200 at (200, 200) client rect as the rect.
3671 RECT clientRect;
3680 };
3686 }
3688 /**************************************************************
3689 *
3690 * SECTION: nsIWidget::EnableDragDrop
3691 *
3692 * Enables/Disables drag and drop of files on this widget.
3693 *
3694 **************************************************************/
3698 // Return early if the window already closed
3700 }
3707 }
3713 }
3714 }
3715 }
3717 /**************************************************************
3718 *
3719 * SECTION: nsIWidget::CaptureMouse
3720 *
3721 * Enables/Disables system mouse capture.
3722 *
3723 **************************************************************/
3726 TRACKMOUSEEVENT mTrack;
3736 }
3739 }
3741 /**************************************************************
3742 *
3743 * SECTION: nsIWidget::CaptureRollupEvents
3744 *
3745 * Dealing with event rollup on destroy for popups. Enables &
3746 * Disables system capture of any and all events that would
3747 * cause a dropdown to be rolled up.
3748 *
3749 **************************************************************/
3755 }
3760 }
3761 }
3763 /**************************************************************
3764 *
3765 * SECTION: nsIWidget::GetAttention
3766 *
3767 * Bring this window to the user's attention.
3768 *
3769 **************************************************************/
3771 // Draw user's attention to this window until it comes to foreground.
3773 // Got window?
3778 // Don't flash if the flash count is 0 or if the foreground window is our
3779 // window handle or that of our owned-most window.
3783 }
3793 }
3799 }
3803 }
3805 /**************************************************************
3806 *
3807 * SECTION: nsIWidget::HasPendingInputEvent
3808 *
3809 * Ask whether there user input events pending. All input events are
3810 * included, including those not targeted at this nsIwidget instance.
3811 *
3812 **************************************************************/
3815 // If there is pending input or the user is currently
3816 // moving the window then return true.
3817 // Note: When the user is moving the window WIN32 spins
3818 // a separate event loop and input events are not
3819 // reported to the application.
3821 GUITHREADINFO guiInfo;
3825 }
3827 /**************************************************************
3828 *
3829 * SECTION: nsIWidget::GetWindowRenderer
3830 *
3831 * Get the window renderer associated with this widget.
3832 *
3833 **************************************************************/
3838 }
3842 }
3844 // Try OMTC first.
3848 }
3854 // Ensure we have a widget proxy even if we're not using the compositor,
3855 // since all our transparent window handling lives there.
3860 // If we're not using the compositor, the options don't actually matter.
3862 mBasicLayersSurface =
3866 }
3871 // Update the size constraints now that the layer manager has been
3872 // created.
3880 }
3881 }
3884 }
3886 /**************************************************************
3887 *
3888 * SECTION: nsBaseWidget::SetCompositorWidgetDelegate
3889 *
3890 * Called to connect the nsWindow to the delegate providing
3891 * platform compositing API access.
3892 *
3893 **************************************************************/
3899 "nsWindow::SetCompositorWidgetDelegate called with a "
3903 }
3904 }
3906 /**************************************************************
3907 *
3908 * SECTION: nsIWidget::OnDefaultButtonLoaded
3909 *
3910 * Called after the dialog is loaded and it has a default button.
3911 *
3912 **************************************************************/
3918 // Don't snap when we are not active.
3924 }
3930 BOOL snapDefaultButton;
3935 }
3942 // The center of the button can be outside of the widget.
3943 // E.g., it could be hidden by scrolling.
3946 }
3951 }
3953 }
3957 }
3963 }
3965 /**************************************************************
3966 **************************************************************
3967 **
3968 ** BLOCK: Moz Events
3969 **
3970 ** Moz GUI event management.
3971 **
3972 **************************************************************
3973 **************************************************************/
3975 /**************************************************************
3976 *
3977 * SECTION: Mozilla event initialization
3978 *
3979 * Helpers for initializing moz events.
3980 *
3981 **************************************************************/
3983 // Event initialization
3986 // get the message position in client coordinates
3989 POINT cpos;
3998 }
4000 // use the point override if provided
4002 }
4005 }
4010 }
4012 /**************************************************************
4013 *
4014 * SECTION: Moz event dispatch helpers
4015 *
4016 * Helpers for dispatching different types of moz events.
4017 *
4018 **************************************************************/
4020 // Main event dispatch. Invokes callback and ProcessEvent method on
4021 // Event Listener object. Part of nsIWidget.
4024 #ifdef WIDGET_DEBUG_OUTPUT
4030 // Top level windows can have a view attached which requires events be sent
4031 // to the underlying base window and the view. Added when we combined the
4032 // base chrome window with the main content child for nc client area (title
4033 // bar) rendering.
4038 }
4040 // the window can be destroyed during processing of seemingly innocuous events
4041 // like, say, mousedowns due to the magic of scripting. mousedowns will return
4042 // nsEventStatus_eIgnore, which causes problems with the deleted window.
4043 // therefore:
4046 }
4054 }
4059 }
4062 nsEventStatus status;
4065 }
4068 nsEventStatus status =
4071 }
4073 // Recursively dispatch synchronous paints for nsIWidget
4074 // descendants with invalidated rectangles.
4078 // its one of our windows so check to see if it has a
4079 // invalidated rect. If it does. Dispatch a synchronous
4080 // paint.
4082 }
4084 }
4086 // Check for pending paints and dispatch any pending paint
4087 // messages for any nsIWidget which is a descendant of the
4088 // top-level window that *this* window is embedded within.
4089 //
4090 // Note: We do not dispatch pending paint messages for non
4091 // nsIWidget managed windows.
4093 // We need to ensure that reflow events do not get starved.
4094 // At the same time, we don't want to recurse through here
4095 // as that would prevent us from dispatching starved paints.
4100 }
4102 // Quickly check to see if there are any paint events pending,
4103 // but only dispatch them if it has been long enough since the
4104 // last paint completed.
4107 // Find the top level window.
4110 // Dispatch pending paints for topWnd and all its descendant windows.
4111 // Note: EnumChildWindows enumerates all descendant windows not just
4112 // the children (but not the window itself).
4115 }
4116 }
4122 }
4123 }
4124 }
4127 LayoutDeviceIntPoint aEventPoint) {
4128 // Allow users to start dragging by double-tapping.
4131 }
4133 // In chrome UI, allow touchdownstartsdrag attributes
4134 // to cause any touchdown event to trigger a drag.
4145 // Check if the element or any parent element has the
4146 // attribute we're looking for.
4149 nsAutoString startDrag;
4153 }
4154 }
4155 }
4156 }
4157 }
4160 }
4162 // Deal with all sort of mouse event
4175 }
4180 // Suppress mouse moves caused by widget creation. Make sure to do this early
4181 // so that we update sLastMouseMovePoint even for touch-induced mousemove
4182 // events.
4187 }
4190 }
4194 // If mTouchWindow is true, then we must have APZ enabled and be
4195 // feeding it raw touch events. In that case we only want to
4196 // send touch-generated mouse events to content if they should
4197 // start a touch-based drag-and-drop gesture, such as on
4198 // double-tapping or when tapping elements marked with the
4199 // touchdownstartsdrag attribute in chrome UI.
4205 }
4206 }
4207 }
4217 // eMouseMove and eMouseExitFromWidget are here because we need to make
4218 // sure capture flag isn't left on after a drag where we wouldn't see a
4219 // button up message (see bug 324131).
4224 sIsInMouseCapture)
4241 }
4243 ModifierKeyState modifierKeyState;
4246 // eContextMenu with Shift state is special. It won't fire "contextmenu"
4247 // event in the web content for blocking web content to prevent its default.
4248 // However, Shift+F10 is a standard shortcut key on Windows. Therefore,
4249 // this should not block web page to prevent its default. I.e., it should
4250 // behave same as ContextMenu key without Shift key.
4251 // XXX Should we allow to block web page to prevent its default with
4252 // Ctrl+Shift+F10 or Alt+Shift+F10 instead?
4257 }
4262 // Mouse events from Windows WM_POINTER*. Fill more information in
4263 // WidgetMouseEvent.
4268 // If we get here the mouse events must be from non-touch sources, so
4269 // convert it to pointer events as well
4272 }
4274 // Static variables used to distinguish simple-, double- and triple-clicks.
4286 BYTE eventButton;
4300 }
4302 // Doubleclicks are used to set the click count, then changed to mousedowns
4303 // We're going to time double-clicks from mouse *up* to next mouse *down*
4314 // remember when this happened for the next mouse down
4320 // now look to see if we want to convert this to a double- or triple-click
4323 sLastClickCount++;
4325 // reset the click count, to count *this* click
4327 }
4328 // Set last Click time on MouseDown only
4334 }
4343 }
4346 #ifdef NS_DEBUG_XX
4349 #endif
4351 // call the event callback
4364 }
4371 }
4372 }
4373 }
4377 }
4378 }
4384 }
4387 }
4390 // retrieve the toplevel window or dialogue
4399 }
4400 }
4403 }
4405 }
4409 // We disable the root window when a picker opens. See PickerOpen. When the
4410 // picker closes (but before PickerClosed is called), our window will get
4411 // focus, but it will still be disabled. This confuses the focus system.
4412 // Therefore, we ignore this focus and explicitly call this function once
4413 // we re-enable the window. Rarely, the picker seems to re-enable our root
4414 // window before we do, but for simplicity, we always ignore focus before
4415 // the final call to PickerClosed. See bug 1883568 for further details.
4417 }
4421 }
4434 }
4435 }
4436 }
4437 }
4441 POINT mp;
4445 }
4450 // WinUtils::GetTopLevelHWND() will return a HWND for the window frame
4451 // (which includes the non-client area). If the mouse has moved into
4452 // the non-client area, we should treat it as a top-level exit.
4457 }
4459 /**************************************************************
4460 *
4461 * SECTION: IPC
4462 *
4463 * IPC related helpers.
4464 *
4465 **************************************************************/
4467 // static
4492 }
4494 #ifdef DEBUG
4498 aMsg);
4500 #endif
4503 }
4511 // Modal UI being displayed in windowless plugins.
4514 LRESULT res;
4517 }
4519 }
4521 // Handle certain sync plugin events sent to the parent which
4522 // trigger ipc calls that result in deadlocks.
4528 // Windowless flash sending WM_ACTIVATE events to the main window
4529 // via calls to ShowWindow.
4533 // Check for Adobe Reader X sync activate message from their
4534 // helper window and ignore. Fixes an annoying focus problem.
4536 ISMEX_SEND) {
4545 }
4546 }
4548 }
4550 // Plugins taking or losing focus triggering focus app messages.
4553 // Windowed plugins that pass sys key events to defwndproc generate
4554 // WM_SYSCOMMAND events to the main window.
4556 // Windowed plugins that fire context menu selection events to parent
4557 // windows.
4559 // IME events fired as a result of synchronous focus changes
4563 }
4568 }
4569 }
4571 /**************************************************************
4572 **************************************************************
4573 **
4574 ** BLOCK: Native events
4575 **
4576 ** Main Windows message handlers and OnXXX handlers for
4577 ** Windows event handling.
4578 **
4579 **************************************************************
4580 **************************************************************/
4582 /**************************************************************
4583 *
4584 * SECTION: Wind proc.
4585 *
4586 * The main Windows event procedures and associated
4587 * message processing methods.
4588 *
4589 **************************************************************/
4595 MENUITEMINFO mii;
4600 // update the options
4611 // intentional fall through
4629 }
4631 hMenu,
4638 }
4639 }
4641 }
4643 // The WndProc procedure for all nsWindows in this toolkit. This merely catches
4644 // SEH exceptions and passes the real work to WindowProcInternal. See bug 587406
4645 // and http://msdn.microsoft.com/en-us/library/ms633573%28VS.85%29.aspx
4647 LPARAM lParam) {
4654 }
4659 // This message was sent to the FAKETRACKPOINTSCROLLABLE.
4661 // Route WM_HSCROLL messages to the main window.
4664 // Handle all other messages with its original window procedure.
4667 }
4668 }
4671 // This is a tracer event for measuring event loop latency.
4672 // See WidgetTraceEvent.cpp for more details.
4675 }
4677 // Get the window which caused the event and ask it to process the message
4682 // Hold the window for the life of this method, in case it gets
4683 // destroyed during processing, unless we're in the dtor already.
4689 // Create this here so that we store the last rolled up popup until after
4690 // the event has been processed.
4691 nsAutoRollup autoRollup;
4693 LRESULT popupHandlingResult;
4697 // Call ProcessMessage
4698 LRESULT retValue;
4701 }
4707 }
4716 }
4717 }
4719 }
4726 }
4730 }
4733 aResult)) {
4735 }
4738 }
4740 // The main windows message processing method. Wraps ProcessMessageInternal so
4741 // we can log aRetValue.
4744 // For some events we might change the parameter values, so log
4745 // before and after we process them.
4751 }
4753 // The main windows message processing method. Called by ProcessMessage.
4759 }
4764 // The DWM resize hack (see bug 1763981) causes us to process a number of
4765 // messages, notably including some WM_WINDOWPOSCHANG{ING,ED} messages which
4766 // would ordinarily result in a whole lot of internal state being updated.
4767 //
4768 // Since we're supposed to end in the same state we started in (and since the
4769 // content shouldn't know about any of this nonsense), just discard any
4770 // messages synchronously dispatched from within the hack.
4773 }
4775 // Glass hit testing w/custom transparent margins.
4776 //
4777 // FIXME(emilio): is this needed? We deal with titlebar buttons non-natively
4778 // now.
4779 LRESULT dwmHitResult;
4784 }
4786 // The preference whether to use a different keyboard layout for each
4787 // window is cached, and updating it will not take effect until the
4788 // next restart. We read the preference here and not upon WM_ACTIVATE to make
4789 // sure that this behavior is consistent. Otherwise, if the user changed the
4790 // preference before having ever lowered the window, the preference would take
4791 // effect immediately.
4796 // (Large blocks of code should be broken out into OnEvent handlers.)
4798 // WM_QUERYENDSESSION must be handled by all windows.
4799 // Otherwise Windows thinks the window can just be killed at will.
4801 // Ask around if it's ok to quit.
4810 quitType);
4819 #if defined(ACCESSIBILITY)
4822 #else
4824 #endif
4828 // For WM_ENDSESSION, wParam indicates whether we need to shutdown
4829 // (TRUE) or not (FALSE).
4833 }
4834 // According to WM_ENDSESSION lParam documentation:
4835 // 0 -> OS shutdown or restart (no way to distinguish)
4836 // ENDSESSION_LOGOFF -> User is logging off
4837 // ENDSESSION_CLOSEAPP -> Application must shutdown
4838 // ENDSESSION_CRITICAL -> Application is forced to shutdown
4839 // The difference of the last two is not very clear.
4850 }
4851 }
4855 // TODO: We do not expect that these days anybody sends us
4856 // MOZ_WM_APP_QUIT, see bug 1827807.
4858 }
4859 // Let's fake a shutdown sequence without actually closing windows etc.
4860 // to avoid Windows killing us in the middle. A proper shutdown would
4861 // require having a chance to pump some messages. Unfortunately
4862 // Windows won't let us do that. Bug 212316.
4871 syncShutdown);
4877 quitType);
4892 // No need to invalidate layout for system color changes, but we need to
4893 // invalidate style.
4898 // Update non-client margin offsets
4902 // We assume pretty much everything could've changed here.
4907 // Invalidate the window so that the repaint will
4908 // pick up the new theme.
4917 // When a session becomes visible, we should invalidate.
4922 }
4926 // We only handle this message for the hidden window,
4927 // as we only need to update the (global) font list once
4928 // for any given change, not once per window!
4931 }
4933 // update the global font list
4941 // These need to update LookAndFeel cached values.
4942 // They affect reduced motion settings / caret blink count / show
4943 // pointer while typing / tooltip offset, so no need to invalidate style
4944 // / layout.
4947 }
4952 }
4954 // NB: We also refresh screens on WM_DISPLAYCHANGE but the rcWork
4955 // values are sometimes wrong at that point. This message then
4956 // arrives soon afterward, when we can get the right rcWork values.
4959 }
4962 // This affects system colors (-moz-win-accentcolor), so gotta pass
4963 // the style flag.
4966 }
4968 // UserInteractionMode, ConvertibleSlateMode, SystemDockMode may cause
4969 // @media(pointer) queries to change, which layout needs to know about
4970 //
4971 // (WM_SETTINGCHANGE will be sent to all top-level windows, so we
4972 // only respond to the hidden top-level window to avoid hammering
4973 // layout with a bunch of NotifyThemeChanged() calls)
4974 //
4981 }
4982 }
4983 }
4989 // Check dbch_devicetype explicitly since we will get other device types
4990 // (e.g. DBT_DEVTYP_VOLUME) for some reasons even if we specify
4991 // DBT_DEVTYP_DEVICEINTERFACE in the filter for
4992 // RegisterDeviceNotification.
4994 // This can only change media queries (any-hover/any-pointer).
4996 }
4997 }
5001 // NOTE: the following block is mirrored in PreXULSkeletonUI.cpp, and
5002 // will need to be kept in sync.
5004 // If `wParam` is `FALSE`, `lParam` points to a `RECT` that contains
5005 // the proposed window rectangle for our window. During our
5006 // processing of the `WM_NCCALCSIZE` message, we are expected to
5007 // modify the `RECT` that `lParam` points to, so that its value upon
5008 // our return is the new client area. We must return 0 if `wParam`
5009 // is `FALSE`.
5010 //
5011 // If `wParam` is `TRUE`, `lParam` points to a `NCCALCSIZE_PARAMS`
5012 // struct. This struct contains an array of 3 `RECT`s, the first of
5013 // which has the exact same meaning as the `RECT` that is pointed to
5014 // by `lParam` when `wParam` is `FALSE`. The remaining `RECT`s, in
5015 // conjunction with our return value, can
5016 // be used to specify portions of the source and destination window
5017 // rectangles that are valid and should be preserved. We opt not to
5018 // implement an elaborate client-area preservation technique, and
5019 // simply return 0, which means "preserve the entire old client area
5020 // and align it with the upper-left corner of our new client area".
5029 // Make client rect's width and height more than 0 to
5030 // avoid problems of webrender and angle.
5036 }
5038 }
5043 }
5054 };
5055 };
5064 }
5065 };
5072 // We don't have a help button.
5080 // Treat this window as transparent.
5084 }
5095 }
5096 }
5098 /*
5099 * If an nc client area margin has been moved, we are responsible
5100 * for calculating where the resize margins are and returning the
5101 * appropriate set of hit test constants. DwmDefWindowProc (above)
5102 * will handle hit testing on it's command buttons if we are on a
5103 * composited desktop.
5104 */
5108 }
5114 }
5117 /*
5118 * WM_SETTEXT paints the titlebar area. Avoid this if we have a
5119 * custom titlebar we paint ourselves, or if we're the ones
5120 * sending the message with an updated title
5121 */
5126 {
5127 // From msdn, the way around this is to disable the visible state
5128 // temporarily. We need the text to be set but we don't want the
5129 // redraw to occur. However, we need to make sure that we don't
5130 // do this at the same time that a Present is happening.
5131 //
5132 // To do this we take mPresentLock in nsWindow::PreRender and
5133 // if that lock is taken we wait before doing WM_SETTEXT
5136 }
5144 }
5147 }
5150 /*
5151 * WM_NCACTIVATE paints nc areas. Avoid this and re-route painting
5152 * through WM_NCPAINT via InvalidateNonClientRegion.
5153 */
5156 }
5158 // There is a case that rendered result is not kept. Bug 1237617
5162 }
5164 // let the dwm handle nc painting on glass
5165 // Never allow native painting if we are on fullscreen
5169 // going active
5172 // invalidate to trigger a paint
5176 // going inactive
5179 // invalidate to trigger a paint
5182 }
5183 }
5186 /*
5187 * ClearType changes often don't send a WM_SETTINGCHANGE message. But they
5188 * do seem to always send a WM_NCPAINT message, so let's update on that.
5189 */
5203 }
5212 // clean up.
5249 // Say we've dealt with erasing the background. (This is actually handled in
5250 // WM_PAINT, where necessary.)
5262 // First MOUSEMOVE over the client area. Ask for MOUSELEAVE
5263 TRACKMOUSEEVENT mTrack;
5269 }
5272 // Suppress dispatch of pending events
5273 // when mouse moves are generated by widget
5274 // creation instead of user input.
5275 POINT mp;
5281 }
5289 }
5296 TRACKMOUSEEVENT mTrack;
5302 }
5303 // If we noticed the mouse moving in our draggable region, forward the
5304 // message as a normal WM_MOUSEMOVE.
5307 // We've transitioned from a draggable area to somewhere else within
5308 // the non-client area - perhaps one of the edges of the window for
5309 // resizing.
5311 }
5315 }
5319 result =
5327 result =
5338 // If we're handling WM_NCMOUSELEAVE and the mouse is still over the
5339 // window, then by process of elimination, the mouse has moved from the
5340 // non-client to client area, so no need to fall-through to the
5341 // WM_MOUSELEAVE handler. We also need to re-register for the
5342 // WM_MOUSELEAVE message, since according to the documentation at [1],
5343 // all tracking requested via TrackMouseEvent is cleared once
5344 // WM_NCMOUSELEAVE or WM_MOUSELEAVE fires.
5345 // [1]:
5346 // https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-trackmouseevent
5347 TRACKMOUSEEVENT mTrack;
5354 }
5355 // We've transitioned from non-client to outside of the window, so
5356 // fall-through to the WM_MOUSELEAVE handler.
5358 }
5364 // Check if the mouse is over the fullscreen transition window, if so
5365 // clear sLastMouseMovePoint. This way the WM_MOUSEMOVE we get after the
5366 // transition window disappears will not be ignored, even if the mouse
5367 // hasn't moved.
5370 }
5372 // We need to check mouse button states and put them in for
5373 // wParam.
5377 // Synthesize an event position because we don't get one from
5378 // WM_MOUSELEAVE.
5385 // If the context menu is brought up by a touch long-press, then
5386 // the APZ code is responsible for dealing with this, so we don't
5387 // need to do anything.
5393 }
5395 // If this WM_CONTEXTMENU is triggered by a mouse's secondary button up
5396 // event in overscroll gutter, we shouldn't open context menu.
5398 mNeedsToPreventContextMenu) {
5401 }
5403 // if the context menu is brought up from the keyboard, |lParam|
5404 // will be -1.
5405 LPARAM pos;
5412 }
5420 // Blank area hit, throw up the system menu.
5424 }
5434 }
5440 POINTER_INPUT_TYPE pointerType;
5444 }
5445 }
5485 result =
5492 result =
5500 result =
5508 result =
5515 result =
5522 result =
5535 // Windows doesn't provide to customize the behavior of 4th nor 5th button
5536 // of mouse. If 5-button mouse works with standard mouse deriver of
5537 // Windows, users cannot disable 4th button (browser back) nor 5th button
5538 // (browser forward). We should allow to do it with our prefs since we can
5539 // prevent Windows to generate WM_APPCOMMAND message if WM_XBUTTONUP
5540 // messages are not sent to DefWindowProc.
5555 }
5563 // The following conditions and switch statement borrow heavily from the
5564 // Chromium source code from
5565 // https://chromium.googlesource.com/chromium/src/+/456d6e533cfb4531995e0ef52c279d4b5aa8a352/ui/views/window/window_resize_utils.cc#45
5576 }
5586 }
5587 }
5616 }
5617 }
5619 // When we get WM_ENTERSIZEMOVE we don't know yet if we're in a live
5620 // resize or move event. Instead we wait for first VM_SIZING message
5621 // within a ENTERSIZEMOVE to consider this a live resize event.
5625 }
5627 }
5632 // Sometimes, we appear to miss a WM_DPICHANGED message while moving
5633 // a window around. Therefore, call ChangedDPI and ResetLayout here
5634 // if it appears that the window's scaling is not what we expect.
5635 // This causes the prescontext and appshell window management code to
5636 // check the appUnitsPerDevPixel value and current widget size, and
5637 // refresh them if necessary. If nothing has changed, these calls will
5638 // return without actually triggering any extra reflow or painting.
5644 }
5645 }
5646 }
5652 }
5654 }
5661 }
5663 // Windows spins a separate hidden event loop when moving a window so we
5664 // don't hear mouse events during this time and WM_EXITSIZEMOVE is fired
5665 // when the hidden event loop exits. We set mDraggingWindowWithMouse to
5666 // true in WM_NCLBUTTONDOWN when we started moving the window with the
5667 // mouse so we know that if mDraggingWindowWithMouse is true, we can send
5668 // a mouse up event.
5675 }
5678 }
5684 }
5686 }
5697 // Dispatch a custom event when this happens in the draggable region, so
5698 // that non-popup-based panels can react to it. This doesn't send an
5699 // actual mousedown event because that would break dragging or interfere
5700 // with other mousedown handling in the caption area.
5705 }
5713 }
5715 }
5721 }
5723 // The WM_ACTIVATE event is fired when a window is raised or lowered,
5724 // and the loword of wParam specifies which. But we don't want to tell
5725 // the focus system about this until the WM_SETFOCUS or WM_KILLFOCUS
5726 // events are fired. Instead, set either the sJustGotActivate or
5727 // gJustGotDeactivate flags and activate/deactivate once the focus
5728 // events arrive.
5733 // when minimizing a window, the deactivation and focus events will
5734 // be fired in the reverse order. Instead, just deactivate right away.
5735 // This can also happen when a modal system dialog is opened, so check
5736 // if the last window to receive the WM_KILLFOCUS message was this one
5737 // or a child of this one.
5744 }
5747 }
5755 ModifierKeyState modifierKeyState;
5761 #ifdef ACCESSIBILITY
5763 #endif
5764 }
5765 }
5769 // Bug 1851991: Sometimes this can be called before gfxPlatform::Init
5770 // when a window is created very early. In that case we just forego
5771 // setting this and accept the GPU process might briefly run at a lower
5772 // priority.
5775 }
5779 // A popup with a parent owner should not be activated when clicked but
5780 // should still allow the mouse event to be fired, so the return value
5781 // is set to MA_NOACTIVATE. But if the owner isn't the frontmost window,
5782 // just use default processing so that the window is activated.
5786 }
5795 // Workaround for race condition in explorer.exe.
5803 // Set the constraints. The minimum size should also be constrained to the
5804 // default window maximum size so that it fits on screen.
5822 // If previous focused window isn't ours, it must have received the
5823 // redirected message. So, we should forget it.
5826 }
5829 }
5838 }
5866 }
5869 #ifdef ACCESSIBILITY
5872 // Do explicit casting to make it working on 64bit systems (see bug 649236
5873 // for details).
5882 }
5895 }
5896 }
5897 }
5899 #endif
5904 // SC_CLOSE may trigger a synchronous confirmation prompt. If we're in the
5905 // middle of something important, put off responding to it.
5910 }
5917 }
5919 // Handle the system menu manually when we're in full screen mode
5920 // so we can set the appropriate options.
5926 }
5934 }
5936 /* Gesture support events */
5938 // According to MS samples, this must be handled to enable
5939 // rotational support in multi-touch drivers.
5948 }
5957 // A GestureNotify event is dispatched to decide which single-finger
5958 // panning direction should be active (including none) and if pan
5959 // feedback should be displayed. Java and plugin windows can make their
5960 // own calls.
5963 nsPointWin touchPoint;
5969 nsEventStatus status;
5974 }
6017 // Support EM_CANPASTE message only when wParam isn't specified or
6018 // is plain text format.
6025 }
6043 TimeStamp skewStamp;
6047 skewStamp);
6048 }
6054 }
6056 }
6058 //*aRetValue = result;
6062 // Events which caused mWnd destruction and aren't consumed
6063 // will crash during the Windows default processing.
6065 }
6066 }
6071 }
6074 }
6076 /**************************************************************
6077 *
6078 * SECTION: Event processing helpers
6079 *
6080 * Special processing for certain event types and
6081 * synthesized events.
6082 *
6083 **************************************************************/
6091 }
6097 }
6099 // Calculations are done in screen coords
6103 // hit return constants:
6104 // HTBORDER - non-resizable border
6105 // HTBOTTOM, HTLEFT, HTRIGHT, HTTOP - resizable border
6106 // HTBOTTOMLEFT, HTBOTTOMRIGHT - resizable corner
6107 // HTTOPLEFT, HTTOPRIGHT - resizable corner
6108 // HTCAPTION - general title bar area
6109 // HTCLIENT - area considered the client
6110 // HTCLOSE - hovering over the close button
6111 // HTMAXBUTTON - maximize button
6112 // HTMINBUTTON - minimize button
6122 // Ensure being accessible to borders of window. Even if contents are in
6123 // this area, the area must behave as border.
6134 // The border size. If there is no content under mouse cursor, the border
6135 // size should be larger than the values in system settings. Otherwise,
6136 // contents under the mouse cursor should be able to override the behavior.
6137 // E.g., user must expect that Firefox button always opens the popup menu
6138 // even when the user clicks on the above edge of it.
6154 }
6156 // (the 2x case here doubles the resize area for corners)
6164 }
6174 }
6181 }
6185 }
6188 }
6189 }
6196 }
6197 }
6200 {
6209 }
6213 }
6220 #ifdef ACCESSIBILITY
6222 #endif
6227 // If we're in the resize region, avoid overriding that with either a
6228 // drag or a client result; resize takes priority over either (but not
6229 // over the window controls, which is why we check this after those).
6234 }
6235 }
6238 }
6241 }
6246 }
6251 }
6256 }
6259 // Retain the previous mode that was notified to observers
6262 // Only notify observers if mode changed
6271 aIsSleepMode
6272 ? NS_WIDGET_SLEEP_OBSERVER_TOPIC
6275 }
6280 }
6281 // These must be checked here too as a lone WM_CHAR could be received
6282 // if a child window didn't handle it (for example Alt+Space in a content
6283 // window)
6284 ModifierKeyState modKeyState;
6287 }
6290 ModifierKeyState modKeyState;
6294 // Bug 1382199: Windows default behavior will trigger the System menu bar
6295 // when F10 is released. Among other things, this causes the System menu bar
6296 // to appear when a web page overrides the contextmenu event. We *never*
6297 // want this default behavior, so eat this key (never pass it to Windows).
6299 }
6301 }
6305 // If this method doesn't call NativeKey::HandleKeyDownMessage(), this method
6306 // must clean up the redirected message information itself. For more
6307 // information, see above comment of
6308 // RedirectedKeyDownMessageManager::AutoFlusher class definition in
6309 // KeyboardLayout.h.
6312 ModifierKeyState modKeyState;
6315 LRESULT result =
6317 // HandleKeyDownMessage cleaned up the redirected message information
6318 // itself, so, we should do nothing.
6323 // We need to let Windows handle this keypress,
6324 // by returning false, if there's a native menu
6325 // bar somewhere in our containing window hierarchy.
6326 // Otherwise we handle the keypress and don't pass
6327 // it on to Windows, by returning true.
6334 }
6336 }
6338 }
6341 }
6352 aUnmodifiedCharacters);
6353 }
6361 INPUT input;
6364 // TODO (bug 1693240):
6365 // Now, we synthesize native mouse events asynchronously since we want to
6366 // synthesize the event on the front window at the point. However, Windows
6367 // does not provide a way to set modifier only while a mouse message is
6368 // being handled, and MOUSEEVENTF_MOVE may be coalesced by Windows. So, we
6369 // need a trick for handling it.
6374 // Reset sLastMouseMovePoint so that even if we're moving the mouse
6375 // to the position it's already at, we still dispatch a mousemove
6376 // event, because the callers of this function expect that.
6404 }
6406 }
6411 }
6418 }
6431 }
6434 LayoutDeviceIntPoint aPoint,
6442 }
6445 #ifdef WINSTATE_DEBUG_OUTPUT
6450 }
6454 }
6457 }
6460 }
6463 }
6466 }
6469 }
6471 #endif
6472 }
6474 /**************************************************************
6475 *
6476 * SECTION: OnXXX message handlers
6477 *
6478 * For message handlers that need to be broken out or
6479 * implemented in specific platform code.
6480 *
6481 **************************************************************/
6486 }
6490 // Handle window size mode changes
6492 // Bug 566135 - Windows theme code calls show window on SW_SHOWMINIMIZED
6493 // windows when fullscreen games disable desktop composition. If we're
6494 // minimized and not being activated, ignore the event and let windows
6495 // handle it.
6499 }
6504 // Skip window size change events below on minimization.
6506 }
6507 }
6509 // Notify visibility change when window is activated.
6513 }
6515 // Handle window position changes
6519 }
6521 // Handle window size changes
6523 RECT r;
6532 RECT drect;
6534 // getting wider
6543 }
6545 RECT drect;
6547 // getting taller
6556 }
6562 #ifdef WINSTATE_DEBUG_OUTPUT
6565 newHeight));
6566 #endif
6569 // It's possible (via Windows Aero Snap) that the size of the window
6570 // has changed such that it violates the aspect ratio constraint. If so,
6571 // queue up an event to enforce the aspect ratio constraint and repaint.
6572 // When resized with Windows Aero Snap, we are in the NOT_RESIZING state.
6575 // Hold a reference to self alive and pass it into the lambda to make
6576 // sure this nsIWidget stays alive long enough to run this function.
6582 }
6583 }));
6584 }
6585 }
6587 // If a maximized window is resized, recalculate the non-client margins.
6590 // gecko resize event already sent by UpdateNonClientMargins.
6592 }
6593 }
6594 }
6596 // Notify the widget listener for size change of client area for gecko
6597 // events. This needs to be done when either window size is changed,
6598 // or window frame is changed. They may not happen together.
6599 // However, we don't invoke that for popup when window frame changes,
6600 // because popups may trigger frame change before size change via
6601 // {Set,Clear}ThemeRegion they invoke in Resize. That would make the
6602 // code below call OnResize with a wrong client size first, which can
6603 // lead to flickerling for some popups.
6606 RECT r;
6607 LayoutDeviceIntSize clientSize;
6612 }
6613 // Send a gecko resize event
6615 }
6616 }
6619 // Update non-client margins if the frame size is changing, and let the
6620 // browser know we are changing size modes, so alternative css can kick in.
6621 // If we're going into fullscreen mode, ignore this, since it'll reset
6622 // margins to normal mode.
6625 }
6627 // Force fullscreen. This works around a bug in Windows 10 1809 where
6628 // using fullscreen when a window is "snapped" causes a spurious resize
6629 // smaller than the full screen, see bug 1482920.
6636 DesktopIntRect deskBounds =
6649 }
6650 }
6651 }
6653 // enforce local z-order rules
6658 nsWindowZ placement;
6668 }
6681 }
6682 }
6683 }
6684 }
6685 // prevent rude external programs from making hidden window visible
6688 // When waking from sleep or switching out of tablet mode, Windows 10
6689 // Version 1809 will reopen popup windows that should be hidden. Detect
6690 // this case and refuse to show the window.
6696 }
6697 }
6700 // Check if we have the idle service, if not we try to get it.
6703 }
6705 // Check that we now have the idle service.
6708 }
6709 }
6711 // Helper function for TouchDeviceNeedsPanGestureConversion(PTOUCHINPUT,
6712 // uint32_t).
6716 // The first call just queries how long the name string will be.
6720 }
6722 // The second call actually populates the string.
6727 }
6728 // The affected device name is "\\?\VIRTUAL_DIGITIZER", but each backslash
6729 // needs to be escaped with another one.
6731 // For some reason, the dataSize returned by the first call is double the
6732 // actual length of the device name (as if it were returning the size of a
6733 // wide-character string in bytes) even though we are using the narrow
6734 // version of the API. For the comparison against the expected device name
6735 // to pass, we truncate the buffer to be no longer tha the expected device
6736 // name.
6739 }
6741 RID_DEVICE_INFO deviceInfo;
6744 result =
6748 }
6749 // The device identifiers that we check for here come from bug 1355162
6750 // comment 1 (see also bug 1511901 comment 35).
6755 }
6757 // Determine if the touch device that originated |aOSEvent| needs to have
6758 // touch events representing a two-finger gesture converted to pan
6759 // gesture events.
6760 // We only do this for touch devices with a specific name and identifiers.
6765 }
6768 }
6771 // Cache the result of this computation for each touch device.
6772 // Touch devices are identified by the HANDLE stored in the hSource
6773 // field of TOUCHINPUT.
6778 }
6780 }
6784 // Checks if the touch device that originated the touch event is one
6785 // for which we want to convert the touch events to pang gesture events.
6790 }
6792 // Only two-finger gestures need conversion.
6795 }
6804 }
6806 // Use the midpoint of the two touches as the start point of the pan gesture.
6810 // To compute the displacement of the pan gesture, we keep track of the
6811 // location of the previous event.
6817 // We need to negate the displacement because for a touch event, moving the
6818 // fingers down results in scrolling up, but for a touchpad gesture, we want
6819 // moving the fingers down to result in scrolling down.
6825 }
6827 // Dispatch an event that originated as an OS touch event.
6828 // Usually, we want to dispatch it as a touch event, but some touchpads
6829 // produce touch events for two-finger scrolling, which need to be converted
6830 // to pan gesture events for correct behaviour.
6832 PTOUCHINPUT aOSEvent) {
6837 }
6840 }
6850 // Walk across the touch point array processing each contact point.
6854 // N.B.: According with MS documentation
6855 // https://msdn.microsoft.com/en-us/library/windows/desktop/dd317334(v=vs.85).aspx
6856 // TOUCHEVENTF_DOWN cannot be combined with TOUCHEVENTF_MOVE or
6857 // TOUCHEVENTF_UP. Possibly, it means that TOUCHEVENTF_MOVE and
6858 // TOUCHEVENTF_UP can be combined together.
6862 // Initialize a touch event to send.
6865 ModifierKeyState modifierKeyState;
6867 }
6868 // Pres shell expects this event to be a eTouchStart
6869 // if any new contact points have been added since the last event sent.
6872 }
6874 }
6876 // Pres shell expects removed contacts points to be delivered in a
6877 // separate eTouchEnd event containing only the contact points that were
6878 // removed.
6880 // Initialize a touch event to send.
6883 ModifierKeyState modifierKeyState;
6885 }
6887 }
6889 // Filter out spurious Windows events we don't understand, like palm
6890 // contact.
6892 }
6894 // Setup the touch point we'll append to the touch event array.
6895 nsPointWin touchPoint;
6900 // Initialize the touch data.
6904 // The contact area info cannot be trusted even when
6905 // TOUCHINPUTMASKF_CONTACTAREA is set when the input source is pen,
6906 // which somehow violates the API docs. (bug 1710509) Ultimately the
6907 // dwFlags check will become redundant since we want to migrate to
6908 // WM_POINTER for pens. (bug 1707075)
6917 // Append touch data to the appropriate event.
6920 }
6923 }
6924 }
6926 // Dispatch touch start and touch move event if we have one.
6929 }
6930 // Dispatch touch end event if we have one.
6933 }
6934 }
6939 }
6941 // Gesture event processing. Handles WM_GESTURE events.
6943 // Treatment for pan events which translate into scroll events:
6948 nsEventStatus status;
6952 ModifierKeyState modifierKeyState;
6963 }
6968 endFeedback);
6971 endFeedback);
6973 }
6978 }
6980 // Other gestures translate into simple gesture events:
6984 }
6986 // Polish up and send off the new event
6987 ModifierKeyState modifierKeyState;
6993 nsEventStatus status;
6997 }
6999 // Only close this if we process and return true.
7003 }
7005 // WM_DESTROY event handler
7009 // If this is a toplevel window, notify the taskbar concealer to clean up any
7010 // relevant state.
7013 }
7015 // Make sure we don't get destroyed in the process of tearing down.
7018 // Dispatch the destroy notification.
7021 // Prevent the widget from sending additional events.
7029 }
7030 // Unregister notifications from terminal services
7033 // We will stop receiving native events after dissociating from our native
7034 // window. We will also disappear from the output of WinUtils::GetNSWindowPtr
7035 // for that window.
7038 // Once mWidgetListener is cleared and the subclass is reset, sCurrentWindow
7039 // can be cleared. (It's used in tracking windows for mouse events.)
7042 // Disconnects us from our parent, will call our GetParent().
7045 // Release references to children, device context, toolkit, and app shell.
7048 // Clear our native parent handle.
7049 // XXX Windows will take care of this in the proper order, and
7050 // SetParent(nullptr)'s remove child on the parent already took place in
7051 // nsBaseWidget's Destroy call above.
7052 // SetParent(nullptr);
7055 // We have to destroy the native drag target before we null out our window
7056 // pointer.
7059 // If we're going away and for some reason we're still the rollup widget,
7060 // rollup and turn off capture.
7065 }
7069 }
7073 // Free GDI window class objects
7077 }
7079 // Destroy any custom cursor resources.
7082 }
7086 }
7089 // Finalize panning feedback to possibly restore window displacement
7092 // Clear the main HWND.
7094 }
7096 // Send a resize message to the listener
7101 }
7106 }
7108 // If there is an attached view, inform it as well as the normal widget
7109 // listener.
7113 }
7116 }
7133 mIsFullyOccluded);
7134 }
7135 }
7139 }
7143 }
7144 }
7153 }
7155 // Content rendering of popup is always done by child window.
7156 // See nsDocumentViewer::ShouldAttachToTopLevel().
7160 }
7163 }
7170 }
7174 }
7178 // Don't try to handle WM_DPICHANGED for popup windows (see bug 1239353);
7179 // they remain tied to their original parent's resolution.
7182 }
7185 }
7190 // Limit the position (if not in the middle of a drag-move) & size,
7191 // if it would overflow the destination screen
7202 }
7205 }
7206 }
7209 }
7213 }
7215 // Callback to generate OnCloakChanged pseudo-events.
7216 /* static */
7227 }
7235 }
7241 // Cloaking events like the one we've just received are sent asynchronously.
7242 // Rather than process them one-by-one, we jump the gun a bit and perform
7243 // updates on all newly cloaked/uncloaked nsWindows at once. This also lets us
7244 // batch operations that consider more than one window's state.
7248 };
7255 }
7260 }
7261 });
7265 }
7269 }
7272 }
7279 }
7281 /**************************************************************
7282 **************************************************************
7283 **
7284 ** BLOCK: IME management and accessibility
7285 **
7286 ** Handles managing IME input and accessibility.
7287 **
7288 **************************************************************
7289 **************************************************************/
7296 }
7304 }
7306 }
7310 }
7312 #ifdef ACCESSIBILITY
7313 # ifdef DEBUG
7314 # define NS_LOG_WMGETOBJECT(aWnd, aHwnd, aAcc) \
7315 if (a11y::logging::IsEnabled(a11y::logging::ePlatforms)) { \
7316 printf( \
7319 aHwnd, ::GetParent(aHwnd), aWnd); \
7321 if (aAcc) { \
7322 nsAutoString name; \
7323 aAcc->Name(name); \
7325 } \
7327 }
7329 # else
7330 # define NS_LOG_WMGETOBJECT(aWnd, aHwnd, aAcc)
7331 # endif
7334 // If the pref was ePlatformIsDisabled, return null here, disabling a11y.
7340 }
7342 // In case of popup window return a popup accessible.
7356 }
7357 }
7358 }
7359 }
7361 // otherwise root document accessible.
7364 }
7365 #endif
7367 /**************************************************************
7368 **************************************************************
7369 **
7370 ** BLOCK: Transparency
7371 **
7372 ** Window transparency helpers.
7373 **
7374 **************************************************************
7375 **************************************************************/
7380 }
7382 // stop on dialogs and popups!
7389 }
7394 }
7405 }
7406 }
7412 }
7422 }
7423 }
7425 /**************************************************************
7426 **************************************************************
7427 **
7428 ** BLOCK: Popup rollup hooks
7429 **
7430 ** Deals with CaptureRollup on popup windows.
7431 **
7432 **************************************************************
7433 **************************************************************/
7435 // Schedules a timer for a window, so we can rollup after processing the hook
7436 // event
7438 // In some cases multiple hooks may be scheduled
7439 // so ignore any other requests once one timer is scheduled
7441 // Remember the window handle and the message ID to be used later
7444 // Schedule native timer for doing the rollup after
7445 // this event is done being processed
7448 }
7449 }
7451 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7454 #endif
7456 // Process Menu messages, rollup when popup is clicked.
7458 LPARAM lParam) {
7459 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7465 inx++;
7466 }
7469 # ifdef DEBUG
7473 # endif
7475 # ifdef DEBUG
7479 # endif
7480 }
7482 }
7484 }
7490 }
7493 }
7495 // Process all mouse messages. Roll up when a click is in a native window
7496 // that doesn't have an nsIWidget.
7498 LPARAM lParam) {
7510 }
7512 }
7513 }
7514 }
7516 }
7518 // Process all messages. Roll up when the window is moving, or
7519 // is resizing or when maximized or mininized.
7521 LPARAM lParam) {
7522 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7526 }
7527 #endif
7534 }
7535 }
7538 }
7540 // Register the special "hooks" for dropdown processing.
7547 // Install msg hook for moving the window and resizing
7552 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7556 }
7557 #endif
7558 }
7560 // Install msg hook for menus
7565 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7570 }
7571 #endif
7572 }
7574 // Install msg hook for the mouse
7579 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7583 }
7584 #endif
7585 }
7586 }
7588 // Unhook special message hooks for dropdowns.
7597 }
7599 }
7605 }
7607 }
7613 }
7615 }
7616 }
7618 // This timer is designed to only fire one time at most each time a "hook"
7619 // function is used to rollup the dropdown. In some cases, the timer may be
7620 // scheduled from the hook, but that hook event or a subsequent event may roll
7621 // up the dropdown before this timer function is executed.
7622 //
7623 // For example, if an MFC control takes focus, the combobox will lose focus and
7624 // rollup before this function fires.
7626 DWORD dwTime) {
7628 // if the window is nullptr then we need to use the ID to kill the timer
7632 }
7635 // Note: DealWithPopups does the check to make sure that the rollup widget
7636 // is set.
7637 LRESULT popupHandlingResult;
7638 nsAutoRollup autoRollup;
7642 }
7643 }
7647 }
7649 // static
7652 RECT r;
7654 POINT mp;
7661 }
7669 }
7671 // was the event inside this window?
7673 }
7675 // static
7679 // If we're dealing with menus, we probably have submenus and we don't want
7680 // to rollup some of them if the click is in a parent menu of the current
7681 // submenu.
7688 // Don't roll up if the mouse event occurred within a menu of the
7689 // same type. If the mouse event occurred in a menu higher than that,
7690 // roll up, but pass the number of popups to Rollup so that only those
7691 // of the same type close up.
7694 }
7698 }
7699 }
7701 }
7703 // static
7705 // While popup is open, popup window might be activated by other application.
7706 // At this time, we need to take back focus to the previous window but it
7707 // causes flickering its nonclient area because WM_NCACTIVATE comes before
7708 // WM_ACTIVATE and we cannot know which window will take focus at receiving
7709 // WM_NCACTIVATE. Therefore, we need a hack for preventing the flickerling.
7710 //
7711 // If non-popup window receives WM_NCACTIVATE at deactivating, default
7712 // wndproc shouldn't handle it as deactivating. Instead, at receiving
7713 // WM_ACTIVIATE after that, WM_NCACTIVATE should be sent again manually.
7714 // This returns true if the window needs to handle WM_NCACTIVATE later.
7718 }
7724 }
7731 }
7732 TOUCHINPUT input;
7738 }
7739 // Note that we don't call CloseTouchInputHandle here because we need
7740 // to read the touch input info again in OnTouch later.
7742 }
7744 // static
7749 // XXX Why do we use the return value of WM_MOUSEACTIVATE for all messages?
7754 }
7757 // NOTE: We deal with this here rather than on the switch below because we
7758 // want to do this even if there are no menus to rollup (tooltips don't set
7759 // the rollup listener etc).
7762 }
7763 }
7771 }
7780 // If we rollup with animations but get occluded right away, we might not
7781 // advance the refresh driver enough for the animation to finish.
7788 // If APZ is disabled, don't allow touch inputs to dismiss popups. The
7789 // compatibility mouse events will do it instead.
7791 }
7795 }
7805 // If any of these mouse events are really compatibility events that
7806 // Windows is sending for touch inputs, then don't allow them to dismiss
7807 // popups when APZ is enabled (instead we do the dismissing as part of
7808 // WM_TOUCH handling which is more correct).
7809 // If we don't do this, then when the user lifts their finger after a
7810 // long-press, the WM_RBUTTONDOWN compatibility event that Windows sends
7811 // us will dismiss the contextmenu popup that we displayed as part of
7812 // handling the long-tap-up.
7814 }
7818 }
7821 WinPointerEvents pointerEvents;
7824 }
7825 POINT pt;
7830 }
7832 // Don't roll up if the event is inside the popup window.
7834 }
7837 POINT pt;
7841 }
7843 // Don't roll up if the event is inside the popup window
7845 }
7849 // We need to check if the popup thinks that it should cause closing
7850 // itself when mouse wheel events are fired outside the rollup widget.
7852 // Check if we should consume this event even if we don't roll-up:
7858 }
7859 }
7869 // NOTE: Don't handle WA_INACTIVE for preventing popup taking focus
7870 // because we cannot distinguish it's caused by mouse or not.
7874 // Cancel notifying widget listeners of deactivating the previous
7875 // active window (see WM_KILLFOCUS case in ProcessMessage()).
7877 // Reactivate the window later.
7880 }
7881 // Don't rollup the popup when focus moves back to the parent window
7882 // from a popup because such case is caused by strange mouse drivers.
7886 // Consume this message here since previous window must not have
7887 // been inactivated since we've already stopped accepting the
7888 // inactivation below.
7890 }
7895 // If focus moves to non-popup widget or focusable popup, the window
7896 // needs to update its nonclient area.
7901 }
7903 }
7904 // If focus moves from/to popup, we don't need to rollup the popup
7905 // because such case is caused by strange mouse drivers. And in
7906 // such case, we should consume the message here since we need to
7907 // hide this odd focus move from our content. (If we didn't consume
7908 // the message here, ProcessMessage() will notify widget listener of
7909 // inactivation and that causes unnecessary reflow for supporting
7910 // -moz-window-inactive pseudo class.
7914 }
7918 }
7919 }
7921 // If the WM_ACTIVATE message is caused by a click in a popup,
7922 // we should not rollup any popups.
7927 }
7928 }
7933 // The previous active window should take back focus.
7935 // FYI: Even without this API call, you see expected result (e.g., the
7936 // owner window of the popup keeps active without flickering
7937 // the non-client area). And also this causes initializing
7938 // TSF and it causes using CPU time a lot. However, even if we
7939 // consume WM_ACTIVE messages, native focus change has already
7940 // been occurred. I.e., a popup window is active now. Therefore,
7941 // you'll see some odd behavior if we don't reactivate the owner
7942 // window here. For example, if you do:
7943 // 1. Turn wheel on a bookmark panel.
7944 // 2. Turn wheel on another window.
7945 // then, you'll see that the another window becomes active but the
7946 // owner window of the bookmark panel looks still active and the
7947 // bookmark panel keeps open. The reason is that the first wheel
7948 // operation gives focus to the bookmark panel. Therefore, when
7949 // the next operation gives focus to the another window, previous
7950 // focus window is the bookmark panel (i.e., a popup window).
7951 // So, in this case, our hack around here prevents to inactivate
7952 // the owner window and roll up the bookmark panel.
7954 }
7960 // Don't just consume WM_NCACTIVATE. It doesn't handle only the
7961 // nonclient area state change.
7963 // Accept the deactivating because it's necessary to receive following
7964 // WM_ACTIVATE.
7968 }
7974 // WM_MOUSEACTIVATE may be caused by moving the mouse (e.g., X-mouse
7975 // of TweakUI is enabled. Then, check if the popup should be rolled up
7976 // with rollup listener. If not, just consume the message.
7980 }
7981 // Otherwise, it should be handled by wndproc.
7983 }
7985 // Prevent the click inside the popup from causing a change in window
7986 // activation. Since the popup is shown non-activated, we need to eat any
7987 // requests to activate the window while it is displayed. Windows will
7988 // automatically activate the popup on the mousedown otherwise.
7992 // If the window is being minimized, close popups.
7996 }
8000 // If focus moves to other window created in different process/thread,
8001 // e.g., a plugin window, popups should be rolled up.
8005 }
8014 }
8016 // Only need to deal with the last rollup for left mouse down events.
8020 popupsToRollup,
8023 allowAnimations,
8024 };
8028 LayoutDeviceIntPoint pos;
8033 POINT pt;
8036 // POINTERDOWN is already in screen coords.
8039 }
8041 }
8049 }
8051 // Tell hook to stop processing messages
8056 // If we are NOT supposed to be consuming events, let it go through
8060 }
8063 }
8065 /**************************************************************
8066 **************************************************************
8067 **
8068 ** BLOCK: Misc. utility methods and functions.
8069 **
8070 ** General use.
8071 **
8072 **************************************************************
8073 **************************************************************/
8075 // Note that the result of GetTopLevelWindow method can be different from the
8076 // result of WinUtils::GetTopLevelHWND(). The result can be non-floating
8077 // window. Because our top level window may be contained in another window
8078 // which is not managed by us.
8090 }
8091 }
8093 // Retrieve the top level parent or owner window
8099 }
8100 }
8102 // Set a flag if hwnd is a (non-popup) visible window from this process,
8103 // and bail out of the enumeration. Otherwise leave the flag unmodified
8104 // and continue the enumeration.
8105 // lParam must be a bool* pointing at the flag to be set.
8107 DWORD pid;
8110 // Don't count popups as visible windows, since they don't take focus,
8111 // in case we only have a popup visible (see bug 1554490 where the gfx
8112 // test window is an offscreen popup).
8118 }
8119 }
8121 }
8123 // Determine if it would be ok to activate a window, taking focus.
8124 // We want to avoid stealing focus from another app (bug 225305).
8128 // There is no foreground window, so don't worry about stealing focus.
8130 }
8131 // We can take focus if the current foreground window is already from
8132 // this process.
8133 DWORD pid;
8137 }
8144 // We're probably creating our first visible window, allow that to
8145 // take focus.
8147 }
8149 }
8154 nsAutoString className;
8160 }
8161 }
8163 }
8166 POINT pt;
8171 }
8174 POINT pt;
8179 }
8186 }
8190 }
8194 }
8198 }
8202 }
8206 }
8210 }
8213 }
8215 // WORKAROUND FOR UNDOCUMENTED BEHAVIOR: `IFileDialog::Show` disables the
8216 // top-level ancestor of its provided owner-window. If the modal window's
8217 // container process crashes, it will never get a chance to undo that.
8218 //
8219 // For simplicity's sake we simply unconditionally perform both the disabling
8220 // and reenabling here, synchronously, on the main thread, rather than leaving
8221 // it to happen in our asynchronously-operated IFileDialog.
8226 // Disable the root-level window synchronously before any file-dialogs get a
8227 // chance to fight over doing it asynchronously.
8230 }
8232 mPickerDisplayCount++;
8233 }
8239 mPickerDisplayCount--;
8241 // Once all the file-dialogs are gone, reenable the root-level window.
8245 }
8249 }
8250 }
8253 // We don't currently support using an accelerated layer manager with
8254 // transparent windows so don't even try. I'm also not sure if we even
8255 // want to support this case. See bug 593471.
8256 //
8257 // Windows' support for transparent accelerated surfaces isn't great.
8258 // Some possible approaches:
8259 // - Readback the data and update it using
8260 // UpdateLayeredWindow/UpdateLayeredWindowIndirect
8261 // This is what WPF does. See
8262 // CD3DDeviceLevel1::PresentWithGDI/CD3DSwapChainWithSwDC in WpfGfx. The
8263 // rationale for not using IDirect3DSurface9::GetDC is explained here:
8264 // https://web.archive.org/web/20160521191104/https://blogs.msdn.microsoft.com/dwayneneed/2008/09/08/transparent-windows-in-wpf/
8265 // - Use D3D11_RESOURCE_MISC_GDI_COMPATIBLE, IDXGISurface1::GetDC(),
8266 // and UpdateLayeredWindowIndirect.
8267 // This is suggested here:
8268 // https://docs.microsoft.com/en-us/archive/msdn-magazine/2009/december/windows-with-c-layered-windows-with-direct2d
8269 // but might have the same problem that IDirect3DSurface9::GetDC has.
8270 // - Creating the window with the WS_EX_NOREDIRECTIONBITMAP flag and use
8271 // DirectComposition.
8272 // Not supported on Win7.
8273 // - Using DwmExtendFrameIntoClientArea with negative margins and something
8274 // to turn off the glass effect.
8275 // This doesn't work when the DWM is not running (Win7)
8276 //
8277 // Also see bug 1150376, D3D11 composition can cause issues on some devices
8278 // on Windows 7 where presentation fails randomly for windows with drop
8279 // shadows.
8282 }
8295 }
8303 }
8305 nsPointWin touchPoint;
8319 MultiTouchInput touchInput;
8326 // POINTER_INFO.dwKeyStates can't be used as it only supports Shift and Ctrl
8327 ModifierKeyState modifierKeyState;
8332 }
8335 // Theoretically flags can be set together but they do not
8338 }
8341 }
8343 }
8347 // APZ is not available on context menu. Follow the behavior of touch input
8348 // which fallbacks to WM_LBUTTON* and WM_GESTURE, to keep consistency.
8350 }
8353 }
8355 // We have to handle WM_POINTER* to fetch and cache pen related information
8356 // and fire WidgetMouseEvent with the cached information the WM_*BUTTONDOWN
8357 // handler. This is because Windows doesn't support ::DoDragDrop in the
8358 // touch or pen message handlers.
8360 // Don't consume the Windows WM_POINTER* messages
8362 }
8365 POINTER_PEN_INFO penInfo{};
8368 }
8370 // When dispatching mouse events with pen, there may be some
8371 // WM_POINTERUPDATE messages between WM_POINTERDOWN and WM_POINTERUP with
8372 // small movements. Those events will reset sLastMousePoint and reset
8373 // sLastClickCount. To prevent that, we keep the last pen down position
8374 // and compare it with the subsequent WM_POINTERUPDATE. If the movement is
8375 // smaller than GetSystemMetrics(SM_CXDRAG), then we suppress firing
8376 // eMouseMove for WM_POINTERUPDATE.
8379 // We don't support chorded buttons for pen. Keep the button at
8380 // WM_POINTERDOWN.
8384 EventMessage message;
8419 // Suppress firing eMouseMove for WM_POINTERUPDATE if the movement
8420 // from last WM_POINTERDOWN is smaller than SM_CXDRAG / SM_CYDRAG
8422 }
8424 }
8431 }
8433 // Windows defines the pen pressure is normalized to a range between 0 and
8434 // 1024. Convert it to float.
8440 buttons);
8441 // Per
8442 // https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-pointer_pen_info,
8443 // the rotation is normalized in a range of 0 to 359.
8447 // Fire touch events but not when the barrel button is pressed.
8452 }
8454 // The aLParam of WM_POINTER* is the screen location. Convert it to client
8455 // location
8461 // Fire eContextMenu manually since consuming WM_POINTER* blocks
8462 // WM_CONTEXTMENU
8465 }
8466 // Consume WM_POINTER* to stop Windows fires WM_*BUTTONDOWN / WM_*BUTTONUP
8467 // WM_MOUSEMOVE.
8469 }
8477 }
8484 }
8485 }
8490 }
8495 }
8497 // static
8500 // Initialize touch injection on the first call
8504 }
8506 InitializeTouchInjectionPtr func =
8512 }
8518 }
8520 sInjectTouchFuncPtr =
8525 }
8527 }
8529 }
8537 }
8539 POINTER_TOUCH_INFO info{};
8561 }
8564 // We sent it too quickly after the previous injection (see bug 1535140
8565 // comment 10). On the first loop iteration we just yield (via Sleep(0))
8566 // and try again. If it happens again on the second loop iteration we
8567 // explicitly Sleep(1) and try again. If that doesn't work either we just
8568 // error out.
8571 }
8574 }
8576 }
8582 }
8583 }
8585 }
8594 POINTER_FLAGS flags;
8596 // We know about this pointer, send an update
8604 }
8608 }
8610 // Missing init state, error out
8613 }
8615 // Create a new pointer
8619 }
8620 }
8622 }
8632 // If we don't have touch injection from the OS, or if we are running a test
8633 // that cannot properly inject events to satisfy the OS requirements (see
8634 // bug 1313170) we can just fake it and synthesize the events from here.
8638 }
8642 }
8651 }
8653 // win api expects a value from 0 to 1024. aPointerPressure is a value
8654 // from 0.0 to 1.0.
8657 // If we already know about this pointer id get it's record
8659 POINTER_FLAGS flags;
8660 // Can't use MOZ_TRY_VAR because it confuses WithEntryHandle
8666 }
8674 }
8676 // Remove the pointer from our tracking list. This is UniquePtr wrapped,
8677 // so shouldn't leak.
8679 }
8680 }
8683 aPointerOrientation)
8684 ? NS_ERROR_UNEXPECTED
8686 });
8687 }
8693 }
8695 // cancel all input points
8700 }
8703 }
8708 }
8710 #if !defined(NTDDI_WIN10_RS5) || (NTDDI_VERSION < NTDDI_WIN10_RS5)
8714 #endif
8720 }
8721 #if !defined(NTDDI_WIN10_RS5) || (NTDDI_VERSION < NTDDI_WIN10_RS5)
8725 }
8726 CreateSyntheticPointerDevice =
8732 }
8733 DestroySyntheticPointerDevice =
8739 }
8745 }
8746 #endif
8747 sSyntheticPenDevice =
8750 }
8759 }
8761 // win api expects a value from 0 to 1024. aPointerPressure is a value
8762 // from 0.0 to 1.0.
8765 // If we already know about this pointer id get it's record
8767 POINTER_FLAGS flags;
8768 // Can't use MOZ_TRY_VAR because it confuses WithEntryHandle
8774 }
8782 }
8784 // Remove the pointer from our tracking list. This is UniquePtr wrapped,
8785 // so shouldn't leak.
8787 }
8788 }
8790 POINTER_TYPE_INFO info{};
8800 // PEN_FLAG_ERASER is not supported this way, unfortunately.
8803 }
8812 ? NS_OK
8814 });
8815 };
8819 ModifierKeyState modKeyState;
8824 }
8826 #ifdef DEBUG
8829 }
8832 #endif
8837 // Check all four sides of our monitor for an appbar. Skip any that aren't
8838 // the system taskbar.
8839 MONITORINFO mi;
8843 APPBARDATA appBarData;
8851 nsAutoString className;
8856 }
8857 }
8858 }
8859 }
8862 }
8865 WINDOWPLACEMENT pl;
8877 }
8878 }
8881 // This will likely cause a callback to
8882 // nsWindow::FrameState::{OnFrameChanging() and OnFrameChanged()}
8897 // Don't call ::ShowWindow if we're trying to "restore" a window that is
8898 // already in a normal state. Prevents a bug where snapping to one side
8899 // of the screen and then minimizing would cause Windows to forget our
8900 // window's correct restored position/size.
8903 }
8904 }
8905 }
8918 // We should never observe fullscreen sizemode unless fullscreen is enabled
8922 // Something went wrong if we somehow saved fullscreen mode when we are
8923 // changing into fullscreen mode
8925 }
8929 }
8932 DoShowWindow aDoShowWindow) {
8935 }
8938 // If we're unminimizing a window, asynchronously notify the taskbar after
8939 // the message has been processed. This redundant notification works around
8940 // a race condition in explorer.exe. (See bug 1835851, or comments in
8941 // TaskbarConcealer.)
8942 //
8943 // Note that we notify regardless of `aMode`: unminimizing a non-fullscreen
8944 // window can also affect the correct taskbar state, yet fail to affect the
8945 // current taskbar state.
8948 }
8949 }
8955 // If we are in fullscreen mode, minimize should work like normal and
8956 // return us to fullscreen mode when unminimized. Maximize isn't really
8957 // available and won't do anything. "Restore" should do the same thing as
8958 // requesting to end fullscreen.
8962 }
8963 }
8966 DoShowWindow aDoShowWindow) {
8969 // Save the size mode from before fullscreen.
8971 }
8974 // NOTE(emilio): When minimizing a fullscreen window we remain with
8975 // mFullscreenMode = true, but mSizeMode = nsSizeMode_Minimized. We need to
8976 // make sure to call SetSizeModeInternal even if mFullscreenMode didn't
8977 // change, to ensure we actually end up with a fullscreen sizemode when
8978 // restoring a window from that state.
8981 aDoShowWindow);
8982 }
8983 }
8990 }
8993 // We don't want to perform the ShowWindow ourselves if we're on the frame
8994 // changed message. Windows has done the frame change for us, and we take care
8995 // of activating as needed. We also don't want to potentially trigger
8996 // more focus / restore. Among other things, this addresses a bug on Win7
8997 // related to window docking. (bug 489258)
9002 // If window was restored, activate the window now to get correct attributes.
9007 }
9009 }
9012 #ifdef WINSTATE_DEBUG_OUTPUT
9014 #endif
9015 }
9018 DoShowWindow aDoShowWindow) {
9021 }
9035 }
9041 }
9044 }
9049 mNeedsToPreventContextMenu =
9054 }