Consolidate Widget Event code, other cleanup.

views/widget/widget_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/widget/widget_win.h"
 
 #include <dwmapi.h>
 
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
@@ skipping 121 matching lines @@
 
 WidgetWin::WidgetWin()
     : ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)),
       close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       use_layered_buffer_(false),
       layered_alpha_(255),
       ALLOW_THIS_IN_INITIALIZER_LIST(paint_layered_window_factory_(this)),
       delete_on_destroy_(true),
       can_update_layered_window_(true),
-      last_mouse_event_was_move_(false),
-      is_mouse_down_(false),
       is_window_(false),
       restore_focus_when_enabled_(false),
       accessibility_view_events_index_(-1),
       accessibility_view_events_(kMaxAccessibilityViewEvents),
       previous_cursor_(NULL) {
   set_native_widget(this);
 }
 
 WidgetWin::~WidgetWin() {
   DestroyRootView();
@@ skipping 161 matching lines @@
 }
 
 TooltipManager* WidgetWin::GetTooltipManager() const {
   return tooltip_manager_.get();
 }
 
 bool WidgetWin::IsScreenReaderActive() const {
   return screen_reader_active_;
 }
 
-void WidgetWin::SetNativeCapture() {
-  DCHECK(!HasNativeCapture());
+void WidgetWin::SetMouseCapture() {
+  DCHECK(!HasMouseCapture());
   SetCapture(hwnd());
 }
 
-void WidgetWin::ReleaseNativeCapture() {
+void WidgetWin::ReleaseMouseCapture() {
   ReleaseCapture();
 }
 
-bool WidgetWin::HasNativeCapture() const {
+bool WidgetWin::HasMouseCapture() const {
   return GetCapture() == hwnd();
 }
 
+bool WidgetWin::ShouldReleaseCaptureOnMouseReleased() const {
+  return true;
+}
+
 gfx::Rect WidgetWin::GetWindowScreenBounds() const {
   RECT r;
   GetWindowRect(&r);
   return gfx::Rect(r);
 }
 
 gfx::Rect WidgetWin::GetClientAreaScreenBounds() const {
   RECT r;
   GetClientRect(&r);
   POINT point = { r.left, r.top };
@@ skipping 211 matching lines @@
 LRESULT WidgetWin::OnAppCommand(HWND window, short app_command, WORD device,
                                 int keystate) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void WidgetWin::OnCancelMode() {
 }
 
 void WidgetWin::OnCaptureChanged(HWND hwnd) {
-  if (is_mouse_down_)
-    GetRootView()->OnMouseCaptureLost();
-  is_mouse_down_ = false;
+  ProcessMouseCaptureLost();
 }
 
 void WidgetWin::OnClose() {
   Close();
 }
 
 void WidgetWin::OnCommand(UINT notification_code, int command_id, HWND window) {
   SetMsgHandled(FALSE);
 }
 
@@ skipping 161 matching lines @@
 LRESULT WidgetWin::OnMouseActivate(UINT message,
                                    WPARAM w_param,
                                    LPARAM l_param) {
   if (GetWindowLong(GWL_EXSTYLE) & WS_EX_NOACTIVATE)
     return MA_NOACTIVATE;
   SetMsgHandled(FALSE);
   return MA_ACTIVATE;
 }
 
 LRESULT WidgetWin::OnMouseLeave(UINT message, WPARAM w_param, LPARAM l_param) {
-  tooltip_manager_->OnMouseLeave();
-  ProcessMouseExited(message, w_param, l_param);
+  if (message != WM_NCMOUSELEAVE)
+    tooltip_manager_->OnMouseLeave();
+
+  MSG msg;
+  MakeMSG(&msg, message, w_param, l_param, 0, GET_X_LPARAM(l_param),
+          GET_Y_LPARAM(l_param));
+  last_mouse_event_was_move_ = false;
+  GetRootView()->OnMouseExited(MouseEvent(msg));
+  // Reset our tracking flag so that future mouse movement over this WidgetWin
+  // results in a new tracking session.
+  active_mouse_tracking_flags_ = 0;
   return 0;
 }
 
 LRESULT WidgetWin::OnMouseMove(UINT message, WPARAM w_param, LPARAM l_param) {
-  ProcessMouseMoved(message, w_param, l_param);
+  if (message == WM_NCMOUSEMOVE)
+    tooltip_manager_->OnMouse(message, w_param, l_param);
+
+  // Windows only fires WM_MOUSELEAVE events if the application begins
+  // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events.
+  // We need to call |TrackMouseEvents| to listen for WM_MOUSELEAVE.
+  if (!HasMouseCapture())
+    TrackMouseEvents((message == WM_NCMOUSEMOVE) ?
+        TME_NONCLIENT | TME_LEAVE : TME_LEAVE);
+  MSG msg;
+  MakeMSG(&msg, message, w_param, l_param, 0, GET_X_LPARAM(l_param),
+          GET_Y_LPARAM(l_param));
+  ProcessMouseMoved(MouseEvent(msg));
   return 0;
 }
 
 LRESULT WidgetWin::OnMouseRange(UINT message, WPARAM w_param, LPARAM l_param) {
-  tooltip_manager_->OnMouse(message, w_param, l_param);
+  MSG msg;
+  MakeMSG(&msg, message, w_param, l_param, 0, GET_X_LPARAM(l_param),
+          GET_Y_LPARAM(l_param));
+  MouseEvent event(msg);
 
-  switch (message) {
-    case WM_LBUTTONDBLCLK:
-    case WM_LBUTTONDOWN:
-    case WM_MBUTTONDBLCLK:
-    case WM_MBUTTONDOWN:
-    case WM_RBUTTONDBLCLK:
-    case WM_RBUTTONDOWN:
-      SetMsgHandled(ProcessMousePressed(message, w_param, l_param));
+  if (!(event.flags() & ui::EF_IS_NON_CLIENT))
+    tooltip_manager_->OnMouse(message, w_param, l_param);
+
+  switch (event.type()) {
+    case ui::ET_MOUSE_PRESSED:
+      SetMsgHandled(ProcessMousePressed(event));
       break;
-    case WM_LBUTTONUP:
-    case WM_MBUTTONUP:
-    case WM_RBUTTONUP:
-      SetMsgHandled(ProcessMouseReleased(message, w_param, l_param));
+    case ui::ET_MOUSE_RELEASED:
+      SetMsgHandled((event.flags() & ui::EF_IS_NON_CLIENT) ? FALSE :
+                    ProcessMouseReleased(event));

[Ben Goodger (Google), 2011/03/30 23:22:55]

This is fine for now. I want you to eventually converge on one function on
NativeWidgetDelegate - OnMouseEvent. THat means all this can be condensed to:

if (IsNonClientMessage(message))
  tooltip_manager_->OnMouse(message, w_param, l_param);

MSG msg;
MakeMsg(...);
SetMsgHandled(delegate_->OnMouseEvent(MouseEvent(msg)));

return 0;

Capiche?

[msw, 2011/03/31 14:01:18]

Done; I did some of this work now.

       break;
     default:
       SetMsgHandled(FALSE);
   }
 
   return 0;
 }
 
 LRESULT WidgetWin::OnMouseWheel(UINT message, WPARAM w_param, LPARAM l_param) {
   // Reroute the mouse-wheel to the window under the mouse pointer if
@@ skipping 28 matching lines @@
 LRESULT WidgetWin::OnNCCalcSize(BOOL w_param, LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 LRESULT WidgetWin::OnNCHitTest(const CPoint& pt) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
-LRESULT WidgetWin::OnNCMouseLeave(UINT message,
-                                  WPARAM w_param,
-                                  LPARAM l_param) {
-  ProcessMouseExited(message, w_param, l_param);
-  return 0;
-}
-
-LRESULT WidgetWin::OnNCMouseMove(UINT message, WPARAM w_param, LPARAM l_param) {
-  tooltip_manager_->OnMouse(message, w_param, l_param);
-  ProcessMouseMoved(message, w_param, l_param);
-
-  // We need to process this message to stop Windows from drawing the window
-  // controls as the mouse moves over the title bar area when the window is
-  // maximized.
-  return 0;
-}
-
-LRESULT WidgetWin::OnNCMouseRange(UINT message,
-                                  WPARAM w_param,
-                                  LPARAM l_param) {
-  switch (message) {
-    case WM_NCLBUTTONDBLCLK:
-    case WM_NCLBUTTONDOWN:
-    case WM_NCMBUTTONDBLCLK:
-    case WM_NCMBUTTONDOWN:
-    case WM_NCRBUTTONDBLCLK:
-    case WM_NCRBUTTONDOWN:
-      SetMsgHandled(ProcessMousePressed(message, w_param, l_param));
-      break;
-    case WM_NCLBUTTONUP:
-    case WM_NCMBUTTONUP:
-    case WM_NCRBUTTONUP:
-    default:
-      SetMsgHandled(FALSE);
-  }
-
-  return 0;
-}
-
 void WidgetWin::OnNCPaint(HRGN rgn) {
   SetMsgHandled(FALSE);
 }
 
 LRESULT WidgetWin::OnNCUAHDrawCaption(UINT msg,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
 }
@@ skipping 110 matching lines @@
     tme.dwFlags = mouse_tracking_flags;
     tme.hwndTrack = hwnd();
     tme.dwHoverTime = 0;
     TrackMouseEvent(&tme);
   } else if (mouse_tracking_flags != active_mouse_tracking_flags_) {
     TrackMouseEvents(active_mouse_tracking_flags_ | TME_CANCEL);
     TrackMouseEvents(mouse_tracking_flags);
   }
 }
 
-bool WidgetWin::ProcessMousePressed(UINT message,
-                                    WPARAM w_param,
-                                    LPARAM l_param) {
-  last_mouse_event_was_move_ = false;
-
-  MSG msg;
-  MakeMSG(&msg, message, w_param, l_param, 0, GET_X_LPARAM(l_param),
-          GET_Y_LPARAM(l_param));
-  if (GetRootView()->OnMousePressed(MouseEvent(msg))) {
-    is_mouse_down_ = true;
-    if (!HasNativeCapture())
-      SetNativeCapture();
-    return true;
-  }
-  return false;
-}
-
-bool WidgetWin::ProcessMouseReleased(UINT message,
-                                     WPARAM w_param,
-                                     LPARAM l_param) {
-  last_mouse_event_was_move_ = false;
-  is_mouse_down_ = false;
-
-  // Release the capture first, that way we don't get confused if
-  // OnMouseReleased blocks.
-  if (HasNativeCapture() && ReleaseCaptureOnMouseReleased())
-    ReleaseNativeCapture();
-
-  MSG msg;
-  MakeMSG(&msg, message, w_param, l_param, 0, GET_X_LPARAM(l_param),
-          GET_Y_LPARAM(l_param));
-  GetRootView()->OnMouseReleased(MouseEvent(msg));
-  return true;
-}
-
-bool WidgetWin::ProcessMouseMoved(UINT message,
-                                  WPARAM w_param,
-                                  LPARAM l_param) {
-  // Windows only fires WM_MOUSELEAVE events if the application begins
-  // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events.
-  // We need to call |TrackMouseEvents| to listen for WM_MOUSELEAVE.
-  if (!HasNativeCapture())
-    TrackMouseEvents((message == WM_NCMOUSEMOVE) ?
-        TME_NONCLIENT | TME_LEAVE : TME_LEAVE);
-  MSG msg;
-  MakeMSG(&msg, message, w_param, l_param, 0, GET_X_LPARAM(l_param),
-          GET_Y_LPARAM(l_param));
-  if (HasNativeCapture() && is_mouse_down_)
-    GetRootView()->OnMouseDragged(MouseEvent(msg));
-  else if (!last_mouse_event_was_move_ ||
-      (last_mouse_move_x_ != GET_X_LPARAM(l_param) ||
-       last_mouse_move_y_ != GET_Y_LPARAM(l_param))) {
-    last_mouse_move_x_ = GET_X_LPARAM(l_param);
-    last_mouse_move_y_ = GET_Y_LPARAM(l_param);
-    last_mouse_event_was_move_ = true;
-    GetRootView()->OnMouseMoved(MouseEvent(msg));
-  }
-  return true;
-}
-
-void WidgetWin::ProcessMouseExited(UINT message,
-                                   WPARAM w_param,
-                                   LPARAM l_param) {
-  last_mouse_event_was_move_ = false;
-  MSG msg;
-  MakeMSG(&msg, message, w_param, l_param, 0, GET_X_LPARAM(l_param),
-          GET_Y_LPARAM(l_param));
-  GetRootView()->OnMouseExited(MouseEvent(msg));
-  // Reset our tracking flag so that future mouse movement over this WidgetWin
-  // results in a new tracking session.
-  active_mouse_tracking_flags_ = 0;
-}
-
 void WidgetWin::OnScreenReaderDetected() {
   screen_reader_active_ = true;
 }
 
-bool WidgetWin::ReleaseCaptureOnMouseReleased() {
-  return true;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetWin, private:
 
 // static
 Window* WidgetWin::GetWindowImpl(HWND hwnd) {
   // NOTE: we can't use GetAncestor here as constrained windows are a Window,
   // but not a top level window.
   HWND parent = hwnd;
   while (parent) {
     WidgetWin* widget =
@@ skipping 176 matching lines @@
     return;
 
   NativeWidget* native_widget = GetNativeWidgetForNativeView(native_view);
   if (native_widget)
     children->insert(native_widget);
   EnumChildWindows(native_view, EnumerateChildWindowsForNativeWidgets,
       reinterpret_cast<LPARAM>(children));
 }
 
 }  // namespace views