Refactored event handler method bodies from widget_win.h to...

views/widget/widget_win.cc

 // Copyright (c) 2006-2008 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 "app/gfx/canvas.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util_win.h"
 #include "app/win_util.h"
@@ skipping 405 matching lines @@
   // We are a proxy to the root view, so we should be bypassed when traversing
   // up and as a result this should not be called.
   NOTREACHED();
   return NULL;
 }
 
 void WidgetWin::SetFocusTraversableParentView(View* parent_view) {
   root_view_->SetFocusTraversableParentView(parent_view);
 }
 
+bool WidgetWin::AcceleratorPressed(const Accelerator& accelerator) {
+  return false;
+}
+
+bool WidgetWin::GetAccelerator(int cmd_id, Accelerator* accelerator) {
+  return false;
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // Message handlers
 
+void WidgetWin::OnActivate(UINT action, BOOL minimized, HWND window) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnActivateApp(BOOL active, DWORD thread_id) {
+  SetMsgHandled(FALSE);
+}
+
+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 (has_capture_) {
     if (is_mouse_down_)
       root_view_->ProcessMouseDragCanceled();
     is_mouse_down_ = false;
     has_capture_ = false;
   }
 }
 
 void WidgetWin::OnClose() {
   Close();
 }
 
+void WidgetWin::OnCommand(UINT notification_code, int command_id, HWND window) {
+  SetMsgHandled(FALSE);
+}
+
+LRESULT WidgetWin::OnCreate(CREATESTRUCT* create_struct) {
+  return 0;
+}
+
 void WidgetWin::OnDestroy() {
   if (drop_target_.get()) {
     RevokeDragDrop(hwnd());
     drop_target_ = NULL;
   }
 
   RemoveProp(hwnd(), kRootViewWindowProperty);
 }
 
+LRESULT WidgetWin::OnDwmCompositionChanged(UINT msg,
+                                           WPARAM w_param,
+                                           LPARAM l_param) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
+void WidgetWin::OnEndSession(BOOL ending, UINT logoff) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnEnterSizeMove() {
+  SetMsgHandled(FALSE);
+}
+
 LRESULT WidgetWin::OnEraseBkgnd(HDC dc) {
   // This is needed for magical win32 flicker ju-ju
   return 1;
 }
 
+void WidgetWin::OnExitMenuLoop(BOOL is_track_popup_menu) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnExitSizeMove() {
+  SetMsgHandled(FALSE);
+}
+
 LRESULT WidgetWin::OnGetObject(UINT uMsg, WPARAM w_param, LPARAM l_param) {
   LRESULT reference_result = static_cast<LRESULT>(0L);
 
   // Accessibility readers will send an OBJID_CLIENT message
   if (OBJID_CLIENT == l_param) {
     // If our MSAA root is already created, reuse that pointer. Otherwise,
     // create a new one.
     if (!accessibility_root_) {
       CComObject<ViewAccessibility>* instance = NULL;
 
@@ skipping 22 matching lines @@
     }
 
     // Create a reference to ViewAccessibility that MSAA will marshall
     // to the client.
     reference_result = LresultFromObject(IID_IAccessible, w_param,
         static_cast<IAccessible*>(accessibility_root_));
   }
   return reference_result;
 }
 
+void WidgetWin::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnHScroll(int scroll_type, short position, HWND scrollbar) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnInitMenu(HMENU menu) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnInitMenuPopup(HMENU menu,
+                                UINT position,
+                                BOOL is_system_menu) {
+  SetMsgHandled(FALSE);
+}
+
 void WidgetWin::OnKeyDown(TCHAR c, UINT rep_cnt, UINT flags) {
   KeyEvent event(Event::ET_KEY_PRESSED, c, rep_cnt, flags);
   SetMsgHandled(root_view_->ProcessKeyEvent(event));
 }
 
 void WidgetWin::OnKeyUp(TCHAR c, UINT rep_cnt, UINT flags) {
   KeyEvent event(Event::ET_KEY_RELEASED, c, rep_cnt, flags);
   SetMsgHandled(root_view_->ProcessKeyEvent(event));
 }
 
@@ skipping 52 matching lines @@
   }
 
   int flags = GET_KEYSTATE_WPARAM(w_param);
   short distance = GET_WHEEL_DELTA_WPARAM(w_param);
   int x = GET_X_LPARAM(l_param);
   int y = GET_Y_LPARAM(l_param);
   MouseWheelEvent e(distance, x, y, Event::ConvertWindowsFlags(flags));
   return root_view_->ProcessMouseWheelEvent(e) ? 0 : 1;
 }
 
+void WidgetWin::OnMove(const CPoint& point) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnMoving(UINT param, const LPRECT new_bounds) {
+}
+
 LRESULT WidgetWin::OnMouseRange(UINT msg, WPARAM w_param, LPARAM l_param) {
   tooltip_manager_->OnMouse(msg, w_param, l_param);
   SetMsgHandled(FALSE);
   return 0;
 }
 
+LRESULT WidgetWin::OnNCActivate(BOOL active) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
+LRESULT WidgetWin::OnNCCalcSize(BOOL w_param, LPARAM l_param) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
+LRESULT WidgetWin::OnNCHitTest(const CPoint& pt) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
 void WidgetWin::OnNCLButtonDblClk(UINT flags, const CPoint& point) {
   SetMsgHandled(ProcessMousePressed(point, flags | MK_LBUTTON, true, true));
 }
 
 void WidgetWin::OnNCLButtonDown(UINT flags, const CPoint& point) {
   SetMsgHandled(ProcessMousePressed(point, flags | MK_LBUTTON, false, true));
 }
 
 void WidgetWin::OnNCLButtonUp(UINT flags, const CPoint& point) {
   SetMsgHandled(FALSE);
@@ skipping 21 matching lines @@
   CPoint temp = point;
   MapWindowPoints(HWND_DESKTOP, hwnd(), &temp, 1);
   ProcessMouseMoved(temp, 0, true);
 
   // 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;
 }
 
