| blob | 43398be99a715eff01e3c9621bcdc3c1b0bbf84a |
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 }
873 // Ignore if this is not a standard window.
883 }
888 }
890 }
892 ////////////////////////////////////////////////////////////////////////////////
893 // HWNDMessageHandler, InputMethodDelegate implementation:
897 }
899 ////////////////////////////////////////////////////////////////////////////////
900 // HWNDMessageHandler, gfx::WindowImpl overrides:
907 }
910 WPARAM w_param,
911 LPARAM l_param) {
918 // Otherwise we handle everything else.
919 // NOTE: We inline ProcessWindowMessage() as 'this' may be destroyed during
920 // dispatch and ProcessWindowMessage() doesn't deal with that well.
931 // DefWindowProc() may have destroyed the window and/or us in a nested
932 // message loop.
935 }
941 }
946 }
949 WPARAM w_param,
950 LPARAM l_param,
952 // Don't track forwarded mouse messages. We expect the caller to track the
953 // mouse.
958 }
961 WPARAM w_param,
962 LPARAM l_param,
968 }
971 WPARAM w_param,
972 LPARAM l_param,
978 }
981 WPARAM w_param,
982 LPARAM l_param,
988 }
991 WPARAM w_param,
992 LPARAM l_param,
999 }
1001 ////////////////////////////////////////////////////////////////////////////////
1002 // HWNDMessageHandler, private:
1008 monitor,
1012 }
1015 // This triggers querying WM_NCCALCSIZE again.
1016 RECT client;
1020 SWP_FRAMECHANGED);
1021 }
1026 // The window does not get keyboard messages unless we focus it.
1028 }
1029 }
1037 }
1042 // If we were run modally, we need to undo the disabled-ness we inflicted on
1043 // the owner's parent hierarchy.
1048 }
1049 }
1050 }
1055 }
1058 // Begin tracking mouse events for this HWND so that we get WM_MOUSELEAVE
1059 // when the user moves the mouse outside this HWND's bounds.
1062 // We're about to cancel active mouse tracking, so empty out the stored
1063 // state.
1067 }
1069 TRACKMOUSEEVENT tme;
1078 }
1079 }
1086 }
1093 // Returning false causes the default handling in OnNCCalcSize() to
1094 // be invoked.
1098 }
1101 // Windows automatically adds a standard width border to all sides when a
1102 // window is maximized.
1109 }
1113 }
1116 // A native frame uses the native window region, and we don't want to mess
1117 // with it.
1118 // WS_EX_COMPOSITED is used instead of WS_EX_LAYERED under aura. WS_EX_LAYERED
1119 // automatically makes clicks on transparent pixels fall through, that isn't
1120 // the case with WS_EX_COMPOSITED. So, we route WS_EX_COMPOSITED through to
1121 // the delegate to allow for a custom hit mask.
1127 }
1129 // Changing the window region is going to force a paint. Only change the
1130 // window region if the region really differs.
1134 RECT window_rect;
1136 HRGN new_region;
1142 MONITORINFO mi;
1154 }
1157 // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
1161 }
1164 }
1173 DWMNCRENDERINGPOLICY policy =
1179 }
1182 WPARAM w_param,
1183 LPARAM l_param) {
1185 // The Widget and HWND can be destroyed in the call to DefWindowProc, so use
1186 // the WeakPtrFactory to avoid unlocking (and crashing) after destruction.
1192 }
1195 // We skip locked updates when Aero is on for two reasons:
1196 // 1. Because it isn't necessary
1197 // 2. Because toggling the WS_VISIBLE flag may occur while the GPU process is
1198 // attempting to present a child window's backbuffer onscreen. When these
1199 // two actions race with one another, the child window will either flicker
1200 // or will simply stop updating entirely.
1204 }
1205 }
1212 }
1213 }
1220 // We need to clip to the dirty rect ourselves.
1231 RECT wr;
1242 }
1246 // Presents will continue to fail as long as the input desktop is
1247 // unavailable.
1251 FROM_HERE,
1254 attempts),
1257 }
1259 }
1261 // Message handlers ------------------------------------------------------------
1267 // Also update the native frame if it is rendering the non-client area.
1270 }
1271 }
1275 WORD device,
1279 // Make sure to return TRUE if the event was handled or in some cases the
1280 // system will execute the default handler which can cause bugs like going
1281 // forward or back two pages instead of one.
1283 }
1287 // Need default handling, otherwise capture and other things aren't canceled.
1289 }
1293 }
1297 }
1301 HWND window) {
1302 // If the notification code is > 1 it means it is control specific and we
1303 // should ignore it.
1306 }
1313 // This is part of the magic to emulate layered windows with Aura
1314 // see the explanation elsewere when we set WS_EX_COMPOSITED style.
1317 }
1318 }
1322 // This message initializes the window so that focus border are shown for
1323 // windows.
1325 WM_CHANGEUISTATE,
1333 }
1335 // Get access to a modifiable copy of the system menu.
1342 // We need to allow the delegate to size its contents since the window may not
1343 // receive a size notification when its initial bounds are specified at window
1344 // creation time.
1351 // TODO(beng): move more of NWW::OnCreate here.
1353 }
1358 }
1363 }
1366 WPARAM w_param,
1367 LPARAM l_param) {
1371 }
1375 }
1380 }
1383 // Please refer to the comments in the OnSize function about the scrollbar
1384 // hack.
1385 // Hide the Windows scrollbar if the scroll styles are present to ensure
1386 // that a paint flicker does not occur while sizing.
1392 }
1395 // Needed to prevent resize flicker.
1397 }
1403 }
1408 // Please refer to the notes in the OnSize function for information about
1409 // the scrolling hack.
1410 // We hide the Windows scrollbar in the OnEnterSizeMove function. We need
1411 // to add the scroll styles back to ensure that scrolling works in legacy
1412 // trackpoint drivers.
1415 }
1425 // Add the native frame border size to the minimum and maximum size if the
1426 // view reports its size as the client size.
1434 // Either axis may be zero, so enlarge them independently.
1439 }
1449 }
1451 }
1454 WPARAM w_param,
1455 LPARAM l_param) {
1458 // Only the lower 32 bits of l_param are valid when checking the object id
1459 // because it sometimes gets sign-extended incorrectly (but not always).
1462 // Accessibility readers will send an OBJID_CLIENT message
1464 // Retrieve MSAA dispatch object for the root view.
1468 // Create a reference that MSAA will marshall to the client.
1471 }
1474 }
1477 WPARAM w_param,
1478 LPARAM l_param) {
1486 }
1508 }
1511 HKL input_language_id) {
1513 }
1516 WPARAM w_param,
1517 LPARAM l_param) {
1523 }
1528 }
1531 WPARAM w_param,
1532 LPARAM l_param) {
1533 // Please refer to the comments in the header for the touch_down_contexts_
1534 // member for the if statement below.
1538 // On Windows, if we select the menu item by touch and if the window at the
1539 // location is another window on the same thread, that window gets a
1540 // WM_MOUSEACTIVATE message and ends up activating itself, which is not
1541 // correct. We workaround this by setting a property on the window at the
1542 // current cursor location. We check for this property in our
1543 // WM_MOUSEACTIVATE handler and don't activate the window if the property is
1544 // set.
1548 }
1549 // A child window activation should be treated as if we lost activation.
1553 // The code below exists for child windows like NPAPI plugins etc which need
1554 // to be activated whenever we receive a WM_MOUSEACTIVATE message. Don't put
1555 // transparent child windows in this bucket as they are not supposed to grab
1556 // activation.
1557 // TODO(ananta)
1558 // Get rid of this code when we deprecate NPAPI plugins.
1564 // TODO(beng): resolve this with the GetWindowLong() check on the subsequent
1565 // line.
1572 }
1575 WPARAM w_param,
1576 LPARAM l_param) {
1578 }
1583 }
1587 }
1590 WPARAM w_param,
1591 LPARAM l_param) {
1592 // Per MSDN, w_param is either TRUE or FALSE. However, MSDN also hints that:
1593 // "If the window is minimized when this message is received, the application
1594 // should pass the message to the DefWindowProc function."
1595 // It is found out that the high word of w_param might be set when the window
1596 // is minimized or restored. To handle this, w_param's high word should be
1597 // cleared before it is converted to BOOL.
1605 }
1610 // On activation, lift any prior restriction against rendering as inactive.
1615 // TODO(beng, et al): Hack to redraw this window and child windows
1616 // synchronously upon activation. Not all child windows are redrawing
1617 // themselves leading to issues like http://crbug.com/74604
1618 // We redraw out-of-process HWNDs asynchronously to avoid hanging the
1619 // whole app if a child HWND belonging to a hung plugin is encountered.
1623 }
1625 // The frame may need to redraw as a result of the activation change.
1626 // We can get WM_NCACTIVATE before we're actually visible. If we're not
1627 // visible, no need to paint.
1631 // Avoid DefWindowProc non-client rendering over our custom frame on newer
1632 // Windows versions only (breaks taskbar activation indication on XP/Vista).
1637 }
1641 }
1644 // We only override the default handling if we need to specify a custom
1645 // non-client edge width. Note that in most cases "no insets" means no
1646 // custom width, but in fullscreen mode or when the NonClientFrameView
1647 // requests it, we want a custom width of 0.
1649 // Let User32 handle the first nccalcsize for captioned windows
1650 // so it updates its internal structures (specifically caption-present)
1651 // Without this Tile & Cascade windows won't work.
1652 // See http://code.google.com/p/chromium/issues/detail?id=900
1658 }
1659 }
1667 }
1677 // Find all auto-hide taskbars along the screen edges and adjust in by the
1678 // thickness of the auto-hide taskbar on each such edge, so the window isn't
1679 // treated as a "fullscreen app", which would cause the taskbars to
1680 // disappear.
1683 // We might end up here if the window was previously minimized and the
1684 // user clicks on the taskbar button to restore it in the previously
1685 // maximized position. In that case WM_NCCALCSIZE is sent before the
1686 // window coordinates are restored to their previous values, so our
1687 // (left,top) would probably be (-32000,-32000) like all minimized
1688 // windows. So the above MonitorFromWindow call fails, but if we check
1689 // the window rect given with WM_NCCALCSIZE (which is our previous
1690 // restored window position) we will get the correct monitor handle.
1693 // This is probably an extreme case that we won't hit, but if we don't
1694 // intersect any monitor, let us not adjust the client rect since our
1695 // window will not be visible anyway.
1697 }
1698 }
1704 // Tricky bit. Due to a bug in DwmDefWindowProc()'s handling of
1705 // WM_NCHITTEST, having any nonclient area atop the window causes the
1706 // caption buttons to draw onscreen but not respond to mouse
1707 // hover/clicks.
1708 // So for a taskbar at the screen top, we can't push the
1709 // client_rect->top down; instead, we move the bottom up by one pixel,
1710 // which is the smallest change we can make and still get a client area
1711 // less than the screen size. This is visibly ugly, but there seems to
1712 // be no better solution.
1716 }
1717 }
1723 // We cannot return WVR_REDRAW when there is nonclient area, or Windows
1724 // exhibits bugs where client pixels and child HWNDs are mispositioned by
1725 // the width/height of the upper-left nonclient area.
1727 }
1729 // If the window bounds change, we're going to relayout and repaint anyway.
1730 // Returning WVR_REDRAW avoids an extra paint before that of the old client
1731 // pixels in the (now wrong) location, and thus makes actions like resizing a
1732 // window from the left edge look slightly less broken.
1733 // We special case when left or top insets are 0, since these conditions
1734 // actually require another repaint to correct the layout after glass gets
1735 // turned on and off.
1739 }
1745 }
1747 // If the DWM is rendering the window controls, we need to give the DWM's
1748 // default window procedure first chance to handle hit testing.
1750 LRESULT result;
1754 }
1755 }
1757 // First, give the NonClientView a chance to test the point to see if it
1758 // provides any of the non-client area.
1765 // Otherwise, we let Windows do all the native frame non-client handling for
1766 // us.
1771 // If we faked the WS_VSCROLL and WS_HSCROLL styles for this window, then
1772 // Windows returns the HTVSCROLL or HTHSCROLL hit test codes if we hover
1773 // or click on the non client portions of the window where the OS
1774 // scrollbars would be drawn. These hittest codes are returned even when
1775 // the scrollbars are hidden, which is the case in Aura. We fake the
1776 // hittest code as HTCLIENT in this case to ensure that we receive client
1777 // mouse messages as opposed to non client mouse messages.
1784 // Normally the HTBOTTOMRIGHT hittest code is received when we hover
1785 // near the bottom right of the window. However due to our fake scroll
1786 // styles, we get this code even when we hover around the area where
1787 // the vertical scrollar down arrow would be drawn.
1788 // We check if the hittest coordinates lie in this region and if yes
1789 // we return HTCLIENT.
1794 RECT window_rect;
1800 POINT pt;
1806 }
1810 }
1811 }
1813 }
1816 // We only do non-client painting if we're not using the native frame.
1817 // It's required to avoid some native painting artifacts from appearing when
1818 // the window is resized.
1822 }
1824 // We have an NC region and need to paint it. We expand the NC region to
1825 // include the dirty region of the root view. This is done to minimize
1826 // paints.
1827 RECT window_rect;
1833 // If the size of the window differs from the size of the root view it
1834 // means we're being asked to paint before we've gotten a WM_SIZE. This can
1835 // happen when the user is interactively resizing the window. To avoid
1836 // mass flickering we don't do anything here. Once we get the WM_SIZE we'll
1837 // reset the region of the window which triggers another WM_NCPAINT and
1838 // all is well.
1840 }
1842 RECT dirty_region;
1843 // A value of 1 indicates paint all.
1850 RECT rgn_bounding_box;
1855 // rgn_bounding_box is in screen coordinates. Map it to window coordinates.
1857 }
1859 // In theory GetDCEx should do what we want, but I couldn't get it to work.
1860 // In particular the docs mentiond DCX_CLIPCHILDREN, but as far as I can tell
1861 // it doesn't work at all. So, instead we get the DC for the window then
1862 // manually clip out the children.
1864 ClipState clip_state;
1874 // The root view has a region that needs to be painted. Include it in the
1875 // region we're going to paint.
1880 }
1884 // gfx::CanvasSkiaPaint's destructor does the actual painting. As such, wrap
1885 // the following in a block to force paint to occur so that we can release
1886 // the dc.
1895 }
1898 // When using a custom frame, we want to avoid calling DefWindowProc() since
1899 // that may render artifacts.
1901 }
1904 WPARAM w_param,
1905 LPARAM l_param) {
1906 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
1907 // an explanation about why we need to handle this message.
1910 }
1913 WPARAM w_param,
1914 LPARAM l_param) {
1915 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
1916 // an explanation about why we need to handle this message.
1919 }
1925 }
1928 // Call BeginPaint()/EndPaint() around the paint handling, as that seems
1929 // to do more to actually validate the window's drawing region. This only
1930 // appears to matter for Windows that have the WS_EX_COMPOSITED style set
1931 // but will be valid in general too.
1932 PAINTSTRUCT ps;
1936 // Try to paint accelerated first.
1940 }
1943 }
1946 WPARAM w_param,
1947 LPARAM l_param) {
1950 }
1953 WPARAM w_param,
1954 LPARAM l_param) {
1959 }
1962 PWTSSESSION_NOTIFICATION session_id) {
1963 // Direct3D presents are ignored while the screen is locked, so force the
1964 // window to be redrawn on unlock.
1969 }
1972 WPARAM w_param,
1973 LPARAM l_param) {
1974 // Reimplement the necessary default behavior here. Calling DefWindowProc can
1975 // trigger weird non-client painting for non-glass windows with custom frames.
1976 // Using a ScopedRedrawLock to prevent caption rendering artifacts may allow
1977 // content behind this window to incorrectly paint in front of this window.
1978 // Invalidating the window to paint over either set of artifacts is not ideal.
2007 // Use the default value, IDC_ARROW.
2009 }
2012 }
2017 }
2020 // Use a ScopedRedrawLock to avoid weird non-client painting.
2023 }
2026 // Use a ScopedRedrawLock to avoid weird non-client painting.
2029 }
2034 // Fire a dummy SetWindowPos() call, so we'll trip the code in
2035 // OnWindowPosChanging() below that notices work area changes.
2043 }
2044 }
2048 // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
2049 // invoked OnSize we ensure the RootView has been laid out.
2052 // We add the WS_VSCROLL and WS_HSCROLL styles to top level windows to ensure
2053 // that legacy trackpad/trackpoint drivers generate the WM_VSCROLL and
2054 // WM_HSCROLL messages and scrolling works.
2055 // We want the scroll styles to be present on the window. However we don't
2056 // want Windows to draw the scrollbars. To achieve this we hide the scroll
2057 // bars and readd them to the window style in a posted task to ensure that we
2058 // don't get nested WM_SIZE messages.
2063 }
2064 }
2071 // Windows uses the 4 lower order bits of |notification_code| for type-
2072 // specific information so we must exclude this when comparing.
2074 // Ignore size/move/maximize in fullscreen mode.
2088 // Circumvent ScopedRedrawLocks and force visibility before entering a
2089 // resize or move modal loop to get continuous sizing/moving feedback.
2092 }
2093 }
2094 }
2096 // Handle SC_KEYMENU, which means that the user has pressed the ALT
2097 // key and released it, so we should focus the menu bar.
2104 // Retrieve the status of shift and control keys to prevent consuming
2105 // shift+alt keys, which are used by Windows to change input languages.
2107 modifiers);
2110 }
2112 // If the delegate can't handle it, the system implementation will be called.
2114 // If the window is being resized by dragging the borders of the window
2115 // with the mouse/touch/keyboard, we flag as being in a size loop.
2124 }
2125 }
2129 }
2132 WPARAM w_param,
2133 LPARAM l_param) {
2134 // Handle touch events only on Aura for now.
2141 TouchEvents touch_events;
2143 POINT point;
2148 // Windows 7 sends touch events for touches in the non-client area,
2149 // whereas Windows 8 does not. In order to unify the behaviour, always
2150 // ignore touch events in the non-client area.
2156 }
2167 touch_down_contexts_++;
2169 FROM_HERE,
2178 }
2181 // input[i].dwTime doesn't necessarily relate to the system time at all,
2182 // so use base::TimeTicks::HighResNow() if possible, or
2183 // base::TimeTicks::Now() otherwise.
2186 else
2204 }
2205 }
2206 // Handle the touch events asynchronously. We need this because touch
2207 // events on windows don't fire if we enter a modal loop in the context of
2208 // a touch event.
2210 FROM_HERE,
2213 }
2217 }
2221 // If somebody's trying to toggle our visibility, change the nonclient area,
2222 // change our Z-order, or activate us, we should probably let it go through.
2224 SWP_FRAMECHANGED)) &&
2226 // Just sizing/moving the window; ignore.
2229 }
2231 RECT window_rect;
2232 HMONITOR monitor;
2241 work_area_changed)) {
2242 // A rect for the monitor we're on changed. Normally Windows notifies
2243 // us about this (and thus we're reaching here due to the SetWindowPos()
2244 // call in OnSettingChange() above), but with some software (e.g.
2245 // nVidia's nView desktop manager) the work area can change asynchronous
2246 // to any notification, and we're just sent a SetWindowPos() call with a
2247 // new (frequently incorrect) position/size. In either case, the best
2248 // response is to throw away the existing position/size information in
2249 // |window_pos| and recalculate it based on the new work rect.
2260 }
2265 // WARNING! Don't set SWP_FRAMECHANGED here, it breaks moving the child
2266 // HWNDs for some reason.
2270 // Now ignore all immediately-following SetWindowPos() changes. Windows
2271 // likes to (incorrectly) recalculate what our position/size should be
2272 // and send us further updates.
2275 FROM_HERE,
2278 }
2282 }
2283 }
2289 // Prevent the window from being made visible if we've been asked to do so.
2290 // See comment in header as to why we might want this.
2292 }
2300 }
2310 }
2316 }
2322 }
2325 touch_down_contexts_--;
2326 }
2329 WPARAM w_param,
2330 LPARAM l_param,
2334 // We handle touch events on Windows Aura. Windows generates synthesized
2335 // mouse messages in response to touch which we should ignore. However touch
2336 // messages are only received for the client area. We need to ignore the
2337 // synthesized mouse messages for all points in the client area and places
2338 // which return HTNOWHERE.
2341 // For mouse events (except wheel events), location is in window coordinates
2342 // and should be converted to screen coordinates for WM_NCHITTEST.
2347 }
2351 }
2353 // Certain logitech drivers send the WM_MOUSEHWHEEL message to the parent
2354 // followed by WM_MOUSEWHEEL messages to the child window causing a vertical
2355 // scroll. We treat these WM_MOUSEWHEEL messages as WM_MOUSEHWHEEL
2356 // messages.
2363 }
2368 // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu()
2369 // expect screen coordinates.
2377 }
2383 // When the mouse is pressed down in these specific non-client areas,
2384 // we need to tell the RootView to send the mouse pressed event (which
2385 // sets capture, allowing subsequent WM_LBUTTONUP (note, _not_
2386 // WM_NCLBUTTONUP) to fire so that the appropriate WM_SYSCOMMAND can be
2387 // sent by the applicable button's ButtonListener. We _have_ to do this
2388 // way rather than letting Windows just send the syscommand itself (as
2389 // would happen if we never did this dance) because for some insane
2390 // reason DefWindowProc for WM_NCLBUTTONDOWN also renders the pressed
2391 // window control button appearance, in the Windows classic style, over
2392 // our view! Ick! By handling this message we prevent Windows from
2393 // doing this undesirable thing, but that means we need to roll the
2394 // sys-command handling ourselves.
2395 // Combine |w_param| with common key state message flags.
2398 }
2399 }
2403 // We SetCapture() to ensure we only show the menu when the button
2404 // down and up are both on the caption. Note: this causes the button up to
2405 // be WM_RBUTTONUP instead of WM_NCRBUTTONUP.
2407 }
2416 // Windows only fires WM_MOUSELEAVE events if the application begins
2417 // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events.
2418 // We need to call |TrackMouseEvents| to listen for WM_MOUSELEAVE.
2422 // Reset our tracking flags so future mouse movement over this
2423 // NativeWidget results in a new tracking session. Fall through for
2424 // OnMouseEvent.
2427 // Reroute the mouse wheel to the window under the pointer if applicable.
2430 }
2432 // There are cases where the code handling the message destroys the window,
2433 // so use the weak ptr to check if destruction occured or not.
2440 // TODO(msw): Eliminate undesired painting, or re-evaluate this workaround.
2441 // DefWindowProc for WM_NCLBUTTONDOWN does weird non-client painting, so we
2442 // need to call it inside a ScopedRedrawLock. This may cause other negative
2443 // side-effects (ex/ stifling non-client mouse releases).
2446 }
2451 }
2455 LPARAM l_param) {
2458 // Ignore mouse messages which occur at the same location as the current
2459 // cursor position and within a time difference of 500 ms from the last
2460 // touch message.
2463 kSynthesizedMouseTouchMessagesTimeDifference)) {
2471 }
2473 }
2479 // Don't redraw the window here, because we need to hide and show the window
2480 // which will also trigger a redraw.
2482 // The non-client view needs to update too.
2486 // For some reason, we need to hide the window after we change from a custom
2487 // frame to a native frame. If we don't, the client area will be filled
2488 // with black. This seems to be related to an interaction between DWM and
2489 // SetWindowRgn, but the details aren't clear. Additionally, we need to
2490 // specify SWP_NOZORDER here, otherwise if you have multiple chrome windows
2491 // open they will re-appear with a non-deterministic Z-order.
2495 }
2496 // WM_DWMCOMPOSITIONCHANGED is only sent to top level windows, however we want
2497 // to notify our children too, since we can have MDI child windows who need to
2498 // update their appearance.
2500 }