ui/views/widget/desktop_aura/desktop_root_window_host_win.cc

   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 #include "ui/views/widget/desktop_aura/desktop_root_window_host_win.h"
   6
   7 #include "base/win/metro.h"
   8 #include "third_party/skia/include/core/SkPath.h"
   9 #include "third_party/skia/include/core/SkRegion.h"
  10 #include "ui/aura/client/aura_constants.h"
  11 #include "ui/aura/client/cursor_client.h"
  12 #include "ui/aura/client/focus_client.h"
  13 #include "ui/aura/client/scoped_tooltip_disabler.h"
  14 #include "ui/aura/root_window.h"
  15 #include "ui/aura/window_property.h"
  16 #include "ui/base/cursor/cursor_loader_win.h"
  17 #include "ui/base/ime/input_method.h"
  18 #include "ui/base/win/shell.h"
  19 #include "ui/compositor/compositor_constants.h"
  20 #include "ui/gfx/insets.h"
  21 #include "ui/gfx/native_widget_types.h"
  22 #include "ui/gfx/path.h"
  23 #include "ui/gfx/path_win.h"
  24 #include "ui/gfx/vector2d.h"
  25 #include "ui/gfx/win/dpi.h"
  26 #include "ui/native_theme/native_theme_aura.h"
  27 #include "ui/native_theme/native_theme_win.h"
  28 #include "ui/views/corewm/compound_event_filter.h"
  29 #include "ui/views/corewm/corewm_switches.h"
  30 #include "ui/views/corewm/input_method_event_filter.h"
  31 #include "ui/views/corewm/tooltip_win.h"
  32 #include "ui/views/corewm/window_animations.h"
  33 #include "ui/views/ime/input_method_bridge.h"
  34 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h"
  35 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_win.h"
  36 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
  37 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
  38 #include "ui/views/widget/root_view.h"
  39 #include "ui/views/widget/widget_delegate.h"
  40 #include "ui/views/widget/widget_hwnd_utils.h"
  41 #include "ui/views/win/fullscreen_handler.h"
  42 #include "ui/views/win/hwnd_message_handler.h"
  43 #include "ui/views/window/native_frame_view.h"
  44
  45 namespace views {
  46
  47 namespace {
  48
  49 gfx::Size GetExpandedWindowSize(DWORD window_style, gfx::Size size) {
  50   if (!(window_style & WS_EX_COMPOSITED) || !ui::win::IsAeroGlassEnabled())
  51     return size;
  52
  53   // Some AMD drivers can't display windows that are less than 64x64 pixels,
  54   // so expand them to be at least that size. http://crbug.com/286609
  55   gfx::Size expanded(std::max(size.width(), 64), std::max(size.height(), 64));
  56   return expanded;
  57 }
  58
  59 void InsetBottomRight(gfx::Rect* rect, gfx::Vector2d vector) {
  60   rect->Inset(0, 0, vector.x(), vector.y());
  61 }
  62
  63 }  // namespace
  64
  65 DEFINE_WINDOW_PROPERTY_KEY(aura::Window*, kContentWindowForRootWindow, NULL);
  66
  67 // Identifies the DesktopWindowTreeHostWin associated with the RootWindow.
  68 DEFINE_WINDOW_PROPERTY_KEY(DesktopWindowTreeHostWin*, kDesktopWindowTreeHostKey,
  69                            NULL);
  70
  71 ////////////////////////////////////////////////////////////////////////////////
  72 // DesktopWindowTreeHostWin, public:
  73
  74 bool DesktopWindowTreeHostWin::is_cursor_visible_ = true;
  75
  76 DesktopWindowTreeHostWin::DesktopWindowTreeHostWin(
  77     internal::NativeWidgetDelegate* native_widget_delegate,
  78     DesktopNativeWidgetAura* desktop_native_widget_aura)
  79     : root_window_(NULL),
  80       message_handler_(new HWNDMessageHandler(this)),
  81       native_widget_delegate_(native_widget_delegate),
  82       desktop_native_widget_aura_(desktop_native_widget_aura),
  83       content_window_(NULL),
  84       drag_drop_client_(NULL),
  85       should_animate_window_close_(false),
  86       pending_close_(false),
  87       has_non_client_view_(false),
  88       tooltip_(NULL) {
  89 }
  90
  91 DesktopWindowTreeHostWin::~DesktopWindowTreeHostWin() {
  92   // WARNING: |content_window_| has been destroyed by the time we get here.
  93   desktop_native_widget_aura_->OnDesktopWindowTreeHostDestroyed(
  94       root_window_);
  95 }
  96
  97 // static
  98 aura::Window* DesktopWindowTreeHostWin::GetContentWindowForHWND(HWND hwnd) {
  99   aura::RootWindow* root = aura::RootWindow::GetForAcceleratedWidget(hwnd);
 100   return root ? root->window()->GetProperty(kContentWindowForRootWindow) : NULL;
 101 }
 102
 103 // static
 104 ui::NativeTheme* DesktopWindowTreeHost::GetNativeTheme(aura::Window* window) {
 105   // Use NativeThemeWin for windows shown on the desktop, those not on the
 106   // desktop come from Ash and get NativeThemeAura.
 107   aura::WindowEventDispatcher* dispatcher =
 108       window ? window->GetDispatcher() : NULL;
 109   if (dispatcher) {
 110     HWND host_hwnd = dispatcher->host()->GetAcceleratedWidget();
 111     if (host_hwnd &&
 112         DesktopWindowTreeHostWin::GetContentWindowForHWND(host_hwnd)) {
 113       return ui::NativeThemeWin::instance();
 114     }
 115   }
 116   return ui::NativeThemeAura::instance();
 117 }
 118
 119 ////////////////////////////////////////////////////////////////////////////////
 120 // DesktopWindowTreeHostWin, DesktopWindowTreeHost implementation:
 121
 122 void DesktopWindowTreeHostWin::Init(
 123     aura::Window* content_window,
 124     const Widget::InitParams& params,
 125     aura::RootWindow::CreateParams* rw_create_params) {
 126   // TODO(beng): SetInitParams().
 127   content_window_ = content_window;
 128
 129   aura::client::SetAnimationHost(content_window_, this);
 130
 131   ConfigureWindowStyles(message_handler_.get(), params,
 132                         GetWidget()->widget_delegate(),
 133                         native_widget_delegate_);
 134
 135   HWND parent_hwnd = NULL;
 136   if (params.parent && params.parent->GetDispatcher()) {
 137     parent_hwnd =
 138         params.parent->GetDispatcher()->host()->GetAcceleratedWidget();
 139   }
 140
 141   message_handler_->set_remove_standard_frame(params.remove_standard_frame);
 142
 143   has_non_client_view_ = Widget::RequiresNonClientView(params.type);
 144
 145   gfx::Rect pixel_bounds = gfx::win::DIPToScreenRect(params.bounds);
 146   message_handler_->Init(parent_hwnd, pixel_bounds);
 147   if (params.type == Widget::InitParams::TYPE_MENU) {
 148     ::SetProp(GetAcceleratedWidget(),
 149               kForceSoftwareCompositor,
 150               reinterpret_cast<HANDLE>(true));
 151   }
 152   CreateCompositor(GetAcceleratedWidget());
 153
 154   rw_create_params->host = this;
 155 }
 156
 157 void DesktopWindowTreeHostWin::OnRootWindowCreated(
 158     aura::RootWindow* root,
 159     const Widget::InitParams& params) {
 160   root_window_ = root;
 161
 162   // The cursor is not necessarily visible when the root window is created.
 163   aura::client::CursorClient* cursor_client =
 164       aura::client::GetCursorClient(root_window_->window());
 165   if (cursor_client)
 166     is_cursor_visible_ = cursor_client->IsCursorVisible();
 167
 168   root_window_->window()->SetProperty(kContentWindowForRootWindow,
 169                                       content_window_);
 170   root_window_->window()->SetProperty(kDesktopWindowTreeHostKey, this);
 171
 172   should_animate_window_close_ =
 173       content_window_->type() != ui::wm::WINDOW_TYPE_NORMAL &&
 174       !views::corewm::WindowAnimationsDisabled(content_window_);
 175
 176 // TODO this is not invoked *after* Init(), but should be ok.
 177   SetWindowTransparency();
 178 }
 179
 180 scoped_ptr<corewm::Tooltip> DesktopWindowTreeHostWin::CreateTooltip() {
 181   DCHECK(!tooltip_);
 182   tooltip_ = new corewm::TooltipWin(GetAcceleratedWidget());
 183   return scoped_ptr<corewm::Tooltip>(tooltip_);
 184 }
 185
 186 scoped_ptr<aura::client::DragDropClient>
 187 DesktopWindowTreeHostWin::CreateDragDropClient(
 188     DesktopNativeCursorManager* cursor_manager) {
 189   drag_drop_client_ = new DesktopDragDropClientWin(root_window_->window(),
 190                                                    GetHWND());
 191   return scoped_ptr<aura::client::DragDropClient>(drag_drop_client_).Pass();
 192 }
 193
 194 void DesktopWindowTreeHostWin::Close() {
 195   // TODO(beng): Move this entire branch to DNWA so it can be shared with X11.
 196   if (should_animate_window_close_) {
 197     pending_close_ = true;
 198     const bool is_animating =
 199         content_window_->layer()->GetAnimator()->IsAnimatingProperty(
 200             ui::LayerAnimationElement::VISIBILITY);
 201     // Animation may not start for a number of reasons.
 202     if (!is_animating)
 203       message_handler_->Close();
 204     // else case, OnWindowHidingAnimationCompleted does the actual Close.
 205   } else {
 206     message_handler_->Close();
 207   }
 208 }
 209
 210 void DesktopWindowTreeHostWin::CloseNow() {
 211   message_handler_->CloseNow();
 212 }
 213
 214 aura::WindowTreeHost* DesktopWindowTreeHostWin::AsWindowTreeHost() {
 215   return this;
 216 }
 217
 218 void DesktopWindowTreeHostWin::ShowWindowWithState(
 219     ui::WindowShowState show_state) {
 220   message_handler_->ShowWindowWithState(show_state);
 221 }
 222
 223 void DesktopWindowTreeHostWin::ShowMaximizedWithBounds(
 224     const gfx::Rect& restored_bounds) {
 225   gfx::Rect pixel_bounds = gfx::win::DIPToScreenRect(restored_bounds);
 226   message_handler_->ShowMaximizedWithBounds(pixel_bounds);
 227 }
 228
 229 bool DesktopWindowTreeHostWin::IsVisible() const {
 230   return message_handler_->IsVisible();
 231 }
 232
 233 void DesktopWindowTreeHostWin::SetSize(const gfx::Size& size) {
 234   gfx::Size size_in_pixels = gfx::win::DIPToScreenSize(size);
 235   gfx::Size expanded = GetExpandedWindowSize(
 236       message_handler_->window_ex_style(), size_in_pixels);
 237   window_enlargement_ =
 238       gfx::Vector2d(expanded.width() - size_in_pixels.width(),
 239                     expanded.height() - size_in_pixels.height());
 240   message_handler_->SetSize(expanded);
 241 }
 242
 243 void DesktopWindowTreeHostWin::StackAtTop() {
 244   message_handler_->StackAtTop();
 245 }
 246
 247 void DesktopWindowTreeHostWin::CenterWindow(const gfx::Size& size) {
 248   gfx::Size size_in_pixels = gfx::win::DIPToScreenSize(size);
 249   gfx::Size expanded_size;
 250   expanded_size = GetExpandedWindowSize(message_handler_->window_ex_style(),
 251                                         size_in_pixels);
 252   window_enlargement_ =
 253       gfx::Vector2d(expanded_size.width() - size_in_pixels.width(),
 254                     expanded_size.height() - size_in_pixels.height());
 255   message_handler_->CenterWindow(expanded_size);
 256 }
 257
 258 void DesktopWindowTreeHostWin::GetWindowPlacement(
 259     gfx::Rect* bounds,
 260     ui::WindowShowState* show_state) const {
 261   message_handler_->GetWindowPlacement(bounds, show_state);
 262   InsetBottomRight(bounds, window_enlargement_);
 263   *bounds = gfx::win::ScreenToDIPRect(*bounds);
 264 }
 265
 266 gfx::Rect DesktopWindowTreeHostWin::GetWindowBoundsInScreen() const {
 267   gfx::Rect pixel_bounds = message_handler_->GetWindowBoundsInScreen();
 268   InsetBottomRight(&pixel_bounds, window_enlargement_);
 269   return gfx::win::ScreenToDIPRect(pixel_bounds);
 270 }
 271
 272 gfx::Rect DesktopWindowTreeHostWin::GetClientAreaBoundsInScreen() const {
 273   gfx::Rect pixel_bounds = message_handler_->GetClientAreaBoundsInScreen();
 274   InsetBottomRight(&pixel_bounds, window_enlargement_);
 275   return gfx::win::ScreenToDIPRect(pixel_bounds);
 276 }
 277
 278 gfx::Rect DesktopWindowTreeHostWin::GetRestoredBounds() const {
 279   gfx::Rect pixel_bounds = message_handler_->GetRestoredBounds();
 280   InsetBottomRight(&pixel_bounds, window_enlargement_);
 281   return gfx::win::ScreenToDIPRect(pixel_bounds);
 282 }
 283
 284 gfx::Rect DesktopWindowTreeHostWin::GetWorkAreaBoundsInScreen() const {
 285   MONITORINFO monitor_info;
 286   monitor_info.cbSize = sizeof(monitor_info);
 287   GetMonitorInfo(MonitorFromWindow(message_handler_->hwnd(),
 288                                    MONITOR_DEFAULTTONEAREST),
 289                  &monitor_info);
 290   gfx::Rect pixel_bounds = gfx::Rect(monitor_info.rcWork);
 291   return gfx::win::ScreenToDIPRect(pixel_bounds);
 292 }
 293
 294 void DesktopWindowTreeHostWin::SetShape(gfx::NativeRegion native_region) {
 295   if (native_region) {
 296     message_handler_->SetRegion(gfx::CreateHRGNFromSkRegion(*native_region));
 297   } else {
 298     message_handler_->SetRegion(NULL);
 299   }
 300
 301   delete native_region;
 302 }
 303
 304 void DesktopWindowTreeHostWin::Activate() {
 305   message_handler_->Activate();
 306 }
 307
 308 void DesktopWindowTreeHostWin::Deactivate() {
 309   message_handler_->Deactivate();
 310 }
 311
 312 bool DesktopWindowTreeHostWin::IsActive() const {
 313   return message_handler_->IsActive();
 314 }
 315
 316 void DesktopWindowTreeHostWin::Maximize() {
 317   message_handler_->Maximize();
 318 }
 319
 320 void DesktopWindowTreeHostWin::Minimize() {
 321   message_handler_->Minimize();
 322 }
 323
 324 void DesktopWindowTreeHostWin::Restore() {
 325   message_handler_->Restore();
 326 }
 327
 328 bool DesktopWindowTreeHostWin::IsMaximized() const {
 329   return message_handler_->IsMaximized();
 330 }
 331
 332 bool DesktopWindowTreeHostWin::IsMinimized() const {
 333   return message_handler_->IsMinimized();
 334 }
 335
 336 bool DesktopWindowTreeHostWin::HasCapture() const {
 337   return message_handler_->HasCapture();
 338 }
 339
 340 void DesktopWindowTreeHostWin::SetAlwaysOnTop(bool always_on_top) {
 341   message_handler_->SetAlwaysOnTop(always_on_top);
 342 }
 343
 344 bool DesktopWindowTreeHostWin::IsAlwaysOnTop() const {
 345   return message_handler_->IsAlwaysOnTop();
 346 }
 347
 348 bool DesktopWindowTreeHostWin::SetWindowTitle(const base::string16& title) {
 349   return message_handler_->SetTitle(title);
 350 }
 351
 352 void DesktopWindowTreeHostWin::ClearNativeFocus() {
 353   message_handler_->ClearNativeFocus();
 354 }
 355
 356 Widget::MoveLoopResult DesktopWindowTreeHostWin::RunMoveLoop(
 357     const gfx::Vector2d& drag_offset,
 358     Widget::MoveLoopSource source,
 359     Widget::MoveLoopEscapeBehavior escape_behavior) {
 360   const bool hide_on_escape =
 361       escape_behavior == Widget::MOVE_LOOP_ESCAPE_BEHAVIOR_HIDE;
 362   return message_handler_->RunMoveLoop(drag_offset, hide_on_escape) ?
 363       Widget::MOVE_LOOP_SUCCESSFUL : Widget::MOVE_LOOP_CANCELED;
 364 }
 365
 366 void DesktopWindowTreeHostWin::EndMoveLoop() {
 367   message_handler_->EndMoveLoop();
 368 }
 369
 370 void DesktopWindowTreeHostWin::SetVisibilityChangedAnimationsEnabled(
 371     bool value) {
 372   message_handler_->SetVisibilityChangedAnimationsEnabled(value);
 373   content_window_->SetProperty(aura::client::kAnimationsDisabledKey, !value);
 374 }
 375
 376 bool DesktopWindowTreeHostWin::ShouldUseNativeFrame() {
 377   return ui::win::IsAeroGlassEnabled();
 378 }
 379
 380 void DesktopWindowTreeHostWin::FrameTypeChanged() {
 381   message_handler_->FrameTypeChanged();
 382   SetWindowTransparency();
 383 }
 384
 385 NonClientFrameView* DesktopWindowTreeHostWin::CreateNonClientFrameView() {
 386   return GetWidget()->ShouldUseNativeFrame() ?
 387       new NativeFrameView(GetWidget()) : NULL;
 388 }
 389
 390 void DesktopWindowTreeHostWin::SetFullscreen(bool fullscreen) {
 391   message_handler_->fullscreen_handler()->SetFullscreen(fullscreen);
 392   // TODO(sky): workaround for ScopedFullscreenVisibility showing window
 393   // directly. Instead of this should listen for visibility changes and then
 394   // update window.
 395   if (message_handler_->IsVisible() && !content_window_->TargetVisibility())
 396     content_window_->Show();
 397   SetWindowTransparency();
 398 }
 399
 400 bool DesktopWindowTreeHostWin::IsFullscreen() const {
 401   return message_handler_->fullscreen_handler()->fullscreen();
 402 }
 403
 404 void DesktopWindowTreeHostWin::SetOpacity(unsigned char opacity) {
 405   message_handler_->SetOpacity(static_cast<BYTE>(opacity));
 406   content_window_->layer()->SetOpacity(opacity / 255.0);
 407 }
 408
 409 void DesktopWindowTreeHostWin::SetWindowIcons(
 410     const gfx::ImageSkia& window_icon, const gfx::ImageSkia& app_icon) {
 411   message_handler_->SetWindowIcons(window_icon, app_icon);
 412 }
 413
 414 void DesktopWindowTreeHostWin::InitModalType(ui::ModalType modal_type) {
 415   message_handler_->InitModalType(modal_type);
 416 }
 417
 418 void DesktopWindowTreeHostWin::FlashFrame(bool flash_frame) {
 419   message_handler_->FlashFrame(flash_frame);
 420 }
 421
 422 void DesktopWindowTreeHostWin::OnRootViewLayout() const {
 423 }
 424
 425 void DesktopWindowTreeHostWin::OnNativeWidgetFocus() {
 426   // HWNDMessageHandler will perform the proper updating on its own.
 427 }
 428
 429 void DesktopWindowTreeHostWin::OnNativeWidgetBlur() {
 430 }
 431
 432 bool DesktopWindowTreeHostWin::IsAnimatingClosed() const {
 433   return pending_close_;
 434 }
 435
 436 ////////////////////////////////////////////////////////////////////////////////
 437 // DesktopWindowTreeHostWin, WindowTreeHost implementation:
 438
 439 aura::RootWindow* DesktopWindowTreeHostWin::GetRootWindow() {
 440   return root_window_;
 441 }
 442
 443 gfx::AcceleratedWidget DesktopWindowTreeHostWin::GetAcceleratedWidget() {
 444   return message_handler_->hwnd();
 445 }
 446
 447 void DesktopWindowTreeHostWin::Show() {
 448   message_handler_->Show();
 449 }
 450
 451 void DesktopWindowTreeHostWin::Hide() {
 452   if (!pending_close_)
 453     message_handler_->Hide();
 454 }
 455
 456 void DesktopWindowTreeHostWin::ToggleFullScreen() {
 457   SetWindowTransparency();
 458 }
 459
 460 // GetBounds and SetBounds work in pixel coordinates, whereas other get/set
 461 // methods work in DIP.
 462
 463 gfx::Rect DesktopWindowTreeHostWin::GetBounds() const {
 464   gfx::Rect bounds(message_handler_->GetClientAreaBounds());
 465   // If the window bounds were expanded we need to return the original bounds
 466   // To achieve this we do the reverse of the expansion, i.e. add the
 467   // window_expansion_top_left_delta_ to the origin and subtract the
 468   // window_expansion_bottom_right_delta_ from the width and height.
 469   gfx::Rect without_expansion(
 470       bounds.x() + window_expansion_top_left_delta_.x(),
 471       bounds.y() + window_expansion_top_left_delta_.y(),
 472       bounds.width() - window_expansion_bottom_right_delta_.x() -
 473           window_enlargement_.x(),
 474       bounds.height() - window_expansion_bottom_right_delta_.y() -
 475           window_enlargement_.y());
 476   return without_expansion;
 477 }
 478
 479 void DesktopWindowTreeHostWin::SetBounds(const gfx::Rect& bounds) {
 480   // If the window bounds have to be expanded we need to subtract the
 481   // window_expansion_top_left_delta_ from the origin and add the
 482   // window_expansion_bottom_right_delta_ to the width and height
 483   gfx::Size old_hwnd_size(message_handler_->GetClientAreaBounds().size());
 484   gfx::Size old_content_size = GetBounds().size();
 485
 486   gfx::Rect expanded(
 487       bounds.x() - window_expansion_top_left_delta_.x(),
 488       bounds.y() - window_expansion_top_left_delta_.y(),
 489       bounds.width() + window_expansion_bottom_right_delta_.x(),
 490       bounds.height() + window_expansion_bottom_right_delta_.y());
 491
 492   gfx::Rect new_expanded(
 493       expanded.origin(),
 494       GetExpandedWindowSize(message_handler_->window_ex_style(),
 495                             expanded.size()));
 496   window_enlargement_ =
 497       gfx::Vector2d(new_expanded.width() - expanded.width(),
 498                     new_expanded.height() - expanded.height());
 499   message_handler_->SetBounds(new_expanded);
 500
 501   // The client area size may have changed even though the window bounds have
 502   // not, if the window bounds were expanded to 64 pixels both times.
 503   if (old_hwnd_size == new_expanded.size() && old_content_size != bounds.size())
 504     HandleClientSizeChanged(new_expanded.size());
 505 }
 506
 507 gfx::Insets DesktopWindowTreeHostWin::GetInsets() const {
 508   return gfx::Insets();
 509 }
 510
 511 void DesktopWindowTreeHostWin::SetInsets(const gfx::Insets& insets) {
 512 }
 513
 514 gfx::Point DesktopWindowTreeHostWin::GetLocationOnNativeScreen() const {
 515   return GetBounds().origin();
 516 }
 517
 518 void DesktopWindowTreeHostWin::SetCapture() {
 519   message_handler_->SetCapture();
 520 }
 521
 522 void DesktopWindowTreeHostWin::ReleaseCapture() {
 523   message_handler_->ReleaseCapture();
 524 }
 525
 526 void DesktopWindowTreeHostWin::SetCursor(gfx::NativeCursor cursor) {
 527   ui::CursorLoaderWin cursor_loader;
 528   cursor_loader.SetPlatformCursor(&cursor);
 529
 530   message_handler_->SetCursor(cursor.platform());
 531 }
 532
 533 bool DesktopWindowTreeHostWin::QueryMouseLocation(gfx::Point* location_return) {
 534   aura::client::CursorClient* cursor_client =
 535       aura::client::GetCursorClient(root_window_->window());
 536   if (cursor_client && !cursor_client->IsMouseEventsEnabled()) {
 537     *location_return = gfx::Point(0, 0);
 538     return false;
 539   }
 540   POINT pt = {0};
 541   ::GetCursorPos(&pt);
 542   *location_return =
 543       gfx::Point(static_cast<int>(pt.x), static_cast<int>(pt.y));
 544   return true;
 545 }
 546
 547 bool DesktopWindowTreeHostWin::ConfineCursorToRootWindow() {
 548   RECT window_rect = root_window_->window()->GetBoundsInScreen().ToRECT();
 549   ::ClipCursor(&window_rect);
 550   return true;
 551 }
 552
 553 void DesktopWindowTreeHostWin::UnConfineCursor() {
 554   ::ClipCursor(NULL);
 555 }
 556
 557 void DesktopWindowTreeHostWin::OnCursorVisibilityChanged(bool show) {
 558   if (is_cursor_visible_ == show)
 559     return;
 560   is_cursor_visible_ = show;
 561   ::ShowCursor(!!show);
 562 }
 563
 564 void DesktopWindowTreeHostWin::MoveCursorTo(const gfx::Point& location) {
 565   POINT cursor_location = location.ToPOINT();
 566   ::ClientToScreen(GetHWND(), &cursor_location);
 567   ::SetCursorPos(cursor_location.x, cursor_location.y);
 568 }
 569
 570 void DesktopWindowTreeHostWin::PostNativeEvent(
 571     const base::NativeEvent& native_event) {
 572 }
 573
 574 void DesktopWindowTreeHostWin::OnDeviceScaleFactorChanged(
 575     float device_scale_factor) {
 576 }
 577
 578 void DesktopWindowTreeHostWin::PrepareForShutdown() {
 579 }
 580
 581
 582 ////////////////////////////////////////////////////////////////////////////////
 583 // DesktopWindowTreeHostWin, ui::EventSource implementation:
 584
 585 ui::EventProcessor* DesktopWindowTreeHostWin::GetEventProcessor() {
 586   return delegate_->GetEventProcessor();
 587 }
 588
 589 ////////////////////////////////////////////////////////////////////////////////
 590 // DesktopWindowTreeHostWin, aura::AnimationHost implementation:
 591
 592 void DesktopWindowTreeHostWin::SetHostTransitionOffsets(
 593     const gfx::Vector2d& top_left_delta,
 594     const gfx::Vector2d& bottom_right_delta) {
 595   gfx::Rect bounds_without_expansion = GetBounds();
 596   window_expansion_top_left_delta_ = top_left_delta;
 597   window_expansion_bottom_right_delta_ = bottom_right_delta;
 598   SetBounds(bounds_without_expansion);
 599 }
 600
 601 void DesktopWindowTreeHostWin::OnWindowHidingAnimationCompleted() {
 602   if (pending_close_)
 603     message_handler_->Close();
 604 }
 605
 606 ////////////////////////////////////////////////////////////////////////////////
 607 // DesktopWindowTreeHostWin, HWNDMessageHandlerDelegate implementation:
 608
 609 bool DesktopWindowTreeHostWin::IsWidgetWindow() const {
 610   return has_non_client_view_;
 611 }
 612
 613 bool DesktopWindowTreeHostWin::IsUsingCustomFrame() const {
 614   return !GetWidget()->ShouldUseNativeFrame();
 615 }
 616
 617 void DesktopWindowTreeHostWin::SchedulePaint() {
 618   GetWidget()->GetRootView()->SchedulePaint();
 619 }
 620
 621 void DesktopWindowTreeHostWin::EnableInactiveRendering() {
 622   native_widget_delegate_->EnableInactiveRendering();
 623 }
 624
 625 bool DesktopWindowTreeHostWin::IsInactiveRenderingDisabled() {
 626   return native_widget_delegate_->IsInactiveRenderingDisabled();
 627 }
 628
 629 bool DesktopWindowTreeHostWin::CanResize() const {
 630   return GetWidget()->widget_delegate()->CanResize();
 631 }
 632
 633 bool DesktopWindowTreeHostWin::CanMaximize() const {
 634   return GetWidget()->widget_delegate()->CanMaximize();
 635 }
 636
 637 bool DesktopWindowTreeHostWin::CanActivate() const {
 638   if (IsModalWindowActive())
 639     return true;
 640   return native_widget_delegate_->CanActivate();
 641 }
 642
 643 bool DesktopWindowTreeHostWin::WidgetSizeIsClientSize() const {
 644   const Widget* widget = GetWidget()->GetTopLevelWidget();
 645   return IsMaximized() || (widget && widget->ShouldUseNativeFrame());
 646 }
 647
 648 bool DesktopWindowTreeHostWin::CanSaveFocus() const {
 649   return GetWidget()->is_top_level();
 650 }
 651
 652 void DesktopWindowTreeHostWin::SaveFocusOnDeactivate() {
 653   GetWidget()->GetFocusManager()->StoreFocusedView(true);
 654 }
 655
 656 void DesktopWindowTreeHostWin::RestoreFocusOnActivate() {
 657   RestoreFocusOnEnable();
 658 }
 659
 660 void DesktopWindowTreeHostWin::RestoreFocusOnEnable() {
 661   GetWidget()->GetFocusManager()->RestoreFocusedView();
 662 }
 663
 664 bool DesktopWindowTreeHostWin::IsModal() const {
 665   return native_widget_delegate_->IsModal();
 666 }
 667
 668 int DesktopWindowTreeHostWin::GetInitialShowState() const {
 669   return SW_SHOWNORMAL;
 670 }
 671
 672 bool DesktopWindowTreeHostWin::WillProcessWorkAreaChange() const {
 673   return GetWidget()->widget_delegate()->WillProcessWorkAreaChange();
 674 }
 675
 676 int DesktopWindowTreeHostWin::GetNonClientComponent(
 677     const gfx::Point& point) const {
 678   gfx::Point dip_position = gfx::win::ScreenToDIPPoint(point);
 679   return native_widget_delegate_->GetNonClientComponent(dip_position);
 680 }
 681
 682 void DesktopWindowTreeHostWin::GetWindowMask(const gfx::Size& size,
 683                                              gfx::Path* path) {
 684   if (GetWidget()->non_client_view()) {
 685     GetWidget()->non_client_view()->GetWindowMask(size, path);
 686   } else if (!window_enlargement_.IsZero()) {
 687     gfx::Rect bounds(WidgetSizeIsClientSize()
 688                          ? message_handler_->GetClientAreaBoundsInScreen()
 689                          : message_handler_->GetWindowBoundsInScreen());
 690     InsetBottomRight(&bounds, window_enlargement_);
 691     path->addRect(SkRect::MakeXYWH(0, 0, bounds.width(), bounds.height()));
 692   }
 693 }
 694
 695 bool DesktopWindowTreeHostWin::GetClientAreaInsets(gfx::Insets* insets) const {
 696   return false;
 697 }
 698
 699 void DesktopWindowTreeHostWin::GetMinMaxSize(gfx::Size* min_size,
 700                                              gfx::Size* max_size) const {
 701   *min_size = native_widget_delegate_->GetMinimumSize();
 702   *max_size = native_widget_delegate_->GetMaximumSize();
 703 }
 704
 705 gfx::Size DesktopWindowTreeHostWin::GetRootViewSize() const {
 706   return GetWidget()->GetRootView()->size();
 707 }
 708
 709 void DesktopWindowTreeHostWin::ResetWindowControls() {
 710   GetWidget()->non_client_view()->ResetWindowControls();
 711 }
 712
 713 void DesktopWindowTreeHostWin::PaintLayeredWindow(gfx::Canvas* canvas) {
 714   GetWidget()->GetRootView()->Paint(canvas);
 715 }
 716
 717 gfx::NativeViewAccessible DesktopWindowTreeHostWin::GetNativeViewAccessible() {
 718   return GetWidget()->GetRootView()->GetNativeViewAccessible();
 719 }
 720
 721 InputMethod* DesktopWindowTreeHostWin::GetInputMethod() {
 722   return GetWidget()->GetInputMethodDirect();
 723 }
 724
 725 bool DesktopWindowTreeHostWin::ShouldHandleSystemCommands() const {
 726   return GetWidget()->widget_delegate()->ShouldHandleSystemCommands();
 727 }
 728
 729 void DesktopWindowTreeHostWin::HandleAppDeactivated() {
 730   native_widget_delegate_->EnableInactiveRendering();
 731 }
 732
 733 void DesktopWindowTreeHostWin::HandleActivationChanged(bool active) {
 734   // This can be invoked from HWNDMessageHandler::Init(), at which point we're
 735   // not in a good state and need to ignore it.
 736   if (!delegate_)
 737     return;
 738
 739   if (active)
 740     delegate_->OnHostActivated();
 741   desktop_native_widget_aura_->HandleActivationChanged(active);
 742 }
 743
 744 bool DesktopWindowTreeHostWin::HandleAppCommand(short command) {
 745   // We treat APPCOMMAND ids as an extension of our command namespace, and just
 746   // let the delegate figure out what to do...
 747   return GetWidget()->widget_delegate() &&
 748       GetWidget()->widget_delegate()->ExecuteWindowsCommand(command);
 749 }
 750
 751 void DesktopWindowTreeHostWin::HandleCancelMode() {
 752   delegate_->OnHostCancelMode();
 753 }
 754
 755 void DesktopWindowTreeHostWin::HandleCaptureLost() {
 756   delegate_->OnHostLostWindowCapture();
 757   native_widget_delegate_->OnMouseCaptureLost();
 758 }
 759
 760 void DesktopWindowTreeHostWin::HandleClose() {
 761   GetWidget()->Close();
 762 }
 763
 764 bool DesktopWindowTreeHostWin::HandleCommand(int command) {
 765   return GetWidget()->widget_delegate()->ExecuteWindowsCommand(command);
 766 }
 767
 768 void DesktopWindowTreeHostWin::HandleAccelerator(
 769     const ui::Accelerator& accelerator) {
 770   GetWidget()->GetFocusManager()->ProcessAccelerator(accelerator);
 771 }
 772
 773 void DesktopWindowTreeHostWin::HandleCreate() {
 774   // TODO(beng): moar
 775   NOTIMPLEMENTED();
 776
 777   native_widget_delegate_->OnNativeWidgetCreated(true);
 778
 779   // 1. Window property association
 780   // 2. MouseWheel.
 781 }
 782
 783 void DesktopWindowTreeHostWin::HandleDestroying() {
 784   drag_drop_client_->OnNativeWidgetDestroying(GetHWND());
 785   native_widget_delegate_->OnNativeWidgetDestroying();
 786
 787   // Destroy the compositor before destroying the HWND since shutdown
 788   // may try to swap to the window.
 789   DestroyCompositor();
 790 }
 791
 792 void DesktopWindowTreeHostWin::HandleDestroyed() {
 793   desktop_native_widget_aura_->OnHostClosed();
 794 }
 795
 796 bool DesktopWindowTreeHostWin::HandleInitialFocus(
 797     ui::WindowShowState show_state) {
 798   return GetWidget()->SetInitialFocus(show_state);
 799 }
 800
 801 void DesktopWindowTreeHostWin::HandleDisplayChange() {
 802   GetWidget()->widget_delegate()->OnDisplayChanged();
 803 }
 804
 805 void DesktopWindowTreeHostWin::HandleBeginWMSizeMove() {
 806   native_widget_delegate_->OnNativeWidgetBeginUserBoundsChange();
 807 }
 808
 809 void DesktopWindowTreeHostWin::HandleEndWMSizeMove() {
 810   native_widget_delegate_->OnNativeWidgetEndUserBoundsChange();
 811 }
 812
 813 void DesktopWindowTreeHostWin::HandleMove() {
 814   native_widget_delegate_->OnNativeWidgetMove();
 815   if (delegate_)
 816     delegate_->OnHostMoved(GetBounds().origin());
 817 }
 818
 819 void DesktopWindowTreeHostWin::HandleWorkAreaChanged() {
 820   GetWidget()->widget_delegate()->OnWorkAreaChanged();
 821 }
 822
 823 void DesktopWindowTreeHostWin::HandleVisibilityChanging(bool visible) {
 824   native_widget_delegate_->OnNativeWidgetVisibilityChanging(visible);
 825 }
 826
 827 void DesktopWindowTreeHostWin::HandleVisibilityChanged(bool visible) {
 828   native_widget_delegate_->OnNativeWidgetVisibilityChanged(visible);
 829 }
 830
 831 void DesktopWindowTreeHostWin::HandleClientSizeChanged(
 832     const gfx::Size& new_size) {
 833   if (delegate_)
 834     NotifyHostResized(new_size);
 835 }
 836
 837 void DesktopWindowTreeHostWin::HandleFrameChanged() {
 838   SetWindowTransparency();
 839   // Replace the frame and layout the contents.
 840   GetWidget()->non_client_view()->UpdateFrame();
 841 }
 842
 843 void DesktopWindowTreeHostWin::HandleNativeFocus(HWND last_focused_window) {
 844   // TODO(beng): inform the native_widget_delegate_.
 845   InputMethod* input_method = GetInputMethod();
 846   if (input_method)
 847     input_method->OnFocus();
 848 }
 849
 850 void DesktopWindowTreeHostWin::HandleNativeBlur(HWND focused_window) {
 851   // TODO(beng): inform the native_widget_delegate_.
 852   InputMethod* input_method = GetInputMethod();
 853   if (input_method)
 854     input_method->OnBlur();
 855 }
 856
 857 bool DesktopWindowTreeHostWin::HandleMouseEvent(const ui::MouseEvent& event) {
 858   SendEventToProcessor(const_cast<ui::MouseEvent*>(&event));
 859   return event.handled();
 860 }
 861
 862 bool DesktopWindowTreeHostWin::HandleKeyEvent(const ui::KeyEvent& event) {
 863   return false;
 864 }
 865
 866 bool DesktopWindowTreeHostWin::HandleUntranslatedKeyEvent(
 867     const ui::KeyEvent& event) {
 868   ui::KeyEvent duplicate_event(event);
 869   SendEventToProcessor(&duplicate_event);
 870   return duplicate_event.handled();
 871 }
 872
 873 void DesktopWindowTreeHostWin::HandleTouchEvent(
 874     const ui::TouchEvent& event) {
 875   // HWNDMessageHandler asynchronously processes touch events. Because of this
 876   // it's possible for the aura::RootWindow to have been destroyed by the time
 877   // we attempt to process them.
 878   if (!GetWidget()->GetNativeView())
 879     return;
 880
 881   // Currently we assume the window that has capture gets touch events too.
 882   aura::RootWindow* root =
 883       aura::RootWindow::GetForAcceleratedWidget(GetCapture());
 884   if (root) {
 885     DesktopWindowTreeHostWin* target =
 886         root->window()->GetProperty(kDesktopWindowTreeHostKey);
 887     if (target && target->HasCapture() && target != this) {
 888       POINT target_location(event.location().ToPOINT());
 889       ClientToScreen(GetHWND(), &target_location);
 890       ScreenToClient(target->GetHWND(), &target_location);
 891       ui::TouchEvent target_event(event, static_cast<View*>(NULL),
 892                                   static_cast<View*>(NULL));
 893       target_event.set_location(gfx::Point(target_location));
 894       target_event.set_root_location(target_event.location());
 895       target->SendEventToProcessor(&target_event);
 896       return;
 897     }
 898   }
 899   SendEventToProcessor(const_cast<ui::TouchEvent*>(&event));
 900 }
 901
 902 bool DesktopWindowTreeHostWin::HandleIMEMessage(UINT message,
 903                                                 WPARAM w_param,
 904                                                 LPARAM l_param,
 905                                                 LRESULT* result) {
 906   MSG msg = {};
 907   msg.hwnd = GetHWND();
 908   msg.message = message;
 909   msg.wParam = w_param;
 910   msg.lParam = l_param;
 911   return desktop_native_widget_aura_->input_method_event_filter()->
 912       input_method()->OnUntranslatedIMEMessage(msg, result);
 913 }
 914
 915 void DesktopWindowTreeHostWin::HandleInputLanguageChange(
 916     DWORD character_set,
 917     HKL input_language_id) {
 918   desktop_native_widget_aura_->input_method_event_filter()->
 919       input_method()->OnInputLocaleChanged();
 920 }
 921
 922 bool DesktopWindowTreeHostWin::HandlePaintAccelerated(
 923     const gfx::Rect& invalid_rect) {
 924   return native_widget_delegate_->OnNativeWidgetPaintAccelerated(invalid_rect);
 925 }
 926
 927 void DesktopWindowTreeHostWin::HandlePaint(gfx::Canvas* canvas) {
 928   compositor()->ScheduleRedrawRect(gfx::Rect());
 929 }
 930
 931 bool DesktopWindowTreeHostWin::HandleTooltipNotify(int w_param,
 932                                                    NMHDR* l_param,
 933                                                    LRESULT* l_result) {
 934   return tooltip_ && tooltip_->HandleNotify(w_param, l_param, l_result);
 935 }
 936
 937 void DesktopWindowTreeHostWin::HandleTooltipMouseMove(UINT message,
 938                                                       WPARAM w_param,
 939                                                       LPARAM l_param) {
 940   // TooltipWin implementation doesn't need this.
 941   // TODO(sky): remove from HWNDMessageHandler once non-aura path nuked.
 942 }
 943
 944 void DesktopWindowTreeHostWin::HandleMenuLoop(bool in_menu_loop) {
 945   if (in_menu_loop) {
 946     tooltip_disabler_.reset(
 947         new aura::client::ScopedTooltipDisabler(root_window_->window()));
 948   } else {
 949     tooltip_disabler_.reset();
 950   }
 951 }
 952
 953 bool DesktopWindowTreeHostWin::PreHandleMSG(UINT message,
 954                                             WPARAM w_param,
 955                                             LPARAM l_param,
 956                                             LRESULT* result) {
 957   return false;
 958 }
 959
 960 void DesktopWindowTreeHostWin::PostHandleMSG(UINT message,
 961                                              WPARAM w_param,
 962                                              LPARAM l_param) {
 963 }
 964
 965 bool DesktopWindowTreeHostWin::HandleScrollEvent(
 966     const ui::ScrollEvent& event) {
 967   SendEventToProcessor(const_cast<ui::ScrollEvent*>(&event));
 968   return event.handled();
 969 }
 970
 971 ////////////////////////////////////////////////////////////////////////////////
 972 // DesktopWindowTreeHostWin, private:
 973
 974 Widget* DesktopWindowTreeHostWin::GetWidget() {
 975   return native_widget_delegate_->AsWidget();
 976 }
 977
 978 const Widget* DesktopWindowTreeHostWin::GetWidget() const {
 979   return native_widget_delegate_->AsWidget();
 980 }
 981
 982 HWND DesktopWindowTreeHostWin::GetHWND() const {
 983   return message_handler_->hwnd();
 984 }
 985
 986 void DesktopWindowTreeHostWin::SetWindowTransparency() {
 987   bool transparent = ShouldUseNativeFrame() && !IsFullscreen();
 988   root_window_->host()->compositor()->SetHostHasTransparentBackground(
 989       transparent);
 990   root_window_->window()->SetTransparent(transparent);
 991   content_window_->SetTransparent(transparent);
 992 }
 993
 994 bool DesktopWindowTreeHostWin::IsModalWindowActive() const {
 995   // This function can get called during window creation which occurs before
 996   // root_window_ has been created.
 997   if (!root_window_)
 998     return false;
 999
1000   aura::Window::Windows::const_iterator index;
1001   for (index = root_window_->window()->children().begin();
1002        index != root_window_->window()->children().end();
1003        ++index) {
1004     if ((*index)->GetProperty(aura::client::kModalKey) !=
1005         ui:: MODAL_TYPE_NONE && (*index)->TargetVisibility())
1006       return true;
1007   }
1008   return false;
1009 }
1010
1011 ////////////////////////////////////////////////////////////////////////////////
1012 // DesktopWindowTreeHost, public:
1013
1014 // static
1015 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
1016     internal::NativeWidgetDelegate* native_widget_delegate,
1017     DesktopNativeWidgetAura* desktop_native_widget_aura) {
1018   return new DesktopWindowTreeHostWin(native_widget_delegate,
1019                                       desktop_native_widget_aura);
1020 }
1021
1022 }  // namespace views