| blob | d726ea930d98d95feceb2da247503f41c5fabb27 |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
7 #include <dwmapi.h>
8 #include <oleacc.h>
9 #include <shellapi.h>
10 #include <wtsapi32.h>
47 // MoveLoopMouseWatcher is used to determine if the user canceled or completed a
48 // move. win32 doesn't appear to offer a way to determine the result of a move,
49 // so we install hooks to determine if we got a mouse up and assume the move
50 // completed.
56 // Returns true if the mouse is up, or if we couldn't install the hook.
60 // Instance that owns the hook. We only allow one instance to hook the mouse
61 // at a time.
64 // Key and mouse callbacks from the hook.
70 // HWNDMessageHandler that created us.
73 // Should the window be hidden when escape is pressed?
76 // Did we get a mouse up?
79 // Hook identifiers.
80 HHOOK mouse_hook_;
81 HHOOK key_hook_;
84 };
86 // static
96 // Only one instance can be active at a time.
104 // We don't care if setting the key hook succeeded.
107 }
109 // Failed installation. Assume we got a mouse up in this case, otherwise
110 // we'll think all drags were canceled.
112 }
113 }
117 }
130 }
132 // static
134 WPARAM w_param,
135 LPARAM l_param) {
140 }
142 // static
144 WPARAM w_param,
145 LPARAM l_param) {
151 DWMWA_TRANSITIONS_FORCEDISABLED,
154 }
157 }
159 }
161 // Called from OnNCActivate.
163 DWORD process_id;
170 }
188 }
191 HWND window;
193 };
195 // Enables or disables the menu item for the specified command and menu.
199 }
201 // Callback used to notify child windows that the top level window received a
202 // DWMCompositionChanged message.
206 }
208 // See comments in OnNCPaint() for details of this struct.
210 // The window being painted.
211 HWND parent;
213 // DC painting to.
214 HDC dc;
216 // Origin of the window in terms of the screen.
219 };
221 // See comments in OnNCPaint() for details of this function.
225 RECT bounds;
232 }
234 }
236 // The thickness of an auto-hide taskbar in pixels.
245 }
252 }
253 }
257 // Windows does not flag synthesized mouse messages from touch in all cases.
258 // This causes us grief as we don't want to process touch and mouse messages
259 // concurrently. Hack as per msdn is to check if the time difference between
260 // the touch message and the mouse move is within 500 ms and at the same
261 // location as the cursor.
266 // A scoping class that prevents a window from being able to redraw in response
267 // to invalidations that may occur within it for the lifetime of the object.
268 //
269 // Why would we want such a thing? Well, it turns out Windows has some
270 // "unorthodox" behavior when it comes to painting its non-client areas.
271 // Occasionally, Windows will paint portions of the default non-client area
272 // right over the top of the custom frame. This is not simply fixed by handling
273 // WM_NCPAINT/WM_PAINT, with some investigation it turns out that this
274 // rendering is being done *inside* the default implementation of some message
275 // handlers and functions:
276 // . WM_SETTEXT
277 // . WM_SETICON
278 // . WM_NCLBUTTONDOWN
279 // . EnableMenuItem, called from our WM_INITMENU handler
280 // The solution is to handle these messages and call DefWindowProc ourselves,
281 // but prevent the window from being able to update itself for the duration of
282 // the call. We do this with this class, which automatically calls its
283 // associated Window's lock and unlock functions as it is created and destroyed.
284 // See documentation in those methods for the technique used.
285 //
286 // The lock only has an effect if the window was visible upon lock creation, as
287 // it doesn't guard against direct visiblility changes, and multiple locks may
288 // exist simultaneously to handle certain nested Windows messages.
289 //
290 // IMPORTANT: Do not use this scoping object for large scopes or periods of
291 // time! IT WILL PREVENT THE WINDOW FROM BEING REDRAWN! (duh).
292 //
293 // I would love to hear Raymond Chen's explanation for all this. And maybe a
294 // list of other messages that this applies to ;-)
305 }
310 }
312 // Cancel the unlock operation, call this if the Widget is being destroyed.
316 // The owner having its style changed.
318 // The owner's HWND, cached to avoid action after window destruction.
319 HWND hwnd_;
320 // Records the HWND visibility at the time of creation.
322 // A flag indicating that the unlock operation was canceled.
324 // If true, perform the redraw lock regardless of Aero state.
328 };
330 ////////////////////////////////////////////////////////////////////////////////
331 // HWNDMessageHandler, public:
363 }
367 // Prevent calls back into this class via WNDPROC now that we've been
368 // destroyed.
370 }
377 // Create the window.
379 // TODO(ananta)
380 // Remove the scrolling hack code once we have scrolling working well.
381 #if defined(ENABLE_SCROLL_HACK)
382 // Certain trackpad drivers on Windows have bugs where in they don't generate
383 // WM_MOUSEWHEEL messages for the trackpoint and trackpad scrolling gestures
384 // unless there is an entry for Chrome with the class name of the Window.
385 // These drivers check if the window under the trackpoint has the WS_VSCROLL/
386 // WS_HSCROLL style and if yes they generate the legacy WM_VSCROLL/WM_HSCROLL
387 // messages. We add these styles to ensure that trackpad/trackpoint scrolling
388 // work.
389 // TODO(ananta)
390 // Look into moving the WS_VSCROLL and WS_HSCROLL style setting logic to the
391 // CalculateWindowStylesFromInitParams function. Doing it there seems to
392 // cause some interactive tests to fail. Investigation needed.
398 }
399 }
400 #endif
405 }
410 // We implement modality by crawling up the hierarchy of windows starting
411 // at the owner, disabling all of them so that they don't receive input
412 // messages.
417 }
418 }
424 // Let's hide ourselves right away.
427 // Modal dialog windows disable their owner windows; re-enable them now so
428 // they can activate as foreground windows upon this window's destruction.
432 // And we delay the close so that if we are called from an ATL callback,
433 // we don't destroy the window before the callback returned (as the caller
434 // may delete ourselves on destroy and the ATL callback would still
435 // dereference us when the callback returns).
438 FROM_HERE,
440 }
441 }
444 // We may already have been destroyed if the selection resulted in a tab
445 // switch which will have reactivated the browser window and closed us, so
446 // we need to check to see if we're still a window before trying to destroy
447 // ourself.
451 }
454 RECT r;
457 }
460 RECT r;
465 }
468 // If we're in fullscreen mode, we've changed the normal bounds to the monitor
469 // rect, so return the saved bounds instead.
476 }
484 }
489 WINDOWPLACEMENT wp;
496 // GetWindowPlacement can return misleading position if a normalized
497 // window was resized using Aero Snap feature (see comment 9 in bug
498 // 36421). As a workaround, using GetWindowRect for normalized windows.
504 MONITORINFO mi;
511 // Convert normal position from workarea coordinates to screen
512 // coordinates.
515 }
516 }
523 else
525 }
526 }
539 // If HWND size is not changed, we will not receive standard size change
540 // notifications. If |force_size_changed| is |true|, we should pretend size is
541 // changed.
545 }
546 }
551 }
558 }
564 }
569 }
574 }
583 }
584 }
585 }
589 DWORD native_show_state;
603 }
606 // When launched from certain programs like bash and Windows Live Messenger,
607 // show_state is set to SW_HIDE, so we need to correct that condition. We
608 // don't just change show_state to SW_SHOWNORMAL because MSDN says we must
609 // always first call ShowWindow with the specified value from STARTUPINFO,
610 // otherwise all future ShowWindow calls will be ignored (!!#@@#!). Instead,
611 // we call ShowWindow again in this case.
615 }
617 // We need to explicitly activate the window if we've been shown with a state
618 // that should activate, because if we're opened from a desktop shortcut while
619 // an existing window is already running it doesn't seem to be enough to use
620 // one of these flags to activate the window.
627 }
635 }
639 // NOTE: Be careful not to activate any windows here (for example, calling
640 // ShowWindow(SW_HIDE) will automatically activate another window). This
641 // code can be called while a window is being deactivated, and activating
642 // another window will screw up the activation that is already in progress.
646 }
647 }
651 }
656 }
660 }
667 }
675 }
677 }
678 }
683 }
687 }
691 }
695 }
699 }
703 }
709 // In Aura, we handle touch events asynchronously. So we need to allow nested
710 // tasks while in windows move loop.
715 // Windows doesn't appear to offer a way to determine whether the user
716 // canceled the move or not. We assume if the user released the mouse it was
717 // successful.
719 }
723 }
730 }
733 FLASHWINFO fwi;
742 }
744 }
748 }
753 }
758 }
762 }
769 }
770 }
784 }
793 }
794 }
798 // Don't redraw the window here, because we invalidate the window later.
800 // The non-client view needs to update too.
808 }
809 }
813 // We must update the back-buffer immediately, since Windows' handling of
814 // invalid rects is somewhat mysterious.
817 // In some situations, such as drag and drop, when Windows itself runs a
818 // nested message loop our message loop appears to be starved and we don't
819 // receive calls to DidProcessMessage(). This only seems to affect layered
820 // windows, so we schedule a redraw manually using a task, since those never
821 // seem to be starved. Also, wtf.
825 FROM_HERE,
828 }
830 // InvalidateRect() expects client coordinates.
833 }
834 }
838 }
845 // We need to make sure to destroy the previous icon, otherwise we'll leak
846 // these GDI objects until we crash!
852 }
860 }
861 }
865 // If we are out of fullscreen and there was a pending DWM transition for the
866 // window, then go ahead and do it now.
869 }
871 ////////////////////////////////////////////////////////////////////////////////
872 // HWNDMessageHandler, InputMethodDelegate implementation:
876 }
878 ////////////////////////////////////////////////////////////////////////////////
879 // HWNDMessageHandler, gfx::WindowImpl overrides:
886 }
889 WPARAM w_param,
890 LPARAM l_param) {
897 // Otherwise we handle everything else.
898 // NOTE: We inline ProcessWindowMessage() as 'this' may be destroyed during
899 // dispatch and ProcessWindowMessage() doesn't deal with that well.
910 // DefWindowProc() may have destroyed the window and/or us in a nested
911 // message loop.
914 }
920 }
925 }
928 WPARAM w_param,
929 LPARAM l_param,
931 // Don't track forwarded mouse messages. We expect the caller to track the
932 // mouse.
937 }
940 WPARAM w_param,
941 LPARAM l_param,
947 }
950 WPARAM w_param,
951 LPARAM l_param,
957 }
960 WPARAM w_param,
961 LPARAM l_param,
967 }
970 WPARAM w_param,
971 LPARAM l_param,
978 }
980 ////////////////////////////////////////////////////////////////////////////////
981 // HWNDMessageHandler, private:
987 monitor,
991 }
994 // This triggers querying WM_NCCALCSIZE again.
995 RECT client;
999 SWP_FRAMECHANGED);
1000 }
1005 // The window does not get keyboard messages unless we focus it.
1007 }
1008 }
1016 }
1021 // If we were run modally, we need to undo the disabled-ness we inflicted on
1022 // the owner's parent hierarchy.
1027 }
1028 }
1029 }
1034 }
1037 // Begin tracking mouse events for this HWND so that we get WM_MOUSELEAVE
1038 // when the user moves the mouse outside this HWND's bounds.
1041 // We're about to cancel active mouse tracking, so empty out the stored
1042 // state.
1046 }
1048 TRACKMOUSEEVENT tme;
1057 }
1058 }
1065 }
1072 // Returning false causes the default handling in OnNCCalcSize() to
1073 // be invoked.
1077 }
1080 // Windows automatically adds a standard width border to all sides when a
1081 // window is maximized.
1088 }
1092 }
1095 // A native frame uses the native window region, and we don't want to mess
1096 // with it.
1097 // WS_EX_COMPOSITED is used instead of WS_EX_LAYERED under aura. WS_EX_LAYERED
1098 // automatically makes clicks on transparent pixels fall through, that isn't
1099 // the case with WS_EX_COMPOSITED. So, we route WS_EX_COMPOSITED through to
1100 // the delegate to allow for a custom hit mask.
1106 }
1108 // Changing the window region is going to force a paint. Only change the
1109 // window region if the region really differs.
1113 RECT window_rect;
1115 HRGN new_region;
1121 MONITORINFO mi;
1133 }
1136 // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
1140 }
1143 }
1152 DWMNCRENDERINGPOLICY policy =
1158 }
1161 WPARAM w_param,
1162 LPARAM l_param) {
1164 // The Widget and HWND can be destroyed in the call to DefWindowProc, so use
1165 // the WeakPtrFactory to avoid unlocking (and crashing) after destruction.
1171 }
1174 // We skip locked updates when Aero is on for two reasons:
1175 // 1. Because it isn't necessary
1176 // 2. Because toggling the WS_VISIBLE flag may occur while the GPU process is
1177 // attempting to present a child window's backbuffer onscreen. When these
1178 // two actions race with one another, the child window will either flicker
1179 // or will simply stop updating entirely.
1183 }
1184 }
1191 }
1192 }
1199 // We need to clip to the dirty rect ourselves.
1210 RECT wr;
1221 }
1225 // Presents will continue to fail as long as the input desktop is
1226 // unavailable.
1230 FROM_HERE,
1233 attempts),
1236 }
1238 }
1240 // Message handlers ------------------------------------------------------------
1246 // Also update the native frame if it is rendering the non-client area.
1249 }
1250 }
1254 WORD device,
1258 // Make sure to return TRUE if the event was handled or in some cases the
1259 // system will execute the default handler which can cause bugs like going
1260 // forward or back two pages instead of one.
1262 }
1266 // Need default handling, otherwise capture and other things aren't canceled.
1268 }
1272 }
1276 }
1280 HWND window) {
1281 // If the notification code is > 1 it means it is control specific and we
1282 // should ignore it.
1285 }
1292 // This is part of the magic to emulate layered windows with Aura
1293 // see the explanation elsewere when we set WS_EX_COMPOSITED style.
1296 }
1297 }
1301 // This message initializes the window so that focus border are shown for
1302 // windows.
1304 WM_CHANGEUISTATE,
1312 }
1314 // Get access to a modifiable copy of the system menu.
1321 // We need to allow the delegate to size its contents since the window may not
1322 // receive a size notification when its initial bounds are specified at window
1323 // creation time.
1330 // TODO(beng): move more of NWW::OnCreate here.
1332 }
1337 }
1342 }
1345 WPARAM w_param,
1346 LPARAM l_param) {
1350 }
1354 }
1359 }
1362 // Please refer to the comments in the OnSize function about the scrollbar
1363 // hack.
1364 // Hide the Windows scrollbar if the scroll styles are present to ensure
1365 // that a paint flicker does not occur while sizing.
1371 }
1374 // Needed to prevent resize flicker.
1376 }
1382 }
1387 // Please refer to the notes in the OnSize function for information about
1388 // the scrolling hack.
1389 // We hide the Windows scrollbar in the OnEnterSizeMove function. We need
1390 // to add the scroll styles back to ensure that scrolling works in legacy
1391 // trackpoint drivers.
1394 }
1401 // Add the native frame border size to the minimum and maximum size if the
1402 // view reports its size as the client size.
1413 }
1414 }
1424 }
1426 }
1429 WPARAM w_param,
1430 LPARAM l_param) {
1433 // Only the lower 32 bits of l_param are valid when checking the object id
1434 // because it sometimes gets sign-extended incorrectly (but not always).
1437 // Accessibility readers will send an OBJID_CLIENT message
1439 // Retrieve MSAA dispatch object for the root view.
1443 // Create a reference that MSAA will marshall to the client.
1446 }
1449 }
1452 WPARAM w_param,
1453 LPARAM l_param) {
1458 }
1473 // TODO: unfortunately, WidgetDelegate does not declare CanMinimize() and some
1474 // code depends on this check, see http://crbug.com/341010.
1482 }
1485 HKL input_language_id) {
1487 }
1490 WPARAM w_param,
1491 LPARAM l_param) {
1497 }
1502 }
1505 WPARAM w_param,
1506 LPARAM l_param) {
1507 // Please refer to the comments in the header for the touch_down_contexts_
1508 // member for the if statement below.
1512 // On Windows, if we select the menu item by touch and if the window at the
1513 // location is another window on the same thread, that window gets a
1514 // WM_MOUSEACTIVATE message and ends up activating itself, which is not
1515 // correct. We workaround this by setting a property on the window at the
1516 // current cursor location. We check for this property in our
1517 // WM_MOUSEACTIVATE handler and don't activate the window if the property is
1518 // set.
1522 }
1523 // A child window activation should be treated as if we lost activation.
1531 // TODO(beng): resolve this with the GetWindowLong() check on the subsequent
1532 // line.
1539 }
1542 WPARAM w_param,
1543 LPARAM l_param) {
1545 }
1550 }
1554 }
1557 WPARAM w_param,
1558 LPARAM l_param) {
1559 // Per MSDN, w_param is either TRUE or FALSE. However, MSDN also hints that:
1560 // "If the window is minimized when this message is received, the application
1561 // should pass the message to the DefWindowProc function."
1562 // It is found out that the high word of w_param might be set when the window
1563 // is minimized or restored. To handle this, w_param's high word should be
1564 // cleared before it is converted to BOOL.
1572 }
1577 // On activation, lift any prior restriction against rendering as inactive.
1582 // TODO(beng, et al): Hack to redraw this window and child windows
1583 // synchronously upon activation. Not all child windows are redrawing
1584 // themselves leading to issues like http://crbug.com/74604
1585 // We redraw out-of-process HWNDs asynchronously to avoid hanging the
1586 // whole app if a child HWND belonging to a hung plugin is encountered.
1590 }
1592 // The frame may need to redraw as a result of the activation change.
1593 // We can get WM_NCACTIVATE before we're actually visible. If we're not
1594 // visible, no need to paint.
1598 // Avoid DefWindowProc non-client rendering over our custom frame on newer
1599 // Windows versions only (breaks taskbar activation indication on XP/Vista).
1604 }
1608 }
1611 // We only override the default handling if we need to specify a custom
1612 // non-client edge width. Note that in most cases "no insets" means no
1613 // custom width, but in fullscreen mode or when the NonClientFrameView
1614 // requests it, we want a custom width of 0.
1616 // Let User32 handle the first nccalcsize for captioned windows
1617 // so it updates its internal structures (specifically caption-present)
1618 // Without this Tile & Cascade windows won't work.
1619 // See http://code.google.com/p/chromium/issues/detail?id=900
1625 }
1626 }
1634 }
1644 // Find all auto-hide taskbars along the screen edges and adjust in by the
1645 // thickness of the auto-hide taskbar on each such edge, so the window isn't
1646 // treated as a "fullscreen app", which would cause the taskbars to
1647 // disappear.
1650 // We might end up here if the window was previously minimized and the
1651 // user clicks on the taskbar button to restore it in the previously
1652 // maximized position. In that case WM_NCCALCSIZE is sent before the
1653 // window coordinates are restored to their previous values, so our
1654 // (left,top) would probably be (-32000,-32000) like all minimized
1655 // windows. So the above MonitorFromWindow call fails, but if we check
1656 // the window rect given with WM_NCCALCSIZE (which is our previous
1657 // restored window position) we will get the correct monitor handle.
1660 // This is probably an extreme case that we won't hit, but if we don't
1661 // intersect any monitor, let us not adjust the client rect since our
1662 // window will not be visible anyway.
1664 }
1665 }
1671 // Tricky bit. Due to a bug in DwmDefWindowProc()'s handling of
1672 // WM_NCHITTEST, having any nonclient area atop the window causes the
1673 // caption buttons to draw onscreen but not respond to mouse
1674 // hover/clicks.
1675 // So for a taskbar at the screen top, we can't push the
1676 // client_rect->top down; instead, we move the bottom up by one pixel,
1677 // which is the smallest change we can make and still get a client area
1678 // less than the screen size. This is visibly ugly, but there seems to
1679 // be no better solution.
1683 }
1684 }
1690 // We cannot return WVR_REDRAW when there is nonclient area, or Windows
1691 // exhibits bugs where client pixels and child HWNDs are mispositioned by
1692 // the width/height of the upper-left nonclient area.
1694 }
1696 // If the window bounds change, we're going to relayout and repaint anyway.
1697 // Returning WVR_REDRAW avoids an extra paint before that of the old client
1698 // pixels in the (now wrong) location, and thus makes actions like resizing a
1699 // window from the left edge look slightly less broken.
1700 // We special case when left or top insets are 0, since these conditions
1701 // actually require another repaint to correct the layout after glass gets
1702 // turned on and off.
1706 }
1712 }
1714 // If the DWM is rendering the window controls, we need to give the DWM's
1715 // default window procedure first chance to handle hit testing.
1717 LRESULT result;
1721 }
1722 }
1724 // First, give the NonClientView a chance to test the point to see if it
1725 // provides any of the non-client area.
1732 // Otherwise, we let Windows do all the native frame non-client handling for
1733 // us.
1738 // If we faked the WS_VSCROLL and WS_HSCROLL styles for this window, then
1739 // Windows returns the HTVSCROLL or HTHSCROLL hit test codes if we hover
1740 // or click on the non client portions of the window where the OS
1741 // scrollbars would be drawn. These hittest codes are returned even when
1742 // the scrollbars are hidden, which is the case in Aura. We fake the
1743 // hittest code as HTCLIENT in this case to ensure that we receive client
1744 // mouse messages as opposed to non client mouse messages.
1751 // Normally the HTBOTTOMRIGHT hittest code is received when we hover
1752 // near the bottom right of the window. However due to our fake scroll
1753 // styles, we get this code even when we hover around the area where
1754 // the vertical scrollar down arrow would be drawn.
1755 // We check if the hittest coordinates lie in this region and if yes
1756 // we return HTCLIENT.
1761 RECT window_rect;
1767 POINT pt;
1773 }
1777 }
1778 }
1780 }
1783 // We only do non-client painting if we're not using the native frame.
1784 // It's required to avoid some native painting artifacts from appearing when
1785 // the window is resized.
1789 }
1791 // We have an NC region and need to paint it. We expand the NC region to
1792 // include the dirty region of the root view. This is done to minimize
1793 // paints.
1794 RECT window_rect;
1800 // If the size of the window differs from the size of the root view it
1801 // means we're being asked to paint before we've gotten a WM_SIZE. This can
1802 // happen when the user is interactively resizing the window. To avoid
1803 // mass flickering we don't do anything here. Once we get the WM_SIZE we'll
1804 // reset the region of the window which triggers another WM_NCPAINT and
1805 // all is well.
1807 }
1809 RECT dirty_region;
1810 // A value of 1 indicates paint all.
1817 RECT rgn_bounding_box;
1822 // rgn_bounding_box is in screen coordinates. Map it to window coordinates.
1824 }
1826 // In theory GetDCEx should do what we want, but I couldn't get it to work.
1827 // In particular the docs mentiond DCX_CLIPCHILDREN, but as far as I can tell
1828 // it doesn't work at all. So, instead we get the DC for the window then
1829 // manually clip out the children.
1831 ClipState clip_state;
1841 // The root view has a region that needs to be painted. Include it in the
1842 // region we're going to paint.
1847 }
1851 // gfx::CanvasSkiaPaint's destructor does the actual painting. As such, wrap
1852 // the following in a block to force paint to occur so that we can release
1853 // the dc.
1862 }
1865 // When using a custom frame, we want to avoid calling DefWindowProc() since
1866 // that may render artifacts.
1868 }
1871 WPARAM w_param,
1872 LPARAM l_param) {
1873 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
1874 // an explanation about why we need to handle this message.
1877 }
1880 WPARAM w_param,
1881 LPARAM l_param) {
1882 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
1883 // an explanation about why we need to handle this message.
1886 }
1892 }
1895 // Call BeginPaint()/EndPaint() around the paint handling, as that seems
1896 // to do more to actually validate the window's drawing region. This only
1897 // appears to matter for Windows that have the WS_EX_COMPOSITED style set
1898 // but will be valid in general too.
1899 PAINTSTRUCT ps;
1903 // Try to paint accelerated first.
1907 }
1910 }
1913 WPARAM w_param,
1914 LPARAM l_param) {
1917 }
1920 WPARAM w_param,
1921 LPARAM l_param) {
1926 }
1929 PWTSSESSION_NOTIFICATION session_id) {
1930 // Direct3D presents are ignored while the screen is locked, so force the
1931 // window to be redrawn on unlock.
1936 }
1939 WPARAM w_param,
1940 LPARAM l_param) {
1941 // Reimplement the necessary default behavior here. Calling DefWindowProc can
1942 // trigger weird non-client painting for non-glass windows with custom frames.
1943 // Using a ScopedRedrawLock to prevent caption rendering artifacts may allow
1944 // content behind this window to incorrectly paint in front of this window.
1945 // Invalidating the window to paint over either set of artifacts is not ideal.
1974 // Use the default value, IDC_ARROW.
1976 }
1979 }
1984 }
1987 // Use a ScopedRedrawLock to avoid weird non-client painting.
1990 }
1993 // Use a ScopedRedrawLock to avoid weird non-client painting.
1996 }
2001 // Fire a dummy SetWindowPos() call, so we'll trip the code in
2002 // OnWindowPosChanging() below that notices work area changes.
2010 }
2011 }
2015 // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
2016 // invoked OnSize we ensure the RootView has been laid out.
2019 // We add the WS_VSCROLL and WS_HSCROLL styles to top level windows to ensure
2020 // that legacy trackpad/trackpoint drivers generate the WM_VSCROLL and
2021 // WM_HSCROLL messages and scrolling works.
2022 // We want the scroll styles to be present on the window. However we don't
2023 // want Windows to draw the scrollbars. To achieve this we hide the scroll
2024 // bars and readd them to the window style in a posted task to ensure that we
2025 // don't get nested WM_SIZE messages.
2030 }
2031 }
2038 // Windows uses the 4 lower order bits of |notification_code| for type-
2039 // specific information so we must exclude this when comparing.
2041 // Ignore size/move/maximize in fullscreen mode.
2055 // Circumvent ScopedRedrawLocks and force visibility before entering a
2056 // resize or move modal loop to get continuous sizing/moving feedback.
2059 }
2060 }
2061 }
2063 // Handle SC_KEYMENU, which means that the user has pressed the ALT
2064 // key and released it, so we should focus the menu bar.
2071 // Retrieve the status of shift and control keys to prevent consuming
2072 // shift+alt keys, which are used by Windows to change input languages.
2074 modifiers);
2077 }
2079 // If the delegate can't handle it, the system implementation will be called.
2081 // If the window is being resized by dragging the borders of the window
2082 // with the mouse/touch/keyboard, we flag as being in a size loop.
2091 }
2092 }
2096 }
2099 WPARAM w_param,
2100 LPARAM l_param) {
2101 // Handle touch events only on Aura for now.
2108 TouchEvents touch_events;
2110 POINT point;
2115 // Windows 7 sends touch events for touches in the non-client area,
2116 // whereas Windows 8 does not. In order to unify the behaviour, always
2117 // ignore touch events in the non-client area.
2123 }
2134 touch_down_contexts_++;
2136 FROM_HERE,
2145 }
2148 // input[i].dwTime doesn't necessarily relate to the system time at all,
2149 // so use base::TimeTicks::HighResNow() if possible, or
2150 // base::TimeTicks::Now() otherwise.
2153 else
2171 }
2172 }
2173 // Handle the touch events asynchronously. We need this because touch
2174 // events on windows don't fire if we enter a modal loop in the context of
2175 // a touch event.
2177 FROM_HERE,
2180 }
2184 }
2188 // If somebody's trying to toggle our visibility, change the nonclient area,
2189 // change our Z-order, or activate us, we should probably let it go through.
2191 SWP_FRAMECHANGED)) &&
2193 // Just sizing/moving the window; ignore.
2196 }
2198 RECT window_rect;
2199 HMONITOR monitor;
2208 work_area_changed)) {
2209 // A rect for the monitor we're on changed. Normally Windows notifies
2210 // us about this (and thus we're reaching here due to the SetWindowPos()
2211 // call in OnSettingChange() above), but with some software (e.g.
2212 // nVidia's nView desktop manager) the work area can change asynchronous
2213 // to any notification, and we're just sent a SetWindowPos() call with a
2214 // new (frequently incorrect) position/size. In either case, the best
2215 // response is to throw away the existing position/size information in
2216 // |window_pos| and recalculate it based on the new work rect.
2227 }
2232 // WARNING! Don't set SWP_FRAMECHANGED here, it breaks moving the child
2233 // HWNDs for some reason.
2237 // Now ignore all immediately-following SetWindowPos() changes. Windows
2238 // likes to (incorrectly) recalculate what our position/size should be
2239 // and send us further updates.
2242 FROM_HERE,
2245 }
2249 }
2250 }
2256 // Prevent the window from being made visible if we've been asked to do so.
2257 // See comment in header as to why we might want this.
2259 }
2267 }
2277 }
2283 }
2289 }
2292 touch_down_contexts_--;
2293 }
2296 WPARAM w_param,
2297 LPARAM l_param,
2301 // We handle touch events on Windows Aura. Windows generates synthesized
2302 // mouse messages in response to touch which we should ignore. However touch
2303 // messages are only received for the client area. We need to ignore the
2304 // synthesized mouse messages for all points in the client area and places
2305 // which return HTNOWHERE.
2308 // For mouse events (except wheel events), location is in window coordinates
2309 // and should be converted to screen coordinates for WM_NCHITTEST.
2314 }
2318 }
2320 // Certain logitech drivers send the WM_MOUSEHWHEEL message to the parent
2321 // followed by WM_MOUSEWHEEL messages to the child window causing a vertical
2322 // scroll. We treat these WM_MOUSEWHEEL messages as WM_MOUSEHWHEEL
2323 // messages.
2330 }
2335 // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu()
2336 // expect screen coordinates.
2344 }
2350 // When the mouse is pressed down in these specific non-client areas,
2351 // we need to tell the RootView to send the mouse pressed event (which
2352 // sets capture, allowing subsequent WM_LBUTTONUP (note, _not_
2353 // WM_NCLBUTTONUP) to fire so that the appropriate WM_SYSCOMMAND can be
2354 // sent by the applicable button's ButtonListener. We _have_ to do this
2355 // way rather than letting Windows just send the syscommand itself (as
2356 // would happen if we never did this dance) because for some insane
2357 // reason DefWindowProc for WM_NCLBUTTONDOWN also renders the pressed
2358 // window control button appearance, in the Windows classic style, over
2359 // our view! Ick! By handling this message we prevent Windows from
2360 // doing this undesirable thing, but that means we need to roll the
2361 // sys-command handling ourselves.
2362 // Combine |w_param| with common key state message flags.
2365 }
2366 }
2370 // We SetCapture() to ensure we only show the menu when the button
2371 // down and up are both on the caption. Note: this causes the button up to
2372 // be WM_RBUTTONUP instead of WM_NCRBUTTONUP.
2374 }
2383 // Windows only fires WM_MOUSELEAVE events if the application begins
2384 // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events.
2385 // We need to call |TrackMouseEvents| to listen for WM_MOUSELEAVE.
2389 // Reset our tracking flags so future mouse movement over this
2390 // NativeWidget results in a new tracking session. Fall through for
2391 // OnMouseEvent.
2394 // Reroute the mouse wheel to the window under the pointer if applicable.
2397 }
2399 // There are cases where the code handling the message destroys the window,
2400 // so use the weak ptr to check if destruction occured or not.
2407 // TODO(msw): Eliminate undesired painting, or re-evaluate this workaround.
2408 // DefWindowProc for WM_NCLBUTTONDOWN does weird non-client painting, so we
2409 // need to call it inside a ScopedRedrawLock. This may cause other negative
2410 // side-effects (ex/ stifling non-client mouse releases).
2413 }
2418 }
2422 LPARAM l_param) {
2425 // Ignore mouse messages which occur at the same location as the current
2426 // cursor position and within a time difference of 500 ms from the last
2427 // touch message.
2430 kSynthesizedMouseTouchMessagesTimeDifference)) {
2438 }
2440 }
2446 // Don't redraw the window here, because we need to hide and show the window
2447 // which will also trigger a redraw.
2449 // The non-client view needs to update too.
2453 // For some reason, we need to hide the window after we change from a custom
2454 // frame to a native frame. If we don't, the client area will be filled
2455 // with black. This seems to be related to an interaction between DWM and
2456 // SetWindowRgn, but the details aren't clear. Additionally, we need to
2457 // specify SWP_NOZORDER here, otherwise if you have multiple chrome windows
2458 // open they will re-appear with a non-deterministic Z-order.
2462 }
2463 // WM_DWMCOMPOSITIONCHANGED is only sent to top level windows, however we want
2464 // to notify our children too, since we can have MDI child windows who need to
2465 // update their appearance.
2467 }