| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ui/views/controls/native/native_view_host.h" |
| |
| #include "base/logging.h" |
| #include "ui/base/cursor/cursor.h" |
| #include "ui/gfx/canvas.h" |
| #include "ui/views/accessibility/native_view_accessibility.h" |
| #include "ui/views/controls/native/native_view_host_wrapper.h" |
| #include "ui/views/widget/widget.h" |
| |
| namespace views { |
| |
| // static |
| const char NativeViewHost::kViewClassName[] = "NativeViewHost"; |
| const char kWidgetNativeViewHostKey[] = "WidgetNativeViewHost"; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NativeViewHost, public: |
| |
| NativeViewHost::NativeViewHost() |
| : native_view_(NULL), |
| fast_resize_(false), |
| fast_resize_at_last_layout_(false), |
| resize_background_color_(SK_ColorWHITE) { |
| } |
| |
| NativeViewHost::~NativeViewHost() { |
| } |
| |
| void NativeViewHost::Attach(gfx::NativeView native_view) { |
| DCHECK(native_view); |
| DCHECK(!native_view_); |
| native_view_ = native_view; |
| native_wrapper_->AttachNativeView(); |
| Layout(); |
| |
| Widget* widget = Widget::GetWidgetForNativeView(native_view); |
| if (widget) |
| widget->SetNativeWindowProperty(kWidgetNativeViewHostKey, this); |
| } |
| |
| void NativeViewHost::Detach() { |
| Detach(false); |
| } |
| |
| void NativeViewHost::SetPreferredSize(const gfx::Size& size) { |
| preferred_size_ = size; |
| PreferredSizeChanged(); |
| } |
| |
| void NativeViewHost::NativeViewDestroyed() { |
| // Detach so we can clear our state and notify the native_wrapper_ to release |
| // ref on the native view. |
| Detach(true); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NativeViewHost, View overrides: |
| |
| gfx::Size NativeViewHost::GetPreferredSize() const { |
| return preferred_size_; |
| } |
| |
| void NativeViewHost::Layout() { |
| if (!native_view_ || !native_wrapper_.get()) |
| return; |
| |
| gfx::Rect vis_bounds = GetVisibleBounds(); |
| bool visible = !vis_bounds.IsEmpty(); |
| |
| if (visible && !fast_resize_) { |
| if (vis_bounds.size() != size()) { |
| // Only a portion of the Widget is really visible. |
| int x = vis_bounds.x(); |
| int y = vis_bounds.y(); |
| native_wrapper_->InstallClip(x, y, vis_bounds.width(), |
| vis_bounds.height()); |
| } else if (native_wrapper_->HasInstalledClip()) { |
| // The whole widget is visible but we installed a clip on the widget, |
| // uninstall it. |
| native_wrapper_->UninstallClip(); |
| } |
| } |
| |
| if (visible) { |
| // Since widgets know nothing about the View hierarchy (they are direct |
| // children of the Widget that hosts our View hierarchy) they need to be |
| // positioned in the coordinate system of the Widget, not the current |
| // view. Also, they should be positioned respecting the border insets |
| // of the native view. |
| gfx::Rect local_bounds = ConvertRectToWidget(GetContentsBounds()); |
| native_wrapper_->ShowWidget(local_bounds.x(), local_bounds.y(), |
| local_bounds.width(), |
| local_bounds.height()); |
| } else { |
| native_wrapper_->HideWidget(); |
| } |
| fast_resize_at_last_layout_ = visible && fast_resize_; |
| } |
| |
| void NativeViewHost::OnPaint(gfx::Canvas* canvas) { |
| // Paint background if there is one. NativeViewHost needs to paint |
| // a background when it is hosted in a TabbedPane. For Gtk implementation, |
| // NativeTabbedPaneGtk uses a NativeWidgetGtk as page container and because |
| // NativeWidgetGtk hook "expose" with its root view's paint, we need to |
| // fill the content. Otherwise, the tab page's background is not properly |
| // cleared. For Windows case, it appears okay to not paint background because |
| // we don't have a container window in-between. However if you want to use |
| // customized background, then this becomes necessary. |
| OnPaintBackground(canvas); |
| |
| // The area behind our window is black, so during a fast resize (where our |
| // content doesn't draw over the full size of our native view, and the native |
| // view background color doesn't show up), we need to cover that blackness |
| // with something so that fast resizes don't result in black flash. |
| // |
| // It would be nice if this used some approximation of the page's |
| // current background color. |
| if (native_wrapper_->HasInstalledClip()) |
| canvas->FillRect(GetLocalBounds(), resize_background_color_); |
| } |
| |
| void NativeViewHost::VisibilityChanged(View* starting_from, bool is_visible) { |
| Layout(); |
| } |
| |
| bool NativeViewHost::GetNeedsNotificationWhenVisibleBoundsChange() const { |
| // The native widget is placed relative to the root. As such, we need to |
| // know when the position of any ancestor changes, or our visibility relative |
| // to other views changed as it'll effect our position relative to the root. |
| return true; |
| } |
| |
| void NativeViewHost::OnVisibleBoundsChanged() { |
| Layout(); |
| } |
| |
| void NativeViewHost::ViewHierarchyChanged( |
| const ViewHierarchyChangedDetails& details) { |
| views::Widget* this_widget = GetWidget(); |
| |
| // A non-NULL |details.move_view| indicates a move operation i.e. |this| is |
| // is being reparented. If the previous and new parents belong to the same |
| // widget, don't remove |this| from the widget. This saves resources from |
| // removing from widget and immediately followed by adding to widget; in |
| // particular, there wouldn't be spurious visibilitychange events for web |
| // contents of |WebView|. |
| if (details.move_view && this_widget && |
| details.move_view->GetWidget() == this_widget) { |
| return; |
| } |
| |
| if (details.is_add && this_widget) { |
| if (!native_wrapper_.get()) |
| native_wrapper_.reset(NativeViewHostWrapper::CreateWrapper(this)); |
| native_wrapper_->AddedToWidget(); |
| } else if (!details.is_add) { |
| native_wrapper_->RemovedFromWidget(); |
| } |
| } |
| |
| const char* NativeViewHost::GetClassName() const { |
| return kViewClassName; |
| } |
| |
| void NativeViewHost::OnFocus() { |
| native_wrapper_->SetFocus(); |
| NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, true); |
| } |
| |
| gfx::NativeViewAccessible NativeViewHost::GetNativeViewAccessible() { |
| if (native_wrapper_.get()) { |
| gfx::NativeViewAccessible accessible_view = |
| native_wrapper_->GetNativeViewAccessible(); |
| if (accessible_view) |
| return accessible_view; |
| } |
| |
| return View::GetNativeViewAccessible(); |
| } |
| |
| gfx::NativeCursor NativeViewHost::GetCursor(const ui::MouseEvent& event) { |
| return native_wrapper_->GetCursor(event.x(), event.y()); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NativeViewHost, private: |
| |
| void NativeViewHost::Detach(bool destroyed) { |
| if (native_view_) { |
| if (!destroyed) { |
| Widget* widget = Widget::GetWidgetForNativeView(native_view_); |
| if (widget) |
| widget->SetNativeWindowProperty(kWidgetNativeViewHostKey, NULL); |
| ClearFocus(); |
| } |
| native_wrapper_->NativeViewDetaching(destroyed); |
| native_view_ = NULL; |
| } |
| } |
| |
| void NativeViewHost::ClearFocus() { |
| FocusManager* focus_manager = GetFocusManager(); |
| if (!focus_manager || !focus_manager->GetFocusedView()) |
| return; |
| |
| Widget::Widgets widgets; |
| Widget::GetAllChildWidgets(native_view(), &widgets); |
| for (Widget::Widgets::iterator i = widgets.begin(); i != widgets.end(); ++i) { |
| focus_manager->ViewRemoved((*i)->GetRootView()); |
| if (!focus_manager->GetFocusedView()) |
| return; |
| } |
| } |
| |
| } // namespace views |