OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // This is just a placeholder - TabContentsViewAura is not yet implemented | 5 #include "content/browser/tab_contents/tab_contents_view_aura.h" |
6 // (instead chrome has it's own TabContentsViewViews that is used for Aura). | 6 |
7 | 7 #include "base/utf_string_conversions.h" |
8 // We need to make sure the compiler sees this interface declaration somewhere | 8 #include "content/browser/renderer_host/render_view_host_factory.h" |
9 // so that it can emit exported versions of the inline ctor/dtor functions, | 9 #include "content/browser/tab_contents/interstitial_page_impl.h" |
10 // otherwise chrome.dll will get a linker error on Windows Aura builds. | 10 #include "content/browser/tab_contents/tab_contents.h" |
| 11 #include "content/public/browser/render_view_host.h" |
| 12 #include "content/public/browser/render_widget_host.h" |
| 13 #include "content/public/browser/render_widget_host_view.h" |
| 14 #include "content/public/browser/web_contents_delegate.h" |
11 #include "content/public/browser/web_contents_view_delegate.h" | 15 #include "content/public/browser/web_contents_view_delegate.h" |
| 16 #include "content/public/browser/web_drag_dest_delegate.h" |
| 17 #include "ui/aura/client/drag_drop_client.h" |
| 18 #include "ui/aura/client/drag_drop_delegate.h" |
| 19 #include "ui/aura/event.h" |
| 20 #include "ui/aura/root_window.h" |
| 21 #include "ui/aura/window.h" |
| 22 #include "ui/base/clipboard/custom_data_helper.h" |
| 23 #include "ui/base/dragdrop/drag_drop_types.h" |
| 24 #include "ui/base/dragdrop/os_exchange_data.h" |
| 25 #include "ui/base/dragdrop/os_exchange_data_provider_aura.h" |
| 26 #include "ui/base/hit_test.h" |
| 27 #include "ui/gfx/compositor/layer.h" |
| 28 #include "ui/gfx/screen.h" |
| 29 #include "webkit/glue/webdropdata.h" |
| 30 |
| 31 namespace { |
| 32 |
| 33 // Listens to all mouse drag events during a drag and drop and sends them to |
| 34 // the renderer. |
| 35 class WebDragSourceAura : public MessageLoopForUI::Observer { |
| 36 public: |
| 37 explicit WebDragSourceAura(TabContents* contents) |
| 38 : contents_(contents) { |
| 39 MessageLoopForUI::current()->AddObserver(this); |
| 40 } |
| 41 |
| 42 virtual ~WebDragSourceAura() { |
| 43 MessageLoopForUI::current()->RemoveObserver(this); |
| 44 } |
| 45 |
| 46 // MessageLoop::Observer implementation: |
| 47 virtual base::EventStatus WillProcessEvent( |
| 48 const base::NativeEvent& event) OVERRIDE { |
| 49 return base::EVENT_CONTINUE; |
| 50 } |
| 51 virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE { |
| 52 ui::EventType type = ui::EventTypeFromNative(event); |
| 53 content::RenderViewHost* rvh = NULL; |
| 54 switch (type) { |
| 55 case ui::ET_MOUSE_DRAGGED: |
| 56 rvh = contents_->GetRenderViewHost(); |
| 57 if (rvh) { |
| 58 gfx::Point screen_loc = ui::EventLocationFromNative(event); |
| 59 gfx::Point client_loc = screen_loc; |
| 60 aura::Window* window = rvh->GetView()->GetNativeView(); |
| 61 aura::Window::ConvertPointToWindow(window->GetRootWindow(), |
| 62 window, &client_loc); |
| 63 rvh->DragSourceMovedTo(client_loc.x(), client_loc.y(), |
| 64 screen_loc.x(), screen_loc.y()); |
| 65 } |
| 66 break; |
| 67 default: |
| 68 break; |
| 69 } |
| 70 } |
| 71 |
| 72 |
| 73 private: |
| 74 TabContents* contents_; |
| 75 |
| 76 DISALLOW_COPY_AND_ASSIGN(WebDragSourceAura); |
| 77 }; |
| 78 |
| 79 // Utility to fill a ui::OSExchangeDataProviderAura object from WebDropData. |
| 80 void PrepareDragData(const WebDropData& drop_data, |
| 81 ui::OSExchangeDataProviderAura* provider) { |
| 82 if (!drop_data.plain_text.empty()) |
| 83 provider->SetString(drop_data.plain_text); |
| 84 if (drop_data.url.is_valid()) |
| 85 provider->SetURL(drop_data.url, drop_data.url_title); |
| 86 if (!drop_data.text_html.empty()) |
| 87 provider->SetHtml(drop_data.text_html, drop_data.html_base_url); |
| 88 if (!drop_data.filenames.empty()) { |
| 89 std::vector<FilePath> paths; |
| 90 for (std::vector<string16>::const_iterator it = drop_data.filenames.begin(); |
| 91 it != drop_data.filenames.end(); ++it) |
| 92 paths.push_back(FilePath::FromUTF8Unsafe(UTF16ToUTF8(*it))); |
| 93 provider->SetFilenames(paths); |
| 94 } |
| 95 if (!drop_data.custom_data.empty()) { |
| 96 Pickle pickle; |
| 97 ui::WriteCustomDataToPickle(drop_data.custom_data, &pickle); |
| 98 provider->SetPickledData(ui::Clipboard::GetWebCustomDataFormatType(), |
| 99 pickle); |
| 100 } |
| 101 } |
| 102 |
| 103 // Utility to fill a WebDropData object from ui::OSExchangeData. |
| 104 void PrepareWebDropData(WebDropData* drop_data, |
| 105 const ui::OSExchangeData& data) { |
| 106 string16 plain_text, url_title; |
| 107 GURL url; |
| 108 |
| 109 data.GetString(&plain_text); |
| 110 if (!plain_text.empty()) |
| 111 drop_data->plain_text = plain_text; |
| 112 |
| 113 data.GetURLAndTitle(&url, &url_title); |
| 114 if (url.is_valid()) { |
| 115 drop_data->url = url; |
| 116 drop_data->url_title = url_title; |
| 117 } |
| 118 |
| 119 data.GetHtml(&drop_data->text_html, &drop_data->html_base_url); |
| 120 |
| 121 std::vector<FilePath> files; |
| 122 if (data.GetFilenames(&files) && !files.empty()) { |
| 123 for (std::vector<FilePath>::const_iterator it = files.begin(); |
| 124 it != files.end(); ++it) |
| 125 drop_data->filenames.push_back(UTF8ToUTF16(it->AsUTF8Unsafe())); |
| 126 } |
| 127 |
| 128 Pickle pickle; |
| 129 if (data.GetPickledData(ui::Clipboard::GetWebCustomDataFormatType(), |
| 130 &pickle)) |
| 131 ui::ReadCustomDataIntoMap(pickle.data(), pickle.size(), |
| 132 &drop_data->custom_data); |
| 133 } |
| 134 |
| 135 // Utilities to convert between WebKit::WebDragOperationsMask and |
| 136 // ui::DragDropTypes. |
| 137 int ConvertFromWeb(WebKit::WebDragOperationsMask ops) { |
| 138 int drag_op = ui::DragDropTypes::DRAG_NONE; |
| 139 if (ops & WebKit::WebDragOperationCopy) |
| 140 drag_op |= ui::DragDropTypes::DRAG_COPY; |
| 141 if (ops & WebKit::WebDragOperationMove) |
| 142 drag_op |= ui::DragDropTypes::DRAG_MOVE; |
| 143 if (ops & WebKit::WebDragOperationLink) |
| 144 drag_op |= ui::DragDropTypes::DRAG_LINK; |
| 145 return drag_op; |
| 146 } |
| 147 |
| 148 WebKit::WebDragOperationsMask ConvertToWeb(int drag_op) { |
| 149 int web_drag_op = WebKit::WebDragOperationNone; |
| 150 if (drag_op & ui::DragDropTypes::DRAG_COPY) |
| 151 web_drag_op |= WebKit::WebDragOperationCopy; |
| 152 if (drag_op & ui::DragDropTypes::DRAG_MOVE) |
| 153 web_drag_op |= WebKit::WebDragOperationMove; |
| 154 if (drag_op & ui::DragDropTypes::DRAG_LINK) |
| 155 web_drag_op |= WebKit::WebDragOperationLink; |
| 156 return (WebKit::WebDragOperationsMask) web_drag_op; |
| 157 } |
| 158 |
| 159 } // namespace |
| 160 |
| 161 |
| 162 //////////////////////////////////////////////////////////////////////////////// |
| 163 // TabContentsViewAura, public: |
| 164 |
| 165 TabContentsViewAura::TabContentsViewAura( |
| 166 TabContents* tab_contents, |
| 167 content::WebContentsViewDelegate* delegate) |
| 168 : tab_contents_(tab_contents), |
| 169 view_(NULL), |
| 170 delegate_(delegate), |
| 171 current_drag_op_(WebKit::WebDragOperationNone), |
| 172 close_tab_after_drag_ends_(false) { |
| 173 } |
| 174 |
| 175 TabContentsViewAura::~TabContentsViewAura() { |
| 176 } |
| 177 |
| 178 //////////////////////////////////////////////////////////////////////////////// |
| 179 // TabContentsViewAura, private: |
| 180 |
| 181 void TabContentsViewAura::SizeChangedCommon(const gfx::Size& size) { |
| 182 if (tab_contents_->GetInterstitialPage()) |
| 183 tab_contents_->GetInterstitialPage()->SetSize(size); |
| 184 content::RenderWidgetHostView* rwhv = |
| 185 tab_contents_->GetRenderWidgetHostView(); |
| 186 if (rwhv) |
| 187 rwhv->SetSize(size); |
| 188 } |
| 189 |
| 190 void TabContentsViewAura::EndDrag(WebKit::WebDragOperationsMask ops) { |
| 191 aura::RootWindow* root_window = GetNativeView()->GetRootWindow(); |
| 192 gfx::Point screen_loc = root_window->last_mouse_location(); |
| 193 gfx::Point client_loc = screen_loc; |
| 194 content::RenderViewHost* rvh = tab_contents_->GetRenderViewHost(); |
| 195 aura::Window* window = rvh->GetView()->GetNativeView(); |
| 196 aura::Window::ConvertPointToWindow(root_window, window, &client_loc); |
| 197 rvh->DragSourceEndedAt(client_loc.x(), client_loc.y(), screen_loc.x(), |
| 198 screen_loc.y(), ops); |
| 199 } |
| 200 |
| 201 content::WebDragDestDelegate* TabContentsViewAura::GetDragDestDelegate() { |
| 202 return delegate_.get() ? delegate_->GetDragDestDelegate() : NULL; |
| 203 } |
| 204 |
| 205 //////////////////////////////////////////////////////////////////////////////// |
| 206 // TabContentsViewAura, WebContentsView implementation: |
| 207 |
| 208 void TabContentsViewAura::CreateView(const gfx::Size& initial_size) { |
| 209 initial_size_ = initial_size; |
| 210 |
| 211 window_.reset(new aura::Window(this)); |
| 212 window_->SetType(aura::client::WINDOW_TYPE_CONTROL); |
| 213 window_->SetTransparent(false); |
| 214 window_->Init(ui::LAYER_TEXTURED); |
| 215 window_->layer()->SetMasksToBounds(true); |
| 216 window_->SetName("TabContentsViewAura"); |
| 217 |
| 218 // TODO(beng): allow for delegate init step. |
| 219 |
| 220 // TODO(beng): drag & drop init. |
| 221 } |
| 222 |
| 223 content::RenderWidgetHostView* TabContentsViewAura::CreateViewForWidget( |
| 224 content::RenderWidgetHost* render_widget_host) { |
| 225 if (render_widget_host->GetView()) { |
| 226 // During testing, the view will already be set up in most cases to the |
| 227 // test view, so we don't want to clobber it with a real one. To verify that |
| 228 // this actually is happening (and somebody isn't accidentally creating the |
| 229 // view twice), we check for the RVH Factory, which will be set when we're |
| 230 // making special ones (which go along with the special views). |
| 231 DCHECK(RenderViewHostFactory::has_factory()); |
| 232 return render_widget_host->GetView(); |
| 233 } |
| 234 |
| 235 view_ = content::RenderWidgetHostView::CreateViewForWidget( |
| 236 render_widget_host); |
| 237 view_->InitAsChild(NULL); |
| 238 GetNativeView()->AddChild(view_->GetNativeView()); |
| 239 view_->Show(); |
| 240 |
| 241 // We listen to drag drop events in the newly created view's window. |
| 242 aura::client::SetDragDropDelegate(view_->GetNativeView(), this); |
| 243 return view_; |
| 244 } |
| 245 |
| 246 gfx::NativeView TabContentsViewAura::GetNativeView() const { |
| 247 return window_.get(); |
| 248 } |
| 249 |
| 250 gfx::NativeView TabContentsViewAura::GetContentNativeView() const { |
| 251 return view_->GetNativeView(); |
| 252 } |
| 253 |
| 254 gfx::NativeWindow TabContentsViewAura::GetTopLevelNativeWindow() const { |
| 255 return window_->GetToplevelWindow(); |
| 256 } |
| 257 |
| 258 void TabContentsViewAura::GetContainerBounds(gfx::Rect *out) const { |
| 259 *out = window_->GetScreenBounds(); |
| 260 } |
| 261 |
| 262 void TabContentsViewAura::SetPageTitle(const string16& title) { |
| 263 window_->set_title(title); |
| 264 } |
| 265 |
| 266 void TabContentsViewAura::OnTabCrashed(base::TerminationStatus status, |
| 267 int error_code) { |
| 268 view_ = NULL; |
| 269 } |
| 270 |
| 271 void TabContentsViewAura::SizeContents(const gfx::Size& size) { |
| 272 gfx::Rect bounds = window_->bounds(); |
| 273 if (bounds.size() != size) { |
| 274 bounds.set_size(size); |
| 275 window_->SetBounds(bounds); |
| 276 } else { |
| 277 // Our size matches what we want but the renderers size may not match. |
| 278 // Pretend we were resized so that the renderers size is updated too. |
| 279 SizeChangedCommon(size); |
| 280 |
| 281 } |
| 282 } |
| 283 |
| 284 void TabContentsViewAura::RenderViewCreated(content::RenderViewHost* host) { |
| 285 } |
| 286 |
| 287 void TabContentsViewAura::Focus() { |
| 288 if (tab_contents_->GetInterstitialPage()) { |
| 289 tab_contents_->GetInterstitialPage()->Focus(); |
| 290 return; |
| 291 } |
| 292 |
| 293 if (delegate_.get() && delegate_->Focus()) |
| 294 return; |
| 295 |
| 296 content::RenderWidgetHostView* rwhv = |
| 297 tab_contents_->GetRenderWidgetHostView(); |
| 298 if (rwhv) |
| 299 rwhv->Focus(); |
| 300 } |
| 301 |
| 302 void TabContentsViewAura::SetInitialFocus() { |
| 303 if (tab_contents_->FocusLocationBarByDefault()) |
| 304 tab_contents_->SetFocusToLocationBar(false); |
| 305 else |
| 306 Focus(); |
| 307 } |
| 308 |
| 309 void TabContentsViewAura::StoreFocus() { |
| 310 if (delegate_.get()) |
| 311 delegate_->StoreFocus(); |
| 312 } |
| 313 |
| 314 void TabContentsViewAura::RestoreFocus() { |
| 315 if (delegate_.get()) |
| 316 delegate_->RestoreFocus(); |
| 317 } |
| 318 |
| 319 bool TabContentsViewAura::IsDoingDrag() const { |
| 320 aura::RootWindow* root_window = GetNativeView()->GetRootWindow(); |
| 321 if (aura::client::GetDragDropClient(root_window)) |
| 322 return aura::client::GetDragDropClient(root_window)->IsDragDropInProgress(); |
| 323 return false; |
| 324 } |
| 325 |
| 326 void TabContentsViewAura::CancelDragAndCloseTab() { |
| 327 DCHECK(IsDoingDrag()); |
| 328 // We can't close the tab while we're in the drag and |
| 329 // |drag_handler_->CancelDrag()| is async. Instead, set a flag to cancel |
| 330 // the drag and when the drag nested message loop ends, close the tab. |
| 331 aura::RootWindow* root_window = GetNativeView()->GetRootWindow(); |
| 332 if (aura::client::GetDragDropClient(root_window)) |
| 333 aura::client::GetDragDropClient(root_window)->DragCancel(); |
| 334 |
| 335 close_tab_after_drag_ends_ = true; |
| 336 } |
| 337 |
| 338 bool TabContentsViewAura::IsEventTracking() const { |
| 339 return false; |
| 340 } |
| 341 |
| 342 void TabContentsViewAura::CloseTabAfterEventTracking() { |
| 343 } |
| 344 |
| 345 void TabContentsViewAura::GetViewBounds(gfx::Rect* out) const { |
| 346 *out = window_->GetScreenBounds(); |
| 347 } |
| 348 |
| 349 //////////////////////////////////////////////////////////////////////////////// |
| 350 // TabContentsViewAura, RenderViewHostDelegate::View implementation: |
| 351 |
| 352 void TabContentsViewAura::CreateNewWindow( |
| 353 int route_id, |
| 354 const ViewHostMsg_CreateWindow_Params& params) { |
| 355 tab_contents_view_helper_.CreateNewWindow(tab_contents_, route_id, params); |
| 356 } |
| 357 |
| 358 void TabContentsViewAura::CreateNewWidget(int route_id, |
| 359 WebKit::WebPopupType popup_type) { |
| 360 tab_contents_view_helper_.CreateNewWidget(tab_contents_, |
| 361 route_id, |
| 362 false, |
| 363 popup_type); |
| 364 } |
| 365 |
| 366 void TabContentsViewAura::CreateNewFullscreenWidget(int route_id) { |
| 367 tab_contents_view_helper_.CreateNewWidget(tab_contents_, |
| 368 route_id, |
| 369 true, |
| 370 WebKit::WebPopupTypeNone); |
| 371 } |
| 372 |
| 373 void TabContentsViewAura::ShowCreatedWindow(int route_id, |
| 374 WindowOpenDisposition disposition, |
| 375 const gfx::Rect& initial_pos, |
| 376 bool user_gesture) { |
| 377 tab_contents_view_helper_.ShowCreatedWindow( |
| 378 tab_contents_, route_id, disposition, initial_pos, user_gesture); |
| 379 } |
| 380 |
| 381 void TabContentsViewAura::ShowCreatedWidget(int route_id, |
| 382 const gfx::Rect& initial_pos) { |
| 383 tab_contents_view_helper_.ShowCreatedWidget(tab_contents_, |
| 384 route_id, |
| 385 false, |
| 386 initial_pos); |
| 387 } |
| 388 |
| 389 void TabContentsViewAura::ShowCreatedFullscreenWidget(int route_id) { |
| 390 tab_contents_view_helper_.ShowCreatedWidget(tab_contents_, |
| 391 route_id, |
| 392 true, |
| 393 gfx::Rect()); |
| 394 } |
| 395 |
| 396 void TabContentsViewAura::ShowContextMenu( |
| 397 const content::ContextMenuParams& params) { |
| 398 // Allow WebContentsDelegates to handle the context menu operation first. |
| 399 if (tab_contents_->GetDelegate() && |
| 400 tab_contents_->GetDelegate()->HandleContextMenu(params)) { |
| 401 return; |
| 402 } |
| 403 |
| 404 if (delegate_.get()) |
| 405 delegate_->ShowContextMenu(params); |
| 406 } |
| 407 |
| 408 void TabContentsViewAura::ShowPopupMenu(const gfx::Rect& bounds, |
| 409 int item_height, |
| 410 double item_font_size, |
| 411 int selected_item, |
| 412 const std::vector<WebMenuItem>& items, |
| 413 bool right_aligned) { |
| 414 // External popup menus are only used on Mac. |
| 415 NOTIMPLEMENTED(); |
| 416 } |
| 417 |
| 418 void TabContentsViewAura::StartDragging( |
| 419 const WebDropData& drop_data, |
| 420 WebKit::WebDragOperationsMask operations, |
| 421 const SkBitmap& image, |
| 422 const gfx::Point& image_offset) { |
| 423 aura::RootWindow* root_window = GetNativeView()->GetRootWindow(); |
| 424 if (!aura::client::GetDragDropClient(root_window)) |
| 425 return; |
| 426 |
| 427 ui::OSExchangeDataProviderAura* provider = new ui::OSExchangeDataProviderAura; |
| 428 PrepareDragData(drop_data, provider); |
| 429 if (!image.isNull()) |
| 430 provider->set_drag_image(image); |
| 431 ui::OSExchangeData data(provider); // takes ownership of |provider|. |
| 432 |
| 433 scoped_ptr<WebDragSourceAura> drag_source( |
| 434 new WebDragSourceAura(tab_contents_)); |
| 435 |
| 436 // We need to enable recursive tasks on the message loop so we can get |
| 437 // updates while in the system DoDragDrop loop. |
| 438 int result_op = 0; |
| 439 { |
| 440 // TODO(sad): Avoid using last_mouse_location here, since the drag may not |
| 441 // always start from a mouse-event (e.g. a touch or gesture event could |
| 442 // initiate the drag). The location information should be carried over from |
| 443 // webkit. http://crbug.com/114754 |
| 444 gfx::Point location(root_window->last_mouse_location()); |
| 445 location.Offset(-image_offset.x(), -image_offset.y()); |
| 446 MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); |
| 447 result_op = aura::client::GetDragDropClient(root_window)->StartDragAndDrop( |
| 448 data, location, ConvertFromWeb(operations)); |
| 449 } |
| 450 |
| 451 EndDrag(ConvertToWeb(result_op)); |
| 452 tab_contents_->GetRenderViewHost()->DragSourceSystemDragEnded();} |
| 453 |
| 454 void TabContentsViewAura::UpdateDragCursor(WebKit::WebDragOperation operation) { |
| 455 current_drag_op_ = operation; |
| 456 } |
| 457 |
| 458 void TabContentsViewAura::GotFocus() { |
| 459 if (tab_contents_->GetDelegate()) |
| 460 tab_contents_->GetDelegate()->WebContentsFocused(tab_contents_); |
| 461 } |
| 462 |
| 463 void TabContentsViewAura::TakeFocus(bool reverse) { |
| 464 if (tab_contents_->GetDelegate() && |
| 465 !tab_contents_->GetDelegate()->TakeFocus(reverse) && |
| 466 delegate_.get()) { |
| 467 delegate_->TakeFocus(reverse); |
| 468 } |
| 469 } |
| 470 |
| 471 //////////////////////////////////////////////////////////////////////////////// |
| 472 // TabContentsViewAura, aura::WindowDelegate implementation: |
| 473 |
| 474 gfx::Size TabContentsViewAura::GetMinimumSize() const { |
| 475 return gfx::Size(); |
| 476 } |
| 477 |
| 478 void TabContentsViewAura::OnBoundsChanged(const gfx::Rect& old_bounds, |
| 479 const gfx::Rect& new_bounds) { |
| 480 SizeChangedCommon(new_bounds.size()); |
| 481 if (delegate_.get()) |
| 482 delegate_->SizeChanged(new_bounds.size()); |
| 483 } |
| 484 |
| 485 void TabContentsViewAura::OnFocus() { |
| 486 } |
| 487 |
| 488 void TabContentsViewAura::OnBlur() { |
| 489 } |
| 490 |
| 491 bool TabContentsViewAura::OnKeyEvent(aura::KeyEvent* event) { |
| 492 return false; |
| 493 } |
| 494 |
| 495 gfx::NativeCursor TabContentsViewAura::GetCursor(const gfx::Point& point) { |
| 496 return gfx::kNullCursor; |
| 497 } |
| 498 |
| 499 int TabContentsViewAura::GetNonClientComponent(const gfx::Point& point) const { |
| 500 return HTCLIENT; |
| 501 } |
| 502 |
| 503 bool TabContentsViewAura::OnMouseEvent(aura::MouseEvent* event) { |
| 504 if (!tab_contents_->GetDelegate()) |
| 505 return false; |
| 506 |
| 507 switch (event->type()) { |
| 508 case ui::ET_MOUSE_PRESSED: |
| 509 tab_contents_->GetDelegate()->ActivateContents(tab_contents_); |
| 510 break; |
| 511 case ui::ET_MOUSE_MOVED: |
| 512 tab_contents_->GetDelegate()->ContentsMouseEvent( |
| 513 tab_contents_, gfx::Screen::GetCursorScreenPoint(), true); |
| 514 break; |
| 515 default: |
| 516 break; |
| 517 } |
| 518 return false; |
| 519 } |
| 520 |
| 521 ui::TouchStatus TabContentsViewAura::OnTouchEvent(aura::TouchEvent* event) { |
| 522 return ui::TOUCH_STATUS_UNKNOWN; |
| 523 } |
| 524 |
| 525 ui::GestureStatus TabContentsViewAura::OnGestureEvent( |
| 526 aura::GestureEvent* event) { |
| 527 return ui::GESTURE_STATUS_UNKNOWN; |
| 528 } |
| 529 |
| 530 bool TabContentsViewAura::CanFocus() { |
| 531 return false; |
| 532 } |
| 533 |
| 534 void TabContentsViewAura::OnCaptureLost() { |
| 535 } |
| 536 |
| 537 void TabContentsViewAura::OnPaint(gfx::Canvas* canvas) { |
| 538 } |
| 539 |
| 540 void TabContentsViewAura::OnWindowDestroying() { |
| 541 } |
| 542 |
| 543 void TabContentsViewAura::OnWindowDestroyed() { |
| 544 } |
| 545 |
| 546 void TabContentsViewAura::OnWindowVisibilityChanged(bool visible) { |
| 547 if (visible) |
| 548 tab_contents_->ShowContents(); |
| 549 else |
| 550 tab_contents_->HideContents(); |
| 551 } |
| 552 //////////////////////////////////////////////////////////////////////////////// |
| 553 // TabContentsViewAura, aura::client::DragDropDelegate implementation: |
| 554 |
| 555 void TabContentsViewAura::OnDragEntered(const aura::DropTargetEvent& event) { |
| 556 if (GetDragDestDelegate()) |
| 557 GetDragDestDelegate()->DragInitialize(tab_contents_); |
| 558 |
| 559 WebDropData drop_data; |
| 560 PrepareWebDropData(&drop_data, event.data()); |
| 561 WebKit::WebDragOperationsMask op = ConvertToWeb(event.source_operations()); |
| 562 |
| 563 gfx::Point screen_pt = |
| 564 GetNativeView()->GetRootWindow()->last_mouse_location(); |
| 565 tab_contents_->GetRenderViewHost()->DragTargetDragEnter( |
| 566 drop_data, event.location(), screen_pt, op); |
| 567 |
| 568 if (GetDragDestDelegate()) { |
| 569 GetDragDestDelegate()->OnReceiveDragData(event.data()); |
| 570 GetDragDestDelegate()->OnDragEnter(); |
| 571 } |
| 572 } |
| 573 |
| 574 int TabContentsViewAura::OnDragUpdated(const aura::DropTargetEvent& event) { |
| 575 WebKit::WebDragOperationsMask op = ConvertToWeb(event.source_operations()); |
| 576 gfx::Point screen_pt = |
| 577 GetNativeView()->GetRootWindow()->last_mouse_location(); |
| 578 tab_contents_->GetRenderViewHost()->DragTargetDragOver( |
| 579 event.location(), screen_pt, op); |
| 580 |
| 581 if (GetDragDestDelegate()) |
| 582 GetDragDestDelegate()->OnDragOver(); |
| 583 |
| 584 return ConvertFromWeb(current_drag_op_); |
| 585 } |
| 586 |
| 587 void TabContentsViewAura::OnDragExited() { |
| 588 tab_contents_->GetRenderViewHost()->DragTargetDragLeave(); |
| 589 if (GetDragDestDelegate()) |
| 590 GetDragDestDelegate()->OnDragLeave(); |
| 591 } |
| 592 |
| 593 int TabContentsViewAura::OnPerformDrop(const aura::DropTargetEvent& event) { |
| 594 tab_contents_->GetRenderViewHost()->DragTargetDrop( |
| 595 event.location(), |
| 596 GetNativeView()->GetRootWindow()->last_mouse_location()); |
| 597 if (GetDragDestDelegate()) |
| 598 GetDragDestDelegate()->OnDrop(); |
| 599 return current_drag_op_; |
| 600 } |
OLD | NEW |