Move more methods from NWW to HWNDMessageHandler.

ui/views/widget/native_widget_win.h

 // Copyright (c) 2012 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.
 
 #ifndef UI_VIEWS_WIDGET_NATIVE_WIDGET_WIN_H_
 #define UI_VIEWS_WIDGET_NATIVE_WIDGET_WIN_H_
 
 #include <atlbase.h>
 #include <atlapp.h>
 #include <atlcrack.h>
@@ skipping 24 matching lines @@
 namespace gfx {
 class Canvas;
 class Font;
 class Rect;
 }
 
 namespace views {
 
 class DropTargetWin;
 class HWNDMessageHandler;
+class InputMethodDelegate;
 class RootView;
 class TooltipManagerWin;
 
 // These two messages aren't defined in winuser.h, but they are sent to windows
 // with captions. They appear to paint the window caption and frame.
 // Unfortunately if you override the standard non-client rendering as we do
 // with CustomFrameWindow, sometimes Windows (not deterministically
 // reproducibly but definitely frequently) will send these messages to the
 // window and paint the standard caption/title over the top of the custom one.
 // So we need to handle these messages in CustomFrameWindow to prevent this
@@ skipping 15 matching lines @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 class VIEWS_EXPORT NativeWidgetWin : public ui::WindowImpl,
                                      public MessageLoopForUI::Observer,
                                      public internal::NativeWidgetPrivate,
                                      public HWNDMessageHandlerDelegate {
  public:
   explicit NativeWidgetWin(internal::NativeWidgetDelegate* delegate);
   virtual ~NativeWidgetWin();
 
-  // Returns true if we are on Windows Vista or greater and composition is
-  // enabled.
-  static bool IsAeroGlassEnabled();
-
   // Returns the system set window title font.
   static gfx::Font GetWindowTitleFont();
 
   // Show the window with the specified show command.
   void Show(int show_state);
 
   // Disable Layered Window updates by setting to false.
   void set_can_update_layered_window(bool can_update_layered_window) {
     can_update_layered_window_ = can_update_layered_window;
   }
@@ skipping 107 matching lines @@
   virtual void* GetNativeWindowProperty(const char* name) const OVERRIDE;
   virtual TooltipManager* GetTooltipManager() const OVERRIDE;
   virtual bool IsScreenReaderActive() const OVERRIDE;
   virtual void SendNativeAccessibilityEvent(
       View* view,
       ui::AccessibilityTypes::Event event_type) OVERRIDE;
   virtual void SetCapture() OVERRIDE;
   virtual void ReleaseCapture() OVERRIDE;
   virtual bool HasCapture() const OVERRIDE;
   virtual InputMethod* CreateInputMethod() OVERRIDE;
+  virtual internal::InputMethodDelegate* GetInputMethodDelegate() OVERRIDE;
   virtual void CenterWindow(const gfx::Size& size) OVERRIDE;
   virtual void GetWindowPlacement(
      gfx::Rect* bounds,
      ui::WindowShowState* show_state) const OVERRIDE;
   virtual void SetWindowTitle(const string16& title) OVERRIDE;
   virtual void SetWindowIcons(const gfx::ImageSkia& window_icon,
                               const gfx::ImageSkia& app_icon) OVERRIDE;
   virtual void SetAccessibleName(const string16& name) OVERRIDE;
   virtual void SetAccessibleRole(ui::AccessibilityTypes::Role role) OVERRIDE;
   virtual void SetAccessibleState(ui::AccessibilityTypes::State state) OVERRIDE;
@@ skipping 231 matching lines @@
   // to SW_SHOWNORMAL, however windows (e.g. the main window) can override this
   // method to provide different values (e.g. retrieve the user's specified
   // show state from the shortcut starutp info).
   virtual int GetShowState() const;
 
   // Returns the insets of the client area relative to the non-client area of
   // the window. Override this function instead of OnNCCalcSize, which is
   // crazily complicated.
   virtual gfx::Insets GetClientAreaInsets() const;
 
-  // Start tracking all mouse events so that this window gets sent mouse leave
-  // messages too.
-  void TrackMouseEvents(DWORD mouse_tracking_flags);
-
   // Called when a MSAA screen reader client is detected.
   virtual void OnScreenReaderDetected();
 
   // Executes the specified SC_command.
   void ExecuteSystemMenuCommand(int command);
 
   // The TooltipManager. This is NULL if there is a problem creating the
   // underlying tooltip window.
   // WARNING: RootView's destructor calls into the TooltipManager. As such, this
   // must be destroyed AFTER root_view_.
   scoped_ptr<TooltipManagerWin> tooltip_manager_;
 
   scoped_refptr<DropTargetWin> drop_target_;
 
   const gfx::Rect& invalid_rect() const { return invalid_rect_; }
 
   // Saved window information from before entering fullscreen mode.
   // TODO(beng): move to private once GetRestoredBounds() moves onto Widget.
   SavedWindowInfo saved_window_info_;
 
  private:
   typedef ScopedVector<ui::ViewProp> ViewProps;
-  typedef std::set<DWORD> TouchIDs;
 
   // TODO(beng): This friendship can be removed once all methods relating to
   //             this object being a WindowImpl are moved to HWNDMessageHandler.
   friend HWNDMessageHandler;
 
   // Overridden from HWNDMessageHandlerDelegate:
   virtual bool IsWidgetWindow() const OVERRIDE;
   virtual bool IsUsingCustomFrame() const OVERRIDE;
   virtual void SchedulePaint() OVERRIDE;
   virtual void EnableInactiveRendering() OVERRIDE;
@@ skipping 15 matching lines @@
   virtual void HandleClose() OVERRIDE;
   virtual bool HandleCommand(int command) OVERRIDE;
   virtual void HandleCreate() OVERRIDE;
   virtual void HandleDestroy() OVERRIDE;
   virtual void HandleDisplayChange() OVERRIDE;
   virtual void HandleGlassModeChange() OVERRIDE;
   virtual void HandleBeginWMSizeMove() OVERRIDE;
   virtual void HandleEndWMSizeMove() OVERRIDE;
   virtual void HandleMove() OVERRIDE;
   virtual void HandleWorkAreaChanged() OVERRIDE;
+  virtual void HandleVisibilityChanged(bool visible) OVERRIDE;
+  virtual void HandleClientSizeChanged(const gfx::Size& new_size) OVERRIDE;
   virtual void HandleNativeFocus(HWND last_focused_window) OVERRIDE;
   virtual void HandleNativeBlur(HWND focused_window) OVERRIDE;
+  virtual bool HandleMouseEvent(const ui::MouseEvent& event) OVERRIDE;
+  virtual bool HandleKeyEvent(const ui::KeyEvent& event) OVERRIDE;
   virtual void HandleScreenReaderDetected() OVERRIDE;
   virtual bool HandleTooltipNotify(int w_param,
                                    NMHDR* l_param,
                                    LRESULT* l_result) OVERRIDE;
+  virtual void HandleTooltipMouseMove(UINT message,
+                                      WPARAM w_param,
+                                      LPARAM l_param) OVERRIDE;
   virtual NativeWidgetWin* AsNativeWidgetWin() OVERRIDE;
 
   // Called after the WM_ACTIVATE message has been processed by the default
   // windows procedure.
   static void PostProcessActivateMessage(NativeWidgetWin* widget,
                                          int activation_state);
 
   void SetInitParams(const Widget::InitParams& params);
 
   // Synchronously paints the invalid contents of the Widget.
   void RedrawInvalidRect();
 
   // Synchronously updates the invalid contents of the Widget. Valid for
   // layered windows only.
   void RedrawLayeredWindowContents();
 
-  // Lock or unlock the window from being able to redraw itself in response to
-  // updates to its invalid region.
-  class ScopedRedrawLock;
-  void LockUpdates(bool force);
-  void UnlockUpdates(bool force);
-
   // Determines whether the delegate expects the client size or the window size.
   bool WidgetSizeIsClientSize() const;
 
-  // Responds to the client area changing size, either at window creation time
-  // or subsequently.
-  void ClientAreaSizeChanged();
-
-  // When removing the standard frame, tells the DWM how much glass we want on
-  // the edges. Currently hardcoded to 10px on all sides.
-  void UpdateDWMFrame();
-
-  // Calls DefWindowProc, safely wrapping the call in a ScopedRedrawLock to
-  // prevent frame flicker. DefWindowProc handling can otherwise render the
-  // classic-look window title bar directly.
-  LRESULT DefWindowProcWithRedrawLock(UINT message,
-                                      WPARAM w_param,
-                                      LPARAM l_param);
-
   // Stops ignoring SetWindowPos() requests (see below).
   void StopIgnoringPosChanges() { ignore_window_pos_changes_ = false; }
 
   void RestoreEnabledIfNecessary();
 
   void SetInitialFocus();
 
   // Notifies any owned windows that we're closing.
   void NotifyOwnedWindowsParentClosing();
 
-  // Overridden from internal::InputMethodDelegate
-  virtual void DispatchKeyEventPostIME(const ui::KeyEvent& key) OVERRIDE;
-
   // Common implementation of fullscreen-related code. This method handles
   // changing from windowed mode to a display mode (dubbed fullscreen mode)
   // where the window occupies a fixed portion (possibly 100%) of the screen.
   // |fullscreen| specifies whether we are entering or leaving fullscreen mode.
   // |for_metro| specifies whether we are doing this at the behest of a metro
   //             snap transition.
   void SetFullscreenInternal(bool fullscreen, bool for_metro);
 
   // A delegate implementation that handles events received here.
   // See class documentation for Widget in widget.h for a note about ownership.
   internal::NativeWidgetDelegate* delegate_;
 
   // The following factory is used for calls to close the NativeWidgetWin
   // instance.
   base::WeakPtrFactory<NativeWidgetWin> close_widget_factory_;
 
-  // The flags currently being used with TrackMouseEvent to track mouse
-  // messages. 0 if there is no active tracking. The value of this member is
-  // used when tracking is canceled.
-  DWORD active_mouse_tracking_flags_;
-
   // Should we keep an off-screen buffer? This is false by default, set to true
   // when WS_EX_LAYERED is specified before the native window is created.
   //
   // NOTE: this is intended to be used with a layered window (a window with an
   // extended window style of WS_EX_LAYERED). If you are using a layered window
   // and NOT changing the layered alpha or anything else, then leave this value
   // alone. OTOH if you are invoking SetLayeredWindowAttributes then you'll
   // most likely want to set this to false, or after changing the alpha toggle
   // the extended style bit to false than back to true. See MSDN for more
   // details.
@@ skipping 61 matching lines @@
   // If this is greater than zero, we should prevent attempts to make the window
   // visible when we handle WM_WINDOWPOSCHANGING. Some calls like
   // ShowWindow(SW_RESTORE) make the window visible in addition to restoring it,
   // when all we want to do is restore it.
   int force_hidden_count_;
 
   // The window styles before we modified them for the drag frame appearance.
   DWORD drag_frame_saved_window_style_;
   DWORD drag_frame_saved_window_ex_style_;
 
-  // Represents the number of ScopedRedrawLocks active against this widget.
-  // If this is greater than zero, the widget should be locked against updates.
-  int lock_updates_count_;
-
   // When true, this flag makes us discard incoming SetWindowPos() requests that
   // only change our position/size.  (We still allow changes to Z-order,
   // activation, etc.)
   bool ignore_window_pos_changes_;
 
   // The following factory is used to ignore SetWindowPos() calls for short time
   // periods.
   base::WeakPtrFactory<NativeWidgetWin> ignore_pos_changes_factory_;
 
   // The last-seen monitor containing us, and its rect and work area.  These are
   // used to catch updates to the rect and work area and react accordingly.
   HMONITOR last_monitor_;
   gfx::Rect last_monitor_rect_, last_work_area_;
 
-  // Set to true when the user presses the right mouse button on the caption
-  // area. We need this so we can correctly show the context menu on mouse-up.
-  bool is_right_mouse_pressed_on_caption_;
-
   // Whether all ancestors have been enabled. This is only used if is_modal_ is
   // true.
   bool restored_enabled_;
 
-  // This flag can be initialized and checked after certain operations (such as
-  // DefWindowProc) to avoid stack-controlled NativeWidgetWin operations (such
-  // as unlocking the Window with a ScopedRedrawLock) after Widget destruction.
-  bool* destroyed_;
-
   // True if the widget is going to have a non_client_view. We cache this value
   // rather than asking the Widget for the non_client_view so that we know at
   // Init time, before the Widget has created the NonClientView.
   bool has_non_client_view_;
 
-  // The set of touch devices currently down.
-  TouchIDs touch_ids_;
-
   scoped_ptr<HWNDMessageHandler> message_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetWin);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIDGET_NATIVE_WIDGET_WIN_H_