src/ui/views/widget/desktop_aura/desktop_window_tree_host_win.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_WIN_H_
   6 #define UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_WIN_H_
   7
   8 #include "ui/aura/client/animation_host.h"
   9 #include "ui/aura/window_tree_host.h"
  10 #include "ui/views/views_export.h"
  11 #include "ui/views/widget/desktop_aura/desktop_window_tree_host.h"
  12 #include "ui/views/win/hwnd_message_handler_delegate.h"
  13
  14 namespace aura {
  15 namespace client {
  16 class DragDropClient;
  17 class FocusClient;
  18 class ScopedTooltipDisabler;
  19 }
  20 }
  21
  22 namespace views {
  23 class DesktopCursorClient;
  24 class DesktopDragDropClientWin;
  25 class HWNDMessageHandler;
  26
  27 namespace corewm {
  28 class TooltipWin;
  29 }
  30
  31 class VIEWS_EXPORT DesktopWindowTreeHostWin
  32     : public DesktopWindowTreeHost,
  33       public aura::client::AnimationHost,
  34       public aura::WindowTreeHost,
  35       public ui::EventSource,
  36       public HWNDMessageHandlerDelegate {
  37  public:
  38   DesktopWindowTreeHostWin(
  39       internal::NativeWidgetDelegate* native_widget_delegate,
  40       DesktopNativeWidgetAura* desktop_native_widget_aura);
  41   virtual ~DesktopWindowTreeHostWin();
  42
  43   // A way of converting an HWND into a content window.
  44   static aura::Window* GetContentWindowForHWND(HWND hwnd);
  45
  46  protected:
  47   // Overridden from DesktopWindowTreeHost:
  48   virtual void Init(aura::Window* content_window,
  49                     const Widget::InitParams& params,
  50                     aura::RootWindow::CreateParams* rw_create_params) OVERRIDE;
  51   virtual void OnRootWindowCreated(aura::RootWindow* root,
  52                                    const Widget::InitParams& params) OVERRIDE;
  53   virtual scoped_ptr<corewm::Tooltip> CreateTooltip() OVERRIDE;
  54   virtual scoped_ptr<aura::client::DragDropClient>
  55       CreateDragDropClient(DesktopNativeCursorManager* cursor_manager) OVERRIDE;
  56   virtual void Close() OVERRIDE;
  57   virtual void CloseNow() OVERRIDE;
  58   virtual aura::WindowTreeHost* AsWindowTreeHost() OVERRIDE;
  59   virtual void ShowWindowWithState(ui::WindowShowState show_state) OVERRIDE;
  60   virtual void ShowMaximizedWithBounds(
  61       const gfx::Rect& restored_bounds) OVERRIDE;
  62   virtual bool IsVisible() const OVERRIDE;
  63   virtual void SetSize(const gfx::Size& size) OVERRIDE;
  64   virtual void StackAtTop() OVERRIDE;
  65   virtual void CenterWindow(const gfx::Size& size) OVERRIDE;
  66   virtual void GetWindowPlacement(
  67       gfx::Rect* bounds,
  68       ui::WindowShowState* show_state) const OVERRIDE;
  69   virtual gfx::Rect GetWindowBoundsInScreen() const OVERRIDE;
  70   virtual gfx::Rect GetClientAreaBoundsInScreen() const OVERRIDE;
  71   virtual gfx::Rect GetRestoredBounds() const OVERRIDE;
  72   virtual gfx::Rect GetWorkAreaBoundsInScreen() const OVERRIDE;
  73   virtual void SetShape(gfx::NativeRegion native_region) OVERRIDE;
  74   virtual void Activate() OVERRIDE;
  75   virtual void Deactivate() OVERRIDE;
  76   virtual bool IsActive() const OVERRIDE;
  77   virtual void Maximize() OVERRIDE;
  78   virtual void Minimize() OVERRIDE;
  79   virtual void Restore() OVERRIDE;
  80   virtual bool IsMaximized() const OVERRIDE;
  81   virtual bool IsMinimized() const OVERRIDE;
  82   virtual bool HasCapture() const OVERRIDE;
  83   virtual void SetAlwaysOnTop(bool always_on_top) OVERRIDE;
  84   virtual bool IsAlwaysOnTop() const OVERRIDE;
  85   virtual bool SetWindowTitle(const base::string16& title) OVERRIDE;
  86   virtual void ClearNativeFocus() OVERRIDE;
  87   virtual Widget::MoveLoopResult RunMoveLoop(
  88       const gfx::Vector2d& drag_offset,
  89       Widget::MoveLoopSource source,
  90       Widget::MoveLoopEscapeBehavior escape_behavior) OVERRIDE;
  91   virtual void EndMoveLoop() OVERRIDE;
  92   virtual void SetVisibilityChangedAnimationsEnabled(bool value) OVERRIDE;
  93   virtual bool ShouldUseNativeFrame() const OVERRIDE;
  94   virtual bool ShouldWindowContentsBeTransparent() const OVERRIDE;
  95   virtual void FrameTypeChanged() OVERRIDE;
  96   virtual NonClientFrameView* CreateNonClientFrameView() OVERRIDE;
  97   virtual void SetFullscreen(bool fullscreen) OVERRIDE;
  98   virtual bool IsFullscreen() const OVERRIDE;
  99   virtual void SetOpacity(unsigned char opacity) OVERRIDE;
 100   virtual void SetWindowIcons(const gfx::ImageSkia& window_icon,
 101                               const gfx::ImageSkia& app_icon) OVERRIDE;
 102   virtual void InitModalType(ui::ModalType modal_type) OVERRIDE;
 103   virtual void FlashFrame(bool flash_frame) OVERRIDE;
 104   virtual void OnRootViewLayout() const OVERRIDE;
 105   virtual void OnNativeWidgetFocus() OVERRIDE;
 106   virtual void OnNativeWidgetBlur() OVERRIDE;
 107   virtual bool IsAnimatingClosed() const OVERRIDE;
 108
 109   // Overridden from aura::WindowTreeHost:
 110   virtual aura::RootWindow* GetRootWindow() OVERRIDE;
 111   virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
 112   virtual void Show() OVERRIDE;
 113   virtual void Hide() OVERRIDE;
 114   virtual void ToggleFullScreen() OVERRIDE;
 115   virtual gfx::Rect GetBounds() const OVERRIDE;
 116   virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
 117   virtual gfx::Insets GetInsets() const OVERRIDE;
 118   virtual void SetInsets(const gfx::Insets& insets) OVERRIDE;
 119   virtual gfx::Point GetLocationOnNativeScreen() const OVERRIDE;
 120   virtual void SetCapture() OVERRIDE;
 121   virtual void ReleaseCapture() OVERRIDE;
 122   virtual bool QueryMouseLocation(gfx::Point* location_return) OVERRIDE;
 123   virtual bool ConfineCursorToRootWindow() OVERRIDE;
 124   virtual void UnConfineCursor() OVERRIDE;
 125   virtual void PostNativeEvent(const base::NativeEvent& native_event) OVERRIDE;
 126   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
 127   virtual void PrepareForShutdown() OVERRIDE;
 128   virtual void SetCursorNative(gfx::NativeCursor cursor) OVERRIDE;
 129   virtual void OnCursorVisibilityChangedNative(bool show) OVERRIDE;
 130   virtual void MoveCursorToNative(const gfx::Point& location) OVERRIDE;
 131
 132   // Overridden frm ui::EventSource
 133   virtual ui::EventProcessor* GetEventProcessor() OVERRIDE;
 134
 135   // Overridden from aura::client::AnimationHost
 136   virtual void SetHostTransitionOffsets(
 137       const gfx::Vector2d& top_left_delta,
 138       const gfx::Vector2d& bottom_right_delta) OVERRIDE;
 139   virtual void OnWindowHidingAnimationCompleted() OVERRIDE;
 140
 141   // Overridden from HWNDMessageHandlerDelegate:
 142   virtual bool IsWidgetWindow() const OVERRIDE;
 143   virtual bool IsUsingCustomFrame() const OVERRIDE;
 144   virtual void SchedulePaint() OVERRIDE;
 145   virtual void EnableInactiveRendering() OVERRIDE;
 146   virtual bool IsInactiveRenderingDisabled() OVERRIDE;
 147   virtual bool CanResize() const OVERRIDE;
 148   virtual bool CanMaximize() const OVERRIDE;
 149   virtual bool CanActivate() const OVERRIDE;
 150   virtual bool WidgetSizeIsClientSize() const OVERRIDE;
 151   virtual bool CanSaveFocus() const OVERRIDE;
 152   virtual void SaveFocusOnDeactivate() OVERRIDE;
 153   virtual void RestoreFocusOnActivate() OVERRIDE;
 154   virtual void RestoreFocusOnEnable() OVERRIDE;
 155   virtual bool IsModal() const OVERRIDE;
 156   virtual int GetInitialShowState() const OVERRIDE;
 157   virtual bool WillProcessWorkAreaChange() const OVERRIDE;
 158   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
 159   virtual void GetWindowMask(const gfx::Size& size, gfx::Path* path) OVERRIDE;
 160   virtual bool GetClientAreaInsets(gfx::Insets* insets) const OVERRIDE;
 161   virtual void GetMinMaxSize(gfx::Size* min_size,
 162                              gfx::Size* max_size) const OVERRIDE;
 163   virtual gfx::Size GetRootViewSize() const OVERRIDE;
 164   virtual void ResetWindowControls() OVERRIDE;
 165   virtual void PaintLayeredWindow(gfx::Canvas* canvas) OVERRIDE;
 166   virtual gfx::NativeViewAccessible GetNativeViewAccessible() OVERRIDE;
 167   virtual bool ShouldHandleSystemCommands() const OVERRIDE;
 168   virtual InputMethod* GetInputMethod() OVERRIDE;
 169   virtual void HandleAppDeactivated() OVERRIDE;
 170   virtual void HandleActivationChanged(bool active) OVERRIDE;
 171   virtual bool HandleAppCommand(short command) OVERRIDE;
 172   virtual void HandleCancelMode() OVERRIDE;
 173   virtual void HandleCaptureLost() OVERRIDE;
 174   virtual void HandleClose() OVERRIDE;
 175   virtual bool HandleCommand(int command) OVERRIDE;
 176   virtual void HandleAccelerator(const ui::Accelerator& accelerator) OVERRIDE;
 177   virtual void HandleCreate() OVERRIDE;
 178   virtual void HandleDestroying() OVERRIDE;
 179   virtual void HandleDestroyed() OVERRIDE;
 180   virtual bool HandleInitialFocus(ui::WindowShowState show_state) OVERRIDE;
 181   virtual void HandleDisplayChange() OVERRIDE;
 182   virtual void HandleBeginWMSizeMove() OVERRIDE;
 183   virtual void HandleEndWMSizeMove() OVERRIDE;
 184   virtual void HandleMove() OVERRIDE;
 185   virtual void HandleWorkAreaChanged() OVERRIDE;
 186   virtual void HandleVisibilityChanging(bool visible) OVERRIDE;
 187   virtual void HandleVisibilityChanged(bool visible) OVERRIDE;
 188   virtual void HandleClientSizeChanged(const gfx::Size& new_size) OVERRIDE;
 189   virtual void HandleFrameChanged() OVERRIDE;
 190   virtual void HandleNativeFocus(HWND last_focused_window) OVERRIDE;
 191   virtual void HandleNativeBlur(HWND focused_window) OVERRIDE;
 192   virtual bool HandleMouseEvent(const ui::MouseEvent& event) OVERRIDE;
 193   virtual bool HandleKeyEvent(const ui::KeyEvent& event) OVERRIDE;
 194   virtual bool HandleUntranslatedKeyEvent(const ui::KeyEvent& event) OVERRIDE;
 195   virtual void HandleTouchEvent(const ui::TouchEvent& event) OVERRIDE;
 196   virtual bool HandleIMEMessage(UINT message,
 197                                 WPARAM w_param,
 198                                 LPARAM l_param,
 199                                 LRESULT* result) OVERRIDE;
 200   virtual void HandleInputLanguageChange(DWORD character_set,
 201                                          HKL input_language_id) OVERRIDE;
 202   virtual bool HandlePaintAccelerated(const gfx::Rect& invalid_rect) OVERRIDE;
 203   virtual void HandlePaint(gfx::Canvas* canvas) OVERRIDE;
 204   virtual bool HandleTooltipNotify(int w_param,
 205                                    NMHDR* l_param,
 206                                    LRESULT* l_result) OVERRIDE;
 207   virtual void HandleTooltipMouseMove(UINT message,
 208                                       WPARAM w_param,
 209                                       LPARAM l_param) OVERRIDE;
 210   virtual void HandleMenuLoop(bool in_menu_loop) OVERRIDE;
 211   virtual bool PreHandleMSG(UINT message,
 212                             WPARAM w_param,
 213                             LPARAM l_param,
 214                             LRESULT* result) OVERRIDE;
 215   virtual void PostHandleMSG(UINT message,
 216                              WPARAM w_param,
 217                              LPARAM l_param) OVERRIDE;
 218   virtual bool HandleScrollEvent(const ui::ScrollEvent& event) OVERRIDE;
 219
 220   Widget* GetWidget();
 221   const Widget* GetWidget() const;
 222   HWND GetHWND() const;
 223
 224  private:
 225   void SetWindowTransparency();
 226
 227   // Returns true if a modal window is active in the current root window chain.
 228   bool IsModalWindowActive() const;
 229
 230   // We are owned by the RootWindow, but we have to have a back pointer to it.
 231   aura::RootWindow* root_window_;
 232
 233   scoped_ptr<HWNDMessageHandler> message_handler_;
 234   scoped_ptr<aura::client::FocusClient> focus_client_;
 235
 236   // TODO(beng): Consider providing an interface to DesktopNativeWidgetAura
 237   //             instead of providing this route back to Widget.
 238   internal::NativeWidgetDelegate* native_widget_delegate_;
 239
 240   DesktopNativeWidgetAura* desktop_native_widget_aura_;
 241
 242   aura::Window* content_window_;
 243
 244   // Owned by DesktopNativeWidgetAura.
 245   DesktopDragDropClientWin* drag_drop_client_;
 246
 247   // When certain windows are being shown, we augment the window size
 248   // temporarily for animation. The following two members contain the top left
 249   // and bottom right offsets which are used to enlarge the window.
 250   gfx::Vector2d window_expansion_top_left_delta_;
 251   gfx::Vector2d window_expansion_bottom_right_delta_;
 252
 253   // Windows are enlarged to be at least 64x64 pixels, so keep track of the
 254   // extra added here.
 255   gfx::Vector2d window_enlargement_;
 256
 257   // Whether the window close should be converted to a hide, and then actually
 258   // closed on the completion of the hide animation. This is cached because
 259   // the property is set on the contained window which has a shorter lifetime.
 260   bool should_animate_window_close_;
 261
 262   // When Close()d and animations are being applied to this window, the close
 263   // of the window needs to be deferred to when the close animation is
 264   // completed. This variable indicates that a Close was converted to a Hide,
 265   // so that when the Hide is completed the host window should be closed.
 266   bool pending_close_;
 267
 268   // True if the widget is going to have a non_client_view. We cache this value
 269   // rather than asking the Widget for the non_client_view so that we know at
 270   // Init time, before the Widget has created the NonClientView.
 271   bool has_non_client_view_;
 272
 273   // Owned by TooltipController, but we need to forward events to it so we keep
 274   // a reference.
 275   corewm::TooltipWin* tooltip_;
 276
 277   // Visibility of the cursor. On Windows we can have multiple root windows and
 278   // the implementation of ::ShowCursor() is based on a counter, so making this
 279   // member static ensures that ::ShowCursor() is always called exactly once
 280   // whenever the cursor visibility state changes.
 281   static bool is_cursor_visible_;
 282
 283   scoped_ptr<aura::client::ScopedTooltipDisabler> tooltip_disabler_;
 284
 285   DISALLOW_COPY_AND_ASSIGN(DesktopWindowTreeHostWin);
 286 };
 287
 288 }  // namespace views
 289
 290 #endif  // UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_WIN_H_