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_native_widget_aura.h" 6 7 #include "base/bind.h" 8 #include "base/debug/trace_event.h" 9 #include "ui/aura/client/aura_constants.h" 10 #include "ui/aura/client/cursor_client.h" 11 #include "ui/aura/client/focus_client.h" 12 #include "ui/aura/client/window_tree_client.h" 13 #include "ui/aura/window.h" 14 #include "ui/aura/window_observer.h" 15 #include "ui/aura/window_property.h" 16 #include "ui/aura/window_tree_host.h" 17 #include "ui/base/hit_test.h" 18 #include "ui/base/ui_base_switches_util.h" 19 #include "ui/compositor/layer.h" 20 #include "ui/gfx/canvas.h" 21 #include "ui/gfx/display.h" 22 #include "ui/gfx/point_conversions.h" 23 #include "ui/gfx/geometry/rect.h" 24 #include "ui/gfx/screen.h" 25 #include "ui/gfx/size_conversions.h" 26 #include "ui/native_theme/native_theme.h" 27 #include "ui/views/corewm/tooltip.h" 28 #include "ui/views/corewm/tooltip_controller.h" 29 #include "ui/views/drag_utils.h" 30 #include "ui/views/ime/input_method_bridge.h" 31 #include "ui/views/ime/null_input_method.h" 32 #include "ui/views/view_constants_aura.h" 33 #include "ui/views/widget/desktop_aura/desktop_capture_client.h" 34 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h" 35 #include "ui/views/widget/desktop_aura/desktop_dispatcher_client.h" 36 #include "ui/views/widget/desktop_aura/desktop_event_client.h" 37 #include "ui/views/widget/desktop_aura/desktop_focus_rules.h" 38 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h" 39 #include "ui/views/widget/desktop_aura/desktop_screen_position_client.h" 40 #include "ui/views/widget/desktop_aura/desktop_window_tree_host.h" 41 #include "ui/views/widget/drop_helper.h" 42 #include "ui/views/widget/native_widget_aura.h" 43 #include "ui/views/widget/root_view.h" 44 #include "ui/views/widget/tooltip_manager_aura.h" 45 #include "ui/views/widget/widget.h" 46 #include "ui/views/widget/widget_aura_utils.h" 47 #include "ui/views/widget/widget_delegate.h" 48 #include "ui/views/widget/window_reorderer.h" 49 #include "ui/views/window/native_frame_view.h" 50 #include "ui/wm/core/compound_event_filter.h" 51 #include "ui/wm/core/cursor_manager.h" 52 #include "ui/wm/core/focus_controller.h" 53 #include "ui/wm/core/input_method_event_filter.h" 54 #include "ui/wm/core/native_cursor_manager.h" 55 #include "ui/wm/core/shadow_controller.h" 56 #include "ui/wm/core/shadow_types.h" 57 #include "ui/wm/core/visibility_controller.h" 58 #include "ui/wm/core/window_modality_controller.h" 59 #include "ui/wm/public/activation_client.h" 60 #include "ui/wm/public/drag_drop_client.h" 61 62 #if defined(OS_WIN) 63 #include "ui/base/win/shell.h" 64 #include "ui/gfx/win/dpi.h" 65 #endif 66 67 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(VIEWS_EXPORT, 68 views::DesktopNativeWidgetAura*); 69 70 namespace views { 71 72 DEFINE_WINDOW_PROPERTY_KEY(DesktopNativeWidgetAura*, 73 kDesktopNativeWidgetAuraKey, NULL); 74 75 namespace { 76 77 // This class provides functionality to create a top level widget to host a 78 // child window. 79 class DesktopNativeWidgetTopLevelHandler : public aura::WindowObserver { 80 public: 81 // This function creates a widget with the bounds passed in which eventually 82 // becomes the parent of the child window passed in. 83 static aura::Window* CreateParentWindow(aura::Window* child_window, 84 const gfx::Rect& bounds, 85 bool full_screen, 86 bool root_is_always_on_top) { 87 // This instance will get deleted when the widget is destroyed. 88 DesktopNativeWidgetTopLevelHandler* top_level_handler = 89 new DesktopNativeWidgetTopLevelHandler; 90 91 child_window->SetBounds(gfx::Rect(bounds.size())); 92 93 Widget::InitParams init_params; 94 init_params.type = full_screen ? Widget::InitParams::TYPE_WINDOW : 95 Widget::InitParams::TYPE_POPUP; 96 init_params.bounds = bounds; 97 init_params.ownership = Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET; 98 init_params.layer_type = aura::WINDOW_LAYER_NOT_DRAWN; 99 init_params.activatable = full_screen ? 100 Widget::InitParams::ACTIVATABLE_YES : 101 Widget::InitParams::ACTIVATABLE_NO; 102 init_params.keep_on_top = root_is_always_on_top; 103 104 // This widget instance will get deleted when the window is 105 // destroyed. 106 top_level_handler->top_level_widget_ = new Widget(); 107 top_level_handler->top_level_widget_->Init(init_params); 108 109 top_level_handler->top_level_widget_->SetFullscreen(full_screen); 110 top_level_handler->top_level_widget_->Show(); 111 112 aura::Window* native_window = 113 top_level_handler->top_level_widget_->GetNativeView(); 114 child_window->AddObserver(top_level_handler); 115 native_window->AddObserver(top_level_handler); 116 top_level_handler->child_window_ = child_window; 117 return native_window; 118 } 119 120 // aura::WindowObserver overrides 121 virtual void OnWindowDestroying(aura::Window* window) OVERRIDE { 122 window->RemoveObserver(this); 123 124 // If the widget is being destroyed by the OS then we should not try and 125 // destroy it again. 126 if (top_level_widget_ && 127 window == top_level_widget_->GetNativeView()) { 128 top_level_widget_ = NULL; 129 return; 130 } 131 132 if (top_level_widget_) { 133 DCHECK(top_level_widget_->GetNativeView()); 134 top_level_widget_->GetNativeView()->RemoveObserver(this); 135 // When we receive a notification that the child of the window created 136 // above is being destroyed we go ahead and initiate the destruction of 137 // the corresponding widget. 138 top_level_widget_->Close(); 139 top_level_widget_ = NULL; 140 } 141 delete this; 142 } 143 144 virtual void OnWindowBoundsChanged(aura::Window* window, 145 const gfx::Rect& old_bounds, 146 const gfx::Rect& new_bounds) OVERRIDE { 147 if (top_level_widget_ && window == child_window_) 148 top_level_widget_->SetSize(new_bounds.size()); 149 } 150 151 private: 152 DesktopNativeWidgetTopLevelHandler() 153 : top_level_widget_(NULL), 154 child_window_(NULL) {} 155 156 virtual ~DesktopNativeWidgetTopLevelHandler() {} 157 158 Widget* top_level_widget_; 159 aura::Window* child_window_; 160 161 DISALLOW_COPY_AND_ASSIGN(DesktopNativeWidgetTopLevelHandler); 162 }; 163 164 class DesktopNativeWidgetAuraWindowTreeClient : 165 public aura::client::WindowTreeClient { 166 public: 167 explicit DesktopNativeWidgetAuraWindowTreeClient( 168 aura::Window* root_window) 169 : root_window_(root_window) { 170 aura::client::SetWindowTreeClient(root_window_, this); 171 } 172 virtual ~DesktopNativeWidgetAuraWindowTreeClient() { 173 aura::client::SetWindowTreeClient(root_window_, NULL); 174 } 175 176 // Overridden from client::WindowTreeClient: 177 virtual aura::Window* GetDefaultParent(aura::Window* context, 178 aura::Window* window, 179 const gfx::Rect& bounds) OVERRIDE { 180 bool is_fullscreen = window->GetProperty(aura::client::kShowStateKey) == 181 ui::SHOW_STATE_FULLSCREEN; 182 bool is_menu = window->type() == ui::wm::WINDOW_TYPE_MENU; 183 184 if (is_fullscreen || is_menu) { 185 bool root_is_always_on_top = false; 186 internal::NativeWidgetPrivate* native_widget = 187 DesktopNativeWidgetAura::ForWindow(root_window_); 188 if (native_widget) 189 root_is_always_on_top = native_widget->IsAlwaysOnTop(); 190 191 return DesktopNativeWidgetTopLevelHandler::CreateParentWindow( 192 window, bounds, is_fullscreen, root_is_always_on_top); 193 } 194 return root_window_; 195 } 196 197 private: 198 aura::Window* root_window_; 199 200 DISALLOW_COPY_AND_ASSIGN(DesktopNativeWidgetAuraWindowTreeClient); 201 }; 202 203 } // namespace 204 205 class FocusManagerEventHandler : public ui::EventHandler { 206 public: 207 FocusManagerEventHandler(DesktopNativeWidgetAura* desktop_native_widget_aura) 208 : desktop_native_widget_aura_(desktop_native_widget_aura) {} 209 210 // Implementation of ui::EventHandler: 211 virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE { 212 Widget* widget = desktop_native_widget_aura_->GetWidget(); 213 if (widget && widget->GetFocusManager()->GetFocusedView() && 214 !widget->GetFocusManager()->OnKeyEvent(*event)) { 215 event->SetHandled(); 216 } 217 } 218 219 private: 220 DesktopNativeWidgetAura* desktop_native_widget_aura_; 221 222 DISALLOW_COPY_AND_ASSIGN(FocusManagerEventHandler); 223 }; 224 225 class RootWindowDestructionObserver : public aura::WindowObserver { 226 public: 227 explicit RootWindowDestructionObserver(DesktopNativeWidgetAura* parent) 228 : parent_(parent) {} 229 virtual ~RootWindowDestructionObserver() {} 230 231 private: 232 // Overridden from aura::WindowObserver: 233 virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE { 234 parent_->RootWindowDestroyed(); 235 window->RemoveObserver(this); 236 delete this; 237 } 238 239 DesktopNativeWidgetAura* parent_; 240 241 DISALLOW_COPY_AND_ASSIGN(RootWindowDestructionObserver); 242 }; 243 244 //////////////////////////////////////////////////////////////////////////////// 245 // DesktopNativeWidgetAura, public: 246 247 int DesktopNativeWidgetAura::cursor_reference_count_ = 0; 248 DesktopNativeCursorManager* DesktopNativeWidgetAura::native_cursor_manager_ = 249 NULL; 250 wm::CursorManager* DesktopNativeWidgetAura::cursor_manager_ = NULL; 251 252 DesktopNativeWidgetAura::DesktopNativeWidgetAura( 253 internal::NativeWidgetDelegate* delegate) 254 : desktop_window_tree_host_(NULL), 255 ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET), 256 close_widget_factory_(this), 257 content_window_container_(NULL), 258 content_window_(new aura::Window(this)), 259 native_widget_delegate_(delegate), 260 last_drop_operation_(ui::DragDropTypes::DRAG_NONE), 261 restore_focus_on_activate_(false), 262 cursor_(gfx::kNullCursor), 263 widget_type_(Widget::InitParams::TYPE_WINDOW) { 264 aura::client::SetFocusChangeObserver(content_window_, this); 265 aura::client::SetActivationChangeObserver(content_window_, this); 266 } 267 268 DesktopNativeWidgetAura::~DesktopNativeWidgetAura() { 269 if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET) 270 delete native_widget_delegate_; 271 else 272 CloseNow(); 273 } 274 275 // static 276 DesktopNativeWidgetAura* DesktopNativeWidgetAura::ForWindow( 277 aura::Window* window) { 278 return window->GetProperty(kDesktopNativeWidgetAuraKey); 279 } 280 281 void DesktopNativeWidgetAura::OnHostClosed() { 282 // Don't invoke Widget::OnNativeWidgetDestroying(), its done by 283 // DesktopWindowTreeHost. 284 285 // The WindowModalityController is at the front of the event pretarget 286 // handler list. We destroy it first to preserve order symantics. 287 if (window_modality_controller_) 288 window_modality_controller_.reset(); 289 290 // Make sure we don't have capture. Otherwise CaptureController and 291 // WindowEventDispatcher are left referencing a deleted Window. 292 { 293 aura::Window* capture_window = capture_client_->GetCaptureWindow(); 294 if (capture_window && host_->window()->Contains(capture_window)) 295 capture_window->ReleaseCapture(); 296 } 297 298 // DesktopWindowTreeHost owns the ActivationController which ShadowController 299 // references. Make sure we destroy ShadowController early on. 300 shadow_controller_.reset(); 301 tooltip_manager_.reset(); 302 if (tooltip_controller_.get()) { 303 host_->window()->RemovePreTargetHandler(tooltip_controller_.get()); 304 aura::client::SetTooltipClient(host_->window(), NULL); 305 tooltip_controller_.reset(); 306 } 307 308 root_window_event_filter_->RemoveHandler(input_method_event_filter_.get()); 309 310 window_tree_client_.reset(); // Uses host_->dispatcher() at destruction. 311 312 capture_client_.reset(); // Uses host_->dispatcher() at destruction. 313 314 // FocusController uses |content_window_|. Destroy it now so that we don't 315 // have to worry about the possibility of FocusController attempting to use 316 // |content_window_| after it's been destroyed but before all child windows 317 // have been destroyed. 318 host_->window()->RemovePreTargetHandler(focus_client_.get()); 319 aura::client::SetFocusClient(host_->window(), NULL); 320 aura::client::SetActivationClient(host_->window(), NULL); 321 focus_client_.reset(); 322 323 host_->RemoveObserver(this); 324 host_.reset(); // Uses input_method_event_filter_ at destruction. 325 // WindowEventDispatcher owns |desktop_window_tree_host_|. 326 desktop_window_tree_host_ = NULL; 327 content_window_ = NULL; 328 329 native_widget_delegate_->OnNativeWidgetDestroyed(); 330 if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET) 331 delete this; 332 } 333 334 void DesktopNativeWidgetAura::OnDesktopWindowTreeHostDestroyed( 335 aura::WindowTreeHost* host) { 336 // |dispatcher_| is still valid, but DesktopWindowTreeHost is nearly 337 // destroyed. Do cleanup here of members DesktopWindowTreeHost may also use. 338 aura::client::SetDispatcherClient(host->window(), NULL); 339 dispatcher_client_.reset(); 340 341 // We explicitly do NOT clear the cursor client property. Since the cursor 342 // manager is a singleton, it can outlive any window hierarchy, and it's 343 // important that objects attached to this destroying window hierarchy have 344 // an opportunity to deregister their observers from the cursor manager. 345 // They may want to do this when they are notified that they're being 346 // removed from the window hierarchy, which happens soon after this 347 // function when DesktopWindowTreeHost* calls DestroyDispatcher(). 348 native_cursor_manager_->RemoveHost(host); 349 350 aura::client::SetScreenPositionClient(host->window(), NULL); 351 position_client_.reset(); 352 353 aura::client::SetDragDropClient(host->window(), NULL); 354 drag_drop_client_.reset(); 355 356 aura::client::SetEventClient(host->window(), NULL); 357 event_client_.reset(); 358 } 359 360 void DesktopNativeWidgetAura::HandleActivationChanged(bool active) { 361 native_widget_delegate_->OnNativeWidgetActivationChanged(active); 362 aura::client::ActivationClient* activation_client = 363 aura::client::GetActivationClient(host_->window()); 364 if (!activation_client) 365 return; 366 if (active) { 367 if (GetWidget()->HasFocusManager()) { 368 // This function can be called before the focus manager has had a 369 // chance to set the focused view. In which case we should get the 370 // last focused view. 371 View* view_for_activation = 372 GetWidget()->GetFocusManager()->GetFocusedView() ? 373 GetWidget()->GetFocusManager()->GetFocusedView() : 374 GetWidget()->GetFocusManager()->GetStoredFocusView(); 375 if (!view_for_activation) 376 view_for_activation = GetWidget()->GetRootView(); 377 activation_client->ActivateWindow( 378 view_for_activation->GetWidget()->GetNativeView()); 379 } 380 } else { 381 // If we're not active we need to deactivate the corresponding 382 // aura::Window. This way if a child widget is active it gets correctly 383 // deactivated (child widgets don't get native desktop activation changes, 384 // only aura activation changes). 385 aura::Window* active_window = activation_client->GetActiveWindow(); 386 if (active_window) 387 activation_client->DeactivateWindow(active_window); 388 } 389 } 390 391 //////////////////////////////////////////////////////////////////////////////// 392 // DesktopNativeWidgetAura, internal::NativeWidgetPrivate implementation: 393 394 void DesktopNativeWidgetAura::InitNativeWidget( 395 const Widget::InitParams& params) { 396 ownership_ = params.ownership; 397 widget_type_ = params.type; 398 399 NativeWidgetAura::RegisterNativeWidgetForWindow(this, content_window_); 400 // Animations on TYPE_WINDOW are handled by the OS. Additionally if we animate 401 // these windows the size of the window gets augmented, effecting restore 402 // bounds and maximized windows in bad ways. 403 if (params.type == Widget::InitParams::TYPE_WINDOW && 404 !params.remove_standard_frame) { 405 content_window_->SetProperty(aura::client::kAnimationsDisabledKey, true); 406 } 407 content_window_->SetType(GetAuraWindowTypeForWidgetType(params.type)); 408 content_window_->Init(params.layer_type); 409 wm::SetShadowType(content_window_, wm::SHADOW_TYPE_NONE); 410 411 content_window_container_ = new aura::Window(NULL); 412 content_window_container_->Init(aura::WINDOW_LAYER_NOT_DRAWN); 413 content_window_container_->Show(); 414 content_window_container_->AddChild(content_window_); 415 416 desktop_window_tree_host_ = params.desktop_window_tree_host ? 417 params.desktop_window_tree_host : 418 DesktopWindowTreeHost::Create(native_widget_delegate_, this); 419 host_.reset(desktop_window_tree_host_->AsWindowTreeHost()); 420 desktop_window_tree_host_->Init(content_window_, params); 421 422 // Mark this window as Desktop root window. 423 host_->window()->SetProperty(views::kDesktopRootWindow, true); 424 425 host_->InitHost(); 426 host_->window()->AddChild(content_window_container_); 427 host_->window()->SetProperty(kDesktopNativeWidgetAuraKey, this); 428 429 host_->window()->AddObserver(new RootWindowDestructionObserver(this)); 430 431 // The WindowsModalityController event filter should be at the head of the 432 // pre target handlers list. This ensures that it handles input events first 433 // when modal windows are at the top of the Zorder. 434 if (widget_type_ == Widget::InitParams::TYPE_WINDOW) 435 window_modality_controller_.reset( 436 new wm::WindowModalityController(host_->window())); 437 438 // |root_window_event_filter_| must be created before 439 // OnWindowTreeHostCreated() is invoked. 440 441 // CEF sets focus to the window the user clicks down on. 442 // TODO(beng): see if we can't do this some other way. CEF seems a heavy- 443 // handed way of accomplishing focus. 444 // No event filter for aura::Env. Create CompoundEventFilter per 445 // WindowEventDispatcher. 446 root_window_event_filter_.reset(new wm::CompoundEventFilter); 447 host_->window()->AddPreTargetHandler(root_window_event_filter_.get()); 448 449 // The host's dispatcher must be added to |native_cursor_manager_| before 450 // OnNativeWidgetCreated() is called. 451 cursor_reference_count_++; 452 if (!native_cursor_manager_) { 453 native_cursor_manager_ = new DesktopNativeCursorManager( 454 DesktopCursorLoaderUpdater::Create()); 455 } 456 if (!cursor_manager_) { 457 cursor_manager_ = new wm::CursorManager( 458 scoped_ptr<wm::NativeCursorManager>(native_cursor_manager_)); 459 } 460 native_cursor_manager_->AddHost(host()); 461 aura::client::SetCursorClient(host_->window(), cursor_manager_); 462 463 desktop_window_tree_host_->OnNativeWidgetCreated(params); 464 465 UpdateWindowTransparency(); 466 467 capture_client_.reset(new DesktopCaptureClient(host_->window())); 468 469 wm::FocusController* focus_controller = 470 new wm::FocusController(new DesktopFocusRules(content_window_)); 471 focus_client_.reset(focus_controller); 472 aura::client::SetFocusClient(host_->window(), focus_controller); 473 aura::client::SetActivationClient(host_->window(), focus_controller); 474 host_->window()->AddPreTargetHandler(focus_controller); 475 476 dispatcher_client_.reset(new DesktopDispatcherClient); 477 aura::client::SetDispatcherClient(host_->window(), 478 dispatcher_client_.get()); 479 480 position_client_.reset(new DesktopScreenPositionClient(host_->window())); 481 482 InstallInputMethodEventFilter(); 483 484 drag_drop_client_ = desktop_window_tree_host_->CreateDragDropClient( 485 native_cursor_manager_); 486 aura::client::SetDragDropClient(host_->window(), 487 drag_drop_client_.get()); 488 489 static_cast<aura::client::FocusClient*>(focus_client_.get())-> 490 FocusWindow(content_window_); 491 492 OnHostResized(host()); 493 494 host_->AddObserver(this); 495 496 window_tree_client_.reset( 497 new DesktopNativeWidgetAuraWindowTreeClient(host_->window())); 498 drop_helper_.reset(new DropHelper(GetWidget()->GetRootView())); 499 aura::client::SetDragDropDelegate(content_window_, this); 500 501 if (params.type != Widget::InitParams::TYPE_TOOLTIP) { 502 tooltip_manager_.reset(new TooltipManagerAura(GetWidget())); 503 tooltip_controller_.reset( 504 new corewm::TooltipController( 505 desktop_window_tree_host_->CreateTooltip())); 506 aura::client::SetTooltipClient(host_->window(), 507 tooltip_controller_.get()); 508 host_->window()->AddPreTargetHandler(tooltip_controller_.get()); 509 } 510 511 if (params.opacity == Widget::InitParams::TRANSLUCENT_WINDOW) { 512 visibility_controller_.reset(new wm::VisibilityController); 513 aura::client::SetVisibilityClient(host_->window(), 514 visibility_controller_.get()); 515 wm::SetChildWindowVisibilityChangesAnimated(host_->window()); 516 wm::SetChildWindowVisibilityChangesAnimated( 517 content_window_container_); 518 } 519 520 if (params.type == Widget::InitParams::TYPE_WINDOW) { 521 focus_manager_event_handler_.reset(new FocusManagerEventHandler(this)); 522 host_->window()->AddPreTargetHandler(focus_manager_event_handler_.get()); 523 } 524 525 event_client_.reset(new DesktopEventClient); 526 aura::client::SetEventClient(host_->window(), event_client_.get()); 527 528 aura::client::GetFocusClient(content_window_)->FocusWindow(content_window_); 529 530 aura::client::SetActivationDelegate(content_window_, this); 531 532 shadow_controller_.reset(new wm::ShadowController( 533 aura::client::GetActivationClient(host_->window()))); 534 535 content_window_->SetProperty(aura::client::kCanMaximizeKey, 536 GetWidget()->widget_delegate()->CanMaximize()); 537 content_window_->SetProperty(aura::client::kCanResizeKey, 538 GetWidget()->widget_delegate()->CanResize()); 539 540 window_reorderer_.reset(new WindowReorderer(content_window_, 541 GetWidget()->GetRootView())); 542 } 543 544 NonClientFrameView* DesktopNativeWidgetAura::CreateNonClientFrameView() { 545 return ShouldUseNativeFrame() ? new NativeFrameView(GetWidget()) : NULL; 546 } 547 548 bool DesktopNativeWidgetAura::ShouldUseNativeFrame() const { 549 return desktop_window_tree_host_->ShouldUseNativeFrame(); 550 } 551 552 bool DesktopNativeWidgetAura::ShouldWindowContentsBeTransparent() const { 553 return desktop_window_tree_host_->ShouldWindowContentsBeTransparent(); 554 } 555 556 void DesktopNativeWidgetAura::FrameTypeChanged() { 557 desktop_window_tree_host_->FrameTypeChanged(); 558 UpdateWindowTransparency(); 559 } 560 561 Widget* DesktopNativeWidgetAura::GetWidget() { 562 return native_widget_delegate_->AsWidget(); 563 } 564 565 const Widget* DesktopNativeWidgetAura::GetWidget() const { 566 return native_widget_delegate_->AsWidget(); 567 } 568 569 gfx::NativeView DesktopNativeWidgetAura::GetNativeView() const { 570 return content_window_; 571 } 572 573 gfx::NativeWindow DesktopNativeWidgetAura::GetNativeWindow() const { 574 return content_window_; 575 } 576 577 Widget* DesktopNativeWidgetAura::GetTopLevelWidget() { 578 return GetWidget(); 579 } 580 581 const ui::Compositor* DesktopNativeWidgetAura::GetCompositor() const { 582 return content_window_ ? content_window_->layer()->GetCompositor() : NULL; 583 } 584 585 ui::Compositor* DesktopNativeWidgetAura::GetCompositor() { 586 return const_cast<ui::Compositor*>( 587 const_cast<const DesktopNativeWidgetAura*>(this)->GetCompositor()); 588 } 589 590 ui::Layer* DesktopNativeWidgetAura::GetLayer() { 591 return content_window_ ? content_window_->layer() : NULL; 592 } 593 594 void DesktopNativeWidgetAura::ReorderNativeViews() { 595 window_reorderer_->ReorderChildWindows(); 596 } 597 598 void DesktopNativeWidgetAura::ViewRemoved(View* view) { 599 DCHECK(drop_helper_.get() != NULL); 600 drop_helper_->ResetTargetViewIfEquals(view); 601 } 602 603 void DesktopNativeWidgetAura::SetNativeWindowProperty(const char* name, 604 void* value) { 605 if (content_window_) 606 content_window_->SetNativeWindowProperty(name, value); 607 } 608 609 void* DesktopNativeWidgetAura::GetNativeWindowProperty(const char* name) const { 610 return content_window_ ? 611 content_window_->GetNativeWindowProperty(name) : NULL; 612 } 613 614 TooltipManager* DesktopNativeWidgetAura::GetTooltipManager() const { 615 return tooltip_manager_.get(); 616 } 617 618 void DesktopNativeWidgetAura::SetCapture() { 619 if (!content_window_) 620 return; 621 622 content_window_->SetCapture(); 623 } 624 625 void DesktopNativeWidgetAura::ReleaseCapture() { 626 if (!content_window_) 627 return; 628 629 content_window_->ReleaseCapture(); 630 } 631 632 bool DesktopNativeWidgetAura::HasCapture() const { 633 return content_window_ && content_window_->HasCapture() && 634 desktop_window_tree_host_->HasCapture(); 635 } 636 637 InputMethod* DesktopNativeWidgetAura::CreateInputMethod() { 638 if (switches::IsTextInputFocusManagerEnabled()) 639 return new NullInputMethod(); 640 641 ui::InputMethod* host = input_method_event_filter_->input_method(); 642 return new InputMethodBridge(this, host, false); 643 } 644 645 internal::InputMethodDelegate* 646 DesktopNativeWidgetAura::GetInputMethodDelegate() { 647 return this; 648 } 649 650 ui::InputMethod* DesktopNativeWidgetAura::GetHostInputMethod() { 651 return input_method_event_filter_->input_method(); 652 } 653 654 void DesktopNativeWidgetAura::CenterWindow(const gfx::Size& size) { 655 if (content_window_) 656 desktop_window_tree_host_->CenterWindow(size); 657 } 658 659 void DesktopNativeWidgetAura::GetWindowPlacement( 660 gfx::Rect* bounds, 661 ui::WindowShowState* maximized) const { 662 if (content_window_) 663 desktop_window_tree_host_->GetWindowPlacement(bounds, maximized); 664 } 665 666 bool DesktopNativeWidgetAura::SetWindowTitle(const base::string16& title) { 667 if (!content_window_) 668 return false; 669 return desktop_window_tree_host_->SetWindowTitle(title); 670 } 671 672 void DesktopNativeWidgetAura::SetWindowIcons(const gfx::ImageSkia& window_icon, 673 const gfx::ImageSkia& app_icon) { 674 if (content_window_) 675 desktop_window_tree_host_->SetWindowIcons(window_icon, app_icon); 676 } 677 678 void DesktopNativeWidgetAura::InitModalType(ui::ModalType modal_type) { 679 // 99% of the time, we should not be asked to create a 680 // DesktopNativeWidgetAura that is modal. We only support window modal 681 // dialogs on the same lines as non AURA. 682 desktop_window_tree_host_->InitModalType(modal_type); 683 } 684 685 gfx::Rect DesktopNativeWidgetAura::GetWindowBoundsInScreen() const { 686 return content_window_ ? 687 desktop_window_tree_host_->GetWindowBoundsInScreen() : gfx::Rect(); 688 } 689 690 gfx::Rect DesktopNativeWidgetAura::GetClientAreaBoundsInScreen() const { 691 return content_window_ ? 692 desktop_window_tree_host_->GetClientAreaBoundsInScreen() : gfx::Rect(); 693 } 694 695 gfx::Rect DesktopNativeWidgetAura::GetRestoredBounds() const { 696 return content_window_ ? 697 desktop_window_tree_host_->GetRestoredBounds() : gfx::Rect(); 698 } 699 700 void DesktopNativeWidgetAura::SetBounds(const gfx::Rect& bounds) { 701 if (!content_window_) 702 return; 703 // TODO(ananta) 704 // This code by default scales the bounds rectangle by 1. 705 // We could probably get rid of this and similar logic from 706 // the DesktopNativeWidgetAura::OnWindowTreeHostResized function. 707 float scale = 1; 708 aura::Window* root = host_->window(); 709 if (root) { 710 scale = gfx::Screen::GetScreenFor(root)-> 711 GetDisplayNearestWindow(root).device_scale_factor(); 712 } 713 gfx::Rect bounds_in_pixels = 714 gfx::ScaleToEnclosingRect(bounds, scale, scale); 715 desktop_window_tree_host_->AsWindowTreeHost()->SetBounds(bounds_in_pixels); 716 } 717 718 void DesktopNativeWidgetAura::SetSize(const gfx::Size& size) { 719 if (content_window_) 720 desktop_window_tree_host_->SetSize(size); 721 } 722 723 void DesktopNativeWidgetAura::StackAbove(gfx::NativeView native_view) { 724 } 725 726 void DesktopNativeWidgetAura::StackAtTop() { 727 if (content_window_) 728 desktop_window_tree_host_->StackAtTop(); 729 } 730 731 void DesktopNativeWidgetAura::StackBelow(gfx::NativeView native_view) { 732 } 733 734 void DesktopNativeWidgetAura::SetShape(gfx::NativeRegion shape) { 735 if (content_window_) 736 desktop_window_tree_host_->SetShape(shape); 737 } 738 739 void DesktopNativeWidgetAura::Close() { 740 if (!content_window_) 741 return; 742 743 content_window_->SuppressPaint(); 744 content_window_->Hide(); 745 746 desktop_window_tree_host_->Close(); 747 } 748 749 void DesktopNativeWidgetAura::CloseNow() { 750 if (content_window_) 751 desktop_window_tree_host_->CloseNow(); 752 } 753 754 void DesktopNativeWidgetAura::Show() { 755 if (!content_window_) 756 return; 757 desktop_window_tree_host_->AsWindowTreeHost()->Show(); 758 content_window_->Show(); 759 } 760 761 void DesktopNativeWidgetAura::Hide() { 762 if (!content_window_) 763 return; 764 desktop_window_tree_host_->AsWindowTreeHost()->Hide(); 765 content_window_->Hide(); 766 } 767 768 void DesktopNativeWidgetAura::ShowMaximizedWithBounds( 769 const gfx::Rect& restored_bounds) { 770 if (!content_window_) 771 return; 772 desktop_window_tree_host_->ShowMaximizedWithBounds(restored_bounds); 773 content_window_->Show(); 774 } 775 776 void DesktopNativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) { 777 if (!content_window_) 778 return; 779 desktop_window_tree_host_->ShowWindowWithState(state); 780 content_window_->Show(); 781 } 782 783 bool DesktopNativeWidgetAura::IsVisible() const { 784 return content_window_ && desktop_window_tree_host_->IsVisible(); 785 } 786 787 void DesktopNativeWidgetAura::Activate() { 788 if (content_window_) 789 desktop_window_tree_host_->Activate(); 790 } 791 792 void DesktopNativeWidgetAura::Deactivate() { 793 if (content_window_) 794 desktop_window_tree_host_->Deactivate(); 795 } 796 797 bool DesktopNativeWidgetAura::IsActive() const { 798 return content_window_ && desktop_window_tree_host_->IsActive(); 799 } 800 801 void DesktopNativeWidgetAura::SetAlwaysOnTop(bool always_on_top) { 802 if (content_window_) 803 desktop_window_tree_host_->SetAlwaysOnTop(always_on_top); 804 } 805 806 bool DesktopNativeWidgetAura::IsAlwaysOnTop() const { 807 return content_window_ && desktop_window_tree_host_->IsAlwaysOnTop(); 808 } 809 810 void DesktopNativeWidgetAura::SetVisibleOnAllWorkspaces(bool always_visible) { 811 if (content_window_) 812 desktop_window_tree_host_->SetVisibleOnAllWorkspaces(always_visible); 813 } 814 815 void DesktopNativeWidgetAura::Maximize() { 816 if (content_window_) 817 desktop_window_tree_host_->Maximize(); 818 } 819 820 void DesktopNativeWidgetAura::Minimize() { 821 if (content_window_) 822 desktop_window_tree_host_->Minimize(); 823 } 824 825 bool DesktopNativeWidgetAura::IsMaximized() const { 826 return content_window_ && desktop_window_tree_host_->IsMaximized(); 827 } 828 829 bool DesktopNativeWidgetAura::IsMinimized() const { 830 return content_window_ && desktop_window_tree_host_->IsMinimized(); 831 } 832 833 void DesktopNativeWidgetAura::Restore() { 834 if (content_window_) 835 desktop_window_tree_host_->Restore(); 836 } 837 838 void DesktopNativeWidgetAura::SetFullscreen(bool fullscreen) { 839 if (content_window_) 840 desktop_window_tree_host_->SetFullscreen(fullscreen); 841 } 842 843 bool DesktopNativeWidgetAura::IsFullscreen() const { 844 return content_window_ && desktop_window_tree_host_->IsFullscreen(); 845 } 846 847 void DesktopNativeWidgetAura::SetOpacity(unsigned char opacity) { 848 if (content_window_) 849 desktop_window_tree_host_->SetOpacity(opacity); 850 } 851 852 void DesktopNativeWidgetAura::SetUseDragFrame(bool use_drag_frame) { 853 } 854 855 void DesktopNativeWidgetAura::FlashFrame(bool flash_frame) { 856 if (content_window_) 857 desktop_window_tree_host_->FlashFrame(flash_frame); 858 } 859 860 void DesktopNativeWidgetAura::RunShellDrag( 861 View* view, 862 const ui::OSExchangeData& data, 863 const gfx::Point& location, 864 int operation, 865 ui::DragDropTypes::DragEventSource source) { 866 views::RunShellDrag(content_window_, data, location, operation, source); 867 } 868 869 void DesktopNativeWidgetAura::SchedulePaintInRect(const gfx::Rect& rect) { 870 if (content_window_) 871 content_window_->SchedulePaintInRect(rect); 872 } 873 874 void DesktopNativeWidgetAura::SetCursor(gfx::NativeCursor cursor) { 875 cursor_ = cursor; 876 aura::client::CursorClient* cursor_client = 877 aura::client::GetCursorClient(host_->window()); 878 if (cursor_client) 879 cursor_client->SetCursor(cursor); 880 } 881 882 bool DesktopNativeWidgetAura::IsMouseEventsEnabled() const { 883 if (!content_window_) 884 return false; 885 aura::client::CursorClient* cursor_client = 886 aura::client::GetCursorClient(host_->window()); 887 return cursor_client ? cursor_client->IsMouseEventsEnabled() : true; 888 } 889 890 void DesktopNativeWidgetAura::ClearNativeFocus() { 891 desktop_window_tree_host_->ClearNativeFocus(); 892 893 if (ShouldActivate()) { 894 aura::client::GetFocusClient(content_window_)-> 895 ResetFocusWithinActiveWindow(content_window_); 896 } 897 } 898 899 gfx::Rect DesktopNativeWidgetAura::GetWorkAreaBoundsInScreen() const { 900 return desktop_window_tree_host_ ? 901 desktop_window_tree_host_->GetWorkAreaBoundsInScreen() : gfx::Rect(); 902 } 903 904 Widget::MoveLoopResult DesktopNativeWidgetAura::RunMoveLoop( 905 const gfx::Vector2d& drag_offset, 906 Widget::MoveLoopSource source, 907 Widget::MoveLoopEscapeBehavior escape_behavior) { 908 if (!content_window_) 909 return Widget::MOVE_LOOP_CANCELED; 910 return desktop_window_tree_host_->RunMoveLoop(drag_offset, source, 911 escape_behavior); 912 } 913 914 void DesktopNativeWidgetAura::EndMoveLoop() { 915 if (content_window_) 916 desktop_window_tree_host_->EndMoveLoop(); 917 } 918 919 void DesktopNativeWidgetAura::SetVisibilityChangedAnimationsEnabled( 920 bool value) { 921 if (content_window_) 922 desktop_window_tree_host_->SetVisibilityChangedAnimationsEnabled(value); 923 } 924 925 ui::NativeTheme* DesktopNativeWidgetAura::GetNativeTheme() const { 926 return DesktopWindowTreeHost::GetNativeTheme(content_window_); 927 } 928 929 void DesktopNativeWidgetAura::OnRootViewLayout() const { 930 if (content_window_) 931 desktop_window_tree_host_->OnRootViewLayout(); 932 } 933 934 bool DesktopNativeWidgetAura::IsTranslucentWindowOpacitySupported() const { 935 return content_window_ && 936 desktop_window_tree_host_->IsTranslucentWindowOpacitySupported(); 937 } 938 939 void DesktopNativeWidgetAura::RepostNativeEvent(gfx::NativeEvent native_event) { 940 OnEvent(native_event); 941 } 942 943 //////////////////////////////////////////////////////////////////////////////// 944 // DesktopNativeWidgetAura, aura::WindowDelegate implementation: 945 946 gfx::Size DesktopNativeWidgetAura::GetMinimumSize() const { 947 return native_widget_delegate_->GetMinimumSize(); 948 } 949 950 gfx::Size DesktopNativeWidgetAura::GetMaximumSize() const { 951 return native_widget_delegate_->GetMaximumSize(); 952 } 953 954 gfx::NativeCursor DesktopNativeWidgetAura::GetCursor(const gfx::Point& point) { 955 return cursor_; 956 } 957 958 int DesktopNativeWidgetAura::GetNonClientComponent( 959 const gfx::Point& point) const { 960 return native_widget_delegate_->GetNonClientComponent(point); 961 } 962 963 bool DesktopNativeWidgetAura::ShouldDescendIntoChildForEventHandling( 964 aura::Window* child, 965 const gfx::Point& location) { 966 views::WidgetDelegate* widget_delegate = GetWidget()->widget_delegate(); 967 return !widget_delegate || 968 widget_delegate->ShouldDescendIntoChildForEventHandling(child, location); 969 } 970 971 bool DesktopNativeWidgetAura::CanFocus() { 972 return true; 973 } 974 975 void DesktopNativeWidgetAura::OnCaptureLost() { 976 native_widget_delegate_->OnMouseCaptureLost(); 977 } 978 979 void DesktopNativeWidgetAura::OnPaint(gfx::Canvas* canvas) { 980 native_widget_delegate_->OnNativeWidgetPaint(canvas); 981 } 982 983 void DesktopNativeWidgetAura::OnDeviceScaleFactorChanged( 984 float device_scale_factor) { 985 } 986 987 void DesktopNativeWidgetAura::OnWindowDestroying(aura::Window* window) { 988 // Cleanup happens in OnHostClosed(). 989 } 990 991 void DesktopNativeWidgetAura::OnWindowDestroyed(aura::Window* window) { 992 // Cleanup happens in OnHostClosed(). We own |content_window_| (indirectly by 993 // way of |dispatcher_|) so there should be no need to do any processing 994 // here. 995 } 996 997 void DesktopNativeWidgetAura::OnWindowTargetVisibilityChanged(bool visible) { 998 } 999 1000 bool DesktopNativeWidgetAura::HasHitTestMask() const { 1001 return native_widget_delegate_->HasHitTestMask(); 1002 } 1003 1004 void DesktopNativeWidgetAura::GetHitTestMask(gfx::Path* mask) const { 1005 native_widget_delegate_->GetHitTestMask(mask); 1006 } 1007 1008 //////////////////////////////////////////////////////////////////////////////// 1009 // DesktopNativeWidgetAura, ui::EventHandler implementation: 1010 1011 void DesktopNativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) { 1012 if (event->is_char()) { 1013 // If a ui::InputMethod object is attached to the root window, character 1014 // events are handled inside the object and are not passed to this function. 1015 // If such object is not attached, character events might be sent (e.g. on 1016 // Windows). In this case, we just skip these. 1017 return; 1018 } 1019 // Renderer may send a key event back to us if the key event wasn't handled, 1020 // and the window may be invisible by that time. 1021 if (!content_window_->IsVisible()) 1022 return; 1023 1024 native_widget_delegate_->OnKeyEvent(event); 1025 if (event->handled()) 1026 return; 1027 1028 if (GetWidget()->HasFocusManager() && 1029 !GetWidget()->GetFocusManager()->OnKeyEvent(*event)) 1030 event->SetHandled(); 1031 } 1032 1033 void DesktopNativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) { 1034 DCHECK(content_window_->IsVisible()); 1035 if (tooltip_manager_.get()) 1036 tooltip_manager_->UpdateTooltip(); 1037 TooltipManagerAura::UpdateTooltipManagerForCapture(GetWidget()); 1038 native_widget_delegate_->OnMouseEvent(event); 1039 // WARNING: we may have been deleted. 1040 } 1041 1042 void DesktopNativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) { 1043 if (event->type() == ui::ET_SCROLL) { 1044 native_widget_delegate_->OnScrollEvent(event); 1045 if (event->handled()) 1046 return; 1047 1048 // Convert unprocessed scroll events into wheel events. 1049 ui::MouseWheelEvent mwe(*static_cast<ui::ScrollEvent*>(event)); 1050 native_widget_delegate_->OnMouseEvent(&mwe); 1051 if (mwe.handled()) 1052 event->SetHandled(); 1053 } else { 1054 native_widget_delegate_->OnScrollEvent(event); 1055 } 1056 } 1057 1058 void DesktopNativeWidgetAura::OnGestureEvent(ui::GestureEvent* event) { 1059 native_widget_delegate_->OnGestureEvent(event); 1060 } 1061 1062 //////////////////////////////////////////////////////////////////////////////// 1063 // DesktopNativeWidgetAura, aura::client::ActivationDelegate implementation: 1064 1065 bool DesktopNativeWidgetAura::ShouldActivate() const { 1066 return native_widget_delegate_->CanActivate(); 1067 } 1068 1069 //////////////////////////////////////////////////////////////////////////////// 1070 // DesktopNativeWidgetAura, aura::client::ActivationChangeObserver 1071 // implementation: 1072 1073 void DesktopNativeWidgetAura::OnWindowActivated(aura::Window* gained_active, 1074 aura::Window* lost_active) { 1075 DCHECK(content_window_ == gained_active || content_window_ == lost_active); 1076 if (gained_active == content_window_ && restore_focus_on_activate_) { 1077 restore_focus_on_activate_ = false; 1078 GetWidget()->GetFocusManager()->RestoreFocusedView(); 1079 } else if (lost_active == content_window_ && GetWidget()->HasFocusManager()) { 1080 DCHECK(!restore_focus_on_activate_); 1081 restore_focus_on_activate_ = true; 1082 // Pass in false so that ClearNativeFocus() isn't invoked. 1083 GetWidget()->GetFocusManager()->StoreFocusedView(false); 1084 } 1085 } 1086 1087 //////////////////////////////////////////////////////////////////////////////// 1088 // DesktopNativeWidgetAura, aura::client::FocusChangeObserver implementation: 1089 1090 void DesktopNativeWidgetAura::OnWindowFocused(aura::Window* gained_focus, 1091 aura::Window* lost_focus) { 1092 if (content_window_ == gained_focus) { 1093 desktop_window_tree_host_->OnNativeWidgetFocus(); 1094 native_widget_delegate_->OnNativeFocus(lost_focus); 1095 1096 // If focus is moving from a descendant Window to |content_window_| then 1097 // native activation hasn't changed. Still, the InputMethod must be informed 1098 // of the Window focus change. 1099 InputMethod* input_method = GetWidget()->GetInputMethod(); 1100 if (input_method) 1101 input_method->OnFocus(); 1102 } else if (content_window_ == lost_focus) { 1103 desktop_window_tree_host_->OnNativeWidgetBlur(); 1104 native_widget_delegate_->OnNativeBlur(gained_focus); 1105 } 1106 } 1107 1108 //////////////////////////////////////////////////////////////////////////////// 1109 // DesktopNativeWidgetAura, views::internal::InputMethodDelegate: 1110 1111 void DesktopNativeWidgetAura::DispatchKeyEventPostIME(const ui::KeyEvent& key) { 1112 FocusManager* focus_manager = 1113 native_widget_delegate_->AsWidget()->GetFocusManager(); 1114 native_widget_delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&key)); 1115 if (key.handled() || !focus_manager) 1116 return; 1117 focus_manager->OnKeyEvent(key); 1118 } 1119 1120 //////////////////////////////////////////////////////////////////////////////// 1121 // DesktopNativeWidgetAura, aura::WindowDragDropDelegate implementation: 1122 1123 void DesktopNativeWidgetAura::OnDragEntered(const ui::DropTargetEvent& event) { 1124 DCHECK(drop_helper_.get() != NULL); 1125 last_drop_operation_ = drop_helper_->OnDragOver(event.data(), 1126 event.location(), event.source_operations()); 1127 } 1128 1129 int DesktopNativeWidgetAura::OnDragUpdated(const ui::DropTargetEvent& event) { 1130 DCHECK(drop_helper_.get() != NULL); 1131 last_drop_operation_ = drop_helper_->OnDragOver(event.data(), 1132 event.location(), event.source_operations()); 1133 return last_drop_operation_; 1134 } 1135 1136 void DesktopNativeWidgetAura::OnDragExited() { 1137 DCHECK(drop_helper_.get() != NULL); 1138 drop_helper_->OnDragExit(); 1139 } 1140 1141 int DesktopNativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) { 1142 DCHECK(drop_helper_.get() != NULL); 1143 Activate(); 1144 return drop_helper_->OnDrop(event.data(), event.location(), 1145 last_drop_operation_); 1146 } 1147 1148 //////////////////////////////////////////////////////////////////////////////// 1149 // DesktopNativeWidgetAura, aura::WindowTreeHostObserver implementation: 1150 1151 void DesktopNativeWidgetAura::OnHostCloseRequested( 1152 const aura::WindowTreeHost* host) { 1153 GetWidget()->Close(); 1154 } 1155 1156 void DesktopNativeWidgetAura::OnHostResized(const aura::WindowTreeHost* host) { 1157 // Don't update the bounds of the child layers when animating closed. If we 1158 // did it would force a paint, which we don't want. We don't want the paint 1159 // as we can't assume any of the children are valid. 1160 if (desktop_window_tree_host_->IsAnimatingClosed()) 1161 return; 1162 1163 gfx::Rect new_bounds = gfx::Rect(host->window()->bounds().size()); 1164 content_window_->SetBounds(new_bounds); 1165 // Can be NULL at start. 1166 if (content_window_container_) 1167 content_window_container_->SetBounds(new_bounds); 1168 native_widget_delegate_->OnNativeWidgetSizeChanged(new_bounds.size()); 1169 } 1170 1171 void DesktopNativeWidgetAura::OnHostMoved(const aura::WindowTreeHost* host, 1172 const gfx::Point& new_origin) { 1173 TRACE_EVENT1("views", "DesktopNativeWidgetAura::OnHostMoved", 1174 "new_origin", new_origin.ToString()); 1175 1176 native_widget_delegate_->OnNativeWidgetMove(); 1177 } 1178 1179 //////////////////////////////////////////////////////////////////////////////// 1180 // DesktopNativeWidgetAura, private: 1181 1182 void DesktopNativeWidgetAura::InstallInputMethodEventFilter() { 1183 DCHECK(!input_method_event_filter_.get()); 1184 1185 input_method_event_filter_.reset(new wm::InputMethodEventFilter( 1186 host_->GetAcceleratedWidget())); 1187 input_method_event_filter_->SetInputMethodPropertyInRootWindow( 1188 host_->window()); 1189 root_window_event_filter_->AddHandler(input_method_event_filter_.get()); 1190 } 1191 1192 void DesktopNativeWidgetAura::UpdateWindowTransparency() { 1193 content_window_->SetTransparent( 1194 desktop_window_tree_host_->ShouldWindowContentsBeTransparent()); 1195 // Regardless of transparency or not, this root content window will always 1196 // fill its bounds completely, so set this flag to true to avoid an 1197 // unecessary clear before update. 1198 content_window_->SetFillsBoundsCompletely(true); 1199 } 1200 1201 void DesktopNativeWidgetAura::RootWindowDestroyed() { 1202 cursor_reference_count_--; 1203 if (cursor_reference_count_ == 0) { 1204 // We are the last DesktopNativeWidgetAura instance, and we are responsible 1205 // for cleaning up |cursor_manager_|. 1206 delete cursor_manager_; 1207 native_cursor_manager_ = NULL; 1208 cursor_manager_ = NULL; 1209 } 1210 } 1211 1212 } // namespace views 1213