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