| blob | b210381aa86ddfa599955604e514a5da5aaee570 |
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 <winuser.h>
190 # if !defined(WINABLEAPI)
191 # include <winable.h>
193 #endif
208 #include <d3d11.h>
210 // ERROR from wingdi.h (below) gets undefined by some code.
211 // #define ERROR 0
212 // #define RGN_ERROR ERROR
213 #define ERROR 0
215 #if !defined(SM_CONVERTIBLESLATEMODE)
216 # define SM_CONVERTIBLESLATEMODE 0x2003
217 #endif
239 /**************************************************************
240 **************************************************************
241 **
242 ** BLOCK: Variables
243 **
244 ** nsWindow Class static initializations and global variables.
245 **
246 **************************************************************
247 **************************************************************/
249 /**************************************************************
250 *
251 * SECTION: nsWindow statics
252 *
253 **************************************************************/
264 // Urgent-message reentrancy depth for the static `WindowProc` callback.
265 //
266 // Three unfortunate facts collide:
267 //
268 // 𝛼) Some messages must be processed promptly. If not, Windows will leave the
269 // receiving window in an intermediate, and potentially unusable, state until
270 // the WindowProc invocation that is handling it returns.
271 //
272 // 𝛽) Some messages have indefinitely long processing time. These are mostly
273 // messages which may cause us to enter a nested modal loop (via
274 // `SpinEventLoopUntil` or similar).
275 //
276 // 𝛾) Sometimes, messages skip the queue entirely. Our `WindowProc` may be
277 // reentrantly reinvoked from the kernel while we're blocking _on_ the
278 // kernel, even briefly, during processing of other messages. (Relevant
279 // search term: `KeUserModeCallback`.)
280 //
281 // The nightmare scenario, then, is that during processing of an 𝛼-message, we
282 // briefly become blocked (e.g., by calling `::SendMessageW()`), and the kernel
283 // takes that opportunity to use 𝛾 to hand us a 𝛽-message. (Concretely, see
284 // bug 1842170.)
285 //
286 // There is little we can do to prevent the first half of this scenario. 𝛼) and
287 // 𝛾) are effectively immutable facts of Windows, and we sometimes legitimately
288 // need to make blocking calls to process 𝛼-messages. (We may not even be aware
289 // that we're making such calls, if they're undocumented implementation details
290 // of another API.)
291 //
292 // In an ideal world, WindowProc would always return promptly (or at least in
293 // bounded time), and 𝛽-messages would not _per se_ exist; long-running modal
294 // states would instead be implemented in async fashion. In practice, that's far
295 // easier said than done -- replacing existing uses of `SpinEventLoopUntil` _et
296 // al._ with asynchronous mechanisms is a collection of mostly-unrelated cross-
297 // cutting architectural tasks, each of potentially unbounded scope. For now,
298 // and for the foreseeable future, we're stuck with them.
299 //
300 // We therefore simply punt. More specifically: if a known 𝛽-message jumps the
301 // queue to come in while we're in the middle of processing a known 𝛼-message,
302 // we:
303 // * properly queue the message for processing later;
304 // * respond to the 𝛽-message as though we actually had processed it; and
305 // * just hope that it can wait until we get around to it.
306 //
307 // The word "known" requires a bit of justification. There is no canonical set
308 // of 𝛼-messages, nor is the set of 𝛽-messages fixed (or even demarcable). We
309 // can't safely assume that all messages are 𝛼-messages, as that could cause
310 // 𝛽-messages to be arbitrarily and surprisingly delayed whenever any nested
311 // event loop is active. We also can't assume all messages are 𝛽-messages,
312 // since one 𝛼-message jumping the queue while processing another 𝛼-message is
313 // part of normal and required operation for windowed Windows applications.
314 //
315 // So we simply add messages to those sets as we identify them. (Or, preferably,
316 // rework the 𝛽-message's handling to make it no longer 𝛽. But see above.)
317 //
318 // ---
319 //
320 // The actual value of `sDepth` is the number of active invocations of
321 // `WindowProc` that are processing known 𝛼-messages.
324 // Hook Data Members for Dropdowns. sProcessHook Tells the
325 // hook methods whether they should be processing the hook
326 // messages.
335 // Used to prevent dispatching mouse events that do not originate from user
336 // input.
347 }
349 // Global event hook for window cloaking. Never deregistered.
350 // - `Nothing` if not yet set.
351 // - `Some(nullptr)` if no attempt should be made to set it.
366 // There's already one inflight with this timestamp. Don't
367 // send a duplicate.
369 }
375 }
380 // The SKEWFIX message is stale; we've sent a new one since then.
381 // Ignore this one.
383 }
388 }
393 HWND mWnd;
394 };
401 /**************************************************************
402 *
403 * SECTION: globals variables
404 *
405 **************************************************************/
414 // General purpose user32.dll hook object
417 // When the client area is extended out into the default window frame area,
418 // this is the minimum amount of space along the edge of resizable windows
419 // we will always display a resize cursor in, regardless of the underlying
420 // content.
423 // Getting this object from the window server can be expensive. Keep it
424 // around, also get it off the main thread. (See bug 1640852)
428 // We should never really try to accelerate windows bigger than this. In some
429 // cases this might lead to no D3D9 acceleration where we could have had it
430 // but D3D9 does not reliably report when it supports bigger windows. 8192
431 // is as safe as we can get, we know at least D3D10 hardware always supports
432 // this, other hardware we expect to report correctly in D3D9.
433 #define MAX_ACCELERATED_DIMENSION 8192
435 // On window open (as well as after), Windows has an unfortunate habit of
436 // sending rather a lot of WM_NCHITTEST messages. Because we have to do point
437 // to DOM target conversions for these, we cache responses for a given
438 // coordinate this many milliseconds:
439 #define HITTEST_CACHE_LIFETIME_MS 50
441 #if defined(ACCESSIBILITY)
445 /**
446 * Windows touchscreen code works by setting a global WH_GETMESSAGE hook and
447 * injecting tiptsf.dll. The touchscreen process then posts registered messages
448 * to our main thread. The tiptsf hook picks up those registered messages and
449 * uses them as commands, some of which call into UIA, which then calls into
450 * MSAA, which then sends WM_GETOBJECT to us.
451 *
452 * We can get ahead of this by installing our own thread-local WH_GETMESSAGE
453 * hook. Since thread-local hooks are called ahead of global hooks, we will
454 * see these registered messages before tiptsf does. At this point we can then
455 * raise a flag that blocks a11y before invoking CallNextHookEx which will then
456 * invoke the global tiptsf hook. Then when we see WM_GETOBJECT, we check the
457 * flag by calling TIPMessageHandler::IsA11yBlocked().
458 *
459 * For Windows 8, we also hook tiptsf!ProcessCaretEvents, which is an a11y hook
460 * function that also calls into UIA.
461 */
467 }
468 }
473 }
477 }
482 }
485 }
491 // Registered messages used by tiptsf
509 }
510 }
517 }
519 }
524 }
527 }
528 };
535 }
542 A11yInstantiationBlocker block;
544 }
545 }
548 }
553 PDWORD_PTR aMsgResult) {
554 // We don't want to handle this unless the message is a WM_GETOBJECT that we
555 // want to block, and the aHwnd is a nsWindow that belongs to the current
556 // (i.e., main) thread.
562 }
564 // In this case we want to fake the result that would happen if we had
565 // decided not to handle WM_GETOBJECT in our WndProc. We hand the message
566 // off to DefWindowProc to accomplish this.
571 }
574 sSendMessageTimeoutWStub;
577 HHOOK mHook;
580 };
592 // This task will get the VirtualDesktopManager from the generic thread pool
593 // since doing this on the main thread on startup causes performance issues.
594 //
595 // See bug 1640852.
596 //
597 // This should be fine and should not require any locking, as when the main
598 // thread will access it, if it races with this function it will either find
599 // it to be null or to have a valid value.
605 #ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
609 }
610 #endif
619 }
623 }
624 };
626 // Ground-truth query: does Windows claim the window is cloaked right now?
628 DWORD cloakedState;
636 }
639 }
643 /**************************************************************
644 **************************************************************
645 **
646 ** BLOCK: nsIWidget impl.
647 **
648 ** nsIWidget interface implementation, broken down into
649 ** sections.
650 **
651 **************************************************************
652 **************************************************************/
654 /**************************************************************
655 *
656 * SECTION: nsWindow construction and destruction
657 *
658 **************************************************************/
675 }
677 // Global initialization
679 // Global app registration id for Win7 and up. See
680 // WinTaskbar.cpp for details.
681 // MSIX packages explicitly do not support setting the appid from within
682 // the app, as it is set in the package manifest instead.
685 }
688 }
689 #if defined(ACCESSIBILITY)
694 }
697 // Init theme data
702 sInstanceCount++;
703 }
708 // If the widget was released without calling Destroy() then the native window
709 // still exists, and we need to destroy it. Destroy() will early-return if it
710 // was already called. In any case it is important to call it before
711 // destroying mPresentLock (cf. 1156182).
714 // Free app icon resources. This must happen after `OnDestroy` (see bug
715 // 708033).
720 sInstanceCount--;
722 // Global shutdown
725 sCurrentCursor = {};
730 }
731 }
734 }
736 /**************************************************************
737 *
738 * SECTION: nsIWidget::Create, nsIWidget::Destroy
739 *
740 * Creating and destroying windows for this widget.
741 *
742 **************************************************************/
744 // Allow Derived classes to modify the height that is passed
745 // when the window is created or resized.
749 LRESULT popupHandlingResult;
751 // We need to consume the event after using it to roll up the popup(s).
753 }
756 // Give the swipe tracker a first pass at the event. If a new pan gesture
757 // has been started since the beginning of the swipe, the swipe tracker
758 // will know to ignore the event.
759 nsEventStatus status =
763 }
764 }
766 APZEventResult result;
769 }
772 }
783 }
786 }
791 }
796 }
803 }
809 }
816 }
823 }
824 }
830 }
831 }
833 // Create the proper widget
837 // Historical note: there was once some belief and/or intent that nsWindows
838 // could be created on arbitrary threads, and this may still be reflected in
839 // some comments.
855 // Ensure that the toolkit is created.
860 HWND parent;
866 mParent =
868 }
882 }
884 // Make sure CreateWindowEx succeeds at creating a toplevel window
887 // See if the caller wants to explictly set clip children and clip siblings
892 }
895 }
896 }
900 // Take specific actions when creating the first top-level window
912 errorString);
913 }
916 "The skeleton UI window style should match the expected "
919 "The skeleton UI window extended style should match the "
923 "The skeleton UI window should be created on the same thread as "
927 // If we successfully consumed the pre-XUL skeleton UI, just update
928 // our internal state to match what is currently being displayed.
933 // These match the margins set in browser-tabsintitlebar.js with
934 // default prefs on Windows. Bug 1673092 tracks lining this up with
935 // that more correctly instead of hard-coding it.
938 // Reset the WNDPROC for this window and its whole class, as we had
939 // to use our own WNDPROC when creating the the skeleton UI window.
946 }
947 }
950 mWnd =
954 }
959 }
964 // C++03 lambda approximation until P2173R1 is available (-std=c++2b)
969 DWORD idEventThread,
970 DWORD dwmsEventTime) {
973 }
974 };
986 err));
987 }
988 }
993 // Although permanent Private Browsing mode is indeed Private Browsing,
994 // we choose to make it look like regular Firefox in terms of the icon
995 // it uses (which also means we shouldn't use the Private Browsing
996 // AUMID).
1001 PROPVARIANT pv;
1002 nsAutoString aumid;
1003 // make sure we're using the private browsing AUMID so that taskbar
1004 // grouping works properly
1010 }
1013 }
1014 }
1019 }
1020 }
1024 // If mDefaultScale is set before mWnd has been set, it will have the scale of
1025 // the primary monitor, rather than the monitor that the window is actually
1026 // on. For non-popup windows this gets corrected by the WM_DPICHANGED message
1027 // which resets mDefaultScale, but for popup windows we don't reset
1028 // mDefaultScale on that message. In order to ensure that popup windows
1029 // spawned on a non-primary monitor end up with the correct scale, we reset
1030 // mDefaultScale here so that it gets recomputed using the correct monitor now
1031 // that we have a mWnd.
1038 }
1044 }
1049 }
1053 // Ugly Thinkpad Driver Hack (Bugs 507222 and 594977)
1054 //
1055 // We create two zero-sized windows as descendants of the top-level window,
1056 // like so:
1057 //
1058 // Top-level window (MozillaWindowClass)
1059 // FAKETRACKPOINTSCROLLCONTAINER (MozillaWindowClass)
1060 // FAKETRACKPOINTSCROLLABLE (MozillaWindowClass)
1061 //
1062 // We need to have the middle window, otherwise the Trackpoint driver
1063 // will fail to deliver scroll messages. WM_MOUSEWHEEL messages are
1064 // sent to the FAKETRACKPOINTSCROLLABLE, which then propagate up the
1065 // window hierarchy until they are handled by nsWindow::WindowProc.
1066 // WM_HSCROLL messages are also sent to the FAKETRACKPOINTSCROLLABLE,
1067 // but these do not propagate automatically, so we have the window
1068 // procedure pretend that they were dispatched to the top-level window
1069 // instead.
1070 //
1071 // The FAKETRACKPOINTSCROLLABLE needs to have the specific window styles it
1072 // is given below so that it catches the Trackpoint driver's heuristics.
1081 // Give the FAKETRACKPOINTSCROLLABLE window a specific ID so that
1082 // WindowProcInternal can distinguish it from the top-level window
1083 // easily.
1086 // Make FAKETRACKPOINTSCROLLABLE use nsWindow::WindowProc, and store the
1087 // old window procedure in its "user data".
1091 }
1093 // We will start receiving native events after associating with our native
1094 // window. We will also become the output of WinUtils::GetNSWindowPtr for that
1095 // window.
1098 }
1100 // Starting with Windows XP, a process always runs within a terminal services
1101 // session. In order to play nicely with RDP, fast user switching, and the
1102 // lock screen, we should be handling WM_WTSSESSION_CHANGE. We must register
1103 // our HWND in order to receive this message.
1116 }
1117 }
1122 }
1131 }
1132 }
1134 // Close this nsWindow
1136 // WM_DESTROY has already fired, avoid calling it twice
1139 // Don't destroy windows that have file pickers open, we'll tear these down
1140 // later once the picker is closed.
1144 // During the destruction of all of our children, make sure we don't get
1145 // deleted.
1150 /**
1151 * On windows the LayerManagerOGL destructor wants the widget to be around for
1152 * cleanup. It also would like to have the HWND intact, so we nullptr it here.
1153 */
1159 // The DestroyWindow function destroys the specified window. The function
1160 // sends WM_DESTROY and WM_NCDESTROY messages to the window to deactivate it
1161 // and remove the keyboard focus from it. The function also destroys the
1162 // window's menu, flushes the thread message queue, destroys timers, removes
1163 // clipboard ownership, and breaks the clipboard viewer chain (if the window
1164 // is at the top of the viewer chain).
1165 //
1166 // If the specified window is a parent or owner window, DestroyWindow
1167 // automatically destroys the associated child or owned windows when it
1168 // destroys the parent or owner window. The function first destroys child or
1169 // owned windows, and then it destroys the parent or owner window.
1172 // Our windows can be subclassed which may prevent us receiving WM_DESTROY. If
1173 // OnDestroy() didn't get called, call it now.
1175 MSGResult msgResult;
1178 }
1179 }
1181 /**************************************************************
1182 *
1183 * SECTION: Window class utilities
1184 *
1185 * Utilities for calculating the proper window class name for
1186 * Create window.
1187 *
1188 **************************************************************/
1190 /* static */
1193 WNDCLASSW wc;
1195 // already registered
1197 }
1212 // For older versions of Win32 (i.e., not XP), the registration may
1213 // fail with aExtraStyle, so we have to re-register without it.
1216 }
1218 }
1222 /* static */
1234 }
1235 }();
1237 }
1239 /**************************************************************
1240 *
1241 * SECTION: Window styles utilities
1242 *
1243 * Return the proper windows styles and extended styles.
1244 *
1245 **************************************************************/
1247 // Return nsWindow styles
1249 DWORD style;
1276 }
1287 }
1292 // XXX The close box can only be removed by changing the window class,
1293 // as far as I know --- roc+moz@cs.cmu.edu
1298 // Looks like getting rid of the system menu also does away with the
1299 // close box. So, we only get rid of the system menu if you want neither it
1300 // nor the close box. How does the Windows "Dialog" window class get just
1301 // closebox and no sysmenu? Who knows.
1314 }
1320 }
1321 }
1325 }
1327 // Return nsWindow extended styles
1336 }
1338 }
1343 }
1348 }
1350 }
1352 /**************************************************************
1353 *
1354 * SECTION: Native window association utilities
1355 *
1356 * Used in Create and Destroy. A nsWindow can associate with its
1357 * underlying native window mWnd. Once a native window is
1358 * associated with a nsWindow, its native events will be handled
1359 * by the static member function nsWindow::WindowProc. Moreover,
1360 * the association will be registered in the WinUtils association
1361 * list, that is, calling WinUtils::GetNSWindowPtr on the native
1362 * window will return the associated nsWindow. This is used in
1363 * nsWindow::WindowProc to correctly dispatch native events to
1364 * the handler methods defined in nsWindow, even though it is a
1365 * static member function.
1366 *
1367 * After dissociation, the native events of the native window will
1368 * no longer be handled by nsWindow::WindowProc, and will thus not
1369 * be dispatched to the nsWindow native event handler methods.
1370 * Moreover, the association will no longer be registered in the
1371 * WinUtils association list, so calling WinUtils::GetNSWindowPtr
1372 * on the native window will return nullptr.
1373 *
1374 **************************************************************/
1380 }
1382 // Connect the this pointer to the native window handle.
1383 // This should be done before SetWindowLongPtrW, because nsWindow::WindowProc
1384 // uses WinUtils::GetNSWindowPtr internally.
1394 }
1398 }
1403 }
1413 }
1415 /**************************************************************
1416 *
1417 * SECTION: nsIWidget::SetParent, nsIWidget::GetParent
1418 *
1419 * Set or clear the parent widgets using window properties, and
1420 * handles calculating native parent handles.
1421 *
1422 **************************************************************/
1424 // Get and set parent widgets
1430 }
1438 }
1440 // If we have no parent, SetParent should return the desktop.
1443 }
1444 }
1452 }
1458 }
1459 }
1464 }
1467 }
1469 }
1474 }
1481 }
1483 }
1488 }
1490 }
1495 }
1499 }
1503 // Must use a flag instead of mWindowType to tell if the window is the
1504 // owned by the topmost widget, because a child window can be embedded
1505 // inside a HWND which is not associated with a nsIWidget.
1507 }
1509 // If this widget has already been destroyed, pretend we have no parent.
1510 // This corresponds to code in Destroy which removes the destroyed
1511 // widget from its parent's child list.
1514 // aIncludeOwner set to true implies walking the parent chain to retrieve the
1515 // root owner. aIncludeOwner set to false implies the search will stop at the
1516 // true parent (default).
1522 else
1528 // If the widget is in the process of being destroyed then
1529 // do NOT return it
1532 }
1533 }
1534 }
1535 }
1538 }
1540 /**************************************************************
1541 *
1542 * SECTION: nsIWidget::Show
1543 *
1544 * Hide or show this component.
1545 *
1546 **************************************************************/
1550 // The first time we decide to actually show the window is when we decide
1551 // that we've taken over the window from the skeleton UI, and we should
1552 // no longer treat resizes / moves specially.
1554 #if defined(ACCESSIBILITY)
1555 // If our HWND has focus and the a11y engine hasn't started yet, fire a
1556 // focus win event. Windows already did this when the skeleton UI appeared,
1557 // but a11y wouldn't have been able to start at that point even if a client
1558 // responded. Firing this now gives clients the chance to respond with
1559 // WM_GETOBJECT, which will trigger the a11y engine. We don't want to do
1560 // this if the a11y engine has already started because it has probably
1561 // already fired focus on a descendant.
1564 }
1566 }
1570 // WS_EX_COMPOSITED conflicts with the WS_EX_LAYERED style and causes
1571 // some popup menus to become invisible.
1575 }
1576 }
1581 // Set the status now so that anyone asking during ShowWindow or
1582 // SetWindowPos would get the correct answer.
1585 // We may have cached an out of date visible state. This can happen
1586 // when session restore sets the full screen mode.
1589 else
1595 // speed up the initial paint after show for
1596 // top level windows:
1599 // Set the cursor before showing the window to avoid the default wait
1600 // cursor.
1618 // Don't flicker the window if we're restoring session
1621 }
1622 }
1624 }
1629 }
1632 }
1635 // ensure popups are the topmost of the TOPMOST
1636 // layer. Remember not to set the SWP_NOZORDER
1637 // flag as that might allow the taskbar to overlap
1638 // the popup.
1642 // PopupLevel::Top popups should be above all else. All other
1643 // types should be placed in front of their owner, without
1644 // changing the owner's z-level relative to other windows.
1651 }
1654 }
1660 }
1661 }
1663 // Clear contents to avoid ghosting of old content if we display
1664 // this window again.
1668 }
1669 }
1675 SWP_NOACTIVATE);
1676 }
1677 }
1678 }
1684 }
1685 }
1689 }
1690 }
1692 /**************************************************************
1693 *
1694 * SECTION: nsIWidget::IsVisible
1695 *
1696 * Returns the visibility state.
1697 *
1698 **************************************************************/
1700 // Return true if the component is visible, false otherwise.
1701 //
1702 // This does not take cloaking into account.
1705 /**************************************************************
1706 *
1707 * SECTION: Touch and APZ-related functions
1708 *
1709 **************************************************************/
1715 }
1721 }
1723 }
1730 }
1731 }
1733 /**************************************************************
1734 *
1735 * SECTION: nsIWidget::SetInputRegion
1736 *
1737 * Sets whether the window should ignore mouse events.
1738 *
1739 **************************************************************/
1742 }
1744 /**************************************************************
1745 *
1746 * SECTION: nsIWidget::Move, nsIWidget::Resize, nsIWidget::Size
1747 *
1748 * Repositioning and sizing a window.
1749 *
1750 **************************************************************/
1760 }
1763 // We can't make ThebesLayers bigger than this anyway.. no point it letting
1764 // a window grow bigger as we won't be able to draw content there in
1765 // general.
1768 }
1773 }
1779 }
1784 }
1787 }
1790 }
1793 }
1795 }
1797 // Move this component
1802 }
1804 // for top-level windows only, convert coordinates from desktop pixels
1805 // (the "parent" coordinate space) to the window's device pixel space
1811 // Check to see if window needs to be moved first
1812 // to avoid a costly call to SetWindowPos. This check
1813 // can not be moved to the calling code in nsView, because
1814 // some platforms do not position child windows correctly
1816 // Only perform this check for non-popup windows, since the positioning can
1817 // in fact change even when the x/y do not. We always need to perform the
1818 // check. See bug #97805 for details.
1820 // Nothing to do, since it is already positioned correctly.
1822 }
1827 #ifdef DEBUG
1828 // complain if a window is moved offscreen (legal, but potentially
1829 // worrisome)
1831 // Make sure this window is actually on the screen before we move it
1832 // XXX: Needs multiple monitor support
1836 RECT workArea;
1838 // no annoying assertions. just mention the issue.
1842 }
1843 }
1845 }
1846 }
1847 #endif
1849 // Normally, when the skeleton UI is disabled, we resize+move the window
1850 // before showing it in order to ensure that it restores to the correct
1851 // position when the user un-maximizes it. However, when we are using the
1852 // skeleton UI, this results in the skeleton UI window being moved around
1853 // undesirably before being locked back into the maximized position. To
1854 // avoid this, we simply set the placement to restore to via
1855 // SetWindowPlacement. It's a little bit more of a dance, though, since we
1856 // need to convert the workspace coords that SetWindowPlacement uses to the
1857 // screen space coordinates we normally use with SetWindowPos.
1865 }
1886 }
1887 }
1890 }
1891 }
1893 // Resize this component
1895 // for top-level windows only, convert coordinates from desktop pixels
1896 // (the "parent" coordinate space) to the window's device pixel space
1907 }
1911 // Avoid unnecessary resizing calls
1915 }
1917 }
1919 // Set cached value for lightweight and printing
1924 }
1927 // Refer to the comment above a similar check in nsWindow::Move
1941 }
1951 }
1952 }
1955 }
1958 }
1960 // Resize this component
1963 // for top-level windows only, convert coordinates from desktop pixels
1964 // (the "parent" coordinate space) to the window's device pixel space
1978 }
1982 // Avoid unnecessary resizing calls
1986 }
1988 }
1990 // Set cached value for lightweight and printing
1994 // Refer to the comment above a similar check in nsWindow::Move
2002 }
2019 }
2028 }
2031 // If we have a fullscreen transition window, we need to make
2032 // it topmost again, otherwise the taskbar may be raised by
2033 // the system unexpectedly when we leave fullscreen state.
2036 }
2037 }
2040 }
2043 }
2048 }
2050 }
2052 /**************************************************************
2053 *
2054 * SECTION: Window Z-order and state.
2055 *
2056 * nsIWidget::PlaceBehind, nsIWidget::SetSizeMode,
2057 * nsIWidget::ConstrainPosition
2058 *
2059 * Z-order, positioning, restore, minimize, and maximize.
2060 *
2061 **************************************************************/
2063 // Position the window behind the given window
2075 // Can't place the window to top so place it behind the foreground window
2076 // (as long as it is not topmost)
2083 }
2086 }
2089 WINDOWPLACEMENT pl;
2093 }
2095 // Maximize, minimize or restore the window.
2097 // If we are still displaying a maximized pre-XUL skeleton UI, ignore the
2098 // noise of sizemode changes. Once we have "shown" the window for the first
2099 // time (called nsWindow::Show(true), even though the window is already
2100 // technically displayed), we will again accept sizemode changes.
2103 }
2106 }
2114 }
2116 GUID desktop;
2120 }
2126 }
2127 }
2130 // If we have a value cached, use that, but also make sure it is
2131 // scheduled to be updated. If we don't yet have a value, get
2132 // one synchronously.
2139 }
2142 }
2155 }
2157 }
2159 #ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
2163 }
2164 #endif
2167 };
2171 }
2175 }
2181 }
2183 GUID desktop;
2190 }
2191 }
2192 }
2198 }
2200 // Constrain a potential move to fit onscreen
2201 // Position (aX, aY) is specified in Windows screen (logical) pixels,
2202 // except when using per-monitor DPI, in which case it's device pixels.
2209 // We need to use the window size in the kind of pixels used for window-
2210 // manipulation APIs.
2216 /* get our playing field. use the current screen, or failing that
2217 for any reason, use device caps for the default screen. */
2218 RECT screenRect;
2224 }
2231 // For normalized windows, use the desktop work area.
2235 }
2237 // For full screen windows, use the desktop.
2241 }
2242 }
2257 }
2259 /**************************************************************
2260 *
2261 * SECTION: nsIWidget::Enable, nsIWidget::IsEnabled
2262 *
2263 * Enabling and disabling the widget.
2264 *
2265 **************************************************************/
2267 // Enable/disable this component
2271 }
2272 }
2274 // Return the current enable state
2278 }
2280 /**************************************************************
2281 *
2282 * SECTION: nsIWidget::SetFocus
2283 *
2284 * Give the focus to this widget.
2285 *
2286 **************************************************************/
2290 #ifdef WINSTATE_DEBUG_OUTPUT
2297 }
2298 #endif
2299 // Uniconify, if necessary
2303 }
2305 }
2306 }
2308 /**************************************************************
2309 *
2310 * SECTION: Bounds
2311 *
2312 * GetBounds, GetClientBounds, GetScreenBounds,
2313 * GetRestoredBounds, GetClientOffset, SetNonClientMargins
2314 *
2315 * Bound calculations.
2316 *
2317 **************************************************************/
2319 // Return the window's full dimensions in screen coordinates.
2320 // If the window has a parent, converts the origin to an offset
2321 // of the parent's screen origin.
2325 }
2327 RECT r;
2330 LayoutDeviceIntRect rect;
2332 // assign size
2335 // popup window bounds' are in screen coordinates, not relative to parent
2336 // window
2340 }
2342 // chrome on parent:
2343 // ___ 5,5 (chrome start)
2344 // | ____ 10,10 (client start)
2345 // | | ____ 20,20 (child start)
2346 // | | |
2347 // 20,20 - 5,5 = 15,15 (??)
2348 // minus GetClientOffset:
2349 // 15,15 - 5,5 = 10,10
2350 //
2351 // no chrome on parent:
2352 // ______ 10,10 (win start)
2353 // | ____ 20,20 (child start)
2354 // | |
2355 // 20,20 - 10,10 = 10,10
2356 //
2357 // walking the chain:
2358 // ___ 5,5 (chrome start)
2359 // | ___ 10,10 (client start)
2360 // | | ___ 20,20 (child start)
2361 // | | | __ 30,30 (child start)
2362 // | | | |
2363 // 30,30 - 20,20 = 10,10 (offset from second child to first)
2364 // 20,20 - 5,5 = 15,15 + 10,10 = 25,25 (??)
2365 // minus GetClientOffset:
2366 // 25,25 - 5,5 = 20,20 (offset from second child to parent client)
2368 // convert coordinates if parent exists
2371 RECT pr;
2375 // adjust for chrome
2381 }
2382 }
2388 }
2391 }
2393 // Get this component dimension
2397 }
2399 RECT r;
2404 }
2407 LayoutDeviceIntRect rect;
2411 }
2413 // Like GetBounds, but don't offset by the parent
2417 }
2419 RECT r;
2423 }
2429 }
2432 }
2441 }
2449 }
2451 // Return the x,y offset of the client area from the origin of the window. If
2452 // the window is borderless returns (0,0).
2456 }
2458 RECT r1;
2463 }
2466 // This will trigger a frame changed event, triggering
2467 // nc calc size and a sizemode gecko event.
2472 // If hidden, just send the frame changed event for now.
2475 }
2477 // Send a gecko size event to trigger reflow.
2482 // Invalidate and update
2484 }
2486 // Internally track the caption status via a window property. Required
2487 // due to our internal handling of WM_NCACTIVATE when custom client
2488 // margins are set.
2492 sGetWindowInfoPtrStub;
2498 }
2501 // No property set, return the default data.
2503 // Call GetWindowInfo and update dwWindowStatus with our
2504 // internally tracked value.
2509 }
2519 }
2521 // Update our internally tracked caption status
2524 }
2526 #define DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 19
2527 #define DWMWA_USE_IMMERSIVE_DARK_MODE 20
2536 }
2539 LayoutDeviceIntMargin nonClientOffset;
2541 // We're dealing with a "normal" window (not maximized, minimized, or
2542 // fullscreen), so process `mNonClientMargins` and set `mNonClientOffset`
2543 // accordingly.
2544 //
2545 // Setting `mNonClientOffset` to 0 has the effect of leaving the default
2546 // frame intact. Setting it to a value greater than 0 reduces the frame
2547 // size by that amount.
2555 }
2564 }
2572 }
2580 }
2582 }
2584 /**
2585 * Called when the window layout changes: full screen mode transitions,
2586 * theme changes, and composition changes. Calculates the new non-client
2587 * margins and fires off a frame changed event, which triggers an nc calc
2588 * size windows event, kicking the changes in.
2589 *
2590 * The offsets calculated here are based on the value of `mNonClientMargins`
2591 * which is specified in the "chromemargins" attribute of the window. For
2592 * each margin, the value specified has the following meaning:
2593 * -1 - leave the default frame in place
2594 * 0 - remove the frame
2595 * >0 - frame size equals min(0, (default frame size - margin value))
2596 *
2597 * This function calculates and populates `mNonClientOffset`.
2598 * In our processing of `WM_NCCALCSIZE`, the frame size will be calculated
2599 * as (default frame size - offset). For example, if the left frame should
2600 * be 1 pixel narrower than the default frame size, `mNonClientOffset.left`
2601 * will equal 1.
2602 *
2603 * For maximized, fullscreen, and minimized windows, the values stored in
2604 * `mNonClientMargins` are ignored, and special processing takes place.
2605 *
2606 * For non-glass windows, we only allow frames to be their default size
2607 * or removed entirely.
2608 */
2612 }
2622 // mCaptionHeight is the default size of the NC area at
2623 // the top of the window. If the window has a caption,
2624 // the size is calculated as the sum of:
2625 // SM_CYFRAME - The thickness of the sizing border
2626 // around a resizable window
2627 // SM_CXPADDEDBORDER - The amount of border padding
2628 // for captioned windows
2629 // SM_CYCAPTION - The height of the caption area
2630 //
2631 // If the window does not have a caption, mCaptionHeight will be equal to
2632 // `WinUtils::GetSystemMetricsForDpi(SM_CYFRAME, dpi)`
2633 mCaptionHeight =
2639 // mHorResizeMargin is the size of the default NC areas on the
2640 // left and right sides of our window. It is calculated as
2641 // the sum of:
2642 // SM_CXFRAME - The thickness of the sizing border
2643 // SM_CXPADDEDBORDER - The amount of border padding
2644 // for captioned windows
2645 //
2646 // If the window does not have a caption, mHorResizeMargin will be equal to
2647 // `WinUtils::GetSystemMetricsForDpi(SM_CXFRAME, dpi)`
2648 mHorResizeMargin =
2653 // mVertResizeMargin is the size of the default NC area at the
2654 // bottom of the window. It is calculated as the sum of:
2655 // SM_CYFRAME - The thickness of the sizing border
2656 // SM_CXPADDEDBORDER - The amount of border padding
2657 // for captioned windows.
2658 //
2659 // If the window does not have a caption, mVertResizeMargin will be equal to
2660 // `WinUtils::GetSystemMetricsForDpi(SM_CYFRAME, dpi)`
2661 mVertResizeMargin =
2665 }
2668 // Use default frame size for minimized windows
2674 // Remove the default frame from the top of our fullscreen window. This
2675 // makes the whole caption part of our client area, allowing us to draw
2676 // in the whole caption area. Additionally remove the default frame from
2677 // the left, right, and bottom.
2683 // We make the entire frame part of the client area. We leave the default
2684 // frame sizes for left, right and bottom since Windows will automagically
2685 // position the edges "offscreen" for maximized windows.
2705 }
2707 // When we are drawing the non-client region, we need
2708 // to clear the portion of the NC region that is exposed by the
2709 // hidden taskbar. As above, we clear the bottom of the NC region
2710 // when the taskbar is at the top of the screen.
2713 }
2716 }
2719 // Force a reflow of content based on the new client
2720 // dimensions.
2722 }
2725 }
2735 }
2738 // Request for a reset
2743 // Force a reflow of content based on the new client
2744 // dimensions.
2751 }
2754 }
2765 }
2768 }
2775 }
2778 // +-+-----------------------+-+
2779 // | | app non-client chrome | |
2780 // | +-----------------------+ |
2781 // | | app client chrome | | }
2782 // | +-----------------------+ | }
2783 // | | app content | | } area we don't want to invalidate
2784 // | +-----------------------+ | }
2785 // | | app client chrome | | }
2786 // | +-----------------------+ |
2787 // +---------------------------+ <
2788 // ^ ^ windows non-client chrome
2789 // client area = app *
2790 RECT rect;
2795 // Subtract app client chrome and app content leaving
2796 // windows non-client chrome and app non-client chrome
2797 // in winRgn.
2808 // triggers ncpaint and paint events for the two areas
2811 }
2813 /**************************************************************
2814 *
2815 * SECTION: nsIWidget::SetBackgroundColor
2816 *
2817 * Sets the window background paint color.
2818 *
2819 **************************************************************/
2827 }
2828 }
2830 /**************************************************************
2831 *
2832 * SECTION: nsIWidget::SetCursor
2833 *
2834 * SetCursor and related utilities for manging cursor state.
2835 *
2836 **************************************************************/
2838 // Set this component cursor
2918 // XXX not 100% appropriate perhaps
2939 }
2940 }
2943 CSSToLayoutDeviceScale aScale) {
2946 }
2950 // Reject cursors greater than 128 pixels in either direction, to prevent
2951 // spoofing.
2952 // XXX ideally we should rescale. Also, we could modify the API to
2953 // allow trusted content to set larger cursors.
2956 }
2958 LayoutDeviceIntSize layoutSize =
2960 LayoutDeviceIntPoint hotspot =
2962 HCURSOR cursor;
2967 }
2970 }
2979 // Cursors in windows are global, so even if our mUpdateCursor flag is
2980 // false we always need to make sure the Windows cursor is up-to-date,
2981 // since stuff like native drag and drop / resizers code can mutate it
2982 // outside of this method.
2985 }
2991 }
2999 }
3005 }
3009 }
3014 }
3016 /**************************************************************
3017 *
3018 * SECTION: nsIWidget::Get/SetTransparencyMode
3019 *
3020 * Manage the transparency mode of the window containing this
3021 * widget. Only works for popup and dialog windows when the
3022 * Desktop Window Manager compositor is not enabled.
3023 *
3024 **************************************************************/
3028 }
3036 }
3039 }
3041 /**************************************************************
3042 *
3043 * SECTION: nsIWidget::UpdateWindowDraggingRegion
3044 *
3045 * For setting the draggable titlebar region from CSS
3046 * with -moz-window-dragging: drag.
3047 *
3048 **************************************************************/
3053 }
3055 /**************************************************************
3056 *
3057 * SECTION: nsIWidget::HideWindowChrome
3058 *
3059 * Show or hide window chrome.
3060 *
3061 **************************************************************/
3068 }
3088 }
3094 }
3095 }
3100 }
3102 /**************************************************************
3103 *
3104 * SECTION: nsWindow::Invalidate
3105 *
3106 * Invalidate an area of the client for painting.
3107 *
3108 **************************************************************/
3110 // Invalidate this component visible area
3115 }
3117 #ifdef WIDGET_DEBUG_OUTPUT
3124 }
3127 }
3130 }
3133 }
3135 // Invalidate this component visible area
3138 #ifdef WIDGET_DEBUG_OUTPUT
3142 RECT rect;
3150 }
3151 }
3154 WPARAM wParam,
3155 LPARAM lParam) {
3163 }
3165 // The message sender should have added ref for us.
3169 }
3175 }
3177 }
3180 LayoutDeviceIntRect mBounds;
3181 HANDLE mSemaphore;
3182 HANDLE mThread;
3183 HWND mWnd;
3191 }
3194 }
3195 }
3196 };
3199 // Initialize window class
3202 WNDCLASSW wc = {};
3209 }
3217 }
3219 // Since AnimateWindow blocks the thread of the transition window,
3220 // we need to hide the cursor for that window, otherwise the system
3221 // would show the busy pointer to the user.
3231 // The initialization data may no longer be valid
3232 // after we release the semaphore.
3235 MSG msg;
3239 }
3243 }
3247 NS_DECL_ISUPPORTS
3251 "FullscreenTransitionData "
3253 }
3260 "FullscreenTransitionData "
3263 }
3264 };
3268 /* virtual */
3270 FullscreenTransitionInitData initData;
3278 // Create a semaphore for synchronizing the window handle which will
3279 // be created by the transition thread and used by the main thread for
3280 // posting the transition messages.
3287 }
3288 }
3291 }
3299 }
3301 /* virtual */
3312 }
3314 /* virtual */
3317 "CleanupFullscreenTransition "
3321 }
3324 // The "DWM resize hack", aka the "fullscreen resize hack", is a workaround
3325 // for DWM's occasional and not-entirely-predictable failure to update its
3326 // internal state when the client area of a window changes without changing
3327 // the window size. The effect of this is that DWM will clip the content of
3328 // the window to its former client area.
3329 //
3330 // It is not known under what circumstances the bug will trigger. Windows 11
3331 // is known to be required, but many Windows 11 machines do not exhibit the
3332 // issue. Even machines that _do_ exhibit it will sometimes not do so when
3333 // apparently-irrelevant changes are made to the configuration. (See bug
3334 // 1763981.)
3335 //
3336 // The bug is triggered by Firefox when a maximized window (which has window
3337 // decorations) becomes fullscreen (which doesn't). To work around this, if we
3338 // think it may occur, we "flicker-resize" the relevant window -- that is, we
3339 // reduce its height by 1px, then restore it. This causes DWM to acquire the
3340 // new client-area metrics.
3341 //
3342 // Note that, in particular, this bug will not occur when using a separate
3343 // compositor window, as our compositor windows never have any nonclient area.
3344 //
3345 // This is admittedly a sledgehammer where a screwdriver should suffice.
3347 // ---------------------------------------------------------------------------
3349 // Regardless of preferences or heuristics, only apply the hack if this is the
3350 // first time we've entered fullscreen across the entire Firefox session.
3351 // (Subsequent transitions to fullscreen, even with different windows, don't
3352 // appear to induce the bug.)
3353 {
3354 // (main thread only; `atomic` not needed)
3360 }
3363 }
3365 // Check whether to try to apply the DWM resize hack, based on the override
3366 // pref and/or some internal heuristics.
3367 {
3369 // The bug has only been seen under Windows 11. (At time of writing, this
3370 // is the latest version of Windows.)
3373 }
3376 // This should never happen...
3378 // ... so if it does, we are in uncharted territory: don't apply the hack.
3381 }
3383 // The bug doesn't occur when we're using a separate compositor window
3384 // (since the compositor window always comprises exactly its client area,
3385 // with no non-client border).
3388 }
3390 // Otherwise, apply the hack.
3392 };
3394 // Figure out whether or not we should perform the hack, and -- arguably
3395 // more importantly -- log that decision.
3403 };
3411 }
3412 }();
3416 }
3417 }
3419 // The DWM bug is believed to involve a race condition: some users have
3420 // reported that setting a custom theme or adding unused command-line
3421 // parameters sometimes causes the bug to vanish.
3422 //
3423 // Out of an abundance of caution, we therefore apply the hack in a later
3424 // event, rather than inline.
3433 }
3435 RECT origRect;
3440 }
3450 });
3461 }));
3462 }
3467 // HACK: Potentially flicker-resize the window, to force DWM to get the right
3468 // client-area information.
3471 }
3473 // Hide chrome and reposition window. Note this will also cache dimensions for
3474 // restoration, so it should only be called once per fullscreen request.
3475 //
3476 // Don't do this when minimized, since our bounds make no sense then, nor when
3477 // coming back from that state.
3483 }
3485 // Possibly notify the taskbar that we have changed our fullscreen mode.
3487 }
3492 }
3494 /**************************************************************
3495 *
3496 * SECTION: Native data storage
3497 *
3498 * nsIWidget::GetNativeData
3499 * nsIWidget::FreeNativeData
3500 *
3501 * Set or clear native data based on a constant.
3502 *
3503 **************************************************************/
3505 // Return some native data according to aDataType
3519 }
3521 }
3529 }
3532 }
3534 // Free some native data according to aDataType
3543 }
3544 }
3546 /**************************************************************
3547 *
3548 * SECTION: nsIWidget::SetTitle
3549 *
3550 * Set the main windows title text.
3551 *
3552 **************************************************************/
3560 }
3562 /**************************************************************
3563 *
3564 * SECTION: nsIWidget::SetIcon
3565 *
3566 * Set the main windows icon.
3567 *
3568 **************************************************************/
3571 HICON icon =
3575 }
3578 }
3585 }
3588 }
3591 // Assume the given string is a local identifier for an icon file.
3597 nsAutoString iconPath;
3600 // XXX this should use MZLU (see bug 239279)
3604 HICON bigIcon =
3608 HICON smallIcon =
3615 }
3616 #ifdef DEBUG_SetIcon
3622 }
3623 #endif
3626 }
3627 #ifdef DEBUG_SetIcon
3633 }
3634 #endif
3635 }
3638 HICON bigIcon =
3641 }
3644 HICON smallIcon =
3647 }
3649 /**************************************************************
3650 *
3651 * SECTION: nsIWidget::WidgetToScreenOffset
3652 *
3653 * Return this widget's origin in screen coordinates.
3654 *
3655 **************************************************************/
3658 POINT point;
3663 }
3668 }
3672 }
3674 // Just use a dummy 200x200 at (200, 200) client rect as the rect.
3675 RECT clientRect;
3684 };
3690 }
3692 /**************************************************************
3693 *
3694 * SECTION: nsIWidget::EnableDragDrop
3695 *
3696 * Enables/Disables drag and drop of files on this widget.
3697 *
3698 **************************************************************/
3702 // Return early if the window already closed
3704 }
3711 }
3717 }
3718 }
3719 }
3721 /**************************************************************
3722 *
3723 * SECTION: nsIWidget::CaptureMouse
3724 *
3725 * Enables/Disables system mouse capture.
3726 *
3727 **************************************************************/
3730 TRACKMOUSEEVENT mTrack;
3740 }
3743 }
3745 /**************************************************************
3746 *
3747 * SECTION: nsIWidget::CaptureRollupEvents
3748 *
3749 * Dealing with event rollup on destroy for popups. Enables &
3750 * Disables system capture of any and all events that would
3751 * cause a dropdown to be rolled up.
3752 *
3753 **************************************************************/
3759 }
3764 }
3765 }
3767 /**************************************************************
3768 *
3769 * SECTION: nsIWidget::GetAttention
3770 *
3771 * Bring this window to the user's attention.
3772 *
3773 **************************************************************/
3775 // Draw user's attention to this window until it comes to foreground.
3777 // Got window?
3782 // Don't flash if the flash count is 0 or if the foreground window is our
3783 // window handle or that of our owned-most window.
3787 }
3797 }
3803 }
3807 }
3809 /**************************************************************
3810 *
3811 * SECTION: nsIWidget::HasPendingInputEvent
3812 *
3813 * Ask whether there user input events pending. All input events are
3814 * included, including those not targeted at this nsIwidget instance.
3815 *
3816 **************************************************************/
3819 // If there is pending input or the user is currently
3820 // moving the window then return true.
3821 // Note: When the user is moving the window WIN32 spins
3822 // a separate event loop and input events are not
3823 // reported to the application.
3825 GUITHREADINFO guiInfo;
3829 }
3831 /**************************************************************
3832 *
3833 * SECTION: nsIWidget::GetWindowRenderer
3834 *
3835 * Get the window renderer associated with this widget.
3836 *
3837 **************************************************************/
3842 }
3846 }
3848 // Try OMTC first.
3852 }
3858 // Ensure we have a widget proxy even if we're not using the compositor,
3859 // since all our transparent window handling lives there.
3864 // If we're not using the compositor, the options don't actually matter.
3866 mBasicLayersSurface =
3870 }
3875 // Update the size constraints now that the layer manager has been
3876 // created.
3884 }
3885 }
3888 }
3890 /**************************************************************
3891 *
3892 * SECTION: nsBaseWidget::SetCompositorWidgetDelegate
3893 *
3894 * Called to connect the nsWindow to the delegate providing
3895 * platform compositing API access.
3896 *
3897 **************************************************************/
3903 "nsWindow::SetCompositorWidgetDelegate called with a "
3907 }
3908 }
3910 /**************************************************************
3911 *
3912 * SECTION: nsIWidget::OnDefaultButtonLoaded
3913 *
3914 * Called after the dialog is loaded and it has a default button.
3915 *
3916 **************************************************************/
3922 // Don't snap when we are not active.
3928 }
3934 BOOL snapDefaultButton;
3939 }
3946 // The center of the button can be outside of the widget.
3947 // E.g., it could be hidden by scrolling.
3950 }
3955 }
3957 }
3961 }
3967 }
3969 /**************************************************************
3970 **************************************************************
3971 **
3972 ** BLOCK: Moz Events
3973 **
3974 ** Moz GUI event management.
3975 **
3976 **************************************************************
3977 **************************************************************/
3979 /**************************************************************
3980 *
3981 * SECTION: Mozilla event initialization
3982 *
3983 * Helpers for initializing moz events.
3984 *
3985 **************************************************************/
3987 // Event initialization
3990 // get the message position in client coordinates
3993 POINT cpos;
4002 }
4004 // use the point override if provided
4006 }
4009 }
4014 }
4016 /**************************************************************
4017 *
4018 * SECTION: Moz event dispatch helpers
4019 *
4020 * Helpers for dispatching different types of moz events.
4021 *
4022 **************************************************************/
4024 // Main event dispatch. Invokes callback and ProcessEvent method on
4025 // Event Listener object. Part of nsIWidget.
4028 #ifdef WIDGET_DEBUG_OUTPUT
4034 // Top level windows can have a view attached which requires events be sent
4035 // to the underlying base window and the view. Added when we combined the
4036 // base chrome window with the main content child for nc client area (title
4037 // bar) rendering.
4042 }
4044 // the window can be destroyed during processing of seemingly innocuous events
4045 // like, say, mousedowns due to the magic of scripting. mousedowns will return
4046 // nsEventStatus_eIgnore, which causes problems with the deleted window.
4047 // therefore:
4050 }
4058 }
4063 }
4066 nsEventStatus status;
4069 }
4072 nsEventStatus status =
4075 }
4077 // Recursively dispatch synchronous paints for nsIWidget
4078 // descendants with invalidated rectangles.
4082 // its one of our windows so check to see if it has a
4083 // invalidated rect. If it does. Dispatch a synchronous
4084 // paint.
4086 }
4088 }
4090 // Check for pending paints and dispatch any pending paint
4091 // messages for any nsIWidget which is a descendant of the
4092 // top-level window that *this* window is embedded within.
4093 //
4094 // Note: We do not dispatch pending paint messages for non
4095 // nsIWidget managed windows.
4097 // We need to ensure that reflow events do not get starved.
4098 // At the same time, we don't want to recurse through here
4099 // as that would prevent us from dispatching starved paints.
4104 }
4106 // Quickly check to see if there are any paint events pending,
4107 // but only dispatch them if it has been long enough since the
4108 // last paint completed.
4111 // Find the top level window.
4114 // Dispatch pending paints for topWnd and all its descendant windows.
4115 // Note: EnumChildWindows enumerates all descendant windows not just
4116 // the children (but not the window itself).
4119 }
4120 }
4126 }
4127 }
4128 }
4131 LayoutDeviceIntPoint aEventPoint) {
4132 // Allow users to start dragging by double-tapping.
4135 }
4137 // In chrome UI, allow touchdownstartsdrag attributes
4138 // to cause any touchdown event to trigger a drag.
4149 // Check if the element or any parent element has the
4150 // attribute we're looking for.
4153 nsAutoString startDrag;
4157 }
4158 }
4159 }
4160 }
4161 }
4164 }
4166 // Deal with all sort of mouse event
4179 }
4184 // Suppress mouse moves caused by widget creation. Make sure to do this early
4185 // so that we update sLastMouseMovePoint even for touch-induced mousemove
4186 // events.
4191 }
4194 }
4198 // If mTouchWindow is true, then we must have APZ enabled and be
4199 // feeding it raw touch events. In that case we only want to
4200 // send touch-generated mouse events to content if they should
4201 // start a touch-based drag-and-drop gesture, such as on
4202 // double-tapping or when tapping elements marked with the
4203 // touchdownstartsdrag attribute in chrome UI.
4209 }
4210 }
4211 }
4221 // eMouseMove and eMouseExitFromWidget are here because we need to make
4222 // sure capture flag isn't left on after a drag where we wouldn't see a
4223 // button up message (see bug 324131).
4228 sIsInMouseCapture)
4245 }
4247 ModifierKeyState modifierKeyState;
4250 // eContextMenu with Shift state is special. It won't fire "contextmenu"
4251 // event in the web content for blocking web content to prevent its default.
4252 // However, Shift+F10 is a standard shortcut key on Windows. Therefore,
4253 // this should not block web page to prevent its default. I.e., it should
4254 // behave same as ContextMenu key without Shift key.
4255 // XXX Should we allow to block web page to prevent its default with
4256 // Ctrl+Shift+F10 or Alt+Shift+F10 instead?
4261 }
4266 // Mouse events from Windows WM_POINTER*. Fill more information in
4267 // WidgetMouseEvent.
4272 // If we get here the mouse events must be from non-touch sources, so
4273 // convert it to pointer events as well
4276 }
4278 // Static variables used to distinguish simple-, double- and triple-clicks.
4290 BYTE eventButton;
4304 }
4306 // Doubleclicks are used to set the click count, then changed to mousedowns
4307 // We're going to time double-clicks from mouse *up* to next mouse *down*
4318 // remember when this happened for the next mouse down
4324 // now look to see if we want to convert this to a double- or triple-click
4327 sLastClickCount++;
4329 // reset the click count, to count *this* click
4331 }
4332 // Set last Click time on MouseDown only
4338 }
4347 }
4350 #ifdef NS_DEBUG_XX
4353 #endif
4355 // call the event callback
4368 }
4375 }
4376 }
4377 }
4381 }
4382 }
4388 }
4391 }
4394 // retrieve the toplevel window or dialogue
4403 }
4404 }
4407 }
4409 }
4413 // We disable the root window when a picker opens. See PickerOpen. When the
4414 // picker closes (but before PickerClosed is called), our window will get
4415 // focus, but it will still be disabled. This confuses the focus system.
4416 // Therefore, we ignore this focus and explicitly call this function once
4417 // we re-enable the window. Rarely, the picker seems to re-enable our root
4418 // window before we do, but for simplicity, we always ignore focus before
4419 // the final call to PickerClosed. See bug 1883568 for further details.
4421 }
4425 }
4438 }
4439 }
4440 }
4441 }
4445 POINT mp;
4449 }
4454 // WinUtils::GetTopLevelHWND() will return a HWND for the window frame
4455 // (which includes the non-client area). If the mouse has moved into
4456 // the non-client area, we should treat it as a top-level exit.
4461 }
4463 /**************************************************************
4464 *
4465 * SECTION: IPC
4466 *
4467 * IPC related helpers.
4468 *
4469 **************************************************************/
4471 // static
4496 }
4498 #ifdef DEBUG
4502 aMsg);
4504 #endif
4507 }
4515 // Modal UI being displayed in windowless plugins.
4518 LRESULT res;
4521 }
4523 }
4525 // Handle certain sync plugin events sent to the parent which
4526 // trigger ipc calls that result in deadlocks.
4532 // Windowless flash sending WM_ACTIVATE events to the main window
4533 // via calls to ShowWindow.
4537 // Check for Adobe Reader X sync activate message from their
4538 // helper window and ignore. Fixes an annoying focus problem.
4540 ISMEX_SEND) {
4549 }
4550 }
4552 }
4554 // Plugins taking or losing focus triggering focus app messages.
4557 // Windowed plugins that pass sys key events to defwndproc generate
4558 // WM_SYSCOMMAND events to the main window.
4560 // Windowed plugins that fire context menu selection events to parent
4561 // windows.
4563 // IME events fired as a result of synchronous focus changes
4567 }
4572 }
4573 }
4575 /**************************************************************
4576 **************************************************************
4577 **
4578 ** BLOCK: Native events
4579 **
4580 ** Main Windows message handlers and OnXXX handlers for
4581 ** Windows event handling.
4582 **
4583 **************************************************************
4584 **************************************************************/
4586 /**************************************************************
4587 *
4588 * SECTION: Wind proc.
4589 *
4590 * The main Windows event procedures and associated
4591 * message processing methods.
4592 *
4593 **************************************************************/
4599 MENUITEMINFO mii;
4604 // update the options
4615 // intentional fall through
4633 }
4635 hMenu,
4642 }
4643 }
4645 }
4647 // The WndProc procedure for all nsWindows in this toolkit. This merely catches
4648 // SEH exceptions and passes the real work to WindowProcInternal. See bug 587406
4649 // and http://msdn.microsoft.com/en-us/library/ms633573%28VS.85%29.aspx
4651 LPARAM lParam) {
4658 }
4663 // This message was sent to the FAKETRACKPOINTSCROLLABLE.
4665 // Route WM_HSCROLL messages to the main window.
4668 // Handle all other messages with its original window procedure.
4671 }
4672 }
4675 // This is a tracer event for measuring event loop latency.
4676 // See WidgetTraceEvent.cpp for more details.
4679 }
4681 // Get the window which caused the event and ask it to process the message
4686 // Hold the window for the life of this method, in case it gets
4687 // destroyed during processing, unless we're in the dtor already.
4693 // Create this here so that we store the last rolled up popup until after
4694 // the event has been processed.
4695 nsAutoRollup autoRollup;
4697 LRESULT popupHandlingResult;
4701 // Call ProcessMessage
4702 LRESULT retValue;
4705 }
4711 }
4720 }
4721 }
4723 }
4730 }
4734 }
4737 aResult)) {
4739 }
4742 }
4744 // The main windows message processing method. Wraps ProcessMessageInternal so
4745 // we can log aRetValue.
4748 // For some events we might change the parameter values, so log
4749 // before and after we process them.
4755 }
4757 // The main windows message processing method. Called by ProcessMessage.
4763 }
4768 // The DWM resize hack (see bug 1763981) causes us to process a number of
4769 // messages, notably including some WM_WINDOWPOSCHANG{ING,ED} messages which
4770 // would ordinarily result in a whole lot of internal state being updated.
4771 //
4772 // Since we're supposed to end in the same state we started in (and since the
4773 // content shouldn't know about any of this nonsense), just discard any
4774 // messages synchronously dispatched from within the hack.
4777 }
4779 // Glass hit testing w/custom transparent margins.
4780 //
4781 // FIXME(emilio): is this needed? We deal with titlebar buttons non-natively
4782 // now.
4783 LRESULT dwmHitResult;
4788 }
4790 // The preference whether to use a different keyboard layout for each
4791 // window is cached, and updating it will not take effect until the
4792 // next restart. We read the preference here and not upon WM_ACTIVATE to make
4793 // sure that this behavior is consistent. Otherwise, if the user changed the
4794 // preference before having ever lowered the window, the preference would take
4795 // effect immediately.
4800 // (Large blocks of code should be broken out into OnEvent handlers.)
4802 // WM_QUERYENDSESSION must be handled by all windows.
4803 // Otherwise Windows thinks the window can just be killed at will.
4805 // Ask around if it's ok to quit.
4814 quitType);
4823 #if defined(ACCESSIBILITY)
4826 #else
4828 #endif
4832 // For WM_ENDSESSION, wParam indicates whether we need to shutdown
4833 // (TRUE) or not (FALSE).
4837 }
4838 // According to WM_ENDSESSION lParam documentation:
4839 // 0 -> OS shutdown or restart (no way to distinguish)
4840 // ENDSESSION_LOGOFF -> User is logging off
4841 // ENDSESSION_CLOSEAPP -> Application must shutdown
4842 // ENDSESSION_CRITICAL -> Application is forced to shutdown
4843 // The difference of the last two is not very clear.
4854 }
4855 }
4859 // TODO: We do not expect that these days anybody sends us
4860 // MOZ_WM_APP_QUIT, see bug 1827807.
4862 }
4863 // Let's fake a shutdown sequence without actually closing windows etc.
4864 // to avoid Windows killing us in the middle. A proper shutdown would
4865 // require having a chance to pump some messages. Unfortunately
4866 // Windows won't let us do that. Bug 212316.
4875 syncShutdown);
4881 quitType);
4896 // No need to invalidate layout for system color changes, but we need to
4897 // invalidate style.
4902 // Update non-client margin offsets
4906 // We assume pretty much everything could've changed here.
4911 // Invalidate the window so that the repaint will
4912 // pick up the new theme.
4921 // When a session becomes visible, we should invalidate.
4926 }
4930 // We only handle this message for the hidden window,
4931 // as we only need to update the (global) font list once
4932 // for any given change, not once per window!
4935 }
4937 // update the global font list
4945 // These need to update LookAndFeel cached values.
4946 // They affect reduced motion settings / caret blink count / show
4947 // pointer while typing / tooltip offset, so no need to invalidate style
4948 // / layout.
4951 }
4956 }
4958 // NB: We also refresh screens on WM_DISPLAYCHANGE but the rcWork
4959 // values are sometimes wrong at that point. This message then
4960 // arrives soon afterward, when we can get the right rcWork values.
4963 }
4966 // This affects system colors (-moz-win-accentcolor), so gotta pass
4967 // the style flag.
4970 }
4972 // UserInteractionMode, ConvertibleSlateMode, SystemDockMode may cause
4973 // @media(pointer) queries to change, which layout needs to know about
4974 //
4975 // (WM_SETTINGCHANGE will be sent to all top-level windows, so we
4976 // only respond to the hidden top-level window to avoid hammering
4977 // layout with a bunch of NotifyThemeChanged() calls)
4978 //
4985 }
4986 }
4987 }
4993 // Check dbch_devicetype explicitly since we will get other device types
4994 // (e.g. DBT_DEVTYP_VOLUME) for some reasons even if we specify
4995 // DBT_DEVTYP_DEVICEINTERFACE in the filter for
4996 // RegisterDeviceNotification.
4998 // This can only change media queries (any-hover/any-pointer).
5000 }
5001 }
5005 // NOTE: the following block is mirrored in PreXULSkeletonUI.cpp, and
5006 // will need to be kept in sync.
5008 // If `wParam` is `FALSE`, `lParam` points to a `RECT` that contains
5009 // the proposed window rectangle for our window. During our
5010 // processing of the `WM_NCCALCSIZE` message, we are expected to
5011 // modify the `RECT` that `lParam` points to, so that its value upon
5012 // our return is the new client area. We must return 0 if `wParam`
5013 // is `FALSE`.
5014 //
5015 // If `wParam` is `TRUE`, `lParam` points to a `NCCALCSIZE_PARAMS`
5016 // struct. This struct contains an array of 3 `RECT`s, the first of
5017 // which has the exact same meaning as the `RECT` that is pointed to
5018 // by `lParam` when `wParam` is `FALSE`. The remaining `RECT`s, in
5019 // conjunction with our return value, can
5020 // be used to specify portions of the source and destination window
5021 // rectangles that are valid and should be preserved. We opt not to
5022 // implement an elaborate client-area preservation technique, and
5023 // simply return 0, which means "preserve the entire old client area
5024 // and align it with the upper-left corner of our new client area".
5033 // Make client rect's width and height more than 0 to
5034 // avoid problems of webrender and angle.
5040 }
5042 }
5047 }
5058 };
5059 };
5068 }
5069 };
5076 // We don't have a help button.
5084 // Treat this window as transparent.
5088 }
5099 }
5100 }
5102 /*
5103 * If an nc client area margin has been moved, we are responsible
5104 * for calculating where the resize margins are and returning the
5105 * appropriate set of hit test constants. DwmDefWindowProc (above)
5106 * will handle hit testing on it's command buttons if we are on a
5107 * composited desktop.
5108 */
5112 }
5118 }
5121 /*
5122 * WM_SETTEXT paints the titlebar area. Avoid this if we have a
5123 * custom titlebar we paint ourselves, or if we're the ones
5124 * sending the message with an updated title
5125 */
5130 {
5131 // From msdn, the way around this is to disable the visible state
5132 // temporarily. We need the text to be set but we don't want the
5133 // redraw to occur. However, we need to make sure that we don't
5134 // do this at the same time that a Present is happening.
5135 //
5136 // To do this we take mPresentLock in nsWindow::PreRender and
5137 // if that lock is taken we wait before doing WM_SETTEXT
5140 }
5148 }
5151 }
5154 /*
5155 * WM_NCACTIVATE paints nc areas. Avoid this and re-route painting
5156 * through WM_NCPAINT via InvalidateNonClientRegion.
5157 */
5162 }
5164 // There is a case that rendered result is not kept. Bug 1237617
5168 }
5170 // let the dwm handle nc painting on glass
5171 // Never allow native painting if we are on fullscreen
5175 // going active
5178 // invalidate to trigger a paint
5182 // going inactive
5185 // invalidate to trigger a paint
5188 }
5189 }
5192 /*
5193 * ClearType changes often don't send a WM_SETTINGCHANGE message. But they
5194 * do seem to always send a WM_NCPAINT message, so let's update on that.
5195 */
5209 }
5218 // clean up.
5255 // Say we've dealt with erasing the background. (This is actually handled in
5256 // WM_PAINT, where necessary.)
5268 // First MOUSEMOVE over the client area. Ask for MOUSELEAVE
5269 TRACKMOUSEEVENT mTrack;
5275 }
5278 // Suppress dispatch of pending events
5279 // when mouse moves are generated by widget
5280 // creation instead of user input.
5281 POINT mp;
5287 }
5295 }
5302 TRACKMOUSEEVENT mTrack;
5308 }
5309 // If we noticed the mouse moving in our draggable region, forward the
5310 // message as a normal WM_MOUSEMOVE.
5313 // We've transitioned from a draggable area to somewhere else within
5314 // the non-client area - perhaps one of the edges of the window for
5315 // resizing.
5317 }
5321 }
5325 result =
5333 result =
5344 // If we're handling WM_NCMOUSELEAVE and the mouse is still over the
5345 // window, then by process of elimination, the mouse has moved from the
5346 // non-client to client area, so no need to fall-through to the
5347 // WM_MOUSELEAVE handler. We also need to re-register for the
5348 // WM_MOUSELEAVE message, since according to the documentation at [1],
5349 // all tracking requested via TrackMouseEvent is cleared once
5350 // WM_NCMOUSELEAVE or WM_MOUSELEAVE fires.
5351 // [1]:
5352 // https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-trackmouseevent
5353 TRACKMOUSEEVENT mTrack;
5360 }
5361 // We've transitioned from non-client to outside of the window, so
5362 // fall-through to the WM_MOUSELEAVE handler.
5364 }
5370 // Check if the mouse is over the fullscreen transition window, if so
5371 // clear sLastMouseMovePoint. This way the WM_MOUSEMOVE we get after the
5372 // transition window disappears will not be ignored, even if the mouse
5373 // hasn't moved.
5376 }
5378 // We need to check mouse button states and put them in for
5379 // wParam.
5383 // Synthesize an event position because we don't get one from
5384 // WM_MOUSELEAVE.
5391 // If the context menu is brought up by a touch long-press, then
5392 // the APZ code is responsible for dealing with this, so we don't
5393 // need to do anything.
5399 }
5401 // If this WM_CONTEXTMENU is triggered by a mouse's secondary button up
5402 // event in overscroll gutter, we shouldn't open context menu.
5404 mNeedsToPreventContextMenu) {
5407 }
5409 // if the context menu is brought up from the keyboard, |lParam|
5410 // will be -1.
5411 LPARAM pos;
5418 }
5426 // Blank area hit, throw up the system menu.
5430 }
5440 }
5446 POINTER_INPUT_TYPE pointerType;
5450 }
5451 }
5491 result =
5498 result =
5506 result =
5514 result =
5521 result =
5528 result =
5541 // Windows doesn't provide to customize the behavior of 4th nor 5th button
5542 // of mouse. If 5-button mouse works with standard mouse deriver of
5543 // Windows, users cannot disable 4th button (browser back) nor 5th button
5544 // (browser forward). We should allow to do it with our prefs since we can
5545 // prevent Windows to generate WM_APPCOMMAND message if WM_XBUTTONUP
5546 // messages are not sent to DefWindowProc.
5561 }
5569 // The following conditions and switch statement borrow heavily from the
5570 // Chromium source code from
5571 // https://chromium.googlesource.com/chromium/src/+/456d6e533cfb4531995e0ef52c279d4b5aa8a352/ui/views/window/window_resize_utils.cc#45
5582 }
5592 }
5593 }
5622 }
5623 }
5625 // When we get WM_ENTERSIZEMOVE we don't know yet if we're in a live
5626 // resize or move event. Instead we wait for first VM_SIZING message
5627 // within a ENTERSIZEMOVE to consider this a live resize event.
5631 }
5633 }
5638 // Sometimes, we appear to miss a WM_DPICHANGED message while moving
5639 // a window around. Therefore, call ChangedDPI and ResetLayout here
5640 // if it appears that the window's scaling is not what we expect.
5641 // This causes the prescontext and appshell window management code to
5642 // check the appUnitsPerDevPixel value and current widget size, and
5643 // refresh them if necessary. If nothing has changed, these calls will
5644 // return without actually triggering any extra reflow or painting.
5650 }
5651 }
5652 }
5658 }
5660 }
5667 }
5669 // Windows spins a separate hidden event loop when moving a window so we
5670 // don't hear mouse events during this time and WM_EXITSIZEMOVE is fired
5671 // when the hidden event loop exits. We set mDraggingWindowWithMouse to
5672 // true in WM_NCLBUTTONDOWN when we started moving the window with the
5673 // mouse so we know that if mDraggingWindowWithMouse is true, we can send
5674 // a mouse up event.
5681 }
5684 }
5690 }
5692 }
5703 // Dispatch a custom event when this happens in the draggable region, so
5704 // that non-popup-based panels can react to it. This doesn't send an
5705 // actual mousedown event because that would break dragging or interfere
5706 // with other mousedown handling in the caption area.
5711 }
5719 }
5721 }
5727 }
5729 // The WM_ACTIVATE event is fired when a window is raised or lowered,
5730 // and the loword of wParam specifies which. But we don't want to tell
5731 // the focus system about this until the WM_SETFOCUS or WM_KILLFOCUS
5732 // events are fired. Instead, set either the sJustGotActivate or
5733 // gJustGotDeactivate flags and activate/deactivate once the focus
5734 // events arrive.
5739 // when minimizing a window, the deactivation and focus events will
5740 // be fired in the reverse order. Instead, just deactivate right away.
5741 // This can also happen when a modal system dialog is opened, so check
5742 // if the last window to receive the WM_KILLFOCUS message was this one
5743 // or a child of this one.
5750 }
5753 }
5761 ModifierKeyState modifierKeyState;
5767 #ifdef ACCESSIBILITY
5769 #endif
5770 }
5771 }
5775 // Bug 1851991: Sometimes this can be called before gfxPlatform::Init
5776 // when a window is created very early. In that case we just forego
5777 // setting this and accept the GPU process might briefly run at a lower
5778 // priority.
5781 }
5785 // A popup with a parent owner should not be activated when clicked but
5786 // should still allow the mouse event to be fired, so the return value
5787 // is set to MA_NOACTIVATE. But if the owner isn't the frontmost window,
5788 // just use default processing so that the window is activated.
5792 }
5801 // Workaround for race condition in explorer.exe.
5809 // Set the constraints. The minimum size should also be constrained to the
5810 // default window maximum size so that it fits on screen.
5828 // If previous focused window isn't ours, it must have received the
5829 // redirected message. So, we should forget it.
5832 }
5835 }
5844 }
5872 }
5875 #ifdef ACCESSIBILITY
5878 // Do explicit casting to make it working on 64bit systems (see bug 649236
5879 // for details).
5888 }
5889 }
5891 #endif
5896 // SC_CLOSE may trigger a synchronous confirmation prompt. If we're in the
5897 // middle of something important, put off responding to it.
5902 }
5909 }
5911 // Handle the system menu manually when we're in full screen mode
5912 // so we can set the appropriate options.
5918 }
5926 }
5928 /* Gesture support events */
5930 // According to MS samples, this must be handled to enable
5931 // rotational support in multi-touch drivers.
5940 }
5949 // A GestureNotify event is dispatched to decide which single-finger
5950 // panning direction should be active (including none) and if pan
5951 // feedback should be displayed. Java and plugin windows can make their
5952 // own calls.
5955 nsPointWin touchPoint;
5961 nsEventStatus status;
5966 }
6009 // Support EM_CANPASTE message only when wParam isn't specified or
6010 // is plain text format.
6017 }
6035 TimeStamp skewStamp;
6039 skewStamp);
6040 }
6046 }
6048 }
6050 //*aRetValue = result;
6054 // Events which caused mWnd destruction and aren't consumed
6055 // will crash during the Windows default processing.
6057 }
6058 }
6063 }
6066 }
6068 /**************************************************************
6069 *
6070 * SECTION: Event processing helpers
6071 *
6072 * Special processing for certain event types and
6073 * synthesized events.
6074 *
6075 **************************************************************/
6083 }
6089 }
6091 // Calculations are done in screen coords
6095 // hit return constants:
6096 // HTBORDER - non-resizable border
6097 // HTBOTTOM, HTLEFT, HTRIGHT, HTTOP - resizable border
6098 // HTBOTTOMLEFT, HTBOTTOMRIGHT - resizable corner
6099 // HTTOPLEFT, HTTOPRIGHT - resizable corner
6100 // HTCAPTION - general title bar area
6101 // HTCLIENT - area considered the client
6102 // HTCLOSE - hovering over the close button
6103 // HTMAXBUTTON - maximize button
6104 // HTMINBUTTON - minimize button
6114 // Ensure being accessible to borders of window. Even if contents are in
6115 // this area, the area must behave as border.
6126 // The border size. If there is no content under mouse cursor, the border
6127 // size should be larger than the values in system settings. Otherwise,
6128 // contents under the mouse cursor should be able to override the behavior.
6129 // E.g., user must expect that Firefox button always opens the popup menu
6130 // even when the user clicks on the above edge of it.
6146 }
6148 // (the 2x case here doubles the resize area for corners)
6156 }
6166 }
6173 }
6177 }
6180 }
6181 }
6188 }
6189 }
6192 {
6201 }
6205 }
6212 #ifdef ACCESSIBILITY
6214 #endif
6219 // If we're in the resize region, avoid overriding that with either a
6220 // drag or a client result; resize takes priority over either (but not
6221 // over the window controls, which is why we check this after those).
6226 }
6227 }
6230 }
6233 }
6238 }
6243 }
6248 }
6251 // Retain the previous mode that was notified to observers
6254 // Only notify observers if mode changed
6263 aIsSleepMode
6264 ? NS_WIDGET_SLEEP_OBSERVER_TOPIC
6267 }
6272 }
6273 // These must be checked here too as a lone WM_CHAR could be received
6274 // if a child window didn't handle it (for example Alt+Space in a content
6275 // window)
6276 ModifierKeyState modKeyState;
6279 }
6282 ModifierKeyState modKeyState;
6286 // Bug 1382199: Windows default behavior will trigger the System menu bar
6287 // when F10 is released. Among other things, this causes the System menu bar
6288 // to appear when a web page overrides the contextmenu event. We *never*
6289 // want this default behavior, so eat this key (never pass it to Windows).
6291 }
6293 }
6297 // If this method doesn't call NativeKey::HandleKeyDownMessage(), this method
6298 // must clean up the redirected message information itself. For more
6299 // information, see above comment of
6300 // RedirectedKeyDownMessageManager::AutoFlusher class definition in
6301 // KeyboardLayout.h.
6304 ModifierKeyState modKeyState;
6307 LRESULT result =
6309 // HandleKeyDownMessage cleaned up the redirected message information
6310 // itself, so, we should do nothing.
6315 // We need to let Windows handle this keypress,
6316 // by returning false, if there's a native menu
6317 // bar somewhere in our containing window hierarchy.
6318 // Otherwise we handle the keypress and don't pass
6319 // it on to Windows, by returning true.
6326 }
6328 }
6330 }
6333 }
6344 aUnmodifiedCharacters);
6345 }
6353 INPUT input;
6356 // TODO (bug 1693240):
6357 // Now, we synthesize native mouse events asynchronously since we want to
6358 // synthesize the event on the front window at the point. However, Windows
6359 // does not provide a way to set modifier only while a mouse message is
6360 // being handled, and MOUSEEVENTF_MOVE may be coalesced by Windows. So, we
6361 // need a trick for handling it.
6366 // Reset sLastMouseMovePoint so that even if we're moving the mouse
6367 // to the position it's already at, we still dispatch a mousemove
6368 // event, because the callers of this function expect that.
6396 }
6398 }
6403 }
6410 }
6423 }
6426 LayoutDeviceIntPoint aPoint,
6434 }
6437 #ifdef WINSTATE_DEBUG_OUTPUT
6442 }
6446 }
6449 }
6452 }
6455 }
6458 }
6461 }
6463 #endif
6464 }
6466 /**************************************************************
6467 *
6468 * SECTION: OnXXX message handlers
6469 *
6470 * For message handlers that need to be broken out or
6471 * implemented in specific platform code.
6472 *
6473 **************************************************************/
6478 }
6482 // Handle window size mode changes
6484 // Bug 566135 - Windows theme code calls show window on SW_SHOWMINIMIZED
6485 // windows when fullscreen games disable desktop composition. If we're
6486 // minimized and not being activated, ignore the event and let windows
6487 // handle it.
6491 }
6496 // Skip window size change events below on minimization.
6498 }
6499 }
6501 // Notify visibility change when window is activated.
6505 }
6507 // Handle window position changes
6511 }
6513 // Handle window size changes
6515 RECT r;
6524 RECT drect;
6526 // getting wider
6535 }
6537 RECT drect;
6539 // getting taller
6548 }
6554 #ifdef WINSTATE_DEBUG_OUTPUT
6557 newHeight));
6558 #endif
6561 // It's possible (via Windows Aero Snap) that the size of the window
6562 // has changed such that it violates the aspect ratio constraint. If so,
6563 // queue up an event to enforce the aspect ratio constraint and repaint.
6564 // When resized with Windows Aero Snap, we are in the NOT_RESIZING state.
6567 // Hold a reference to self alive and pass it into the lambda to make
6568 // sure this nsIWidget stays alive long enough to run this function.
6574 }
6575 }));
6576 }
6577 }
6579 // If a maximized window is resized, recalculate the non-client margins.
6582 // gecko resize event already sent by UpdateNonClientMargins.
6584 }
6585 }
6586 }
6588 // Notify the widget listener for size change of client area for gecko
6589 // events. This needs to be done when either window size is changed,
6590 // or window frame is changed. They may not happen together.
6591 // However, we don't invoke that for popup when window frame changes,
6592 // because popups may trigger frame change before size change via
6593 // {Set,Clear}ThemeRegion they invoke in Resize. That would make the
6594 // code below call OnResize with a wrong client size first, which can
6595 // lead to flickerling for some popups.
6598 RECT r;
6599 LayoutDeviceIntSize clientSize;
6604 }
6605 // Send a gecko resize event
6607 }
6608 }
6611 // Update non-client margins if the frame size is changing, and let the
6612 // browser know we are changing size modes, so alternative css can kick in.
6613 // If we're going into fullscreen mode, ignore this, since it'll reset
6614 // margins to normal mode.
6617 }
6619 // Force fullscreen. This works around a bug in Windows 10 1809 where
6620 // using fullscreen when a window is "snapped" causes a spurious resize
6621 // smaller than the full screen, see bug 1482920.
6628 DesktopIntRect deskBounds =
6641 }
6642 }
6643 }
6645 // enforce local z-order rules
6650 nsWindowZ placement;
6660 }
6673 }
6674 }
6675 }
6676 }
6677 // prevent rude external programs from making hidden window visible
6680 // When waking from sleep or switching out of tablet mode, Windows 10
6681 // Version 1809 will reopen popup windows that should be hidden. Detect
6682 // this case and refuse to show the window.
6688 }
6689 }
6692 // Check if we have the idle service, if not we try to get it.
6695 }
6697 // Check that we now have the idle service.
6700 }
6701 }
6703 // Helper function for TouchDeviceNeedsPanGestureConversion(PTOUCHINPUT,
6704 // uint32_t).
6708 // The first call just queries how long the name string will be.
6712 }
6714 // The second call actually populates the string.
6719 }
6720 // The affected device name is "\\?\VIRTUAL_DIGITIZER", but each backslash
6721 // needs to be escaped with another one.
6723 // For some reason, the dataSize returned by the first call is double the
6724 // actual length of the device name (as if it were returning the size of a
6725 // wide-character string in bytes) even though we are using the narrow
6726 // version of the API. For the comparison against the expected device name
6727 // to pass, we truncate the buffer to be no longer tha the expected device
6728 // name.
6731 }
6733 RID_DEVICE_INFO deviceInfo;
6736 result =
6740 }
6741 // The device identifiers that we check for here come from bug 1355162
6742 // comment 1 (see also bug 1511901 comment 35).
6747 }
6749 // Determine if the touch device that originated |aOSEvent| needs to have
6750 // touch events representing a two-finger gesture converted to pan
6751 // gesture events.
6752 // We only do this for touch devices with a specific name and identifiers.
6757 }
6760 }
6763 // Cache the result of this computation for each touch device.
6764 // Touch devices are identified by the HANDLE stored in the hSource
6765 // field of TOUCHINPUT.
6770 }
6772 }
6776 // Checks if the touch device that originated the touch event is one
6777 // for which we want to convert the touch events to pang gesture events.
6782 }
6784 // Only two-finger gestures need conversion.
6787 }
6796 }
6798 // Use the midpoint of the two touches as the start point of the pan gesture.
6802 // To compute the displacement of the pan gesture, we keep track of the
6803 // location of the previous event.
6809 // We need to negate the displacement because for a touch event, moving the
6810 // fingers down results in scrolling up, but for a touchpad gesture, we want
6811 // moving the fingers down to result in scrolling down.
6817 }
6819 // Dispatch an event that originated as an OS touch event.
6820 // Usually, we want to dispatch it as a touch event, but some touchpads
6821 // produce touch events for two-finger scrolling, which need to be converted
6822 // to pan gesture events for correct behaviour.
6824 PTOUCHINPUT aOSEvent) {
6829 }
6832 }
6842 // Walk across the touch point array processing each contact point.
6846 // N.B.: According with MS documentation
6847 // https://msdn.microsoft.com/en-us/library/windows/desktop/dd317334(v=vs.85).aspx
6848 // TOUCHEVENTF_DOWN cannot be combined with TOUCHEVENTF_MOVE or
6849 // TOUCHEVENTF_UP. Possibly, it means that TOUCHEVENTF_MOVE and
6850 // TOUCHEVENTF_UP can be combined together.
6854 // Initialize a touch event to send.
6857 ModifierKeyState modifierKeyState;
6859 }
6860 // Pres shell expects this event to be a eTouchStart
6861 // if any new contact points have been added since the last event sent.
6864 }
6866 }
6868 // Pres shell expects removed contacts points to be delivered in a
6869 // separate eTouchEnd event containing only the contact points that were
6870 // removed.
6872 // Initialize a touch event to send.
6875 ModifierKeyState modifierKeyState;
6877 }
6879 }
6881 // Filter out spurious Windows events we don't understand, like palm
6882 // contact.
6884 }
6886 // Setup the touch point we'll append to the touch event array.
6887 nsPointWin touchPoint;
6892 // Initialize the touch data.
6896 // The contact area info cannot be trusted even when
6897 // TOUCHINPUTMASKF_CONTACTAREA is set when the input source is pen,
6898 // which somehow violates the API docs. (bug 1710509) Ultimately the
6899 // dwFlags check will become redundant since we want to migrate to
6900 // WM_POINTER for pens. (bug 1707075)
6909 // Append touch data to the appropriate event.
6912 }
6915 }
6916 }
6918 // Dispatch touch start and touch move event if we have one.
6921 }
6922 // Dispatch touch end event if we have one.
6925 }
6926 }
6931 }
6933 // Gesture event processing. Handles WM_GESTURE events.
6935 // Treatment for pan events which translate into scroll events:
6940 nsEventStatus status;
6944 ModifierKeyState modifierKeyState;
6955 }
6960 endFeedback);
6963 endFeedback);
6965 }
6970 }
6972 // Other gestures translate into simple gesture events:
6976 }
6978 // Polish up and send off the new event
6979 ModifierKeyState modifierKeyState;
6985 nsEventStatus status;
6989 }
6991 // Only close this if we process and return true.
6995 }
6997 // WM_DESTROY event handler
7001 // If this is a toplevel window, notify the taskbar concealer to clean up any
7002 // relevant state.
7005 }
7007 // Make sure we don't get destroyed in the process of tearing down.
7010 // Dispatch the destroy notification.
7013 // Prevent the widget from sending additional events.
7021 }
7022 // Unregister notifications from terminal services
7025 // We will stop receiving native events after dissociating from our native
7026 // window. We will also disappear from the output of WinUtils::GetNSWindowPtr
7027 // for that window.
7030 // Once mWidgetListener is cleared and the subclass is reset, sCurrentWindow
7031 // can be cleared. (It's used in tracking windows for mouse events.)
7034 // Disconnects us from our parent, will call our GetParent().
7037 // Release references to children, device context, toolkit, and app shell.
7040 // Clear our native parent handle.
7041 // XXX Windows will take care of this in the proper order, and
7042 // SetParent(nullptr)'s remove child on the parent already took place in
7043 // nsBaseWidget's Destroy call above.
7044 // SetParent(nullptr);
7047 // We have to destroy the native drag target before we null out our window
7048 // pointer.
7051 // If we're going away and for some reason we're still the rollup widget,
7052 // rollup and turn off capture.
7057 }
7061 }
7065 // Free GDI window class objects
7069 }
7071 // Destroy any custom cursor resources.
7074 }
7078 }
7081 // Finalize panning feedback to possibly restore window displacement
7084 // Clear the main HWND.
7086 }
7088 // Send a resize message to the listener
7093 }
7098 }
7100 // If there is an attached view, inform it as well as the normal widget
7101 // listener.
7105 }
7108 }
7125 mIsFullyOccluded);
7126 }
7127 }
7131 }
7135 }
7136 }
7145 }
7147 // Content rendering of popup is always done by child window.
7148 // See nsDocumentViewer::ShouldAttachToTopLevel().
7152 }
7155 }
7162 }
7166 }
7170 // Don't try to handle WM_DPICHANGED for popup windows (see bug 1239353);
7171 // they remain tied to their original parent's resolution.
7174 }
7177 }
7182 // Limit the position (if not in the middle of a drag-move) & size,
7183 // if it would overflow the destination screen
7194 }
7197 }
7198 }
7201 }
7205 }
7207 // Callback to generate OnCloakChanged pseudo-events.
7208 /* static */
7219 }
7227 }
7233 // Cloaking events like the one we've just received are sent asynchronously.
7234 // Rather than process them one-by-one, we jump the gun a bit and perform
7235 // updates on all newly cloaked/uncloaked nsWindows at once. This also lets us
7236 // batch operations that consider more than one window's state.
7240 };
7247 }
7252 }
7253 });
7257 }
7261 }
7264 }
7271 }
7273 /**************************************************************
7274 **************************************************************
7275 **
7276 ** BLOCK: IME management and accessibility
7277 **
7278 ** Handles managing IME input and accessibility.
7279 **
7280 **************************************************************
7281 **************************************************************/
7288 }
7296 }
7298 }
7302 }
7304 #ifdef ACCESSIBILITY
7305 # ifdef DEBUG
7306 # define NS_LOG_WMGETOBJECT(aWnd, aHwnd, aAcc) \
7307 if (a11y::logging::IsEnabled(a11y::logging::ePlatforms)) { \
7308 printf( \
7311 aHwnd, ::GetParent(aHwnd), aWnd); \
7313 if (aAcc) { \
7314 nsAutoString name; \
7315 aAcc->Name(name); \
7317 } \
7319 }
7321 # else
7322 # define NS_LOG_WMGETOBJECT(aWnd, aHwnd, aAcc)
7323 # endif
7326 // If the pref was ePlatformIsDisabled, return null here, disabling a11y.
7332 }
7334 // In case of popup window return a popup accessible.
7348 }
7349 }
7350 }
7351 }
7353 // otherwise root document accessible.
7356 }
7357 #endif
7359 /**************************************************************
7360 **************************************************************
7361 **
7362 ** BLOCK: Transparency
7363 **
7364 ** Window transparency helpers.
7365 **
7366 **************************************************************
7367 **************************************************************/
7372 // stop on dialogs and popups!
7379 }
7384 }
7387 // If we're switching to the use of a transparent window, hide the chrome
7388 // on our parent.
7392 // if we're switching out of transparent, re-enable our parent's chrome.
7394 }
7405 }
7406 }
7410 else
7421 }
7422 }
7424 /**************************************************************
7425 **************************************************************
7426 **
7427 ** BLOCK: Popup rollup hooks
7428 **
7429 ** Deals with CaptureRollup on popup windows.
7430 **
7431 **************************************************************
7432 **************************************************************/
7434 // Schedules a timer for a window, so we can rollup after processing the hook
7435 // event
7437 // In some cases multiple hooks may be scheduled
7438 // so ignore any other requests once one timer is scheduled
7440 // Remember the window handle and the message ID to be used later
7443 // Schedule native timer for doing the rollup after
7444 // this event is done being processed
7447 }
7448 }
7450 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7453 #endif
7455 // Process Menu messages, rollup when popup is clicked.
7457 LPARAM lParam) {
7458 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7464 inx++;
7465 }
7468 # ifdef DEBUG
7472 # endif
7474 # ifdef DEBUG
7478 # endif
7479 }
7481 }
7483 }
7489 }
7492 }
7494 // Process all mouse messages. Roll up when a click is in a native window
7495 // that doesn't have an nsIWidget.
7497 LPARAM lParam) {
7509 }
7511 }
7512 }
7513 }
7515 }
7517 // Process all messages. Roll up when the window is moving, or
7518 // is resizing or when maximized or mininized.
7520 LPARAM lParam) {
7521 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7525 }
7526 #endif
7533 }
7534 }
7537 }
7539 // Register the special "hooks" for dropdown processing.
7546 // Install msg hook for moving the window and resizing
7551 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7555 }
7556 #endif
7557 }
7559 // Install msg hook for menus
7564 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7569 }
7570 #endif
7571 }
7573 // Install msg hook for the mouse
7578 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
7582 }
7583 #endif
7584 }
7585 }
7587 // Unhook special message hooks for dropdowns.
7596 }
7598 }
7604 }
7606 }
7612 }
7614 }
7615 }
7617 // This timer is designed to only fire one time at most each time a "hook"
7618 // function is used to rollup the dropdown. In some cases, the timer may be
7619 // scheduled from the hook, but that hook event or a subsequent event may roll
7620 // up the dropdown before this timer function is executed.
7621 //
7622 // For example, if an MFC control takes focus, the combobox will lose focus and
7623 // rollup before this function fires.
7625 DWORD dwTime) {
7627 // if the window is nullptr then we need to use the ID to kill the timer
7631 }
7634 // Note: DealWithPopups does the check to make sure that the rollup widget
7635 // is set.
7636 LRESULT popupHandlingResult;
7637 nsAutoRollup autoRollup;
7641 }
7642 }
7646 }
7648 // static
7651 RECT r;
7653 POINT mp;
7660 }
7668 }
7670 // was the event inside this window?
7672 }
7674 // static
7678 // If we're dealing with menus, we probably have submenus and we don't want
7679 // to rollup some of them if the click is in a parent menu of the current
7680 // submenu.
7687 // Don't roll up if the mouse event occurred within a menu of the
7688 // same type. If the mouse event occurred in a menu higher than that,
7689 // roll up, but pass the number of popups to Rollup so that only those
7690 // of the same type close up.
7693 }
7697 }
7698 }
7700 }
7702 // static
7704 // While popup is open, popup window might be activated by other application.
7705 // At this time, we need to take back focus to the previous window but it
7706 // causes flickering its nonclient area because WM_NCACTIVATE comes before
7707 // WM_ACTIVATE and we cannot know which window will take focus at receiving
7708 // WM_NCACTIVATE. Therefore, we need a hack for preventing the flickerling.
7709 //
7710 // If non-popup window receives WM_NCACTIVATE at deactivating, default
7711 // wndproc shouldn't handle it as deactivating. Instead, at receiving
7712 // WM_ACTIVIATE after that, WM_NCACTIVATE should be sent again manually.
7713 // This returns true if the window needs to handle WM_NCACTIVATE later.
7717 }
7723 }
7730 }
7731 TOUCHINPUT input;
7737 }
7738 // Note that we don't call CloseTouchInputHandle here because we need
7739 // to read the touch input info again in OnTouch later.
7741 }
7743 // static
7748 // XXX Why do we use the return value of WM_MOUSEACTIVATE for all messages?
7753 }
7756 // NOTE: We deal with this here rather than on the switch below because we
7757 // want to do this even if there are no menus to rollup (tooltips don't set
7758 // the rollup listener etc).
7761 }
7762 }
7770 }
7779 // If we rollup with animations but get occluded right away, we might not
7780 // advance the refresh driver enough for the animation to finish.
7787 // If APZ is disabled, don't allow touch inputs to dismiss popups. The
7788 // compatibility mouse events will do it instead.
7790 }
7794 }
7804 // If any of these mouse events are really compatibility events that
7805 // Windows is sending for touch inputs, then don't allow them to dismiss
7806 // popups when APZ is enabled (instead we do the dismissing as part of
7807 // WM_TOUCH handling which is more correct).
7808 // If we don't do this, then when the user lifts their finger after a
7809 // long-press, the WM_RBUTTONDOWN compatibility event that Windows sends
7810 // us will dismiss the contextmenu popup that we displayed as part of
7811 // handling the long-tap-up.
7813 }
7817 }
7820 WinPointerEvents pointerEvents;
7823 }
7824 POINT pt;
7829 }
7831 // Don't roll up if the event is inside the popup window.
7833 }
7836 POINT pt;
7840 }
7842 // Don't roll up if the event is inside the popup window
7844 }
7848 // We need to check if the popup thinks that it should cause closing
7849 // itself when mouse wheel events are fired outside the rollup widget.
7851 // Check if we should consume this event even if we don't roll-up:
7857 }
7858 }
7868 // NOTE: Don't handle WA_INACTIVE for preventing popup taking focus
7869 // because we cannot distinguish it's caused by mouse or not.
7873 // Cancel notifying widget listeners of deactivating the previous
7874 // active window (see WM_KILLFOCUS case in ProcessMessage()).
7876 // Reactivate the window later.
7879 }
7880 // Don't rollup the popup when focus moves back to the parent window
7881 // from a popup because such case is caused by strange mouse drivers.
7885 // Consume this message here since previous window must not have
7886 // been inactivated since we've already stopped accepting the
7887 // inactivation below.
7889 }
7894 // If focus moves to non-popup widget or focusable popup, the window
7895 // needs to update its nonclient area.
7900 }
7902 }
7903 // If focus moves from/to popup, we don't need to rollup the popup
7904 // because such case is caused by strange mouse drivers. And in
7905 // such case, we should consume the message here since we need to
7906 // hide this odd focus move from our content. (If we didn't consume
7907 // the message here, ProcessMessage() will notify widget listener of
7908 // inactivation and that causes unnecessary reflow for supporting
7909 // -moz-window-inactive pseudo class.
7913 }
7917 }
7918 }
7920 // If the WM_ACTIVATE message is caused by a click in a popup,
7921 // we should not rollup any popups.
7926 }
7927 }
7932 // The previous active window should take back focus.
7934 // FYI: Even without this API call, you see expected result (e.g., the
7935 // owner window of the popup keeps active without flickering
7936 // the non-client area). And also this causes initializing
7937 // TSF and it causes using CPU time a lot. However, even if we
7938 // consume WM_ACTIVE messages, native focus change has already
7939 // been occurred. I.e., a popup window is active now. Therefore,
7940 // you'll see some odd behavior if we don't reactivate the owner
7941 // window here. For example, if you do:
7942 // 1. Turn wheel on a bookmark panel.
7943 // 2. Turn wheel on another window.
7944 // then, you'll see that the another window becomes active but the
7945 // owner window of the bookmark panel looks still active and the
7946 // bookmark panel keeps open. The reason is that the first wheel
7947 // operation gives focus to the bookmark panel. Therefore, when
7948 // the next operation gives focus to the another window, previous
7949 // focus window is the bookmark panel (i.e., a popup window).
7950 // So, in this case, our hack around here prevents to inactivate
7951 // the owner window and roll up the bookmark panel.
7953 }
7959 // Don't just consume WM_NCACTIVATE. It doesn't handle only the
7960 // nonclient area state change.
7962 // Accept the deactivating because it's necessary to receive following
7963 // WM_ACTIVATE.
7967 }
7973 // WM_MOUSEACTIVATE may be caused by moving the mouse (e.g., X-mouse
7974 // of TweakUI is enabled. Then, check if the popup should be rolled up
7975 // with rollup listener. If not, just consume the message.
7979 }
7980 // Otherwise, it should be handled by wndproc.
7982 }
7984 // Prevent the click inside the popup from causing a change in window
7985 // activation. Since the popup is shown non-activated, we need to eat any
7986 // requests to activate the window while it is displayed. Windows will
7987 // automatically activate the popup on the mousedown otherwise.
7991 // If the window is being minimized, close popups.
7995 }
7999 // If focus moves to other window created in different process/thread,
8000 // e.g., a plugin window, popups should be rolled up.
8004 }
8013 }
8015 // Only need to deal with the last rollup for left mouse down events.
8019 popupsToRollup,
8022 allowAnimations,
8023 };
8027 LayoutDeviceIntPoint pos;
8032 POINT pt;
8035 // POINTERDOWN is already in screen coords.
8038 }
8040 }
8048 }
8050 // Tell hook to stop processing messages
8055 // If we are NOT supposed to be consuming events, let it go through
8059 }
8062 }
8064 /**************************************************************
8065 **************************************************************
8066 **
8067 ** BLOCK: Misc. utility methods and functions.
8068 **
8069 ** General use.
8070 **
8071 **************************************************************
8072 **************************************************************/
8074 // Note that the result of GetTopLevelWindow method can be different from the
8075 // result of WinUtils::GetTopLevelHWND(). The result can be non-floating
8076 // window. Because our top level window may be contained in another window
8077 // which is not managed by us.
8089 }
8090 }
8092 // Retrieve the top level parent or owner window
8098 }
8099 }
8101 // Set a flag if hwnd is a (non-popup) visible window from this process,
8102 // and bail out of the enumeration. Otherwise leave the flag unmodified
8103 // and continue the enumeration.
8104 // lParam must be a bool* pointing at the flag to be set.
8106 DWORD pid;
8109 // Don't count popups as visible windows, since they don't take focus,
8110 // in case we only have a popup visible (see bug 1554490 where the gfx
8111 // test window is an offscreen popup).
8117 }
8118 }
8120 }
8122 // Determine if it would be ok to activate a window, taking focus.
8123 // We want to avoid stealing focus from another app (bug 225305).
8127 // There is no foreground window, so don't worry about stealing focus.
8129 }
8130 // We can take focus if the current foreground window is already from
8131 // this process.
8132 DWORD pid;
8136 }
8143 // We're probably creating our first visible window, allow that to
8144 // take focus.
8146 }
8148 }
8153 nsAutoString className;
8159 }
8160 }
8162 }
8165 POINT pt;
8170 }
8173 POINT pt;
8178 }
8185 }
8189 }
8193 }
8197 }
8201 }
8205 }
8209 }
8212 }
8214 // WORKAROUND FOR UNDOCUMENTED BEHAVIOR: `IFileDialog::Show` disables the
8215 // top-level ancestor of its provided owner-window. If the modal window's
8216 // container process crashes, it will never get a chance to undo that.
8217 //
8218 // For simplicity's sake we simply unconditionally perform both the disabling
8219 // and reenabling here, synchronously, on the main thread, rather than leaving
8220 // it to happen in our asynchronously-operated IFileDialog.
8225 // Disable the root-level window synchronously before any file-dialogs get a
8226 // chance to fight over doing it asynchronously.
8229 }
8231 mPickerDisplayCount++;
8232 }
8238 mPickerDisplayCount--;
8240 // Once all the file-dialogs are gone, reenable the root-level window.
8244 }
8248 }
8249 }
8252 // We don't currently support using an accelerated layer manager with
8253 // transparent windows so don't even try. I'm also not sure if we even
8254 // want to support this case. See bug 593471.
8255 //
8256 // Windows' support for transparent accelerated surfaces isn't great.
8257 // Some possible approaches:
8258 // - Readback the data and update it using
8259 // UpdateLayeredWindow/UpdateLayeredWindowIndirect
8260 // This is what WPF does. See
8261 // CD3DDeviceLevel1::PresentWithGDI/CD3DSwapChainWithSwDC in WpfGfx. The
8262 // rationale for not using IDirect3DSurface9::GetDC is explained here:
8263 // https://web.archive.org/web/20160521191104/https://blogs.msdn.microsoft.com/dwayneneed/2008/09/08/transparent-windows-in-wpf/
8264 // - Use D3D11_RESOURCE_MISC_GDI_COMPATIBLE, IDXGISurface1::GetDC(),
8265 // and UpdateLayeredWindowIndirect.
8266 // This is suggested here:
8267 // https://docs.microsoft.com/en-us/archive/msdn-magazine/2009/december/windows-with-c-layered-windows-with-direct2d
8268 // but might have the same problem that IDirect3DSurface9::GetDC has.
8269 // - Creating the window with the WS_EX_NOREDIRECTIONBITMAP flag and use
8270 // DirectComposition.
8271 // Not supported on Win7.
8272 // - Using DwmExtendFrameIntoClientArea with negative margins and something
8273 // to turn off the glass effect.
8274 // This doesn't work when the DWM is not running (Win7)
8275 //
8276 // Also see bug 1150376, D3D11 composition can cause issues on some devices
8277 // on Windows 7 where presentation fails randomly for windows with drop
8278 // shadows.
8281 }
8294 }
8302 }
8304 nsPointWin touchPoint;
8318 MultiTouchInput touchInput;
8325 // POINTER_INFO.dwKeyStates can't be used as it only supports Shift and Ctrl
8326 ModifierKeyState modifierKeyState;
8331 }
8334 // Theoretically flags can be set together but they do not
8337 }
8340 }
8342 }
8346 // APZ is not available on context menu. Follow the behavior of touch input
8347 // which fallbacks to WM_LBUTTON* and WM_GESTURE, to keep consistency.
8349 }
8352 }
8354 // We have to handle WM_POINTER* to fetch and cache pen related information
8355 // and fire WidgetMouseEvent with the cached information the WM_*BUTTONDOWN
8356 // handler. This is because Windows doesn't support ::DoDragDrop in the
8357 // touch or pen message handlers.
8359 // Don't consume the Windows WM_POINTER* messages
8361 }
8364 POINTER_PEN_INFO penInfo{};
8367 }
8369 // When dispatching mouse events with pen, there may be some
8370 // WM_POINTERUPDATE messages between WM_POINTERDOWN and WM_POINTERUP with
8371 // small movements. Those events will reset sLastMousePoint and reset
8372 // sLastClickCount. To prevent that, we keep the last pen down position
8373 // and compare it with the subsequent WM_POINTERUPDATE. If the movement is
8374 // smaller than GetSystemMetrics(SM_CXDRAG), then we suppress firing
8375 // eMouseMove for WM_POINTERUPDATE.
8378 // We don't support chorded buttons for pen. Keep the button at
8379 // WM_POINTERDOWN.
8383 EventMessage message;
8418 // Suppress firing eMouseMove for WM_POINTERUPDATE if the movement
8419 // from last WM_POINTERDOWN is smaller than SM_CXDRAG / SM_CYDRAG
8421 }
8423 }
8430 }
8432 // Windows defines the pen pressure is normalized to a range between 0 and
8433 // 1024. Convert it to float.
8439 buttons);
8440 // Per
8441 // https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-pointer_pen_info,
8442 // the rotation is normalized in a range of 0 to 359.
8446 // Fire touch events but not when the barrel button is pressed.
8451 }
8453 // The aLParam of WM_POINTER* is the screen location. Convert it to client
8454 // location
8460 // Fire eContextMenu manually since consuming WM_POINTER* blocks
8461 // WM_CONTEXTMENU
8464 }
8465 // Consume WM_POINTER* to stop Windows fires WM_*BUTTONDOWN / WM_*BUTTONUP
8466 // WM_MOUSEMOVE.
8468 }
8476 }
8483 }
8484 }
8489 }
8494 }
8496 // static
8499 // Initialize touch injection on the first call
8503 }
8505 InitializeTouchInjectionPtr func =
8511 }
8517 }
8519 sInjectTouchFuncPtr =
8524 }
8526 }
8528 }
8536 }
8538 POINTER_TOUCH_INFO info{};
8560 }
8563 // We sent it too quickly after the previous injection (see bug 1535140
8564 // comment 10). On the first loop iteration we just yield (via Sleep(0))
8565 // and try again. If it happens again on the second loop iteration we
8566 // explicitly Sleep(1) and try again. If that doesn't work either we just
8567 // error out.
8570 }
8573 }
8575 }
8581 }
8582 }
8584 }
8593 POINTER_FLAGS flags;
8595 // We know about this pointer, send an update
8603 }
8607 }
8609 // Missing init state, error out
8612 }
8614 // Create a new pointer
8618 }
8619 }
8621 }
8631 // If we don't have touch injection from the OS, or if we are running a test
8632 // that cannot properly inject events to satisfy the OS requirements (see
8633 // bug 1313170) we can just fake it and synthesize the events from here.
8637 }
8641 }
8650 }
8652 // win api expects a value from 0 to 1024. aPointerPressure is a value
8653 // from 0.0 to 1.0.
8656 // If we already know about this pointer id get it's record
8658 POINTER_FLAGS flags;
8659 // Can't use MOZ_TRY_VAR because it confuses WithEntryHandle
8665 }
8673 }
8675 // Remove the pointer from our tracking list. This is UniquePtr wrapped,
8676 // so shouldn't leak.
8678 }
8679 }
8682 aPointerOrientation)
8683 ? NS_ERROR_UNEXPECTED
8685 });
8686 }
8692 }
8694 // cancel all input points
8699 }
8702 }
8707 }
8709 #if !defined(NTDDI_WIN10_RS5) || (NTDDI_VERSION < NTDDI_WIN10_RS5)
8713 #endif
8719 }
8720 #if !defined(NTDDI_WIN10_RS5) || (NTDDI_VERSION < NTDDI_WIN10_RS5)
8724 }
8725 CreateSyntheticPointerDevice =
8731 }
8732 DestroySyntheticPointerDevice =
8738 }
8744 }
8745 #endif
8746 sSyntheticPenDevice =
8749 }
8758 }
8760 // win api expects a value from 0 to 1024. aPointerPressure is a value
8761 // from 0.0 to 1.0.
8764 // If we already know about this pointer id get it's record
8766 POINTER_FLAGS flags;
8767 // Can't use MOZ_TRY_VAR because it confuses WithEntryHandle
8773 }
8781 }
8783 // Remove the pointer from our tracking list. This is UniquePtr wrapped,
8784 // so shouldn't leak.
8786 }
8787 }
8789 POINTER_TYPE_INFO info{};
8799 // PEN_FLAG_ERASER is not supported this way, unfortunately.
8802 }
8811 ? NS_OK
8813 });
8814 };
8818 ModifierKeyState modKeyState;
8823 }
8825 #ifdef DEBUG
8828 }
8831 #endif
8836 // Check all four sides of our monitor for an appbar. Skip any that aren't
8837 // the system taskbar.
8838 MONITORINFO mi;
8842 APPBARDATA appBarData;
8850 nsAutoString className;
8855 }
8856 }
8857 }
8858 }
8861 }
8864 WINDOWPLACEMENT pl;
8876 }
8877 }
8880 // This will likely cause a callback to
8881 // nsWindow::FrameState::{OnFrameChanging() and OnFrameChanged()}
8896 // Don't call ::ShowWindow if we're trying to "restore" a window that is
8897 // already in a normal state. Prevents a bug where snapping to one side
8898 // of the screen and then minimizing would cause Windows to forget our
8899 // window's correct restored position/size.
8902 }
8903 }
8904 }
8917 // We should never observe fullscreen sizemode unless fullscreen is enabled
8921 // Something went wrong if we somehow saved fullscreen mode when we are
8922 // changing into fullscreen mode
8924 }
8928 }
8931 DoShowWindow aDoShowWindow) {
8934 }
8937 // If we're unminimizing a window, asynchronously notify the taskbar after
8938 // the message has been processed. This redundant notification works around
8939 // a race condition in explorer.exe. (See bug 1835851, or comments in
8940 // TaskbarConcealer.)
8941 //
8942 // Note that we notify regardless of `aMode`: unminimizing a non-fullscreen
8943 // window can also affect the correct taskbar state, yet fail to affect the
8944 // current taskbar state.
8947 }
8948 }
8954 // If we are in fullscreen mode, minimize should work like normal and
8955 // return us to fullscreen mode when unminimized. Maximize isn't really
8956 // available and won't do anything. "Restore" should do the same thing as
8957 // requesting to end fullscreen.
8961 }
8962 }
8965 DoShowWindow aDoShowWindow) {
8968 // Save the size mode from before fullscreen.
8970 }
8973 // NOTE(emilio): When minimizing a fullscreen window we remain with
8974 // mFullscreenMode = true, but mSizeMode = nsSizeMode_Minimized. We need to
8975 // make sure to call SetSizeModeInternal even if mFullscreenMode didn't
8976 // change, to ensure we actually end up with a fullscreen sizemode when
8977 // restoring a window from that state.
8980 aDoShowWindow);
8981 }
8982 }
8989 }
8992 // We don't want to perform the ShowWindow ourselves if we're on the frame
8993 // changed message. Windows has done the frame change for us, and we take care
8994 // of activating as needed. We also don't want to potentially trigger
8995 // more focus / restore. Among other things, this addresses a bug on Win7
8996 // related to window docking. (bug 489258)
9001 // If window was restored, activate the window now to get correct attributes.
9006 }
9008 }
9011 #ifdef WINSTATE_DEBUG_OUTPUT
9013 #endif
9014 }
9017 DoShowWindow aDoShowWindow) {
9020 }
9034 }
9040 }
9043 }
9048 mNeedsToPreventContextMenu =
9053 }