Update MouseEvent (initial pass).

views/window/window_win.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "views/window/window_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/i18n/rtl.h"
@@ skipping 633 matching lines @@
   InitClass();
   DCHECK(window_delegate_);
   DCHECK(!window_delegate_->window_);
   window_delegate_->window_ = this;
   // Initialize these values to 0 so that subclasses can override the default
   // behavior before calling Init.
   set_window_style(0);
   set_window_ex_style(0);
 }
 
-void WindowWin::Init(HWND parent, const gfx::Rect& bounds) {
+void WindowWin::Init(gfx::NativeView parent, const gfx::Rect& bounds) {
   // We need to save the parent window, since later calls to GetParent() will
   // return NULL.
   owning_hwnd_ = parent;
   // We call this after initializing our members since our implementations of
   // assorted WidgetWin functions may be called during initialization.
   is_modal_ = window_delegate_->IsModal();
   if (is_modal_)
     BecomeModal();
 
   if (window_style() == 0)
@@ skipping 145 matching lines @@
   ScopedRedrawLock lock(this);
   EnableMenuItem(menu, SC_RESTORE, is_minimized || is_maximized);
   EnableMenuItem(menu, SC_MOVE, is_restored);
   EnableMenuItem(menu, SC_SIZE, window_delegate_->CanResize() && is_restored);
   EnableMenuItem(menu, SC_MAXIMIZE,
       window_delegate_->CanMaximize() && !is_fullscreen && !is_maximized);
   EnableMenuItem(menu, SC_MINIMIZE,
       window_delegate_->CanMaximize() && !is_minimized);
 }
 
-void WindowWin::OnMouseLeave() {
+LRESULT WindowWin::OnMouseLeave(UINT message, WPARAM w_param, LPARAM l_param) {
   // We only need to manually track WM_MOUSELEAVE messages between the client
   // and non-client area when we're not using the native frame.
   if (non_client_view_->UseNativeFrame()) {
     SetMsgHandled(FALSE);
-    return;
+    return 0;
   }
 
   bool process_mouse_exited = true;
   POINT pt;
   if (GetCursorPos(&pt)) {
     LRESULT ht_component =
         ::SendMessage(GetNativeView(), WM_NCHITTEST, 0, MAKELPARAM(pt.x, pt.y));
     if (ht_component != HTNOWHERE) {
       // If the mouse moved into a part of the window's non-client area, then
       // don't send a mouse exited event since the mouse is still within the
       // bounds of the ChromeView that's rendering the frame. Note that we do
       // _NOT_ do this for windows with native frames, since in that case the
       // mouse really will have left the bounds of the RootView.
       process_mouse_exited = false;
     }
   }
 
   if (process_mouse_exited)
     ProcessMouseExited();
+  return 0;
 }
 
+LRESULT WindowWin::OnMouseRange(UINT message, WPARAM w_param, LPARAM l_param) {
+  if (message == WM_RBUTTONUP) {
+    if (is_right_mouse_pressed_on_caption_) {
+      is_right_mouse_pressed_on_caption_ = false;
+      ReleaseCapture();
+      // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu()
+      // expect screen coordinates.
+      CPoint screen_point(l_param);
+      MapWindowPoints(GetNativeView(), HWND_DESKTOP, &screen_point, 1);
+      w_param = SendMessage(GetNativeView(), WM_NCHITTEST, 0,
+                            MAKELPARAM(screen_point.x, screen_point.y));
+      if (w_param == HTCAPTION || w_param == HTSYSMENU) {
+        UINT flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RETURNCMD;
+        if (base::i18n::IsRTL())
+          flags |= TPM_RIGHTALIGN;
+        HMENU system_menu = GetSystemMenu(GetNativeView(), FALSE);
+        int id = TrackPopupMenu(system_menu, flags, screen_point.x,
+                                screen_point.y, 0, GetNativeView(), NULL);
+        ExecuteSystemMenuCommand(id);
+        return 0;
+      }
+    }
+  }
+
+  WidgetWin::OnMouseRange(message, w_param, l_param);
+  return 0;
+}
+
+
 LRESULT WindowWin::OnNCActivate(BOOL active) {
   is_active_ = !!active;
 
   // The frame may need to redraw as a result of the activation change.
   // We can get WM_NCACTIVATE before we're actually visible. If we're not
   // visible, no need to paint.
   if (IsVisible())
     non_client_view_->SchedulePaint();
 
   // If we're active again, we should be allowed to render as inactive, so
@@ skipping 98 matching lines @@
   MapWindowPoints(HWND_DESKTOP, GetNativeView(), &temp, 1);
   int component = non_client_view_->NonClientHitTest(gfx::Point(temp));
   if (component != HTNOWHERE)
     return component;
 
   // Otherwise, we let Windows do all the native frame non-client handling for
   // us.
   return WidgetWin::OnNCHitTest(point);
 }
 
-void WindowWin::OnNCPaint(HRGN rgn) {
-  // When using a custom frame, we want to avoid calling DefWindowProc() since
-  // that may render artifacts.
-  SetMsgHandled(!non_client_view_->UseNativeFrame());
-}
-
-void WindowWin::OnNCLButtonDown(UINT ht_component, const CPoint& point) {
+LRESULT WindowWin::OnNCMouseRange(UINT message,
+                                  WPARAM w_param,
+                                  LPARAM l_param) {
   // When we're using a native frame, window controls work without us
   // interfering.
-  if (!non_client_view_->UseNativeFrame()) {
-    switch (ht_component) {
+  if (message == WM_NCLBUTTONDOWN && !non_client_view_->UseNativeFrame()) {
+    switch (w_param) {
       case HTCLOSE:
       case HTMINBUTTON:
       case HTMAXBUTTON: {
         // When the mouse is pressed down in these specific non-client areas,
         // we need to tell the RootView to send the mouse pressed event (which
         // sets capture, allowing subsequent WM_LBUTTONUP (note, _not_
         // WM_NCLBUTTONUP) to fire so that the appropriate WM_SYSCOMMAND can be
         // sent by the applicable button's ButtonListener. We _have_ to do this
         // way rather than letting Windows just send the syscommand itself (as
         // would happen if we never did this dance) because for some insane
         // reason DefWindowProc for WM_NCLBUTTONDOWN also renders the pressed
         // window control button appearance, in the Windows classic style, over
         // our view! Ick! By handling this message we prevent Windows from
         // doing this undesirable thing, but that means we need to roll the
         // sys-command handling ourselves.
-        ProcessNCMousePress(point, MK_LBUTTON);
-        return;
+        // Combine |w_param| with common key state message flags.
+        w_param |= ((GetKeyState(VK_CONTROL) & 0x80) == 0x80)? MK_CONTROL : 0;
+        w_param |= ((GetKeyState(VK_SHIFT) & 0x80) == 0x80)? MK_SHIFT : 0;
+        ProcessMousePressed(message, w_param, l_param);
+        return 0;
       }
     }
-  }
-
-  WidgetWin::OnNCLButtonDown(ht_component, point);
-
-  /* TODO(beng): Fix the standard non-client over-painting bug. This code
-                 doesn't work but identifies the problem.
-  if (!IsMsgHandled()) {
-    // WindowWin::OnNCLButtonDown set the message as unhandled. This normally
-    // means WidgetWin::ProcessWindowMessage will pass it to
-    // DefWindowProc. Sadly, DefWindowProc for WM_NCLBUTTONDOWN does weird
-    // non-client painting, so we need to call it directly here inside a
-    // scoped update lock.
-    ScopedRedrawLock lock(this);
-    DefWindowProc(GetNativeView(), WM_NCLBUTTONDOWN, ht_component,
-                  MAKELPARAM(point.x, point.y));
-    SetMsgHandled(TRUE);
-  }
-  */
-}
-
-void WindowWin::OnNCRButtonDown(UINT ht_component, const CPoint& point) {
-  if (ht_component == HTCAPTION || ht_component == HTSYSMENU) {
+  } else if (message == WM_NCRBUTTONDOWN &&
+      (w_param == HTCAPTION || w_param == HTSYSMENU)) {
     is_right_mouse_pressed_on_caption_ = true;
     // We SetCapture() to ensure we only show the menu when the button down and
     // up are both on the caption.  Note: this causes the button up to be
     // WM_RBUTTONUP instead of WM_NCRBUTTONUP.
     SetCapture();
   }
 
-  WidgetWin::OnNCRButtonDown(ht_component, point);
+  WidgetWin::OnNCMouseRange(message, w_param, l_param);
+
+  /* TODO(beng): Fix the standard non-client over-painting bug. This code
+                 doesn't work but identifies the problem.
+  if (message == WM_NCLBUTTONDOWN && !IsMsgHandled()) {
+    // WindowWin::OnNCLButtonDown set the message as unhandled. This normally
+    // means WidgetWin::ProcessWindowMessage will pass it to
+    // DefWindowProc. Sadly, DefWindowProc for WM_NCLBUTTONDOWN does weird
+    // non-client painting, so we need to call it directly here inside a
+    // scoped update lock.
+    ScopedRedrawLock lock(this);
+    DefWindowProc(GetNativeView(), WM_NCLBUTTONDOWN, w_param, l_param);
+    SetMsgHandled(TRUE);
+  }
+  */
+
+  return 0;
 }
 
-void WindowWin::OnRButtonUp(UINT ht_component, const CPoint& point) {
-  if (is_right_mouse_pressed_on_caption_) {
-    is_right_mouse_pressed_on_caption_ = false;
-    ReleaseCapture();
-    // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu()
-    // expect screen coordinates.
-    CPoint screen_point(point);
-    MapWindowPoints(GetNativeView(), HWND_DESKTOP, &screen_point, 1);
-    ht_component = SendMessage(GetNativeView(), WM_NCHITTEST, 0,
-                               MAKELPARAM(screen_point.x, screen_point.y));
-    if (ht_component == HTCAPTION || ht_component == HTSYSMENU) {
-      UINT flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RETURNCMD;
-      if (base::i18n::IsRTL())
-        flags |= TPM_RIGHTALIGN;
-      HMENU system_menu = GetSystemMenu(GetNativeView(), FALSE);
-      int id = TrackPopupMenu(system_menu, flags, screen_point.x,
-                              screen_point.y, 0, GetNativeView(), NULL);
-      ExecuteSystemMenuCommand(id);
-      return;
-    }
-  }
-
-  WidgetWin::OnRButtonUp(ht_component, point);
+void WindowWin::OnNCPaint(HRGN rgn) {
+  // When using a custom frame, we want to avoid calling DefWindowProc() since
+  // that may render artifacts.
+  SetMsgHandled(!non_client_view_->UseNativeFrame());
 }
 
 LRESULT WindowWin::OnNCUAHDrawCaption(UINT msg, WPARAM w_param,
                                       LPARAM l_param) {
   // See comment in widget_win.h at the definition of WM_NCUAHDRAWCAPTION for
   // an explanation about why we need to handle this message.
   SetMsgHandled(!non_client_view_->UseNativeFrame());
   return 0;
 }
 
@@ skipping 386 matching lines @@
     VARIANT var;
     AccessibilityTypes::State state = window_delegate_->accessible_state();
     if (state) {
       var.lVal = ViewAccessibility::MSAAState(state);
       hr = pAccPropServices->SetHwndProp(GetNativeView(), OBJID_CLIENT,
         CHILDID_SELF, PROPID_ACC_STATE, var);
     }
   }
 }
 
-void WindowWin::ProcessNCMousePress(const CPoint& point, int flags) {
-  CPoint temp = point;
-  MapWindowPoints(HWND_DESKTOP, GetNativeView(), &temp, 1);
-  UINT message_flags = 0;
-  if ((GetKeyState(VK_CONTROL) & 0x80) == 0x80)
-    message_flags |= MK_CONTROL;
-  if ((GetKeyState(VK_SHIFT) & 0x80) == 0x80)
-    message_flags |= MK_SHIFT;
-  message_flags |= flags;
-  ProcessMousePressed(temp, message_flags, false, false);
-}
-
 LRESULT WindowWin::CallDefaultNCActivateHandler(BOOL active) {
   // The DefWindowProc handling for WM_NCACTIVATE renders the classic-look
   // window title bar directly, so we need to use a redraw lock here to prevent
   // it from doing so.
   ScopedRedrawLock lock(this);
   return DefWindowProc(GetNativeView(), WM_NCACTIVATE, active, 0);
 }
 
 void WindowWin::GetWindowBoundsAndMaximizedState(gfx::Rect* bounds,
                                                  bool* maximized) const {
@@ skipping 38 matching lines @@
     Window::CloseSecondaryWidget(native_widget->GetWidget());
   return TRUE;
 }
 }  // namespace
 
 void Window::CloseAllSecondaryWindows() {
   EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
 }
 
 }  // namespace views