+void WidgetWin::OnNCPaint(HRGN rgn) {
+  SetMsgHandled(FALSE);
+}
+
 void WidgetWin::OnNCRButtonDblClk(UINT flags, const CPoint& point) {
   SetMsgHandled(ProcessMousePressed(point, flags | MK_RBUTTON, true, true));
 }
 
 void WidgetWin::OnNCRButtonDown(UINT flags, const CPoint& point) {
   SetMsgHandled(ProcessMousePressed(point, flags | MK_RBUTTON, false, true));
 }
 
 void WidgetWin::OnNCRButtonUp(UINT flags, const CPoint& point) {
   SetMsgHandled(FALSE);
 }
 
+LRESULT WidgetWin::OnNCUAHDrawCaption(UINT msg,
+                                      WPARAM w_param,
+                                      LPARAM l_param) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
+LRESULT WidgetWin::OnNCUAHDrawFrame(UINT msg, WPARAM w_param, LPARAM l_param) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
 LRESULT WidgetWin::OnNotify(int w_param, NMHDR* l_param) {
   // We can be sent this message before the tooltip manager is created, if a
   // subclass overrides OnCreate and creates some kind of Windows control there
   // that sends WM_NOTIFY messages.
   if (tooltip_manager_.get()) {
     bool handled;
     LRESULT result = tooltip_manager_->OnNotify(w_param, l_param, &handled);
     SetMsgHandled(handled);
     return result;
   }
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void WidgetWin::OnPaint(HDC dc) {
   root_view_->OnPaint(hwnd());
 }
 
+LRESULT WidgetWin::OnPowerBroadcast(DWORD power_event, DWORD data) {
+  base::SystemMonitor* monitor = base::SystemMonitor::Get();
+  if (monitor)
+    monitor->ProcessWmPowerBroadcastMessage(power_event);
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
 void WidgetWin::OnRButtonDown(UINT flags, const CPoint& point) {
   ProcessMousePressed(point, flags | MK_RBUTTON, false, false);
 }
 
 void WidgetWin::OnRButtonUp(UINT flags, const CPoint& point) {
   ProcessMouseReleased(point, flags | MK_RBUTTON);
 }
 
 void WidgetWin::OnRButtonDblClk(UINT flags, const CPoint& point) {
   ProcessMousePressed(point, flags | MK_RBUTTON, true, false);
 }
 
+LRESULT WidgetWin::OnReflectedMessage(UINT msg,
+                                      WPARAM w_param,
+                                      LPARAM l_param) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
+void WidgetWin::OnSetFocus(HWND focused_window) {
+  SetMsgHandled(FALSE);
+}
+
+LRESULT WidgetWin::OnSetIcon(UINT size_type, HICON new_icon) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
+LRESULT WidgetWin::OnSetText(const wchar_t* text) {
+  SetMsgHandled(FALSE);
+  return 0;
+}
+
+void WidgetWin::OnSettingChange(UINT flags, const wchar_t* section) {
+  SetMsgHandled(FALSE);
+}
+
 void WidgetWin::OnSize(UINT param, const CSize& size) {
   ChangeSize(param, size);
 }
 
+void WidgetWin::OnSysCommand(UINT notification_code, CPoint click) {
+}
+
 void WidgetWin::OnThemeChanged() {
   // Notify NativeTheme.
   gfx::NativeTheme::instance()->CloseHandles();
 }
 
 void WidgetWin::OnFinalMessage(HWND window) {
   if (delete_on_destroy_)
     delete this;
 }
 
+void WidgetWin::OnVScroll(int scroll_type, short position, HWND scrollbar) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnWindowPosChanging(WINDOWPOS* window_pos) {
+  SetMsgHandled(FALSE);
+}
+
+void WidgetWin::OnWindowPosChanged(WINDOWPOS* window_pos) {
+  SetMsgHandled(FALSE);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, protected:
 
 void WidgetWin::TrackMouseEvents(DWORD mouse_tracking_flags) {
   // Begin tracking mouse events for this HWND so that we get WM_MOUSELEAVE
   // when the user moves the mouse outside this HWND's bounds.
   if (active_mouse_tracking_flags_ == 0 || mouse_tracking_flags & TME_CANCEL) {
     if (mouse_tracking_flags & TME_CANCEL) {
       // We're about to cancel active mouse tracking, so empty out the stored
       // state.
@@ skipping 113 matching lines @@
 
   // Resizing changes the size of the view hierarchy and thus forces a
   // complete relayout.
   root_view_->SetBounds(0, 0, rect.Width(), rect.Height());
   root_view_->SchedulePaint();
 
   if (use_layered_buffer_)
     PaintNow(gfx::Rect(rect));
 }
 
+bool WidgetWin::ReleaseCaptureOnMouseReleased() {
+  return true;
+}
+
 RootView* WidgetWin::CreateRootView() {
   return new RootView(this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, private:
 
 // static
 Window* WidgetWin::GetWindowImpl(HWND hwnd) {
   // NOTE: we can't use GetAncestor here as constrained windows are a Window,
@@ skipping 153 matching lines @@
   WidgetWin* popup = new WidgetWin;
   popup->set_window_style(WS_POPUP);
   popup->set_window_ex_style(WS_EX_LAYERED | WS_EX_TOOLWINDOW |
                              WS_EX_TRANSPARENT |
                              l10n_util::GetExtendedTooltipStyles());
   popup->set_delete_on_destroy(delete_on_destroy);
   return popup;
 }
 
 }  // namespace views