| blob | f9ab527b33b4448e05c2d066586a5877254d4622 |
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>
48 // MoveLoopMouseWatcher is used to determine if the user canceled or completed a
49 // move. win32 doesn't appear to offer a way to determine the result of a move,
50 // so we install hooks to determine if we got a mouse up and assume the move
51 // completed.
57 // Returns true if the mouse is up, or if we couldn't install the hook.
61 // Instance that owns the hook. We only allow one instance to hook the mouse
62 // at a time.
65 // Key and mouse callbacks from the hook.
71 // HWNDMessageHandler that created us.
74 // Should the window be hidden when escape is pressed?
77 // Did we get a mouse up?
80 // Hook identifiers.
81 HHOOK mouse_hook_;
82 HHOOK key_hook_;
85 };
87 // static
97 // Only one instance can be active at a time.
105 // We don't care if setting the key hook succeeded.
108 }
110 // Failed installation. Assume we got a mouse up in this case, otherwise
111 // we'll think all drags were canceled.
113 }
114 }
118 }
131 }
133 // static
135 WPARAM w_param,
136 LPARAM l_param) {
141 }
143 // static
145 WPARAM w_param,
146 LPARAM l_param) {
152 DWMWA_TRANSITIONS_FORCEDISABLED,
155 }
158 }
160 }
162 // Called from OnNCActivate.
164 DWORD process_id;
171 }
189 }
192 HWND window;
194 };
196 // Enables or disables the menu item for the specified command and menu.
200 }
202 // Callback used to notify child windows that the top level window received a
203 // DWMCompositionChanged message.
207 }
209 // See comments in OnNCPaint() for details of this struct.
211 // The window being painted.
212 HWND parent;
214 // DC painting to.
215 HDC dc;
217 // Origin of the window in terms of the screen.
220 };
222 // See comments in OnNCPaint() for details of this function.
226 RECT bounds;
233 }
235 }
237 // The thickness of an auto-hide taskbar in pixels.
246 }
253 }
254 }
258 // Windows does not flag synthesized mouse messages from touch in all cases.
259 // This causes us grief as we don't want to process touch and mouse messages
260 // concurrently. Hack as per msdn is to check if the time difference between
261 // the touch message and the mouse move is within 500 ms and at the same
262 // location as the cursor.
267 // A scoping class that prevents a window from being able to redraw in response
268 // to invalidations that may occur within it for the lifetime of the object.
269 //
270 // Why would we want such a thing? Well, it turns out Windows has some
271 // "unorthodox" behavior when it comes to painting its non-client areas.
272 // Occasionally, Windows will paint portions of the default non-client area
273 // right over the top of the custom frame. This is not simply fixed by handling
274 // WM_NCPAINT/WM_PAINT, with some investigation it turns out that this
275 // rendering is being done *inside* the default implementation of some message
276 // handlers and functions:
277 // . WM_SETTEXT
278 // . WM_SETICON
279 // . WM_NCLBUTTONDOWN
280 // . EnableMenuItem, called from our WM_INITMENU handler
281 // The solution is to handle these messages and call DefWindowProc ourselves,
282 // but prevent the window from being able to update itself for the duration of
283 // the call. We do this with this class, which automatically calls its
284 // associated Window's lock and unlock functions as it is created and destroyed.
285 // See documentation in those methods for the technique used.
286 //
287 // The lock only has an effect if the window was visible upon lock creation, as
288 // it doesn't guard against direct visiblility changes, and multiple locks may
289 // exist simultaneously to handle certain nested Windows messages.
290 //
291 // IMPORTANT: Do not use this scoping object for large scopes or periods of
292 // time! IT WILL PREVENT THE WINDOW FROM BEING REDRAWN! (duh).
293 //
294 // I would love to hear Raymond Chen's explanation for all this. And maybe a
295 // list of other messages that this applies to ;-)
306 }
311 }
313 // Cancel the unlock operation, call this if the Widget is being destroyed.
317 // The owner having its style changed.
319 // The owner's HWND, cached to avoid action after window destruction.
320 HWND hwnd_;
321 // Records the HWND visibility at the time of creation.
323 // A flag indicating that the unlock operation was canceled.
325 // If true, perform the redraw lock regardless of Aero state.
329 };
331 ////////////////////////////////////////////////////////////////////////////////
332 // 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 }
797 // Called when the frame type could possibly be changing (theme change or
798 // DWM composition change).
801 // Don't redraw the window here, because we need to hide and show the window
802 // which will also trigger a redraw.
805 // The non-client view needs to update too.
809 // For some reason, we need to hide the window after we change from a custom
810 // frame to a native frame. If we don't, the client area will be filled
811 // with black. This seems to be related to an interaction between DWM and
812 // SetWindowRgn, but the details aren't clear. Additionally, we need to
813 // specify SWP_NOZORDER here, otherwise if you have multiple chrome windows
814 // open they will re-appear with a non-deterministic Z-order.
818 // Invalidate the window to force a paint. There may be child windows which
819 // could resize in this context. Don't paint right away.
821 }
823 // WM_DWMCOMPOSITIONCHANGED is only sent to top level windows, however we want
824 // to notify our children too, since we can have MDI child windows who need to
825 // update their appearance.
827 }
831 // We must update the back-buffer immediately, since Windows' handling of
832 // invalid rects is somewhat mysterious.
835 // In some situations, such as drag and drop, when Windows itself runs a
836 // nested message loop our message loop appears to be starved and we don't
837 // receive calls to DidProcessMessage(). This only seems to affect layered
838 // windows, so we schedule a redraw manually using a task, since those never
839 // seem to be starved. Also, wtf.
843 FROM_HERE,
846 }
848 // InvalidateRect() expects client coordinates.
851 }
852 }
856 }
863 // We need to make sure to destroy the previous icon, otherwise we'll leak
864 // these GDI objects until we crash!
870 }
878 }
879 }
881 ////////////////////////////////////////////////////////////////////////////////
882 // HWNDMessageHandler, InputMethodDelegate implementation:
886 }
888 ////////////////////////////////////////////////////////////////////////////////
889 // HWNDMessageHandler, gfx::WindowImpl overrides:
896 }
899 WPARAM w_param,
900 LPARAM l_param) {
907 // Otherwise we handle everything else.
908 // NOTE: We inline ProcessWindowMessage() as 'this' may be destroyed during
909 // dispatch and ProcessWindowMessage() doesn't deal with that well.
921 // DefWindowProc() may have destroyed the window in a nested message loop.
929 }
934 }
937 WPARAM w_param,
938 LPARAM l_param) {
939 // Don't track forwarded mouse messages. We expect the caller to track the
940 // mouse.
942 }
945 WPARAM w_param,
946 LPARAM l_param) {
948 }
951 WPARAM w_param,
952 LPARAM l_param) {
954 }
957 WPARAM w_param,
958 LPARAM l_param) {
960 }
963 WPARAM w_param,
964 LPARAM l_param) {
967 }
969 ////////////////////////////////////////////////////////////////////////////////
970 // HWNDMessageHandler, private:
976 monitor,
980 }
983 // This triggers querying WM_NCCALCSIZE again.
984 RECT client;
988 SWP_FRAMECHANGED);
989 }
994 // The window does not get keyboard messages unless we focus it.
996 }
997 }
1005 }
1010 // If we were run modally, we need to undo the disabled-ness we inflicted on
1011 // the owner's parent hierarchy.
1016 }
1017 }
1018 }
1023 }
1026 // Begin tracking mouse events for this HWND so that we get WM_MOUSELEAVE
1027 // when the user moves the mouse outside this HWND's bounds.
1030 // We're about to cancel active mouse tracking, so empty out the stored
1031 // state.
1035 }
1037 TRACKMOUSEEVENT tme;
1046 }
1047 }
1054 }
1061 // Returning false causes the default handling in OnNCCalcSize() to
1062 // be invoked.
1066 }
1069 // Windows automatically adds a standard width border to all sides when a
1070 // window is maximized.
1078 }
1082 }
1085 // A native frame uses the native window region, and we don't want to mess
1086 // with it.
1087 // WS_EX_COMPOSITED is used instead of WS_EX_LAYERED under aura. WS_EX_LAYERED
1088 // automatically makes clicks on transparent pixels fall through, that isn't
1089 // the case with WS_EX_COMPOSITED. So, we route WS_EX_COMPOSITED through to
1090 // the delegate to allow for a custom hit mask.
1096 }
1098 // Changing the window region is going to force a paint. Only change the
1099 // window region if the region really differs.
1103 RECT window_rect;
1105 HRGN new_region;
1111 MONITORINFO mi;
1123 }
1126 // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
1130 }
1133 }
1139 DWMNCRENDERINGPOLICY policy =
1145 }
1148 WPARAM w_param,
1149 LPARAM l_param) {
1151 // The Widget and HWND can be destroyed in the call to DefWindowProc, so use
1152 // the WeakPtrFactory to avoid unlocking (and crashing) after destruction.
1158 }
1161 // We skip locked updates when Aero is on for two reasons:
1162 // 1. Because it isn't necessary
1163 // 2. Because toggling the WS_VISIBLE flag may occur while the GPU process is
1164 // attempting to present a child window's backbuffer onscreen. When these
1165 // two actions race with one another, the child window will either flicker
1166 // or will simply stop updating entirely.
1170 }
1171 }
1178 }
1179 }
1186 // We need to clip to the dirty rect ourselves.
1197 RECT wr;
1208 }
1212 // Presents will continue to fail as long as the input desktop is
1213 // unavailable.
1217 FROM_HERE,
1220 attempts),
1223 }
1225 }
1227 // Message handlers ------------------------------------------------------------
1233 // Also update the native frame if it is rendering the non-client area.
1236 }
1237 }
1241 WORD device,
1245 // Make sure to return TRUE if the event was handled or in some cases the
1246 // system will execute the default handler which can cause bugs like going
1247 // forward or back two pages instead of one.
1249 }
1253 // Need default handling, otherwise capture and other things aren't canceled.
1255 }
1259 }
1263 }
1267 HWND window) {
1268 // If the notification code is > 1 it means it is control specific and we
1269 // should ignore it.
1272 }
1279 // This is part of the magic to emulate layered windows with Aura
1280 // see the explanation elsewere when we set WS_EX_COMPOSITED style.
1283 }
1284 }
1288 // This message initializes the window so that focus border are shown for
1289 // windows.
1291 WM_CHANGEUISTATE,
1299 }
1301 // Get access to a modifiable copy of the system menu.
1308 // We need to allow the delegate to size its contents since the window may not
1309 // receive a size notification when its initial bounds are specified at window
1310 // creation time.
1317 // TODO(beng): move more of NWW::OnCreate here.
1319 }
1324 }
1329 }
1332 WPARAM w_param,
1333 LPARAM l_param) {
1337 }
1341 }
1346 }
1349 // Please refer to the comments in the OnSize function about the scrollbar
1350 // hack.
1351 // Hide the Windows scrollbar if the scroll styles are present to ensure
1352 // that a paint flicker does not occur while sizing.
1358 }
1361 // Needed to prevent resize flicker.
1363 }
1369 }
1374 // Please refer to the notes in the OnSize function for information about
1375 // the scrolling hack.
1376 // We hide the Windows scrollbar in the OnEnterSizeMove function. We need
1377 // to add the scroll styles back to ensure that scrolling works in legacy
1378 // trackpoint drivers.
1381 }
1388 // Add the native frame border size to the minimum and maximum size if the
1389 // view reports its size as the client size.
1400 }
1401 }
1411 }
1413 }
1416 WPARAM w_param,
1417 LPARAM l_param) {
1420 // Accessibility readers will send an OBJID_CLIENT message
1422 // Retrieve MSAA dispatch object for the root view.
1426 // Create a reference that MSAA will marshall to the client.
1429 }
1432 }
1435 WPARAM w_param,
1436 LPARAM l_param) {
1441 }
1456 // TODO: unfortunately, WidgetDelegate does not declare CanMinimize() and some
1457 // code depends on this check, see http://crbug.com/341010.
1465 }
1468 HKL input_language_id) {
1470 }
1473 WPARAM w_param,
1474 LPARAM l_param) {
1480 }
1485 }
1488 WPARAM w_param,
1489 LPARAM l_param) {
1490 // Please refer to the comments in the header for the touch_down_contexts_
1491 // member for the if statement below.
1495 // On Windows, if we select the menu item by touch and if the window at the
1496 // location is another window on the same thread, that window gets a
1497 // WM_MOUSEACTIVATE message and ends up activating itself, which is not
1498 // correct. We workaround this by setting a property on the window at the
1499 // current cursor location. We check for this property in our
1500 // WM_MOUSEACTIVATE handler and don't activate the window if the property is
1501 // set.
1505 }
1506 // A child window activation should be treated as if we lost activation.
1514 // TODO(beng): resolve this with the GetWindowLong() check on the subsequent
1515 // line.
1522 }
1525 WPARAM w_param,
1526 LPARAM l_param) {
1528 }
1533 }
1537 }
1540 WPARAM w_param,
1541 LPARAM l_param) {
1542 // Per MSDN, w_param is either TRUE or FALSE. However, MSDN also hints that:
1543 // "If the window is minimized when this message is received, the application
1544 // should pass the message to the DefWindowProc function."
1545 // It is found out that the high word of w_param might be set when the window
1546 // is minimized or restored. To handle this, w_param's high word should be
1547 // cleared before it is converted to BOOL.
1555 }
1560 // On activation, lift any prior restriction against rendering as inactive.
1565 // TODO(beng, et al): Hack to redraw this window and child windows
1566 // synchronously upon activation. Not all child windows are redrawing
1567 // themselves leading to issues like http://crbug.com/74604
1568 // We redraw out-of-process HWNDs asynchronously to avoid hanging the
1569 // whole app if a child HWND belonging to a hung plugin is encountered.
1573 }
1575 // The frame may need to redraw as a result of the activation change.
1576 // We can get WM_NCACTIVATE before we're actually visible. If we're not
1577 // visible, no need to paint.
1581 // Avoid DefWindowProc non-client rendering over our custom frame on newer
1582 // Windows versions only (breaks taskbar activation indication on XP/Vista).
1587 }
1591 }
1594 // We only override the default handling if we need to specify a custom
1595 // non-client edge width. Note that in most cases "no insets" means no
1596 // custom width, but in fullscreen mode or when the NonClientFrameView
1597 // requests it, we want a custom width of 0.
1599 // Let User32 handle the first nccalcsize for captioned windows
1600 // so it updates its internal structures (specifically caption-present)
1601 // Without this Tile & Cascade windows won't work.
1602 // See http://code.google.com/p/chromium/issues/detail?id=900
1608 }
1609 }
1617 }
1627 // Find all auto-hide taskbars along the screen edges and adjust in by the
1628 // thickness of the auto-hide taskbar on each such edge, so the window isn't
1629 // treated as a "fullscreen app", which would cause the taskbars to
1630 // disappear.
1633 // We might end up here if the window was previously minimized and the
1634 // user clicks on the taskbar button to restore it in the previously
1635 // maximized position. In that case WM_NCCALCSIZE is sent before the
1636 // window coordinates are restored to their previous values, so our
1637 // (left,top) would probably be (-32000,-32000) like all minimized
1638 // windows. So the above MonitorFromWindow call fails, but if we check
1639 // the window rect given with WM_NCCALCSIZE (which is our previous
1640 // restored window position) we will get the correct monitor handle.
1643 // This is probably an extreme case that we won't hit, but if we don't
1644 // intersect any monitor, let us not adjust the client rect since our
1645 // window will not be visible anyway.
1647 }
1648 }
1654 // Tricky bit. Due to a bug in DwmDefWindowProc()'s handling of
1655 // WM_NCHITTEST, having any nonclient area atop the window causes the
1656 // caption buttons to draw onscreen but not respond to mouse
1657 // hover/clicks.
1658 // So for a taskbar at the screen top, we can't push the
1659 // client_rect->top down; instead, we move the bottom up by one pixel,
1660 // which is the smallest change we can make and still get a client area
1661 // less than the screen size. This is visibly ugly, but there seems to
1662 // be no better solution.
1666 }
1667 }
1673 // We cannot return WVR_REDRAW when there is nonclient area, or Windows
1674 // exhibits bugs where client pixels and child HWNDs are mispositioned by
1675 // the width/height of the upper-left nonclient area.
1677 }
1679 // If the window bounds change, we're going to relayout and repaint anyway.
1680 // Returning WVR_REDRAW avoids an extra paint before that of the old client
1681 // pixels in the (now wrong) location, and thus makes actions like resizing a
1682 // window from the left edge look slightly less broken.
1683 // We special case when left or top insets are 0, since these conditions
1684 // actually require another repaint to correct the layout after glass gets
1685 // turned on and off.
1689 }
1695 }
1697 // If the DWM is rendering the window controls, we need to give the DWM's
1698 // default window procedure first chance to handle hit testing.
1700 LRESULT result;
1704 }
1705 }
1707 // First, give the NonClientView a chance to test the point to see if it
1708 // provides any of the non-client area.
1715 // Otherwise, we let Windows do all the native frame non-client handling for
1716 // us.
1721 // If we faked the WS_VSCROLL and WS_HSCROLL styles for this window, then
1722 // Windows returns the HTVSCROLL or HTHSCROLL hit test codes if we hover
1723 // or click on the non client portions of the window where the OS
1724 // scrollbars would be drawn. These hittest codes are returned even when
1725 // the scrollbars are hidden, which is the case in Aura. We fake the
1726 // hittest code as HTCLIENT in this case to ensure that we receive client
1727 // mouse messages as opposed to non client mouse messages.
1734 // Normally the HTBOTTOMRIGHT hittest code is received when we hover
1735 // near the bottom right of the window. However due to our fake scroll
1736 // styles, we get this code even when we hover around the area where
1737 // the vertical scrollar down arrow would be drawn.
1738 // We check if the hittest coordinates lie in this region and if yes
1739 // we return HTCLIENT.
1746 RECT window_rect;
1752 POINT pt;
1758 }
1762 }
1763 }
1765 }
1768 // We only do non-client painting if we're not using the native frame.
1769 // It's required to avoid some native painting artifacts from appearing when
1770 // the window is resized.
1774 }
1776 // We have an NC region and need to paint it. We expand the NC region to
1777 // include the dirty region of the root view. This is done to minimize
1778 // paints.
1779 RECT window_rect;
1785 // If the size of the window differs from the size of the root view it
1786 // means we're being asked to paint before we've gotten a WM_SIZE. This can
1787 // happen when the user is interactively resizing the window. To avoid
1788 // mass flickering we don't do anything here. Once we get the WM_SIZE we'll
1789 // reset the region of the window which triggers another WM_NCPAINT and
1790 // all is well.
1792 }
1794 RECT dirty_region;
1795 // A value of 1 indicates paint all.
1802 RECT rgn_bounding_box;
1807 // rgn_bounding_box is in screen coordinates. Map it to window coordinates.
1809 }
1811 // In theory GetDCEx should do what we want, but I couldn't get it to work.
1812 // In particular the docs mentiond DCX_CLIPCHILDREN, but as far as I can tell
1813 // it doesn't work at all. So, instead we get the DC for the window then
1814 // manually clip out the children.
1816 ClipState clip_state;
1826 // The root view has a region that needs to be painted. Include it in the
1827 // region we're going to paint.
1832 }
1836 // gfx::CanvasSkiaPaint's destructor does the actual painting. As such, wrap
1837 // the following in a block to force paint to occur so that we can release
1838 // the dc.
1847 }
1850 // When using a custom frame, we want to avoid calling DefWindowProc() since
1851 // that may render artifacts.
1853 }
1856 WPARAM w_param,
1857 LPARAM l_param) {
1858 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
1859 // an explanation about why we need to handle this message.
1862 }
1865 WPARAM w_param,
1866 LPARAM l_param) {
1867 // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
1868 // an explanation about why we need to handle this message.
1871 }
1877 }
1880 // Call BeginPaint()/EndPaint() around the paint handling, as that seems
1881 // to do more to actually validate the window's drawing region. This only
1882 // appears to matter for Windows that have the WS_EX_COMPOSITED style set
1883 // but will be valid in general too.
1884 PAINTSTRUCT ps;
1888 // Try to paint accelerated first.
1892 }
1895 }
1898 WPARAM w_param,
1899 LPARAM l_param) {
1902 }
1905 WPARAM w_param,
1906 LPARAM l_param) {
1911 }
1914 PWTSSESSION_NOTIFICATION session_id) {
1915 // Direct3D presents are ignored while the screen is locked, so force the
1916 // window to be redrawn on unlock.
1921 }
1924 WPARAM w_param,
1925 LPARAM l_param) {
1926 // Reimplement the necessary default behavior here. Calling DefWindowProc can
1927 // trigger weird non-client painting for non-glass windows with custom frames.
1928 // Using a ScopedRedrawLock to prevent caption rendering artifacts may allow
1929 // content behind this window to incorrectly paint in front of this window.
1930 // Invalidating the window to paint over either set of artifacts is not ideal.
1959 // Use the default value, IDC_ARROW.
1961 }
1964 }
1969 }
1972 // Use a ScopedRedrawLock to avoid weird non-client painting.
1975 }
1978 // Use a ScopedRedrawLock to avoid weird non-client painting.
1981 }
1986 // Fire a dummy SetWindowPos() call, so we'll trip the code in
1987 // OnWindowPosChanging() below that notices work area changes.
1995 }
1996 }
2000 // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
2001 // invoked OnSize we ensure the RootView has been laid out.
2004 // We add the WS_VSCROLL and WS_HSCROLL styles to top level windows to ensure
2005 // that legacy trackpad/trackpoint drivers generate the WM_VSCROLL and
2006 // WM_HSCROLL messages and scrolling works.
2007 // We want the scroll styles to be present on the window. However we don't
2008 // want Windows to draw the scrollbars. To achieve this we hide the scroll
2009 // bars and readd them to the window style in a posted task to ensure that we
2010 // don't get nested WM_SIZE messages.
2015 }
2016 }
2023 // Windows uses the 4 lower order bits of |notification_code| for type-
2024 // specific information so we must exclude this when comparing.
2026 // Ignore size/move/maximize in fullscreen mode.
2040 // Circumvent ScopedRedrawLocks and force visibility before entering a
2041 // resize or move modal loop to get continuous sizing/moving feedback.
2044 }
2045 }
2046 }
2048 // Handle SC_KEYMENU, which means that the user has pressed the ALT
2049 // key and released it, so we should focus the menu bar.
2056 // Retrieve the status of shift and control keys to prevent consuming
2057 // shift+alt keys, which are used by Windows to change input languages.
2059 modifiers);
2062 }
2064 // If the delegate can't handle it, the system implementation will be called.
2066 // If the window is being resized by dragging the borders of the window
2067 // with the mouse/touch/keyboard, we flag as being in a size loop.
2076 }
2077 }
2081 }
2084 WPARAM w_param,
2085 LPARAM l_param) {
2086 // Handle touch events only on Aura for now.
2093 TouchEvents touch_events;
2095 POINT point;
2102 // Windows 7 sends touch events for touches in the non-client area,
2103 // whereas Windows 8 does not. In order to unify the behaviour, always
2104 // ignore touch events in the non-client area.
2110 }
2121 touch_down_contexts_++;
2123 FROM_HERE,
2132 }
2135 // input[i].dwTime doesn't necessarily relate to the system time at all,
2136 // so use base::TimeTicks::HighResNow() if possible, or
2137 // base::TimeTicks::Now() otherwise.
2140 else
2158 }
2159 }
2160 // Handle the touch events asynchronously. We need this because touch
2161 // events on windows don't fire if we enter a modal loop in the context of
2162 // a touch event.
2164 FROM_HERE,
2167 }
2171 }
2175 // If somebody's trying to toggle our visibility, change the nonclient area,
2176 // change our Z-order, or activate us, we should probably let it go through.
2178 SWP_FRAMECHANGED)) &&
2180 // Just sizing/moving the window; ignore.
2183 }
2185 RECT window_rect;
2186 HMONITOR monitor;
2195 work_area_changed)) {
2196 // A rect for the monitor we're on changed. Normally Windows notifies
2197 // us about this (and thus we're reaching here due to the SetWindowPos()
2198 // call in OnSettingChange() above), but with some software (e.g.
2199 // nVidia's nView desktop manager) the work area can change asynchronous
2200 // to any notification, and we're just sent a SetWindowPos() call with a
2201 // new (frequently incorrect) position/size. In either case, the best
2202 // response is to throw away the existing position/size information in
2203 // |window_pos| and recalculate it based on the new work rect.
2215 }
2220 // WARNING! Don't set SWP_FRAMECHANGED here, it breaks moving the child
2221 // HWNDs for some reason.
2225 // Now ignore all immediately-following SetWindowPos() changes. Windows
2226 // likes to (incorrectly) recalculate what our position/size should be
2227 // and send us further updates.
2230 FROM_HERE,
2233 }
2237 }
2238 }
2244 // Prevent the window from being made visible if we've been asked to do so.
2245 // See comment in header as to why we might want this.
2247 }
2255 }
2265 }
2271 }
2277 }
2280 touch_down_contexts_--;
2281 }
2284 WPARAM w_param,
2285 LPARAM l_param,
2289 // We handle touch events on Windows Aura. Windows generates synthesized
2290 // mouse messages in response to touch which we should ignore. However touch
2291 // messages are only received for the client area. We need to ignore the
2292 // synthesized mouse messages for all points in the client area and places
2293 // which return HTNOWHERE.
2296 // For mouse events (except wheel events), location is in window coordinates
2297 // and should be converted to screen coordinates for WM_NCHITTEST.
2302 }
2306 }
2308 // Certain logitech drivers send the WM_MOUSEHWHEEL message to the parent
2309 // followed by WM_MOUSEWHEEL messages to the child window causing a vertical
2310 // scroll. We treat these WM_MOUSEWHEEL messages as WM_MOUSEHWHEEL
2311 // messages.
2318 }
2323 // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu()
2324 // expect screen coordinates.
2332 }
2338 // When the mouse is pressed down in these specific non-client areas,
2339 // we need to tell the RootView to send the mouse pressed event (which
2340 // sets capture, allowing subsequent WM_LBUTTONUP (note, _not_
2341 // WM_NCLBUTTONUP) to fire so that the appropriate WM_SYSCOMMAND can be
2342 // sent by the applicable button's ButtonListener. We _have_ to do this
2343 // way rather than letting Windows just send the syscommand itself (as
2344 // would happen if we never did this dance) because for some insane
2345 // reason DefWindowProc for WM_NCLBUTTONDOWN also renders the pressed
2346 // window control button appearance, in the Windows classic style, over
2347 // our view! Ick! By handling this message we prevent Windows from
2348 // doing this undesirable thing, but that means we need to roll the
2349 // sys-command handling ourselves.
2350 // Combine |w_param| with common key state message flags.
2353 }
2354 }
2358 // We SetCapture() to ensure we only show the menu when the button
2359 // down and up are both on the caption. Note: this causes the button up to
2360 // be WM_RBUTTONUP instead of WM_NCRBUTTONUP.
2362 }
2374 // Windows only fires WM_MOUSELEAVE events if the application begins
2375 // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events.
2376 // We need to call |TrackMouseEvents| to listen for WM_MOUSELEAVE.
2380 // Reset our tracking flags so future mouse movement over this
2381 // NativeWidget results in a new tracking session. Fall through for
2382 // OnMouseEvent.
2385 // Reroute the mouse wheel to the window under the pointer if applicable.
2388 }
2390 // There are cases where the code handling the message destroys the window,
2391 // so use the weak ptr to check if destruction occured or not.
2398 // TODO(msw): Eliminate undesired painting, or re-evaluate this workaround.
2399 // DefWindowProc for WM_NCLBUTTONDOWN does weird non-client painting, so we
2400 // need to call it inside a ScopedRedrawLock. This may cause other negative
2401 // side-effects (ex/ stifling non-client mouse releases).
2404 }
2409 }
2413 LPARAM l_param) {
2416 // Ignore mouse messages which occur at the same location as the current
2417 // cursor position and within a time difference of 500 ms from the last
2418 // touch message.
2421 kSynthesizedMouseTouchMessagesTimeDifference)) {
2429 }
2431 }