ui/views/controls/native/native_view_host_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/controls/native/native_view_host_aura.h"
   6
   7 #include "base/logging.h"
   8 #include "ui/aura/client/aura_constants.h"
   9 #include "ui/aura/client/focus_client.h"
  10 #include "ui/aura/window.h"
  11 #include "ui/aura/window_delegate.h"
  12 #include "ui/base/cursor/cursor.h"
  13 #include "ui/base/hit_test.h"
  14 #include "ui/views/controls/native/native_view_host.h"
  15 #include "ui/views/view_constants_aura.h"
  16 #include "ui/views/widget/widget.h"
  17
  18 namespace views {
  19
  20 class NativeViewHostAura::ClippingWindowDelegate : public aura::WindowDelegate {
  21  public:
  22   ClippingWindowDelegate() : native_view_(NULL) {}
  23   ~ClippingWindowDelegate() override {}
  24
  25   void set_native_view(aura::Window* native_view) {
  26     native_view_ = native_view;
  27   }
  28
  29   gfx::Size GetMinimumSize() const override { return gfx::Size(); }
  30   gfx::Size GetMaximumSize() const override { return gfx::Size(); }
  31   void OnBoundsChanged(const gfx::Rect& old_bounds,
  32                        const gfx::Rect& new_bounds) override {}
  33   gfx::NativeCursor GetCursor(const gfx::Point& point) override {
  34     return gfx::kNullCursor;
  35   }
  36   int GetNonClientComponent(const gfx::Point& point) const override {
  37     return HTCLIENT;
  38   }
  39   bool ShouldDescendIntoChildForEventHandling(
  40       aura::Window* child,
  41       const gfx::Point& location) override {
  42     return true;
  43   }
  44   bool CanFocus() override {
  45     // Ask the hosted native view's delegate because directly calling
  46     // aura::Window::CanFocus() will call back into this when checking whether
  47     // parents can focus.
  48     return native_view_ && native_view_->delegate()
  49         ? native_view_->delegate()->CanFocus()
  50         : true;
  51   }
  52   void OnCaptureLost() override {}
  53   void OnPaint(const ui::PaintContext& context) override {}
  54   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
  55   void OnWindowDestroying(aura::Window* window) override {}
  56   void OnWindowDestroyed(aura::Window* window) override {}
  57   void OnWindowTargetVisibilityChanged(bool visible) override {}
  58   bool HasHitTestMask() const override { return false; }
  59   void GetHitTestMask(gfx::Path* mask) const override {}
  60
  61  private:
  62   aura::Window* native_view_;
  63 };
  64
  65 NativeViewHostAura::NativeViewHostAura(NativeViewHost* host)
  66     : host_(host),
  67       clipping_window_delegate_(new ClippingWindowDelegate()),
  68       clipping_window_(clipping_window_delegate_.get()) {
  69   // Set the type so descendant views (including popups) get positioned
  70   // appropriately.
  71   clipping_window_.SetType(ui::wm::WINDOW_TYPE_CONTROL);
  72   clipping_window_.Init(ui::LAYER_NOT_DRAWN);
  73   clipping_window_.set_owned_by_parent(false);
  74   clipping_window_.SetName("NativeViewHostAuraClip");
  75   clipping_window_.layer()->SetMasksToBounds(true);
  76   clipping_window_.SetProperty(views::kHostViewKey, static_cast<View*>(host_));
  77 }
  78
  79 NativeViewHostAura::~NativeViewHostAura() {
  80   if (host_->native_view()) {
  81     host_->native_view()->RemoveObserver(this);
  82     host_->native_view()->ClearProperty(views::kHostViewKey);
  83     host_->native_view()->ClearProperty(aura::client::kHostWindowKey);
  84     clipping_window_.ClearProperty(views::kHostViewKey);
  85     if (host_->native_view()->parent() == &clipping_window_)
  86       clipping_window_.RemoveChild(host_->native_view());
  87   }
  88 }
  89
  90 ////////////////////////////////////////////////////////////////////////////////
  91 // NativeViewHostAura, NativeViewHostWrapper implementation:
  92 void NativeViewHostAura::AttachNativeView() {
  93   clipping_window_delegate_->set_native_view(host_->native_view());
  94   host_->native_view()->AddObserver(this);
  95   host_->native_view()->SetProperty(views::kHostViewKey,
  96       static_cast<View*>(host_));
  97   AddClippingWindow();
  98 }
  99
 100 void NativeViewHostAura::NativeViewDetaching(bool destroyed) {
 101   clipping_window_delegate_->set_native_view(NULL);
 102   RemoveClippingWindow();
 103   if (!destroyed) {
 104     host_->native_view()->RemoveObserver(this);
 105     host_->native_view()->ClearProperty(views::kHostViewKey);
 106     host_->native_view()->ClearProperty(aura::client::kHostWindowKey);
 107     host_->native_view()->Hide();
 108     if (host_->native_view()->parent())
 109       Widget::ReparentNativeView(host_->native_view(), NULL);
 110   }
 111 }
 112
 113 void NativeViewHostAura::AddedToWidget() {
 114   if (!host_->native_view())
 115     return;
 116
 117   AddClippingWindow();
 118   if (host_->IsDrawn())
 119     host_->native_view()->Show();
 120   else
 121     host_->native_view()->Hide();
 122   host_->Layout();
 123 }
 124
 125 void NativeViewHostAura::RemovedFromWidget() {
 126   if (host_->native_view()) {
 127     host_->native_view()->Hide();
 128     host_->native_view()->ClearProperty(aura::client::kHostWindowKey);
 129     if (host_->native_view()->parent())
 130       host_->native_view()->parent()->RemoveChild(host_->native_view());
 131     RemoveClippingWindow();
 132   }
 133 }
 134
 135 void NativeViewHostAura::InstallClip(int x, int y, int w, int h) {
 136   clip_rect_.reset(
 137       new gfx::Rect(host_->ConvertRectToWidget(gfx::Rect(x, y, w, h))));
 138 }
 139
 140 bool NativeViewHostAura::HasInstalledClip() {
 141   return clip_rect_;
 142 }
 143
 144 void NativeViewHostAura::UninstallClip() {
 145   clip_rect_.reset();
 146 }
 147
 148 void NativeViewHostAura::ShowWidget(int x, int y, int w, int h) {
 149   int width = w;
 150   int height = h;
 151   if (host_->fast_resize()) {
 152     gfx::Point origin(x, y);
 153     views::View::ConvertPointFromWidget(host_, &origin);
 154     InstallClip(origin.x(), origin.y(), w, h);
 155     width = host_->native_view()->bounds().width();
 156     height = host_->native_view()->bounds().height();
 157   }
 158   clipping_window_.SetBounds(clip_rect_ ? *clip_rect_
 159                                         : gfx::Rect(x, y, w, h));
 160
 161   gfx::Point clip_offset = clipping_window_.bounds().origin();
 162   host_->native_view()->SetBounds(
 163       gfx::Rect(x - clip_offset.x(), y - clip_offset.y(), width, height));
 164   host_->native_view()->Show();
 165   clipping_window_.Show();
 166 }
 167
 168 void NativeViewHostAura::HideWidget() {
 169   host_->native_view()->Hide();
 170   clipping_window_.Hide();
 171 }
 172
 173 void NativeViewHostAura::SetFocus() {
 174   aura::Window* window = host_->native_view();
 175   aura::client::FocusClient* client = aura::client::GetFocusClient(window);
 176   if (client)
 177     client->FocusWindow(window);
 178 }
 179
 180 gfx::NativeViewAccessible NativeViewHostAura::GetNativeViewAccessible() {
 181   return NULL;
 182 }
 183
 184 gfx::NativeCursor NativeViewHostAura::GetCursor(int x, int y) {
 185   if (host_->native_view())
 186     return host_->native_view()->GetCursor(gfx::Point(x, y));
 187   return gfx::kNullCursor;
 188 }
 189
 190 void NativeViewHostAura::OnWindowDestroying(aura::Window* window) {
 191   DCHECK(window == host_->native_view());
 192   clipping_window_delegate_->set_native_view(NULL);
 193 }
 194
 195 void NativeViewHostAura::OnWindowDestroyed(aura::Window* window) {
 196   DCHECK(window == host_->native_view());
 197   host_->NativeViewDestroyed();
 198 }
 199
 200 // static
 201 NativeViewHostWrapper* NativeViewHostWrapper::CreateWrapper(
 202     NativeViewHost* host) {
 203   return new NativeViewHostAura(host);
 204 }
 205
 206 void NativeViewHostAura::AddClippingWindow() {
 207   RemoveClippingWindow();
 208
 209   host_->native_view()->SetProperty(aura::client::kHostWindowKey,
 210                                     host_->GetWidget()->GetNativeView());
 211   Widget::ReparentNativeView(host_->native_view(),
 212                              &clipping_window_);
 213   if (host_->GetWidget()->GetNativeView()) {
 214     Widget::ReparentNativeView(&clipping_window_,
 215                                host_->GetWidget()->GetNativeView());
 216   }
 217 }
 218
 219 void NativeViewHostAura::RemoveClippingWindow() {
 220   clipping_window_.Hide();
 221   if (host_->native_view())
 222     host_->native_view()->ClearProperty(aura::client::kHostWindowKey);
 223
 224   if (host_->native_view()->parent() == &clipping_window_) {
 225     if (host_->GetWidget() && host_->GetWidget()->GetNativeView()) {
 226       Widget::ReparentNativeView(host_->native_view(),
 227                                  host_->GetWidget()->GetNativeView());
 228     } else {
 229       clipping_window_.RemoveChild(host_->native_view());
 230     }
 231     host_->native_view()->SetBounds(clipping_window_.bounds());
 232   }
 233   if (clipping_window_.parent())
 234     clipping_window_.parent()->RemoveChild(&clipping_window_);
 235 }
 236
 237 }  // namespace views