ui/views/widget/native_widget_aura.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/native_widget_aura.h"
   6
   7 #include "base/bind.h"
   8 #include "base/strings/string_util.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/screen_position_client.h"
  14 #include "ui/aura/client/window_tree_client.h"
  15 #include "ui/aura/env.h"
  16 #include "ui/aura/window.h"
  17 #include "ui/aura/window_event_dispatcher.h"
  18 #include "ui/aura/window_observer.h"
  19 #include "ui/aura/window_tree_host.h"
  20 #include "ui/base/dragdrop/os_exchange_data.h"
  21 #include "ui/base/ui_base_types.h"
  22 #include "ui/compositor/layer.h"
  23 #include "ui/events/event.h"
  24 #include "ui/gfx/canvas.h"
  25 #include "ui/gfx/font_list.h"
  26 #include "ui/gfx/screen.h"
  27 #include "ui/native_theme/native_theme_aura.h"
  28 #include "ui/views/drag_utils.h"
  29 #include "ui/views/views_delegate.h"
  30 #include "ui/views/widget/drop_helper.h"
  31 #include "ui/views/widget/native_widget_delegate.h"
  32 #include "ui/views/widget/root_view.h"
  33 #include "ui/views/widget/tooltip_manager_aura.h"
  34 #include "ui/views/widget/widget_aura_utils.h"
  35 #include "ui/views/widget/widget_delegate.h"
  36 #include "ui/views/widget/window_reorderer.h"
  37 #include "ui/wm/core/shadow_types.h"
  38 #include "ui/wm/core/window_animations.h"
  39 #include "ui/wm/core/window_util.h"
  40 #include "ui/wm/public/activation_client.h"
  41 #include "ui/wm/public/drag_drop_client.h"
  42 #include "ui/wm/public/window_move_client.h"
  43 #include "ui/wm/public/window_types.h"
  44
  45 #if defined(OS_WIN)
  46 #include "base/win/scoped_gdi_object.h"
  47 #include "base/win/win_util.h"
  48 #include "ui/base/l10n/l10n_util_win.h"
  49 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
  50 #endif
  51
  52 #if defined(USE_X11) && !defined(OS_CHROMEOS)
  53 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
  54 #endif
  55
  56 #if !defined(OS_CHROMEOS)
  57 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
  58 #include "ui/views/widget/desktop_aura/desktop_window_tree_host.h"
  59 #endif
  60
  61 namespace views {
  62
  63 namespace {
  64
  65 void SetRestoreBounds(aura::Window* window, const gfx::Rect& bounds) {
  66   window->SetProperty(aura::client::kRestoreBoundsKey, new gfx::Rect(bounds));
  67 }
  68
  69 }  // namespace
  70
  71 ////////////////////////////////////////////////////////////////////////////////
  72 // NativeWidgetAura, public:
  73
  74 NativeWidgetAura::NativeWidgetAura(internal::NativeWidgetDelegate* delegate)
  75     : delegate_(delegate),
  76       window_(new aura::Window(this)),
  77       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
  78       destroying_(false),
  79       cursor_(gfx::kNullCursor),
  80       saved_window_state_(ui::SHOW_STATE_DEFAULT),
  81       close_widget_factory_(this) {
  82   aura::client::SetFocusChangeObserver(window_, this);
  83   aura::client::SetActivationChangeObserver(window_, this);
  84 }
  85
  86 // static
  87 void NativeWidgetAura::RegisterNativeWidgetForWindow(
  88       internal::NativeWidgetPrivate* native_widget,
  89       aura::Window* window) {
  90   window->set_user_data(native_widget);
  91 }
  92
  93 ////////////////////////////////////////////////////////////////////////////////
  94 // NativeWidgetAura, internal::NativeWidgetPrivate implementation:
  95
  96 void NativeWidgetAura::InitNativeWidget(const Widget::InitParams& params) {
  97   // Aura needs to know which desktop (Ash or regular) will manage this widget.
  98   // See Widget::InitParams::context for details.
  99   DCHECK(params.parent || params.context);
 100
 101   ownership_ = params.ownership;
 102
 103   RegisterNativeWidgetForWindow(this, window_);
 104   window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
 105   window_->SetProperty(aura::client::kShowStateKey, params.show_state);
 106   if (params.type == Widget::InitParams::TYPE_BUBBLE)
 107     aura::client::SetHideOnDeactivate(window_, true);
 108   window_->SetTransparent(
 109       params.opacity == Widget::InitParams::TRANSLUCENT_WINDOW);
 110   window_->Init(params.layer_type);
 111   if (params.shadow_type == Widget::InitParams::SHADOW_TYPE_NONE)
 112     SetShadowType(window_, wm::SHADOW_TYPE_NONE);
 113   else if (params.shadow_type == Widget::InitParams::SHADOW_TYPE_DROP)
 114     SetShadowType(window_, wm::SHADOW_TYPE_RECTANGULAR);
 115   if (params.type == Widget::InitParams::TYPE_CONTROL)
 116     window_->Show();
 117
 118   delegate_->OnNativeWidgetCreated(false);
 119
 120   gfx::Rect window_bounds = params.bounds;
 121   gfx::NativeView parent = params.parent;
 122   gfx::NativeView context = params.context;
 123   if (!params.child) {
 124     // Set up the transient child before the window is added. This way the
 125     // LayoutManager knows the window has a transient parent.
 126     if (parent && parent->type() != ui::wm::WINDOW_TYPE_UNKNOWN) {
 127       wm::AddTransientChild(parent, window_);
 128       if (!context)
 129         context = parent;
 130       parent = NULL;
 131     }
 132     // SetAlwaysOnTop before SetParent so that always-on-top container is used.
 133     SetAlwaysOnTop(params.keep_on_top);
 134     // Make sure we have a real |window_bounds|.
 135     if (parent && window_bounds == gfx::Rect()) {
 136       // If a parent is specified but no bounds are given,
 137       // use the origin of the parent's display so that the widget
 138       // will be added to the same display as the parent.
 139       gfx::Rect bounds = gfx::Screen::GetScreenFor(parent)->
 140           GetDisplayNearestWindow(parent).bounds();
 141       window_bounds.set_origin(bounds.origin());
 142     }
 143   }
 144
 145   // Set properties before adding to the parent so that its layout manager sees
 146   // the correct values.
 147   OnSizeConstraintsChanged();
 148
 149   if (parent) {
 150     parent->AddChild(window_);
 151   } else {
 152     aura::client::ParentWindowWithContext(
 153         window_, context->GetRootWindow(), window_bounds);
 154   }
 155
 156   // Start observing property changes.
 157   window_->AddObserver(this);
 158
 159   // Wait to set the bounds until we have a parent. That way we can know our
 160   // true state/bounds (the LayoutManager may enforce a particular
 161   // state/bounds).
 162   if (IsMaximized())
 163     SetRestoreBounds(window_, window_bounds);
 164   else
 165     SetBounds(window_bounds);
 166   window_->set_ignore_events(!params.accept_events);
 167   DCHECK(GetWidget()->GetRootView());
 168   if (params.type != Widget::InitParams::TYPE_TOOLTIP)
 169     tooltip_manager_.reset(new views::TooltipManagerAura(GetWidget()));
 170
 171   drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));
 172   if (params.type != Widget::InitParams::TYPE_TOOLTIP &&
 173       params.type != Widget::InitParams::TYPE_POPUP) {
 174     aura::client::SetDragDropDelegate(window_, this);
 175   }
 176
 177   aura::client::SetActivationDelegate(window_, this);
 178
 179   window_reorderer_.reset(new WindowReorderer(window_,
 180       GetWidget()->GetRootView()));
 181 }
 182
 183 NonClientFrameView* NativeWidgetAura::CreateNonClientFrameView() {
 184   return NULL;
 185 }
 186
 187 bool NativeWidgetAura::ShouldUseNativeFrame() const {
 188   // There is only one frame type for aura.
 189   return false;
 190 }
 191
 192 bool NativeWidgetAura::ShouldWindowContentsBeTransparent() const {
 193   return false;
 194 }
 195
 196 void NativeWidgetAura::FrameTypeChanged() {
 197   // This is called when the Theme has changed; forward the event to the root
 198   // widget.
 199   GetWidget()->ThemeChanged();
 200   GetWidget()->GetRootView()->SchedulePaint();
 201 }
 202
 203 Widget* NativeWidgetAura::GetWidget() {
 204   return delegate_->AsWidget();
 205 }
 206
 207 const Widget* NativeWidgetAura::GetWidget() const {
 208   return delegate_->AsWidget();
 209 }
 210
 211 gfx::NativeView NativeWidgetAura::GetNativeView() const {
 212   return window_;
 213 }
 214
 215 gfx::NativeWindow NativeWidgetAura::GetNativeWindow() const {
 216   return window_;
 217 }
 218
 219 Widget* NativeWidgetAura::GetTopLevelWidget() {
 220   NativeWidgetPrivate* native_widget = GetTopLevelNativeWidget(GetNativeView());
 221   return native_widget ? native_widget->GetWidget() : NULL;
 222 }
 223
 224 const ui::Compositor* NativeWidgetAura::GetCompositor() const {
 225   return window_ ? window_->layer()->GetCompositor() : NULL;
 226 }
 227
 228 const ui::Layer* NativeWidgetAura::GetLayer() const {
 229   return window_ ? window_->layer() : NULL;
 230 }
 231
 232 void NativeWidgetAura::ReorderNativeViews() {
 233   window_reorderer_->ReorderChildWindows();
 234 }
 235
 236 void NativeWidgetAura::ViewRemoved(View* view) {
 237   DCHECK(drop_helper_.get() != NULL);
 238   drop_helper_->ResetTargetViewIfEquals(view);
 239 }
 240
 241 void NativeWidgetAura::SetNativeWindowProperty(const char* name, void* value) {
 242   if (window_)
 243     window_->SetNativeWindowProperty(name, value);
 244 }
 245
 246 void* NativeWidgetAura::GetNativeWindowProperty(const char* name) const {
 247   return window_ ? window_->GetNativeWindowProperty(name) : NULL;
 248 }
 249
 250 TooltipManager* NativeWidgetAura::GetTooltipManager() const {
 251   return tooltip_manager_.get();
 252 }
 253
 254 void NativeWidgetAura::SetCapture() {
 255   if (window_)
 256     window_->SetCapture();
 257 }
 258
 259 void NativeWidgetAura::ReleaseCapture() {
 260   if (window_)
 261     window_->ReleaseCapture();
 262 }
 263
 264 bool NativeWidgetAura::HasCapture() const {
 265   return window_ && window_->HasCapture();
 266 }
 267
 268 ui::InputMethod* NativeWidgetAura::GetInputMethod() {
 269   if (!window_)
 270     return nullptr;
 271   aura::Window* root_window = window_->GetRootWindow();
 272   return root_window ? root_window->GetHost()->GetInputMethod() : nullptr;
 273 }
 274
 275 void NativeWidgetAura::CenterWindow(const gfx::Size& size) {
 276   if (!window_)
 277     return;
 278
 279   gfx::Rect parent_bounds(window_->parent()->GetBoundsInRootWindow());
 280   // When centering window, we take the intersection of the host and
 281   // the parent. We assume the root window represents the visible
 282   // rect of a single screen.
 283   gfx::Rect work_area = gfx::Screen::GetScreenFor(window_)->
 284       GetDisplayNearestWindow(window_).work_area();
 285
 286   aura::client::ScreenPositionClient* screen_position_client =
 287       aura::client::GetScreenPositionClient(window_->GetRootWindow());
 288   if (screen_position_client) {
 289     gfx::Point origin = work_area.origin();
 290     screen_position_client->ConvertPointFromScreen(window_->GetRootWindow(),
 291                                                    &origin);
 292     work_area.set_origin(origin);
 293   }
 294
 295   parent_bounds.Intersect(work_area);
 296
 297   // If |window_|'s transient parent's bounds are big enough to fit it, then we
 298   // center it with respect to the transient parent.
 299   if (wm::GetTransientParent(window_)) {
 300     gfx::Rect transient_parent_rect =
 301         wm::GetTransientParent(window_)->GetBoundsInRootWindow();
 302     transient_parent_rect.Intersect(work_area);
 303     if (transient_parent_rect.height() >= size.height() &&
 304         transient_parent_rect.width() >= size.width())
 305       parent_bounds = transient_parent_rect;
 306   }
 307
 308   gfx::Rect window_bounds(
 309       parent_bounds.x() + (parent_bounds.width() - size.width()) / 2,
 310       parent_bounds.y() + (parent_bounds.height() - size.height()) / 2,
 311       size.width(),
 312       size.height());
 313   // Don't size the window bigger than the parent, otherwise the user may not be
 314   // able to close or move it.
 315   window_bounds.AdjustToFit(parent_bounds);
 316
 317   // Convert the bounds back relative to the parent.
 318   gfx::Point origin = window_bounds.origin();
 319   aura::Window::ConvertPointToTarget(window_->GetRootWindow(),
 320       window_->parent(), &origin);
 321   window_bounds.set_origin(origin);
 322   window_->SetBounds(window_bounds);
 323 }
 324
 325 void NativeWidgetAura::GetWindowPlacement(
 326     gfx::Rect* bounds,
 327     ui::WindowShowState* show_state) const {
 328   // The interface specifies returning restored bounds, not current bounds.
 329   *bounds = GetRestoredBounds();
 330   *show_state = window_ ? window_->GetProperty(aura::client::kShowStateKey) :
 331       ui::SHOW_STATE_DEFAULT;
 332 }
 333
 334 bool NativeWidgetAura::SetWindowTitle(const base::string16& title) {
 335   if (!window_)
 336     return false;
 337   if (window_->title() == title)
 338     return false;
 339   window_->SetTitle(title);
 340   return true;
 341 }
 342
 343 void NativeWidgetAura::SetWindowIcons(const gfx::ImageSkia& window_icon,
 344                                       const gfx::ImageSkia& app_icon) {
 345   // Aura doesn't have window icons.
 346 }
 347
 348 void NativeWidgetAura::InitModalType(ui::ModalType modal_type) {
 349   if (modal_type != ui::MODAL_TYPE_NONE)
 350     window_->SetProperty(aura::client::kModalKey, modal_type);
 351 }
 352
 353 gfx::Rect NativeWidgetAura::GetWindowBoundsInScreen() const {
 354   return window_ ? window_->GetBoundsInScreen() : gfx::Rect();
 355 }
 356
 357 gfx::Rect NativeWidgetAura::GetClientAreaBoundsInScreen() const {
 358   // View-to-screen coordinate system transformations depend on this returning
 359   // the full window bounds, for example View::ConvertPointToScreen().
 360   return window_ ? window_->GetBoundsInScreen() : gfx::Rect();
 361 }
 362
 363 gfx::Rect NativeWidgetAura::GetRestoredBounds() const {
 364   if (!window_)
 365     return gfx::Rect();
 366
 367   // Restored bounds should only be relevant if the window is minimized,
 368   // maximized, fullscreen or docked. However, in some places the code expects
 369   // GetRestoredBounds() to return the current window bounds if the window is
 370   // not in either state.
 371   if (IsMinimized() || IsMaximized() || IsFullscreen()) {
 372     // Restore bounds are in screen coordinates, no need to convert.
 373     gfx::Rect* restore_bounds =
 374         window_->GetProperty(aura::client::kRestoreBoundsKey);
 375     if (restore_bounds)
 376       return *restore_bounds;
 377   }
 378   gfx::Rect bounds = window_->GetBoundsInScreen();
 379   if (IsDocked()) {
 380     // Restore bounds are in screen coordinates, no need to convert.
 381     gfx::Rect* restore_bounds =
 382         window_->GetProperty(aura::client::kRestoreBoundsKey);
 383     // Use current window horizontal offset origin in order to preserve docked
 384     // alignment but preserve restored size and vertical offset for the time
 385     // when the |window_| gets undocked.
 386     if (restore_bounds) {
 387       bounds.set_size(restore_bounds->size());
 388       bounds.set_y(restore_bounds->y());
 389     }
 390   }
 391   return bounds;
 392 }
 393
 394 void NativeWidgetAura::SetBounds(const gfx::Rect& bounds) {
 395   if (!window_)
 396     return;
 397
 398   aura::Window* root = window_->GetRootWindow();
 399   if (root) {
 400     aura::client::ScreenPositionClient* screen_position_client =
 401         aura::client::GetScreenPositionClient(root);
 402     if (screen_position_client) {
 403       gfx::Display dst_display =
 404           gfx::Screen::GetScreenFor(window_)->GetDisplayMatching(bounds);
 405       screen_position_client->SetBounds(window_, bounds, dst_display);
 406       return;
 407     }
 408   }
 409   window_->SetBounds(bounds);
 410 }
 411
 412 void NativeWidgetAura::SetSize(const gfx::Size& size) {
 413   if (window_)
 414     window_->SetBounds(gfx::Rect(window_->bounds().origin(), size));
 415 }
 416
 417 void NativeWidgetAura::StackAbove(gfx::NativeView native_view) {
 418   if (window_ && window_->parent() &&
 419       window_->parent() == native_view->parent())
 420     window_->parent()->StackChildAbove(window_, native_view);
 421 }
 422
 423 void NativeWidgetAura::StackAtTop() {
 424   if (window_)
 425     window_->parent()->StackChildAtTop(window_);
 426 }
 427
 428 void NativeWidgetAura::StackBelow(gfx::NativeView native_view) {
 429   if (window_ && window_->parent() &&
 430       window_->parent() == native_view->parent())
 431     window_->parent()->StackChildBelow(window_, native_view);
 432 }
 433
 434 void NativeWidgetAura::SetShape(SkRegion* region) {
 435   if (window_)
 436     window_->layer()->SetAlphaShape(make_scoped_ptr(region));
 437   else
 438     delete region;
 439 }
 440
 441 void NativeWidgetAura::Close() {
 442   // |window_| may already be deleted by parent window. This can happen
 443   // when this widget is child widget or has transient parent
 444   // and ownership is WIDGET_OWNS_NATIVE_WIDGET.
 445   DCHECK(window_ ||
 446          ownership_ == Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 447   if (window_) {
 448     window_->SuppressPaint();
 449     Hide();
 450     window_->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_NONE);
 451   }
 452
 453   if (!close_widget_factory_.HasWeakPtrs()) {
 454     base::MessageLoop::current()->PostTask(
 455         FROM_HERE,
 456         base::Bind(&NativeWidgetAura::CloseNow,
 457                    close_widget_factory_.GetWeakPtr()));
 458   }
 459 }
 460
 461 void NativeWidgetAura::CloseNow() {
 462   delete window_;
 463 }
 464
 465 void NativeWidgetAura::Show() {
 466   ShowWithWindowState(ui::SHOW_STATE_NORMAL);
 467 }
 468
 469 void NativeWidgetAura::Hide() {
 470   if (window_)
 471     window_->Hide();
 472 }
 473
 474 void NativeWidgetAura::ShowMaximizedWithBounds(
 475     const gfx::Rect& restored_bounds) {
 476   SetRestoreBounds(window_, restored_bounds);
 477   ShowWithWindowState(ui::SHOW_STATE_MAXIMIZED);
 478 }
 479
 480 void NativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
 481   if (!window_)
 482     return;
 483
 484   if (state == ui::SHOW_STATE_MAXIMIZED || state == ui::SHOW_STATE_FULLSCREEN ||
 485       state == ui::SHOW_STATE_DOCKED) {
 486     window_->SetProperty(aura::client::kShowStateKey, state);
 487   }
 488   window_->Show();
 489   if (delegate_->CanActivate()) {
 490     if (state != ui::SHOW_STATE_INACTIVE)
 491       Activate();
 492     // SetInitialFocus() should be always be called, even for
 493     // SHOW_STATE_INACTIVE. If the window has to stay inactive, the method will
 494     // do the right thing.
 495     SetInitialFocus(state);
 496   }
 497 }
 498
 499 bool NativeWidgetAura::IsVisible() const {
 500   return window_ && window_->IsVisible();
 501 }
 502
 503 void NativeWidgetAura::Activate() {
 504   if (!window_)
 505     return;
 506
 507   // We don't necessarily have a root window yet. This can happen with
 508   // constrained windows.
 509   if (window_->GetRootWindow()) {
 510     aura::client::GetActivationClient(window_->GetRootWindow())->ActivateWindow(
 511         window_);
 512   }
 513   if (window_->GetProperty(aura::client::kDrawAttentionKey))
 514     window_->SetProperty(aura::client::kDrawAttentionKey, false);
 515 }
 516
 517 void NativeWidgetAura::Deactivate() {
 518   if (!window_)
 519     return;
 520   aura::client::GetActivationClient(window_->GetRootWindow())->DeactivateWindow(
 521       window_);
 522 }
 523
 524 bool NativeWidgetAura::IsActive() const {
 525   return window_ && wm::IsActiveWindow(window_);
 526 }
 527
 528 void NativeWidgetAura::SetAlwaysOnTop(bool on_top) {
 529   if (window_)
 530     window_->SetProperty(aura::client::kAlwaysOnTopKey, on_top);
 531 }
 532
 533 bool NativeWidgetAura::IsAlwaysOnTop() const {
 534   return window_ && window_->GetProperty(aura::client::kAlwaysOnTopKey);
 535 }
 536
 537 void NativeWidgetAura::SetVisibleOnAllWorkspaces(bool always_visible) {
 538   // Not implemented on chromeos or for child widgets.
 539 }
 540
 541 void NativeWidgetAura::Maximize() {
 542   if (window_)
 543     window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 544 }
 545
 546 void NativeWidgetAura::Minimize() {
 547   if (window_)
 548     window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
 549 }
 550
 551 bool NativeWidgetAura::IsMaximized() const {
 552   return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
 553       ui::SHOW_STATE_MAXIMIZED;
 554 }
 555
 556 bool NativeWidgetAura::IsMinimized() const {
 557   return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
 558       ui::SHOW_STATE_MINIMIZED;
 559 }
 560
 561 void NativeWidgetAura::Restore() {
 562   if (window_)
 563     window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 564 }
 565
 566 void NativeWidgetAura::SetFullscreen(bool fullscreen) {
 567   if (!window_ || IsFullscreen() == fullscreen)
 568     return;  // Nothing to do.
 569
 570   // Save window state before entering full screen so that it could restored
 571   // when exiting full screen.
 572   if (fullscreen)
 573     saved_window_state_ = window_->GetProperty(aura::client::kShowStateKey);
 574
 575   window_->SetProperty(
 576       aura::client::kShowStateKey,
 577       fullscreen ? ui::SHOW_STATE_FULLSCREEN : saved_window_state_);
 578 }
 579
 580 bool NativeWidgetAura::IsFullscreen() const {
 581   return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
 582       ui::SHOW_STATE_FULLSCREEN;
 583 }
 584
 585 void NativeWidgetAura::SetOpacity(unsigned char opacity) {
 586   if (window_)
 587     window_->layer()->SetOpacity(opacity / 255.0);
 588 }
 589
 590 void NativeWidgetAura::SetUseDragFrame(bool use_drag_frame) {
 591   NOTIMPLEMENTED();
 592 }
 593
 594 void NativeWidgetAura::FlashFrame(bool flash) {
 595   if (window_)
 596     window_->SetProperty(aura::client::kDrawAttentionKey, flash);
 597 }
 598
 599 void NativeWidgetAura::RunShellDrag(View* view,
 600                                     const ui::OSExchangeData& data,
 601                                     const gfx::Point& location,
 602                                     int operation,
 603                                     ui::DragDropTypes::DragEventSource source) {
 604   if (window_)
 605     views::RunShellDrag(window_, data, location, operation, source);
 606 }
 607
 608 void NativeWidgetAura::SchedulePaintInRect(const gfx::Rect& rect) {
 609   if (window_)
 610     window_->SchedulePaintInRect(rect);
 611 }
 612
 613 void NativeWidgetAura::SetCursor(gfx::NativeCursor cursor) {
 614   cursor_ = cursor;
 615   aura::client::CursorClient* cursor_client =
 616       aura::client::GetCursorClient(window_->GetRootWindow());
 617   if (cursor_client)
 618     cursor_client->SetCursor(cursor);
 619 }
 620
 621 bool NativeWidgetAura::IsMouseEventsEnabled() const {
 622   if (!window_)
 623     return false;
 624   aura::client::CursorClient* cursor_client =
 625       aura::client::GetCursorClient(window_->GetRootWindow());
 626   return cursor_client ? cursor_client->IsMouseEventsEnabled() : true;
 627 }
 628
 629 void NativeWidgetAura::ClearNativeFocus() {
 630   aura::client::FocusClient* client = aura::client::GetFocusClient(window_);
 631   if (window_ && client && window_->Contains(client->GetFocusedWindow()))
 632     client->ResetFocusWithinActiveWindow(window_);
 633 }
 634
 635 gfx::Rect NativeWidgetAura::GetWorkAreaBoundsInScreen() const {
 636   if (!window_)
 637     return gfx::Rect();
 638   return gfx::Screen::GetScreenFor(window_)->
 639       GetDisplayNearestWindow(window_).work_area();
 640 }
 641
 642 Widget::MoveLoopResult NativeWidgetAura::RunMoveLoop(
 643     const gfx::Vector2d& drag_offset,
 644     Widget::MoveLoopSource source,
 645     Widget::MoveLoopEscapeBehavior escape_behavior) {
 646   // |escape_behavior| is only needed on windows when running the native message
 647   // loop.
 648   if (!window_ || !window_->GetRootWindow())
 649     return Widget::MOVE_LOOP_CANCELED;
 650   aura::client::WindowMoveClient* move_client =
 651       aura::client::GetWindowMoveClient(window_->GetRootWindow());
 652   if (!move_client)
 653     return Widget::MOVE_LOOP_CANCELED;
 654
 655   SetCapture();
 656   aura::client::WindowMoveSource window_move_source =
 657       source == Widget::MOVE_LOOP_SOURCE_MOUSE ?
 658       aura::client::WINDOW_MOVE_SOURCE_MOUSE :
 659       aura::client::WINDOW_MOVE_SOURCE_TOUCH;
 660   if (move_client->RunMoveLoop(window_, drag_offset, window_move_source) ==
 661           aura::client::MOVE_SUCCESSFUL) {
 662     return Widget::MOVE_LOOP_SUCCESSFUL;
 663   }
 664   return Widget::MOVE_LOOP_CANCELED;
 665 }
 666
 667 void NativeWidgetAura::EndMoveLoop() {
 668   if (!window_ || !window_->GetRootWindow())
 669     return;
 670   aura::client::WindowMoveClient* move_client =
 671       aura::client::GetWindowMoveClient(window_->GetRootWindow());
 672   if (move_client)
 673     move_client->EndMoveLoop();
 674 }
 675
 676 void NativeWidgetAura::SetVisibilityChangedAnimationsEnabled(bool value) {
 677   if (window_)
 678     window_->SetProperty(aura::client::kAnimationsDisabledKey, !value);
 679 }
 680
 681 void NativeWidgetAura::SetVisibilityAnimationDuration(
 682     const base::TimeDelta& duration) {
 683   wm::SetWindowVisibilityAnimationDuration(window_, duration);
 684 }
 685
 686 void NativeWidgetAura::SetVisibilityAnimationTransition(
 687     Widget::VisibilityTransition transition) {
 688   wm::WindowVisibilityAnimationTransition wm_transition = wm::ANIMATE_NONE;
 689   switch (transition) {
 690     case Widget::ANIMATE_SHOW:
 691       wm_transition = wm::ANIMATE_SHOW;
 692       break;
 693     case Widget::ANIMATE_HIDE:
 694       wm_transition = wm::ANIMATE_HIDE;
 695       break;
 696     case Widget::ANIMATE_BOTH:
 697       wm_transition = wm::ANIMATE_BOTH;
 698       break;
 699     case Widget::ANIMATE_NONE:
 700       wm_transition = wm::ANIMATE_NONE;
 701       break;
 702   }
 703   wm::SetWindowVisibilityAnimationTransition(window_, wm_transition);
 704 }
 705
 706 ui::NativeTheme* NativeWidgetAura::GetNativeTheme() const {
 707 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
 708   return DesktopWindowTreeHost::GetNativeTheme(window_);
 709 #else
 710   return ui::NativeThemeAura::instance();
 711 #endif
 712 }
 713
 714 void NativeWidgetAura::OnRootViewLayout() {
 715 }
 716
 717 bool NativeWidgetAura::IsTranslucentWindowOpacitySupported() const {
 718   return true;
 719 }
 720
 721 void NativeWidgetAura::OnSizeConstraintsChanged() {
 722   window_->SetProperty(aura::client::kCanMaximizeKey,
 723                        GetWidget()->widget_delegate()->CanMaximize());
 724   window_->SetProperty(aura::client::kCanMinimizeKey,
 725                        GetWidget()->widget_delegate()->CanMinimize());
 726   window_->SetProperty(aura::client::kCanResizeKey,
 727                        GetWidget()->widget_delegate()->CanResize());
 728 }
 729
 730 void NativeWidgetAura::RepostNativeEvent(gfx::NativeEvent native_event) {
 731   OnEvent(native_event);
 732 }
 733
 734 ////////////////////////////////////////////////////////////////////////////////
 735 // NativeWidgetAura, aura::WindowDelegate implementation:
 736
 737 gfx::Size NativeWidgetAura::GetMinimumSize() const {
 738   return delegate_->GetMinimumSize();
 739 }
 740
 741 gfx::Size NativeWidgetAura::GetMaximumSize() const {
 742   // If a window have a maximum size, the window should not be
 743   // maximizable.
 744   DCHECK(delegate_->GetMaximumSize().IsEmpty() ||
 745          !window_->GetProperty(aura::client::kCanMaximizeKey));
 746   return delegate_->GetMaximumSize();
 747 }
 748
 749 void NativeWidgetAura::OnBoundsChanged(const gfx::Rect& old_bounds,
 750                                        const gfx::Rect& new_bounds) {
 751   // Assume that if the old bounds was completely empty a move happened. This
 752   // handles the case of a maximize animation acquiring the layer (acquiring a
 753   // layer results in clearing the bounds).
 754   if (old_bounds.origin() != new_bounds.origin() ||
 755       (old_bounds == gfx::Rect(0, 0, 0, 0) && !new_bounds.IsEmpty())) {
 756     delegate_->OnNativeWidgetMove();
 757   }
 758   if (old_bounds.size() != new_bounds.size())
 759     delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
 760 }
 761
 762 gfx::NativeCursor NativeWidgetAura::GetCursor(const gfx::Point& point) {
 763   return cursor_;
 764 }
 765
 766 int NativeWidgetAura::GetNonClientComponent(const gfx::Point& point) const {
 767   return delegate_->GetNonClientComponent(point);
 768 }
 769
 770 bool NativeWidgetAura::ShouldDescendIntoChildForEventHandling(
 771       aura::Window* child,
 772       const gfx::Point& location) {
 773   views::WidgetDelegate* widget_delegate = GetWidget()->widget_delegate();
 774   if (widget_delegate &&
 775       !widget_delegate->ShouldDescendIntoChildForEventHandling(child, location))
 776     return false;
 777
 778   // Don't descend into |child| if there is a view with a Layer that contains
 779   // the point and is stacked above |child|s layer.
 780   typedef std::vector<ui::Layer*> Layers;
 781   const Layers& root_layers(delegate_->GetRootLayers());
 782   if (root_layers.empty())
 783     return true;
 784
 785   Layers::const_iterator child_layer_iter(
 786       std::find(window_->layer()->children().begin(),
 787                 window_->layer()->children().end(), child->layer()));
 788   if (child_layer_iter == window_->layer()->children().end())
 789     return true;
 790
 791   for (std::vector<ui::Layer*>::const_reverse_iterator i = root_layers.rbegin();
 792        i != root_layers.rend(); ++i) {
 793     ui::Layer* layer = *i;
 794     if (layer->visible() && layer->bounds().Contains(location)) {
 795       Layers::const_iterator root_layer_iter(
 796           std::find(window_->layer()->children().begin(),
 797                     window_->layer()->children().end(), layer));
 798       if (root_layer_iter > child_layer_iter)
 799         return false;
 800     }
 801   }
 802   return true;
 803 }
 804
 805 bool NativeWidgetAura::CanFocus() {
 806   return ShouldActivate();
 807 }
 808
 809 void NativeWidgetAura::OnCaptureLost() {
 810   delegate_->OnMouseCaptureLost();
 811 }
 812
 813 void NativeWidgetAura::OnPaint(const ui::PaintContext& context) {
 814   delegate_->OnNativeWidgetPaint(context);
 815 }
 816
 817 void NativeWidgetAura::OnDeviceScaleFactorChanged(float device_scale_factor) {
 818   GetWidget()->DeviceScaleFactorChanged(device_scale_factor);
 819 }
 820
 821 void NativeWidgetAura::OnWindowDestroying(aura::Window* window) {
 822   window_->RemoveObserver(this);
 823   delegate_->OnNativeWidgetDestroying();
 824
 825   // If the aura::Window is destroyed, we can no longer show tooltips.
 826   tooltip_manager_.reset();
 827 }
 828
 829 void NativeWidgetAura::OnWindowDestroyed(aura::Window* window) {
 830   window_ = NULL;
 831   delegate_->OnNativeWidgetDestroyed();
 832   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
 833     delete this;
 834 }
 835
 836 void NativeWidgetAura::OnWindowTargetVisibilityChanged(bool visible) {
 837   delegate_->OnNativeWidgetVisibilityChanged(visible);
 838 }
 839
 840 bool NativeWidgetAura::HasHitTestMask() const {
 841   return delegate_->HasHitTestMask();
 842 }
 843
 844 void NativeWidgetAura::GetHitTestMask(gfx::Path* mask) const {
 845   DCHECK(mask);
 846   delegate_->GetHitTestMask(mask);
 847 }
 848
 849 ////////////////////////////////////////////////////////////////////////////////
 850 // NativeWidgetAura, aura::WindowObserver implementation:
 851
 852 void NativeWidgetAura::OnWindowPropertyChanged(aura::Window* window,
 853                                                const void* key,
 854                                                intptr_t old) {
 855   if (key == aura::client::kShowStateKey)
 856     delegate_->OnNativeWidgetWindowShowStateChanged();
 857 }
 858
 859 ////////////////////////////////////////////////////////////////////////////////
 860 // NativeWidgetAura, ui::EventHandler implementation:
 861
 862 void NativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
 863   DCHECK(window_);
 864   // Renderer may send a key event back to us if the key event wasn't handled,
 865   // and the window may be invisible by that time.
 866   if (!window_->IsVisible())
 867     return;
 868
 869   FocusManager* focus_manager = GetWidget()->GetFocusManager();
 870   delegate_->OnKeyEvent(event);
 871   if (!event->handled() && focus_manager)
 872     focus_manager->OnKeyEvent(*event);
 873   event->SetHandled();
 874 }
 875
 876 void NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
 877   DCHECK(window_);
 878   DCHECK(window_->IsVisible());
 879   if (event->type() == ui::ET_MOUSEWHEEL) {
 880     delegate_->OnMouseEvent(event);
 881     if (event->handled())
 882       return;
 883   }
 884
 885   if (tooltip_manager_.get())
 886     tooltip_manager_->UpdateTooltip();
 887   TooltipManagerAura::UpdateTooltipManagerForCapture(GetWidget());
 888   delegate_->OnMouseEvent(event);
 889 }
 890
 891 void NativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
 892   delegate_->OnScrollEvent(event);
 893 }
 894
 895 void NativeWidgetAura::OnGestureEvent(ui::GestureEvent* event) {
 896   DCHECK(window_);
 897   DCHECK(window_->IsVisible() || event->IsEndingEvent());
 898   delegate_->OnGestureEvent(event);
 899 }
 900
 901 ////////////////////////////////////////////////////////////////////////////////
 902 // NativeWidgetAura, aura::client::ActivationDelegate implementation:
 903
 904 bool NativeWidgetAura::ShouldActivate() const {
 905   return delegate_->CanActivate();
 906 }
 907
 908 ////////////////////////////////////////////////////////////////////////////////
 909 // NativeWidgetAura, aura::client::ActivationChangeObserver implementation:
 910
 911 void NativeWidgetAura::OnWindowActivated(
 912     aura::client::ActivationChangeObserver::ActivationReason,
 913     aura::Window* gained_active,
 914     aura::Window* lost_active) {
 915   DCHECK(window_ == gained_active || window_ == lost_active);
 916   if (GetWidget()->GetFocusManager()) {
 917     if (window_ == gained_active)
 918       GetWidget()->GetFocusManager()->RestoreFocusedView();
 919     else if (window_ == lost_active)
 920       GetWidget()->GetFocusManager()->StoreFocusedView(true);
 921   }
 922   delegate_->OnNativeWidgetActivationChanged(window_ == gained_active);
 923 }
 924
 925 ////////////////////////////////////////////////////////////////////////////////
 926 // NativeWidgetAura, aura::client::FocusChangeObserver:
 927
 928 void NativeWidgetAura::OnWindowFocused(aura::Window* gained_focus,
 929                                        aura::Window* lost_focus) {
 930   if (window_ == gained_focus)
 931     delegate_->OnNativeFocus();
 932   else if (window_ == lost_focus)
 933     delegate_->OnNativeBlur();
 934 }
 935
 936 ////////////////////////////////////////////////////////////////////////////////
 937 // NativeWidgetAura, aura::WindowDragDropDelegate implementation:
 938
 939 void NativeWidgetAura::OnDragEntered(const ui::DropTargetEvent& event) {
 940   DCHECK(drop_helper_.get() != NULL);
 941   last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
 942       event.location(), event.source_operations());
 943 }
 944
 945 int NativeWidgetAura::OnDragUpdated(const ui::DropTargetEvent& event) {
 946   DCHECK(drop_helper_.get() != NULL);
 947   last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
 948       event.location(), event.source_operations());
 949   return last_drop_operation_;
 950 }
 951
 952 void NativeWidgetAura::OnDragExited() {
 953   DCHECK(drop_helper_.get() != NULL);
 954   drop_helper_->OnDragExit();
 955 }
 956
 957 int NativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
 958   DCHECK(drop_helper_.get() != NULL);
 959   return drop_helper_->OnDrop(event.data(), event.location(),
 960       last_drop_operation_);
 961 }
 962
 963 ////////////////////////////////////////////////////////////////////////////////
 964 // NativeWidgetAura, protected:
 965
 966 NativeWidgetAura::~NativeWidgetAura() {
 967   destroying_ = true;
 968   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
 969     delete delegate_;
 970   else
 971     CloseNow();
 972 }
 973
 974 ////////////////////////////////////////////////////////////////////////////////
 975 // NativeWidgetAura, private:
 976
 977 bool NativeWidgetAura::IsDocked() const {
 978   return window_ &&
 979          window_->GetProperty(aura::client::kShowStateKey) ==
 980              ui::SHOW_STATE_DOCKED;
 981 }
 982
 983 void NativeWidgetAura::SetInitialFocus(ui::WindowShowState show_state) {
 984   // The window does not get keyboard messages unless we focus it.
 985   if (!GetWidget()->SetInitialFocus(show_state))
 986     window_->Focus();
 987 }
 988
 989 ////////////////////////////////////////////////////////////////////////////////
 990 // Widget, public:
 991
 992 namespace {
 993 #if defined(OS_WIN) || (defined(USE_X11) && !defined(OS_CHROMEOS))
 994 void CloseWindow(aura::Window* window) {
 995   if (window) {
 996     Widget* widget = Widget::GetWidgetForNativeView(window);
 997     if (widget && widget->is_secondary_widget())
 998       // To avoid the delay in shutdown caused by using Close which may wait
 999       // for animations, use CloseNow. Because this is only used on secondary
1000       // widgets it seems relatively safe to skip the extra processing of
1001       // Close.
1002       widget->CloseNow();
1003   }
1004 }
1005 #endif
1006
1007 #if defined(OS_WIN)
1008 BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
1009   aura::Window* root_window =
1010       DesktopWindowTreeHostWin::GetContentWindowForHWND(hwnd);
1011   CloseWindow(root_window);
1012   return TRUE;
1013 }
1014 #endif
1015 }  // namespace
1016
1017 // static
1018 void Widget::CloseAllSecondaryWidgets() {
1019 #if defined(OS_WIN)
1020   EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
1021 #endif
1022
1023 #if defined(USE_X11) && !defined(OS_CHROMEOS)
1024   DesktopWindowTreeHostX11::CleanUpWindowList(CloseWindow);
1025 #endif
1026 }
1027
1028 bool Widget::ConvertRect(const Widget* source,
1029                          const Widget* target,
1030                          gfx::Rect* rect) {
1031   return false;
1032 }
1033
1034 namespace internal {
1035
1036 ////////////////////////////////////////////////////////////////////////////////
1037 // internal::NativeWidgetPrivate, public:
1038
1039 // static
1040 NativeWidgetPrivate* NativeWidgetPrivate::CreateNativeWidget(
1041     internal::NativeWidgetDelegate* delegate) {
1042   return new NativeWidgetAura(delegate);
1043 }
1044
1045 // static
1046 NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeView(
1047     gfx::NativeView native_view) {
1048   // Cast must match type supplied to RegisterNativeWidgetForWindow().
1049   return reinterpret_cast<NativeWidgetPrivate*>(native_view->user_data());
1050 }
1051
1052 // static
1053 NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeWindow(
1054     gfx::NativeWindow native_window) {
1055   // Cast must match type supplied to RegisterNativeWidgetForWindow().
1056   return reinterpret_cast<NativeWidgetPrivate*>(native_window->user_data());
1057 }
1058
1059 // static
1060 NativeWidgetPrivate* NativeWidgetPrivate::GetTopLevelNativeWidget(
1061     gfx::NativeView native_view) {
1062   aura::Window* window = native_view;
1063   NativeWidgetPrivate* top_level_native_widget = NULL;
1064   while (window) {
1065     NativeWidgetPrivate* native_widget = GetNativeWidgetForNativeView(window);
1066     if (native_widget)
1067       top_level_native_widget = native_widget;
1068     window = window->parent();
1069   }
1070   return top_level_native_widget;
1071 }
1072
1073 // static
1074 void NativeWidgetPrivate::GetAllChildWidgets(gfx::NativeView native_view,
1075                                              Widget::Widgets* children) {
1076   {
1077     // Code expects widget for |native_view| to be added to |children|.
1078     NativeWidgetPrivate* native_widget = static_cast<NativeWidgetPrivate*>(
1079         GetNativeWidgetForNativeView(native_view));
1080     if (native_widget && native_widget->GetWidget())
1081       children->insert(native_widget->GetWidget());
1082   }
1083
1084   const aura::Window::Windows& child_windows = native_view->children();
1085   for (aura::Window::Windows::const_iterator i = child_windows.begin();
1086        i != child_windows.end(); ++i) {
1087     GetAllChildWidgets((*i), children);
1088   }
1089 }
1090
1091 // static
1092 void NativeWidgetPrivate::GetAllOwnedWidgets(gfx::NativeView native_view,
1093                                              Widget::Widgets* owned) {
1094   // Add all owned widgets.
1095   for (aura::Window* transient_child : wm::GetTransientChildren(native_view)) {
1096     NativeWidgetPrivate* native_widget = static_cast<NativeWidgetPrivate*>(
1097         GetNativeWidgetForNativeView(transient_child));
1098     if (native_widget && native_widget->GetWidget())
1099       owned->insert(native_widget->GetWidget());
1100     GetAllOwnedWidgets(transient_child, owned);
1101   }
1102
1103   // Add all child windows.
1104   for (aura::Window* child : native_view->children())
1105     GetAllChildWidgets(child, owned);
1106 }
1107
1108 // static
1109 void NativeWidgetPrivate::ReparentNativeView(gfx::NativeView native_view,
1110                                              gfx::NativeView new_parent) {
1111   DCHECK(native_view != new_parent);
1112
1113   gfx::NativeView previous_parent = native_view->parent();
1114   if (previous_parent == new_parent)
1115     return;
1116
1117   Widget::Widgets widgets;
1118   GetAllChildWidgets(native_view, &widgets);
1119
1120   // First notify all the widgets that they are being disassociated
1121   // from their previous parent.
1122   for (Widget::Widgets::iterator it = widgets.begin();
1123       it != widgets.end(); ++it) {
1124     (*it)->NotifyNativeViewHierarchyWillChange();
1125   }
1126
1127   if (new_parent) {
1128     new_parent->AddChild(native_view);
1129   } else {
1130     // The following looks weird, but it's the equivalent of what aura has
1131     // always done. (The previous behaviour of aura::Window::SetParent() used
1132     // NULL as a special value that meant ask the WindowTreeClient where things
1133     // should go.)
1134     //
1135     // This probably isn't strictly correct, but its an invariant that a Window
1136     // in use will be attached to a RootWindow, so we can't just call
1137     // RemoveChild here. The only possible thing that could assign a RootWindow
1138     // in this case is the stacking client of the current RootWindow. This
1139     // matches our previous behaviour; the global stacking client would almost
1140     // always reattach the window to the same RootWindow.
1141     aura::Window* root_window = native_view->GetRootWindow();
1142     aura::client::ParentWindowWithContext(
1143         native_view, root_window, root_window->GetBoundsInScreen());
1144   }
1145
1146   // And now, notify them that they have a brand new parent.
1147   for (Widget::Widgets::iterator it = widgets.begin();
1148       it != widgets.end(); ++it) {
1149     (*it)->NotifyNativeViewHierarchyChanged();
1150   }
1151 }
1152
1153 // static
1154 bool NativeWidgetPrivate::IsMouseButtonDown() {
1155   return aura::Env::GetInstance()->IsMouseButtonDown();
1156 }
1157
1158 // static
1159 gfx::FontList NativeWidgetPrivate::GetWindowTitleFontList() {
1160 #if defined(OS_WIN)
1161   NONCLIENTMETRICS_XP ncm;
1162   base::win::GetNonClientMetrics(&ncm);
1163   l10n_util::AdjustUIFont(&(ncm.lfCaptionFont));
1164   base::win::ScopedHFONT caption_font(CreateFontIndirect(&(ncm.lfCaptionFont)));
1165   return gfx::FontList(gfx::Font(caption_font));
1166 #else
1167   return gfx::FontList();
1168 #endif
1169 }
1170
1171 }  // namespace internal
1172 }  // namespace views