Move more code from NWW to HWNDMessageHandler.

ui/views/win/hwnd_message_handler.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_WIN_HWND_MESSAGE_HANDLER_H_
 #define UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_
 
 #include <atlbase.h>
 #include <atlapp.h>
 #include <atlmisc.h>
 #include <windows.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/string16.h"
 #include "ui/base/accessibility/accessibility_types.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/ime/input_method_delegate.h"
 #include "ui/views/views_export.h"
 
 namespace gfx {
 class Canvas;
+class ImageSkia;
 class Insets;
 }
 
 namespace views {
 
 class FullscreenHandler;
 class HWNDMessageHandlerDelegate;
 class InputMethod;
 
 VIEWS_EXPORT bool IsAeroGlassEnabled();
 
 // An object that handles messages for a HWND that implements the views
 // "Custom Frame" look. The purpose of this class is to isolate the windows-
 // specific message handling from the code that wraps it. It is intended to be
 // used by both a views::NativeWidget and an aura::RootWindowHost
 // implementation.
 // TODO(beng): This object should eventually *become* the WindowImpl.
 class VIEWS_EXPORT HWNDMessageHandler : public internal::InputMethodDelegate {
  public:
   explicit HWNDMessageHandler(HWNDMessageHandlerDelegate* delegate);
   ~HWNDMessageHandler();
 
   void Init(const gfx::Rect& bounds);
   void InitModalType(ui::ModalType modal_type);
 
+  void Close();
   void CloseNow();
 
   gfx::Rect GetWindowBoundsInScreen() const;
   gfx::Rect GetClientAreaBoundsInScreen() const;
   gfx::Rect GetRestoredBounds() const;
   void GetWindowPlacement(gfx::Rect* bounds,
                           ui::WindowShowState* show_state) const;
   gfx::Rect GetWorkAreaBoundsInScreen() const;
 
   void SetBounds(const gfx::Rect& bounds);
   void SetSize(const gfx::Size& size);
   void CenterWindow(const gfx::Size& size);
 
   void SetRegion(HRGN rgn);
 
   void StackAbove(HWND other_hwnd);
   void StackAtTop();
 
+  void Show();
+  void ShowWindowWithState(ui::WindowShowState show_state);
+  // TODO(beng): distinguish from ShowWindowWithState().
+  void Show(int show_state);
   void ShowMaximizedWithBounds(const gfx::Rect& bounds);
   void Hide();
 
   void Maximize();
   void Minimize();
   void Restore();
 
   void Activate();
   void Deactivate();
 
   void SetAlwaysOnTop(bool on_top);
 
   bool IsVisible() const;
   bool IsActive() const;
   bool IsMinimized() const;
   bool IsMaximized() const;
 
   bool RunMoveLoop(const gfx::Point& drag_offset);
+  void EndMoveLoop();
 
   // Tells the HWND its client area has changed.
   void SendFrameChanged();
 
   void FlashFrame(bool flash);
 
   void ClearNativeFocus();
   void FocusHWND(HWND hwnd);
 
   void SetCapture();
   void ReleaseCapture();
   bool HasCapture() const;
 
   FullscreenHandler* fullscreen_handler() { return fullscreen_handler_.get(); }
 
   void SetVisibilityChangedAnimationsEnabled(bool enabled);
 
   InputMethod* CreateInputMethod();
 
+  void SetTitle(const string16& title);
+
+  void SetAccessibleName(const string16& name);
+  void SetAccessibleRole(ui::AccessibilityTypes::Role role);
+  void SetAccessibleState(ui::AccessibilityTypes::State state);
   void SendNativeAccessibilityEvent(int id,
                                     ui::AccessibilityTypes::Event event_type);
 
   void SetCursor(HCURSOR cursor);
 
   void FrameTypeChanged();
 
   // 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;
   }
   void SchedulePaintInRect(const gfx::Rect& rect);
   void SetOpacity(BYTE opacity);
 
+  void SetWindowIcons(const gfx::ImageSkia& window_icon,
+                      const gfx::ImageSkia& app_icon);
+
   // Message Handlers.
   void OnActivate(UINT action, BOOL minimized, HWND window);
   // TODO(beng): Once this object becomes the WindowImpl, these methods can
   //             be made private.
   void OnActivateApp(BOOL active, DWORD thread_id);
   // TODO(beng): return BOOL is temporary until this object becomes a
   //             WindowImpl.
   BOOL OnAppCommand(HWND window, short command, WORD device, int keystate);
   void OnCancelMode();
   void OnCaptureChanged(HWND window);
@@ skipping 59 matching lines @@
   //             WindowImpl.
   HWND hwnd();
   HWND hwnd() const;
 
  private:
   typedef std::set<DWORD> TouchIDs;
 
   // TODO(beng): remove once this is the WindowImpl.
   friend class NativeWidgetWin;
 
-  // Overridden from internal::InputMethodDelegate
+  // Overridden from internal::InputMethodDelegate:
   virtual void DispatchKeyEventPostIME(const ui::KeyEvent& key) OVERRIDE;
 
+  // Overridden from WindowImpl:
+  virtual HICON GetDefaultWindowIcon() const;
+  virtual LRESULT OnWndProc(UINT message, WPARAM w_param, LPARAM l_param);
+
+  // Can be called after the delegate has had the opportunity to set focus and
+  // did not do so.
+  void SetInitialFocus();
+
+  // Called after the WM_ACTIVATE message has been processed by the default
+  // windows procedure.
+  void PostProcessActivateMessage(int activation_state);
+
+  // Enables disabled owner windows that may have been disabled due to this
+  // window's modality.
+  void RestoreEnabledIfNecessary();
+
   // Executes the specified SC_command.
   void ExecuteSystemMenuCommand(int command);
 
   // Start tracking all mouse events so that this window gets sent mouse leave
   // messages too.
   void TrackMouseEvents(DWORD mouse_tracking_flags);
 
   // Responds to the client area changing size, either at window creation time
   // or subsequently.
   void ClientAreaSizeChanged();
@@ skipping 28 matching lines @@
   // layered windows only.
   void RedrawLayeredWindowContents();
 
   // TODO(beng): Remove once this class becomes the WindowImpl.
   void SetMsgHandled(BOOL handled);
 
   HWNDMessageHandlerDelegate* delegate_;
 
   scoped_ptr<FullscreenHandler> fullscreen_handler_;
 
+  // The following factory is used for calls to close the NativeWidgetWin
+  // instance.
+  base::WeakPtrFactory<HWNDMessageHandler> close_widget_factory_;
+
   bool remove_standard_frame_;
 
+  // Whether the focus should be restored next time we get enabled.  Needed to
+  // restore focus correctly when Windows modal dialogs are displayed.
+  bool restore_focus_when_enabled_;
+
+  // Whether all ancestors have been enabled. This is only used if is_modal_ is
+  // true.
+  bool restored_enabled_;
+
   // The last cursor that was active before the current one was selected. Saved
   // so that we can restore it.
   HCURSOR previous_cursor_;
 
   // Event handling ------------------------------------------------------------
 
   // 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_;
@@ skipping 68 matching lines @@
   // True if we are allowed to update the layered window from the DIB backing
   // store if necessary.
   bool can_update_layered_window_;
 
   DISALLOW_COPY_AND_ASSIGN(HWNDMessageHandler);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIN_HWND_MESSAGE_HANDLER_H_