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