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 640 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::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();
@@ skipping 106 matching lines @@
   // 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::OnNCLButtonDown(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) {
+    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;
+        ProcessNCMousePress(message, w_param, l_param);
+        return 0;
       }
     }
   }
 
-  WidgetWin::OnNCLButtonDown(ht_component, point);
+  WidgetWin::OnNCLButtonDown(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 (!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));
+    DefWindowProc(GetNativeView(), WM_NCLBUTTONDOWN, w_param, l_param);
     SetMsgHandled(TRUE);
   }
   */
+  return 0;
 }
 
-void WindowWin::OnNCRButtonDown(UINT ht_component, const CPoint& point) {
-  if (ht_component == HTCAPTION || ht_component == HTSYSMENU) {
+LRESULT WindowWin::OnNCRButtonDown(UINT message,
+                                   WPARAM w_param,
+                                   LPARAM l_param) {
+  if (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::OnNCRButtonDown(message, w_param, l_param);
+  return 0;
 }
 
-void WindowWin::OnRButtonUp(UINT ht_component, const CPoint& point) {
+LRESULT WindowWin::OnRButtonUp(UINT message, WPARAM w_param, LPARAM l_param) {
   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);
+    CPoint screen_point(GET_X_LPARAM(l_param), GET_Y_LPARAM(l_param));
     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) {
+    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;
+      return 0;
     }
   }
 
-  WidgetWin::OnRButtonUp(ht_component, point);
+  WidgetWin::OnRButtonUp(message, w_param, l_param);
+  return 0;
 }
 
 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 401 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);
+// TODO(msw): ProcessNCMousePress could be made class/file private (or inlined in OnNCLButtonDown).
+void WindowWin::ProcessNCMousePress(UINT message,
+                                    WPARAM w_param,
+                                    LPARAM l_param) {
+  // TODO(msw): Ensure point translation is correct. Move into ProcessMouseMoved???
+  CPoint point(GET_X_LPARAM(l_param), GET_Y_LPARAM(l_param));
+  MapWindowPoints(HWND_DESKTOP, GetNativeView(), &point, 1);
+  l_param = MAKELPARAM(point.x, point.y);
+  // TODO(msw): Consolidate code with new Event processing?
+  w_param |= ((GetKeyState(VK_CONTROL) & 0x80) == 0x80)? MK_CONTROL : 0;
+  w_param |= ((GetKeyState(VK_SHIFT) & 0x80) == 0x80)? MK_SHIFT : 0;
+  // TODO(msw): Why did this send non_client:=false to ProcessMousePressed???
+  //            Because this already did the xform? Can this be cleaned up?
+  DCHECK(message == WM_NCLBUTTONDOWN);
+  message = WM_LBUTTONDOWN;
+  ProcessMousePressed(message, w_param, l_param);
 }
 
 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);
 }
 
@@ skipping 44 matching lines @@
   Window::CloseSecondaryWidget(root_view->GetWidget());
   return TRUE;
 }
 }  // namespace
 
 void Window::CloseAllSecondaryWindows() {
   EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
 }
 
 }  // namespace views