diff --git a/cef.gyp b/cef.gyp index a03c1773e..b33918fd0 100644 --- a/cef.gyp +++ b/cef.gyp @@ -330,6 +330,8 @@ 'libcef_dll/cpptoc/domevent_cpptoc.h', 'libcef_dll/cpptoc/domnode_cpptoc.cc', 'libcef_dll/cpptoc/domnode_cpptoc.h', + 'libcef_dll/cpptoc/drag_data_cpptoc.cc', + 'libcef_dll/cpptoc/drag_data_cpptoc.h', 'libcef_dll/cpptoc/frame_cpptoc.cc', 'libcef_dll/cpptoc/frame_cpptoc.h', 'libcef_dll/cpptoc/post_data_cpptoc.cc', @@ -371,6 +373,8 @@ 'libcef_dll/ctocpp/domvisitor_ctocpp.h', 'libcef_dll/ctocpp/download_handler_ctocpp.cc', 'libcef_dll/ctocpp/download_handler_ctocpp.h', + 'libcef_dll/ctocpp/drag_handler_ctocpp.cc', + 'libcef_dll/ctocpp/drag_handler_ctocpp.h', 'libcef_dll/ctocpp/find_handler_ctocpp.cc', 'libcef_dll/ctocpp/find_handler_ctocpp.h', 'libcef_dll/ctocpp/focus_handler_ctocpp.cc', @@ -483,6 +487,8 @@ 'libcef_dll/cpptoc/domvisitor_cpptoc.h', 'libcef_dll/cpptoc/download_handler_cpptoc.cc', 'libcef_dll/cpptoc/download_handler_cpptoc.h', + 'libcef_dll/cpptoc/drag_handler_cpptoc.cc', + 'libcef_dll/cpptoc/drag_handler_cpptoc.h', 'libcef_dll/cpptoc/find_handler_cpptoc.cc', 'libcef_dll/cpptoc/find_handler_cpptoc.h', 'libcef_dll/cpptoc/focus_handler_cpptoc.cc', @@ -530,6 +536,8 @@ 'libcef_dll/ctocpp/domevent_ctocpp.h', 'libcef_dll/ctocpp/domnode_ctocpp.cc', 'libcef_dll/ctocpp/domnode_ctocpp.h', + 'libcef_dll/ctocpp/drag_data_ctocpp.cc', + 'libcef_dll/ctocpp/drag_data_ctocpp.h', 'libcef_dll/ctocpp/frame_ctocpp.cc', 'libcef_dll/ctocpp/frame_ctocpp.h', 'libcef_dll/ctocpp/post_data_ctocpp.cc', @@ -688,6 +696,8 @@ 'libcef/cef_thread.h', 'libcef/cef_time.cc', 'libcef/cef_time_util.h', + 'libcef/drag_data_impl.cc', + 'libcef/drag_data_impl.h', 'libcef/drag_download_file.cc', 'libcef/drag_download_file.h', 'libcef/drag_download_util.cc', diff --git a/include/cef.h b/include/cef.h index df5bcd5bb..fd324352c 100644 --- a/include/cef.h +++ b/include/cef.h @@ -65,6 +65,7 @@ class CefDOMEventListener; class CefDOMNode; class CefDOMVisitor; class CefDownloadHandler; +class CefDragData; class CefFrame; class CefPostData; class CefPostDataElement; @@ -1541,6 +1542,40 @@ public: }; +/// +// Implement this interface to handle events related to dragging. The methods of +// this class will be called on the UI thread. +/// +/*--cef(source=client)--*/ +class CefDragHandler : public virtual CefBase +{ +public: + typedef cef_drag_operations_mask_t DragOperationsMask; + + /// + // Called when the browser window initiates a drag event. |dragData| + // contains the drag event data and |mask| represents the type of drag + // operation. Return false for default drag handling behavior or true to + // cancel the drag event. + /// + /*--cef()--*/ + virtual bool OnDragStart(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) { return false; } + + /// + // Called when an external drag event enters the browser window. |dragData| + // contains the drag event data and |mask| represents the type of drag + // operation. Return false for default drag handling behavior or true to + // cancel the drag event. + /// + /*--cef()--*/ + virtual bool OnDragEnter(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) { return false; } +}; + + /// // Implement this interface to provide handler implementations. /// @@ -1619,6 +1654,12 @@ public: /// /*--cef()--*/ virtual CefRefPtr GetRenderHandler() { return NULL; } + + /// + // Return the handler for drag events. + /// + /*--cef()--*/ + virtual CefRefPtr GetDragHandler() { return NULL; } }; @@ -3391,4 +3432,88 @@ public: virtual void Drain(CefRefPtr& remainder) {} }; + +/// +// Class used to represent drag data. The methods of this class may be called +// on any thread. +/// +/*--cef(source=library)--*/ +class CefDragData : public virtual CefBase +{ +public: + /// + // Returns true if the drag data is a link. + /// + /*--cef()--*/ + virtual bool IsLink() =0; + + /// + // Returns true if the drag data is a text or html fragment. + /// + /*--cef()--*/ + virtual bool IsFragment() =0; + + /// + // Returns true if the drag data is a file. + /// + /*--cef()--*/ + virtual bool IsFile() =0; + + /// + // Return the link URL that is being dragged. + /// + /*--cef()--*/ + virtual CefString GetLinkURL() =0; + + /// + // Return the title associated with the link being dragged. + /// + /*--cef()--*/ + virtual CefString GetLinkTitle() =0; + + /// + // Return the metadata, if any, associated with the link being dragged. + /// + /*--cef()--*/ + virtual CefString GetLinkMetadata() =0; + + /// + // Return the plain text fragment that is being dragged. + /// + /*--cef()--*/ + virtual CefString GetFragmentText() =0; + + /// + // Return the text/html fragment that is being dragged. + /// + /*--cef()--*/ + virtual CefString GetFragmentHtml() =0; + + /// + // Return the base URL that the fragment came from. This value is used for + // resolving relative URLs and may be empty. + /// + /*--cef()--*/ + virtual CefString GetFragmentBaseURL() =0; + + /// + // Return the extension of the file being dragged out of the browser window. + /// + /*--cef()--*/ + virtual CefString GetFileExtension() =0; + + /// + // Return the name of the file being dragged out of the browser window. + /// + /*--cef()--*/ + virtual CefString GetFileName() =0; + + /// + // Retrieve the list of file names that are being dragged into the browser + // window. + /// + /*--cef()--*/ + virtual bool GetFileNames(std::vector& names) =0; +}; + #endif // _CEF_H diff --git a/include/cef_capi.h b/include/cef_capi.h index ffb15ccc7..59f16b05e 100644 --- a/include/cef_capi.h +++ b/include/cef_capi.h @@ -1335,6 +1335,38 @@ typedef struct _cef_render_handler_t } cef_render_handler_t; +/// +// Implement this structure to handle events related to dragging. The functions +// of this structure will be called on the UI thread. +/// +typedef struct _cef_drag_handler_t +{ + // Base structure. + cef_base_t base; + + /// + // Called when the browser window initiates a drag event. |dragData| contains + // the drag event data and |mask| represents the type of drag operation. + // Return false (0) for default drag handling behavior or true (1) to cancel + // the drag event. + /// + int (CEF_CALLBACK *on_drag_start)(struct _cef_drag_handler_t* self, + struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData, + enum cef_drag_operations_mask_t mask); + + /// + // Called when an external drag event enters the browser window. |dragData| + // contains the drag event data and |mask| represents the type of drag + // operation. Return false (0) for default drag handling behavior or true (1) + // to cancel the drag event. + /// + int (CEF_CALLBACK *on_drag_enter)(struct _cef_drag_handler_t* self, + struct _cef_browser_t* browser, struct _cef_drag_data_t* dragData, + enum cef_drag_operations_mask_t mask); + +} cef_drag_handler_t; + + /// // Implement this structure to provide handler implementations. /// @@ -1415,6 +1447,12 @@ typedef struct _cef_client_t struct _cef_render_handler_t* (CEF_CALLBACK *get_render_handler)( struct _cef_client_t* self); + /// + // Return the handler for drag events. + /// + struct _cef_drag_handler_t* (CEF_CALLBACK *get_drag_handler)( + struct _cef_client_t* self); + } cef_client_t; @@ -3190,6 +3228,97 @@ typedef struct _cef_content_filter_t } cef_content_filter_t; +/// +// Structure used to represent drag data. The functions of this structure may be +// called on any thread. +/// +typedef struct _cef_drag_data_t +{ + // Base structure. + cef_base_t base; + + /// + // Returns true (1) if the drag data is a link. + /// + int (CEF_CALLBACK *is_link)(struct _cef_drag_data_t* self); + + /// + // Returns true (1) if the drag data is a text or html fragment. + /// + int (CEF_CALLBACK *is_fragment)(struct _cef_drag_data_t* self); + + /// + // Returns true (1) if the drag data is a file. + /// + int (CEF_CALLBACK *is_file)(struct _cef_drag_data_t* self); + + /// + // Return the link URL that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_link_url)( + struct _cef_drag_data_t* self); + + /// + // Return the title associated with the link being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_link_title)( + struct _cef_drag_data_t* self); + + /// + // Return the metadata, if any, associated with the link being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_link_metadata)( + struct _cef_drag_data_t* self); + + /// + // Return the plain text fragment that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_fragment_text)( + struct _cef_drag_data_t* self); + + /// + // Return the text/html fragment that is being dragged. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_fragment_html)( + struct _cef_drag_data_t* self); + + /// + // Return the base URL that the fragment came from. This value is used for + // resolving relative URLs and may be NULL. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_fragment_base_url)( + struct _cef_drag_data_t* self); + + /// + // Return the extension of the file being dragged out of the browser window. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_file_extension)( + struct _cef_drag_data_t* self); + + /// + // Return the name of the file being dragged out of the browser window. + /// + // The resulting string must be freed by calling cef_string_userfree_free(). + cef_string_userfree_t (CEF_CALLBACK *get_file_name)( + struct _cef_drag_data_t* self); + + /// + // Retrieve the list of file names that are being dragged into the browser + // window. + /// + int (CEF_CALLBACK *get_file_names)(struct _cef_drag_data_t* self, + cef_string_list_t names); + +} cef_drag_data_t; + + #ifdef __cplusplus } #endif diff --git a/include/internal/cef_types.h b/include/internal/cef_types.h index 45802f1d1..7e53e6ada 100644 --- a/include/internal/cef_types.h +++ b/include/internal/cef_types.h @@ -550,6 +550,23 @@ enum cef_handler_errorcode_t ERR_INSECURE_RESPONSE = -501, }; +/// +// "Verb" of a drag-and-drop operation as negotiated between the source and +// destination. These constants match their equivalents in WebCore's +// DragActions.h and should not be renumbered. +/// +enum cef_drag_operations_mask_t +{ + DRAG_OPERATION_NONE = 0, + DRAG_OPERATION_COPY = 1, + DRAG_OPERATION_LINK = 2, + DRAG_OPERATION_GENERIC = 4, + DRAG_OPERATION_PRIVATE = 8, + DRAG_OPERATION_MOVE = 16, + DRAG_OPERATION_DELETE = 32, + DRAG_OPERATION_EVERY = UINT_MAX +}; + /// // V8 access control values. /// diff --git a/libcef/browser_webkit_glue.h b/libcef/browser_webkit_glue.h index 6524c9148..4d9bb7b02 100644 --- a/libcef/browser_webkit_glue.h +++ b/libcef/browser_webkit_glue.h @@ -15,6 +15,10 @@ class WebFrame; class WebView; } +#if defined(OS_MACOSX) +class FilePath; +#endif + namespace webkit_glue { #if defined(OS_WIN) @@ -28,6 +32,7 @@ BOOL SaveBitmapToFile(HBITMAP hBmp, HDC hDC, LPCTSTR file, LPBYTE lpBits); #if defined(OS_MACOSX) void InitializeDataPak(); +FilePath GetResourcesFilePath(); #endif // Text encoding objects must be initialized on the main thread. diff --git a/libcef/browser_webview_delegate_mac.mm b/libcef/browser_webview_delegate_mac.mm index fee6a238f..e496b6543 100644 --- a/libcef/browser_webview_delegate_mac.mm +++ b/libcef/browser_webview_delegate_mac.mm @@ -5,6 +5,7 @@ #include "browser_webview_delegate.h" #import "browser_webview_mac.h" #include "browser_impl.h" +#include "drag_data_impl.h" #import "include/cef_application_mac.h" #import @@ -138,6 +139,21 @@ void BrowserWebViewDelegate::startDragging(const WebDragData& data, if (!view) return; + WebDropData drop_data(data); + + CefRefPtr client = browser_->GetClient(); + if (client.get()) { + CefRefPtr handler = client->GetDragHandler(); + if (handler.get()) { + CefRefPtr data(new CefDragDataImpl(drop_data)); + if (handler->OnDragStart(browser_, data, + static_cast(mask))) { + browser_->UIT_GetWebView()->dragSourceSystemDragEnded(); + return; + } + } + } + // By allowing nested tasks, the code below also allows Close(), // which would deallocate |this|. The same problem can occur while // processing -sendEvent:, so Close() is deferred in that case. @@ -148,13 +164,16 @@ void BrowserWebViewDelegate::startDragging(const WebDragData& data, // The drag invokes a nested event loop, arrange to continue // processing events. MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); - NSDragOperation op_mask = static_cast(mask); - const SkBitmap& bitmap = gfx::CGImageToSkBitmap(image.getCGImageRef()); - CGColorSpaceRef color_space = base::mac::GetSystemColorSpace(); - NSImage* ns_image = gfx::SkBitmapToNSImageWithColorSpace(bitmap, color_space); + + NSImage* ns_image = nil; + if (!image.isNull()) { + const SkBitmap& bitmap = gfx::CGImageToSkBitmap(image.getCGImageRef()); + CGColorSpaceRef color_space = base::mac::GetSystemColorSpace(); + ns_image = gfx::SkBitmapToNSImageWithColorSpace(bitmap, color_space); + } NSPoint offset = NSPointFromCGPoint(gfx::Point(image_offset).ToCGPoint()); - [view startDragWithDropData:WebDropData(data) - dragOperationMask:op_mask + [view startDragWithDropData:drop_data + dragOperationMask:static_cast(mask) image:ns_image offset:offset]; } diff --git a/libcef/browser_webview_delegate_win.cc b/libcef/browser_webview_delegate_win.cc index 2ddbfb305..04af41d74 100644 --- a/libcef/browser_webview_delegate_win.cc +++ b/libcef/browser_webview_delegate_win.cc @@ -12,6 +12,7 @@ #include "browser_impl.h" #include "browser_webview_delegate.h" #include "cef_context.h" +#include "drag_data_impl.h" #include "web_drop_target_win.h" #include @@ -190,8 +191,23 @@ void BrowserWebViewDelegate::startDragging( return; } + WebDropData drop_data(data); + + CefRefPtr client = browser_->GetClient(); + if (client.get()) { + CefRefPtr handler = client->GetDragHandler(); + if (handler.get()) { + CefRefPtr data(new CefDragDataImpl(drop_data)); + if (handler->OnDragStart(browser_, data, + static_cast(mask))) { + EndDragging(); + return; + } + } + } + drag_delegate_ = new BrowserDragDelegate(this); - drag_delegate_->StartDragging(WebDropData(data), mask, image.getSkBitmap(), + drag_delegate_->StartDragging(drop_data, mask, image.getSkBitmap(), image_offset); } @@ -563,8 +579,7 @@ end: void BrowserWebViewDelegate::RegisterDragDrop() { DCHECK(!drop_target_); - drop_target_ = new WebDropTarget(browser_->UIT_GetWebViewWndHandle(), - browser_->UIT_GetWebView()); + drop_target_ = new WebDropTarget(browser_); } void BrowserWebViewDelegate::RevokeDragDrop() { diff --git a/libcef/drag_data_impl.cc b/libcef/drag_data_impl.cc new file mode 100644 index 000000000..0cf1559b3 --- /dev/null +++ b/libcef/drag_data_impl.cc @@ -0,0 +1,78 @@ +// Copyright (c) 2011 The Chromium Embedded Framework 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 "drag_data_impl.h" + +CefDragDataImpl::CefDragDataImpl(const WebDropData& data) + : data_(data) +{ +} + +bool CefDragDataImpl::IsLink() +{ + return (data_.url.is_valid() && data_.file_extension.empty()); +} + +bool CefDragDataImpl::IsFragment() +{ + return (!data_.url.is_valid() && data_.file_extension.empty() && + data_.filenames.empty()); +} + +bool CefDragDataImpl::IsFile() +{ + return (!data_.file_extension.empty() || !data_.filenames.empty()); +} + +CefString CefDragDataImpl::GetLinkURL() +{ + return data_.url.spec(); +} + +CefString CefDragDataImpl::GetLinkTitle() +{ + return data_.url_title; +} + +CefString CefDragDataImpl::GetLinkMetadata() +{ + return data_.download_metadata; +} + +CefString CefDragDataImpl::GetFragmentText() +{ + return data_.plain_text; +} + +CefString CefDragDataImpl::GetFragmentHtml() +{ + return data_.text_html; +} + +CefString CefDragDataImpl::GetFragmentBaseURL() +{ + return data_.html_base_url.spec(); +} + +CefString CefDragDataImpl::GetFileExtension() +{ + return data_.file_extension; +} + +CefString CefDragDataImpl::GetFileName() +{ + return data_.file_description_filename; +} + +bool CefDragDataImpl::GetFileNames(std::vector& names) +{ + if (data_.filenames.empty()) + return false; + + std::vector::const_iterator it = data_.filenames.begin(); + for (; it != data_.filenames.end(); ++it) + names.push_back(*it); + + return true; +} diff --git a/libcef/drag_data_impl.h b/libcef/drag_data_impl.h new file mode 100644 index 000000000..4f878a445 --- /dev/null +++ b/libcef/drag_data_impl.h @@ -0,0 +1,36 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. + +#ifndef _DRAG_DATA_IMPL_H +#define _DRAG_DATA_IMPL_H + +#include "../include/cef.h" +#include "webkit/glue/webdropdata.h" + +// Implementation of CefDragData. +class CefDragDataImpl : public CefDragData +{ +public: + explicit CefDragDataImpl(const WebDropData& data); + + virtual bool IsLink(); + virtual bool IsFragment(); + virtual bool IsFile(); + virtual CefString GetLinkURL(); + virtual CefString GetLinkTitle(); + virtual CefString GetLinkMetadata(); + virtual CefString GetFragmentText(); + virtual CefString GetFragmentHtml(); + virtual CefString GetFragmentBaseURL(); + virtual CefString GetFileExtension(); + virtual CefString GetFileName(); + virtual bool GetFileNames(std::vector& names); + +protected: + WebDropData data_; + + IMPLEMENT_REFCOUNTING(CefDragDataImpl); +}; + +#endif // _DRAG_DATA_IMPL_H diff --git a/libcef/web_drag_source_mac.mm b/libcef/web_drag_source_mac.mm index 69e40a302..56479d6a7 100644 --- a/libcef/web_drag_source_mac.mm +++ b/libcef/web_drag_source_mac.mm @@ -4,6 +4,7 @@ // found in the LICENSE file. #include "browser_impl.h" +#include "browser_webkit_glue.h" #import "browser_webview_mac.h" #include "drag_download_util.h" #include "download_util.h" @@ -140,6 +141,14 @@ void PromiseWriterTask::Run() { dropData_.reset(new WebDropData(*dropData)); DCHECK(dropData_.get()); + if (image == nil) { + // No drag image was provided so create one. + FilePath path = webkit_glue::GetResourcesFilePath(); + path = path.AppendASCII("urlIcon.png"); + image = [[NSImage alloc] + initWithContentsOfFile:SysUTF8ToNSString(path.value())]; + } + dragImage_.reset([image retain]); imageOffset_ = offset; diff --git a/libcef/web_drop_target_mac.mm b/libcef/web_drop_target_mac.mm index 80432f1fa..e648f9c6c 100644 --- a/libcef/web_drop_target_mac.mm +++ b/libcef/web_drop_target_mac.mm @@ -6,6 +6,7 @@ #include "browser_impl.h" #import "browser_webview_mac.h" #include "cef_context.h" +#include "drag_data_impl.h" #import "web_drop_target_mac.h" #import "web_drag_utils_mac.h" @@ -30,8 +31,10 @@ using WebKit::WebView; // drag&drop messages to WebCore and handle navigation on a successful drop // (if necessary). - (id)initWithWebView:(BrowserWebView*)view { - if ((self = [super init])) + if ((self = [super init])) { view_ = view; + canceled_ = false; + } return self; } @@ -86,17 +89,34 @@ using WebKit::WebView; WebView* webview = view_.browser->UIT_GetWebView(); // Fill out a WebDropData from pasteboard. - WebDropData data; - [self populateWebDropData:&data fromPasteboard:[info draggingPasteboard]]; + WebDropData drop_data; + [self populateWebDropData:&drop_data + fromPasteboard:[info draggingPasteboard]]; + + NSDragOperation mask = [info draggingSourceOperationMask]; + + canceled_ = false; + + CefRefPtr client = view_.browser->GetClient(); + if (client.get()) { + CefRefPtr handler = client->GetDragHandler(); + if (handler.get()) { + CefRefPtr data(new CefDragDataImpl(drop_data)); + if (handler->OnDragEnter(view_.browser, data, + static_cast(mask))) { + canceled_ = true; + return NSDragOperationNone; + } + } + } // Create the appropriate mouse locations for WebCore. The draggingLocation // is in window coordinates. Both need to be flipped. NSPoint windowPoint = [info draggingLocation]; NSPoint viewPoint = [self flipWindowPointToView:windowPoint view:view]; NSPoint screenPoint = [self flipWindowPointToScreen:windowPoint view:view]; - NSDragOperation mask = [info draggingSourceOperationMask]; WebDragOperation op = - webview->dragTargetDragEnter(data.ToDragData(), + webview->dragTargetDragEnter(drop_data.ToDragData(), WebPoint(viewPoint.x, viewPoint.y), WebPoint(screenPoint.x, screenPoint.y), static_cast(mask)); @@ -108,6 +128,9 @@ using WebKit::WebView; if (current_wvh_ != _Context->current_webviewhost()) return; + if (canceled_) + return; + WebView* webview = view_.browser->UIT_GetWebView(); // Nothing to do in the interstitial case. @@ -127,6 +150,9 @@ using WebKit::WebView; return NSDragOperationNone; } + if (canceled_) + return NSDragOperationNone; + WebView* webview = view_.browser->UIT_GetWebView(); // Create the appropriate mouse locations for WebCore. The draggingLocation diff --git a/libcef/web_drop_target_win.cc b/libcef/web_drop_target_win.cc index cc02d135d..776f19fce 100644 --- a/libcef/web_drop_target_win.cc +++ b/libcef/web_drop_target_win.cc @@ -3,9 +3,11 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "web_drop_target_win.h" +#include "browser_impl.h" #include "cef_context.h" +#include "drag_data_impl.h" #include "web_drag_utils_win.h" +#include "web_drop_target_win.h" #include #include @@ -28,6 +30,7 @@ using WebKit::WebDragOperationLink; using WebKit::WebDragOperationMove; using WebKit::WebDragOperationGeneric; using WebKit::WebPoint; +using WebKit::WebView; namespace { @@ -44,11 +47,12 @@ DWORD GetPreferredDropEffect(DWORD effect) { } // namespace -WebDropTarget::WebDropTarget(HWND source_hwnd, WebKit::WebView* view) - : ui::DropTarget(source_hwnd), - view_(view), +WebDropTarget::WebDropTarget(CefBrowserImpl* browser) + : ui::DropTarget(browser->UIT_GetWebViewWndHandle()), + browser_(browser), current_wvh_(NULL), - drag_cursor_(WebDragOperationNone) { + drag_cursor_(WebDragOperationNone), + canceled_(false) { } WebDropTarget::~WebDropTarget() { @@ -69,15 +73,33 @@ DWORD WebDropTarget::OnDragEnter(IDataObject* data_object, if (drop_data.url.is_empty()) ui::OSExchangeDataProviderWin::GetPlainTextURL(data_object, &drop_data.url); + WebKit::WebDragOperationsMask mask = + web_drag_utils_win::WinDragOpMaskToWebDragOpMask(effects); + + canceled_ = false; + + CefRefPtr client = browser_->GetClient(); + if (client.get()) { + CefRefPtr handler = client->GetDragHandler(); + if (handler.get()) { + CefRefPtr data(new CefDragDataImpl(drop_data)); + if (handler->OnDragEnter(browser_, data, + static_cast(mask))) { + canceled_ = true; + return DROPEFFECT_NONE; + } + } + } + drag_cursor_ = WebDragOperationNone; POINT client_pt = cursor_position; ScreenToClient(GetHWND(), &client_pt); - WebDragOperation operation = view_->dragTargetDragEnter( + WebDragOperation operation = browser_->UIT_GetWebView()->dragTargetDragEnter( drop_data.ToDragData(), WebPoint(client_pt.x, client_pt.y), WebPoint(cursor_position.x, cursor_position.y), - web_drag_utils_win::WinDragOpMaskToWebDragOpMask(effects)); + mask); return web_drag_utils_win::WebDragOpToWinDragOp(operation); } @@ -90,9 +112,12 @@ DWORD WebDropTarget::OnDragOver(IDataObject* data_object, if (current_wvh_ != _Context->current_webviewhost()) OnDragEnter(data_object, key_state, cursor_position, effects); + if (canceled_) + return DROPEFFECT_NONE; + POINT client_pt = cursor_position; ScreenToClient(GetHWND(), &client_pt); - WebDragOperation operation = view_->dragTargetDragOver( + WebDragOperation operation = browser_->UIT_GetWebView()->dragTargetDragOver( WebPoint(client_pt.x, client_pt.y), WebPoint(cursor_position.x, cursor_position.y), web_drag_utils_win::WinDragOpMaskToWebDragOpMask(effects)); @@ -105,7 +130,10 @@ void WebDropTarget::OnDragLeave(IDataObject* data_object) { if (current_wvh_ != _Context->current_webviewhost()) return; - view_->dragTargetDragLeave(); + if (canceled_) + return; + + browser_->UIT_GetWebView()->dragTargetDragLeave(); } DWORD WebDropTarget::OnDrop(IDataObject* data_object, @@ -118,7 +146,7 @@ DWORD WebDropTarget::OnDrop(IDataObject* data_object, POINT client_pt = cursor_position; ScreenToClient(GetHWND(), &client_pt); - view_->dragTargetDrop( + browser_->UIT_GetWebView()->dragTargetDrop( WebPoint(client_pt.x, client_pt.y), WebPoint(cursor_position.x, cursor_position.y)); diff --git a/libcef/web_drop_target_win.h b/libcef/web_drop_target_win.h index 1e78629fe..13b6e44f8 100644 --- a/libcef/web_drop_target_win.h +++ b/libcef/web_drop_target_win.h @@ -11,9 +11,7 @@ #include "third_party/WebKit/Source/WebKit/chromium/public/WebDragOperation.h" #include "ui/base/dragdrop/drop_target.h" -namespace WebKit { -class WebView; -}; +class CefBrowserImpl; class WebViewHost; // A helper object that provides drop capabilities to a WebView. The @@ -23,7 +21,7 @@ class WebDropTarget : public ui::DropTarget { public: // Create a new WebDropTarget associating it with the given HWND and // WebView. - WebDropTarget(HWND source_hwnd, WebKit::WebView* view); + WebDropTarget(CefBrowserImpl* browser); virtual ~WebDropTarget(); void set_drag_cursor(WebKit::WebDragOperation op) { @@ -49,8 +47,8 @@ class WebDropTarget : public ui::DropTarget { DWORD effect); private: - // Our associated WebView. - WebKit::WebView* view_; + // Our associated CefBrowserImpl. + CefBrowserImpl* browser_; // We keep track of the web view host we're dragging over. If it changes // during a drag, we need to re-send the DragEnter message. WARNING: @@ -62,6 +60,9 @@ class WebDropTarget : public ui::DropTarget { // content area. This can be updated async during a drag operation. WebKit::WebDragOperation drag_cursor_; + // True if the drag has been canceled. + bool canceled_; + DISALLOW_COPY_AND_ASSIGN(WebDropTarget); }; diff --git a/libcef_dll/cpptoc/client_cpptoc.cc b/libcef_dll/cpptoc/client_cpptoc.cc index 590b808c1..4d5770149 100644 --- a/libcef_dll/cpptoc/client_cpptoc.cc +++ b/libcef_dll/cpptoc/client_cpptoc.cc @@ -12,6 +12,7 @@ #include "libcef_dll/cpptoc/client_cpptoc.h" #include "libcef_dll/cpptoc/display_handler_cpptoc.h" +#include "libcef_dll/cpptoc/drag_handler_cpptoc.h" #include "libcef_dll/cpptoc/find_handler_cpptoc.h" #include "libcef_dll/cpptoc/focus_handler_cpptoc.h" #include "libcef_dll/cpptoc/jsbinding_handler_cpptoc.h" @@ -207,6 +208,21 @@ cef_render_handler_t* CEF_CALLBACK client_get_render_handler( return NULL; } +cef_drag_handler_t* CEF_CALLBACK client_get_drag_handler( + struct _cef_client_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefRefPtr handlerPtr = + CefClientCppToC::Get(self)->GetDragHandler(); + if(handlerPtr.get()) + return CefDragHandlerCppToC::Wrap(handlerPtr); + + return NULL; +} + // CONSTRUCTOR - Do not edit by hand. @@ -225,6 +241,7 @@ CefClientCppToC::CefClientCppToC(CefClient* cls) struct_.struct_.get_jsdialog_handler = client_get_jsdialog_handler; struct_.struct_.get_jsbinding_handler = client_get_jsbinding_handler; struct_.struct_.get_render_handler = client_get_render_handler; + struct_.struct_.get_drag_handler = client_get_drag_handler; } #ifndef NDEBUG diff --git a/libcef_dll/cpptoc/drag_data_cpptoc.cc b/libcef_dll/cpptoc/drag_data_cpptoc.cc new file mode 100644 index 000000000..1aa09af03 --- /dev/null +++ b/libcef_dll/cpptoc/drag_data_cpptoc.cc @@ -0,0 +1,174 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// A portion of this file was generated by the CEF translator tool. When +// making changes by hand only do so within the body of existing function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/drag_data_cpptoc.h" +#include "libcef_dll/transfer_util.h" + + +// MEMBER FUNCTIONS - Body may be edited by hand. + +int CEF_CALLBACK drag_data_is_link(struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return 0; + + return CefDragDataCppToC::Get(self)->IsLink(); +} + +int CEF_CALLBACK drag_data_is_fragment(struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return 0; + + return CefDragDataCppToC::Get(self)->IsFragment(); +} + +int CEF_CALLBACK drag_data_is_file(struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return 0; + + return CefDragDataCppToC::Get(self)->IsFile(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_link_url( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetLinkURL(); + return str.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_link_title( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetLinkTitle(); + return str.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_link_metadata( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetLinkMetadata(); + return str.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_fragment_text( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetFragmentText(); + return str.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_fragment_html( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetFragmentHtml(); + return str.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_fragment_base_url( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetFragmentBaseURL(); + return str.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_file_extension( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetFileExtension(); + return str.DetachToUserFree(); +} + +cef_string_userfree_t CEF_CALLBACK drag_data_get_file_name( + struct _cef_drag_data_t* self) +{ + DCHECK(self); + if (!self) + return NULL; + + CefString str = CefDragDataCppToC::Get(self)->GetFileName(); + return str.DetachToUserFree(); +} + +int CEF_CALLBACK drag_data_get_file_names(struct _cef_drag_data_t* self, + cef_string_list_t names) +{ + DCHECK(self); + if (!self) + return 0; + + StringList file_names; + if (CefDragDataCppToC::Get(self)->GetFileNames(file_names)) { + transfer_string_list_contents(file_names, names); + return 1; + } + + return 0; +} + + +// CONSTRUCTOR - Do not edit by hand. + +CefDragDataCppToC::CefDragDataCppToC(CefDragData* cls) + : CefCppToC(cls) +{ + struct_.struct_.is_link = drag_data_is_link; + struct_.struct_.is_fragment = drag_data_is_fragment; + struct_.struct_.is_file = drag_data_is_file; + struct_.struct_.get_link_url = drag_data_get_link_url; + struct_.struct_.get_link_title = drag_data_get_link_title; + struct_.struct_.get_link_metadata = drag_data_get_link_metadata; + struct_.struct_.get_fragment_text = drag_data_get_fragment_text; + struct_.struct_.get_fragment_html = drag_data_get_fragment_html; + struct_.struct_.get_fragment_base_url = drag_data_get_fragment_base_url; + struct_.struct_.get_file_extension = drag_data_get_file_extension; + struct_.struct_.get_file_name = drag_data_get_file_name; + struct_.struct_.get_file_names = drag_data_get_file_names; +} + +#ifndef NDEBUG +template<> long CefCppToC::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/cpptoc/drag_data_cpptoc.h b/libcef_dll/cpptoc/drag_data_cpptoc.h new file mode 100644 index 000000000..24fe84fd0 --- /dev/null +++ b/libcef_dll/cpptoc/drag_data_cpptoc.h @@ -0,0 +1,34 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// +#ifndef _DRAGDATA_CPPTOC_H +#define _DRAGDATA_CPPTOC_H + +#ifndef BUILDING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed DLL-side only") +#else // BUILDING_CEF_SHARED + +#include "include/cef.h" +#include "include/cef_capi.h" +#include "libcef_dll/cpptoc/cpptoc.h" + +// Wrap a C++ class with a C structure. +// This class may be instantiated and accessed DLL-side only. +class CefDragDataCppToC + : public CefCppToC +{ +public: + CefDragDataCppToC(CefDragData* cls); + virtual ~CefDragDataCppToC() {} +}; + +#endif // BUILDING_CEF_SHARED +#endif // _DRAGDATA_CPPTOC_H + diff --git a/libcef_dll/cpptoc/drag_handler_cpptoc.cc b/libcef_dll/cpptoc/drag_handler_cpptoc.cc new file mode 100644 index 000000000..406b6c9d7 --- /dev/null +++ b/libcef_dll/cpptoc/drag_handler_cpptoc.cc @@ -0,0 +1,62 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// A portion of this file was generated by the CEF translator tool. When +// making changes by hand only do so within the body of existing function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/drag_handler_cpptoc.h" +#include "libcef_dll/ctocpp/browser_ctocpp.h" +#include "libcef_dll/ctocpp/drag_data_ctocpp.h" + + +// MEMBER FUNCTIONS - Body may be edited by hand. + +int CEF_CALLBACK drag_handler_on_drag_start(struct _cef_drag_handler_t* self, + cef_browser_t* browser, struct _cef_drag_data_t* dragData, + enum cef_drag_operations_mask_t mask) +{ + DCHECK(self); + DCHECK(browser); + DCHECK(dragData); + if (!self || !browser || !dragData) + return 0; + + return CefDragHandlerCppToC::Get(self)->OnDragStart( + CefBrowserCToCpp::Wrap(browser), CefDragDataCToCpp::Wrap(dragData), mask); +} + +int CEF_CALLBACK drag_handler_on_drag_enter(struct _cef_drag_handler_t* self, + cef_browser_t* browser, struct _cef_drag_data_t* dragData, + enum cef_drag_operations_mask_t mask) +{ + DCHECK(self); + DCHECK(browser); + DCHECK(dragData); + if (!self || !browser || !dragData) + return 0; + + return CefDragHandlerCppToC::Get(self)->OnDragEnter( + CefBrowserCToCpp::Wrap(browser), CefDragDataCToCpp::Wrap(dragData), mask); +} + + +// CONSTRUCTOR - Do not edit by hand. + +CefDragHandlerCppToC::CefDragHandlerCppToC(CefDragHandler* cls) + : CefCppToC(cls) +{ + struct_.struct_.on_drag_start = drag_handler_on_drag_start; + struct_.struct_.on_drag_enter = drag_handler_on_drag_enter; +} + +#ifndef NDEBUG +template<> long CefCppToC::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/cpptoc/drag_handler_cpptoc.h b/libcef_dll/cpptoc/drag_handler_cpptoc.h new file mode 100644 index 000000000..14f4a8792 --- /dev/null +++ b/libcef_dll/cpptoc/drag_handler_cpptoc.h @@ -0,0 +1,34 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// +#ifndef _DRAGHANDLER_CPPTOC_H +#define _DRAGHANDLER_CPPTOC_H + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include "include/cef.h" +#include "include/cef_capi.h" +#include "libcef_dll/cpptoc/cpptoc.h" + +// Wrap a C++ class with a C structure. +// This class may be instantiated and accessed wrapper-side only. +class CefDragHandlerCppToC + : public CefCppToC +{ +public: + CefDragHandlerCppToC(CefDragHandler* cls); + virtual ~CefDragHandlerCppToC() {} +}; + +#endif // USING_CEF_SHARED +#endif // _DRAGHANDLER_CPPTOC_H + diff --git a/libcef_dll/ctocpp/client_ctocpp.cc b/libcef_dll/ctocpp/client_ctocpp.cc index ddd076905..9bce2b6f2 100644 --- a/libcef_dll/ctocpp/client_ctocpp.cc +++ b/libcef_dll/ctocpp/client_ctocpp.cc @@ -12,6 +12,7 @@ #include "libcef_dll/ctocpp/client_ctocpp.h" #include "libcef_dll/ctocpp/display_handler_ctocpp.h" +#include "libcef_dll/ctocpp/drag_handler_ctocpp.h" #include "libcef_dll/ctocpp/find_handler_ctocpp.h" #include "libcef_dll/ctocpp/focus_handler_ctocpp.h" #include "libcef_dll/ctocpp/jsbinding_handler_ctocpp.h" @@ -175,6 +176,18 @@ CefRefPtr CefClientCToCpp::GetRenderHandler() return NULL; } +CefRefPtr CefClientCToCpp::GetDragHandler() +{ + if (CEF_MEMBER_MISSING(struct_, get_drag_handler)) + return NULL; + + cef_drag_handler_t* handlerStruct = struct_->get_drag_handler(struct_); + if(handlerStruct) + return CefDragHandlerCToCpp::Wrap(handlerStruct); + + return NULL; +} + #ifndef NDEBUG template<> long CefCToCpp GetJSDialogHandler() OVERRIDE; virtual CefRefPtr GetJSBindingHandler() OVERRIDE; virtual CefRefPtr GetRenderHandler() OVERRIDE; + virtual CefRefPtr GetDragHandler() OVERRIDE; }; #endif // BUILDING_CEF_SHARED diff --git a/libcef_dll/ctocpp/drag_data_ctocpp.cc b/libcef_dll/ctocpp/drag_data_ctocpp.cc new file mode 100644 index 000000000..c341663e8 --- /dev/null +++ b/libcef_dll/ctocpp/drag_data_ctocpp.cc @@ -0,0 +1,151 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// A portion of this file was generated by the CEF translator tool. When +// making changes by hand only do so within the body of existing static and +// virtual method implementations. See the translator.README.txt file in the +// tools directory for more information. +// + +#include "libcef_dll/ctocpp/drag_data_ctocpp.h" +#include "libcef_dll/transfer_util.h" + + +// VIRTUAL METHODS - Body may be edited by hand. + +bool CefDragDataCToCpp::IsLink() +{ + if (CEF_MEMBER_MISSING(struct_, is_link)) + return false; + + return struct_->is_link(struct_) ? true : false; +} + +bool CefDragDataCToCpp::IsFragment() +{ + if (CEF_MEMBER_MISSING(struct_, is_fragment)) + return false; + + return struct_->is_fragment(struct_) ? true : false; +} + +bool CefDragDataCToCpp::IsFile() +{ + if (CEF_MEMBER_MISSING(struct_, is_file)) + return false; + + return struct_->is_file(struct_) ? true : false; +} + +CefString CefDragDataCToCpp::GetLinkURL() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_link_url)) + return str; + + cef_string_userfree_t strPtr = struct_->get_link_url(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +CefString CefDragDataCToCpp::GetLinkTitle() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_link_title)) + return str; + + cef_string_userfree_t strPtr = struct_->get_link_title(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +CefString CefDragDataCToCpp::GetLinkMetadata() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_link_metadata)) + return str; + + cef_string_userfree_t strPtr = struct_->get_link_metadata(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +CefString CefDragDataCToCpp::GetFragmentText() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_fragment_text)) + return str; + + cef_string_userfree_t strPtr = struct_->get_fragment_text(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +CefString CefDragDataCToCpp::GetFragmentHtml() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_fragment_html)) + return str; + + cef_string_userfree_t strPtr = struct_->get_fragment_html(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +CefString CefDragDataCToCpp::GetFragmentBaseURL() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_fragment_base_url)) + return str; + + cef_string_userfree_t strPtr = struct_->get_fragment_base_url(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +CefString CefDragDataCToCpp::GetFileExtension() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_file_extension)) + return str; + + cef_string_userfree_t strPtr = struct_->get_file_extension(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +CefString CefDragDataCToCpp::GetFileName() +{ + CefString str; + if (CEF_MEMBER_MISSING(struct_, get_file_name)) + return str; + + cef_string_userfree_t strPtr = struct_->get_file_name(struct_); + str.AttachToUserFree(strPtr); + return str; +} + +bool CefDragDataCToCpp::GetFileNames(std::vector& names) +{ + if (CEF_MEMBER_MISSING(struct_, get_file_names)) + return false; + + cef_string_list_t list = cef_string_list_alloc(); + if(struct_->get_file_names(struct_, list)) { + transfer_string_list_contents(list, names); + cef_string_list_free(list); + return true; + } + + return false; +} + + +#ifndef NDEBUG +template<> long CefCToCpp::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/ctocpp/drag_data_ctocpp.h b/libcef_dll/ctocpp/drag_data_ctocpp.h new file mode 100644 index 000000000..105a4c288 --- /dev/null +++ b/libcef_dll/ctocpp/drag_data_ctocpp.h @@ -0,0 +1,50 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// ------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef _DRAGDATA_CTOCPP_H +#define _DRAGDATA_CTOCPP_H + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include "include/cef.h" +#include "include/cef_capi.h" +#include "libcef_dll/ctocpp/ctocpp.h" + +// Wrap a C structure with a C++ class. +// This class may be instantiated and accessed wrapper-side only. +class CefDragDataCToCpp + : public CefCToCpp +{ +public: + CefDragDataCToCpp(cef_drag_data_t* str) + : CefCToCpp(str) {} + virtual ~CefDragDataCToCpp() {} + + // CefDragData methods + virtual bool IsLink() OVERRIDE; + virtual bool IsFragment() OVERRIDE; + virtual bool IsFile() OVERRIDE; + virtual CefString GetLinkURL() OVERRIDE; + virtual CefString GetLinkTitle() OVERRIDE; + virtual CefString GetLinkMetadata() OVERRIDE; + virtual CefString GetFragmentText() OVERRIDE; + virtual CefString GetFragmentHtml() OVERRIDE; + virtual CefString GetFragmentBaseURL() OVERRIDE; + virtual CefString GetFileExtension() OVERRIDE; + virtual CefString GetFileName() OVERRIDE; + virtual bool GetFileNames(std::vector& names) OVERRIDE; +}; + +#endif // USING_CEF_SHARED +#endif // _DRAGDATA_CTOCPP_H + diff --git a/libcef_dll/ctocpp/drag_handler_ctocpp.cc b/libcef_dll/ctocpp/drag_handler_ctocpp.cc new file mode 100644 index 000000000..80836ae6a --- /dev/null +++ b/libcef_dll/ctocpp/drag_handler_ctocpp.cc @@ -0,0 +1,45 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// A portion of this file was generated by the CEF translator tool. When +// making changes by hand only do so within the body of existing static and +// virtual method implementations. See the translator.README.txt file in the +// tools directory for more information. +// + +#include "libcef_dll/cpptoc/browser_cpptoc.h" +#include "libcef_dll/cpptoc/drag_data_cpptoc.h" +#include "libcef_dll/ctocpp/drag_handler_ctocpp.h" + + +// VIRTUAL METHODS - Body may be edited by hand. + +bool CefDragHandlerCToCpp::OnDragStart(CefRefPtr browser, + CefRefPtr dragData, DragOperationsMask mask) +{ + if (CEF_MEMBER_MISSING(struct_, on_drag_start)) + return false; + + return struct_->on_drag_start(struct_, CefBrowserCppToC::Wrap(browser), + CefDragDataCppToC::Wrap(dragData), mask) ? true : false; +} + +bool CefDragHandlerCToCpp::OnDragEnter(CefRefPtr browser, + CefRefPtr dragData, DragOperationsMask mask) +{ + if (CEF_MEMBER_MISSING(struct_, on_drag_enter)) + return false; + + return struct_->on_drag_enter(struct_, CefBrowserCppToC::Wrap(browser), + CefDragDataCppToC::Wrap(dragData), mask) ? true : false; +} + + +#ifndef NDEBUG +template<> long CefCToCpp::DebugObjCt = 0; +#endif + diff --git a/libcef_dll/ctocpp/drag_handler_ctocpp.h b/libcef_dll/ctocpp/drag_handler_ctocpp.h new file mode 100644 index 000000000..285193a6f --- /dev/null +++ b/libcef_dll/ctocpp/drag_handler_ctocpp.h @@ -0,0 +1,43 @@ +// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// ------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef _DRAGHANDLER_CTOCPP_H +#define _DRAGHANDLER_CTOCPP_H + +#ifndef BUILDING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed DLL-side only") +#else // BUILDING_CEF_SHARED + +#include "include/cef.h" +#include "include/cef_capi.h" +#include "libcef_dll/ctocpp/ctocpp.h" + +// Wrap a C structure with a C++ class. +// This class may be instantiated and accessed DLL-side only. +class CefDragHandlerCToCpp + : public CefCToCpp +{ +public: + CefDragHandlerCToCpp(cef_drag_handler_t* str) + : CefCToCpp( + str) {} + virtual ~CefDragHandlerCToCpp() {} + + // CefDragHandler methods + virtual bool OnDragStart(CefRefPtr browser, + CefRefPtr dragData, DragOperationsMask mask) OVERRIDE; + virtual bool OnDragEnter(CefRefPtr browser, + CefRefPtr dragData, DragOperationsMask mask) OVERRIDE; +}; + +#endif // BUILDING_CEF_SHARED +#endif // _DRAGHANDLER_CTOCPP_H + diff --git a/tests/cefclient/client_handler.cpp b/tests/cefclient/client_handler.cpp index 5891b2ef1..41ca944bb 100644 --- a/tests/cefclient/client_handler.cpp +++ b/tests/cefclient/client_handler.cpp @@ -235,6 +235,35 @@ void ClientHandler::OnJSBinding(CefRefPtr browser, InitBindingTest(browser, frame, object); } +bool ClientHandler::OnDragStart(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) +{ + REQUIRE_UI_THREAD(); + + // Forbid dragging of image files. + if (dragData->IsFile()) { + std::string fileExt = dragData->GetFileExtension(); + if (fileExt == ".png" || fileExt == ".jpg" || fileExt == ".gif") + return true; + } + + return false; +} + +bool ClientHandler::OnDragEnter(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) +{ + REQUIRE_UI_THREAD(); + + // Forbid dragging of link URLs. + if (dragData->IsLink()) + return true; + + return false; +} + void ClientHandler::NotifyDownloadComplete(const CefString& fileName) { SetLastDownloadFile(fileName); diff --git a/tests/cefclient/client_handler.h b/tests/cefclient/client_handler.h index 7ca49cc89..e1fd49168 100644 --- a/tests/cefclient/client_handler.h +++ b/tests/cefclient/client_handler.h @@ -23,6 +23,7 @@ class ClientHandler : public CefClient, public CefDisplayHandler, public CefPrintHandler, public CefJSBindingHandler, + public CefDragHandler, public DownloadListener { public: @@ -42,6 +43,8 @@ public: { return this; } virtual CefRefPtr GetJSBindingHandler() OVERRIDE { return this; } + virtual CefRefPtr GetDragHandler() OVERRIDE + { return this; } // CefLifeSpanHandler methods virtual bool OnBeforePopup(CefRefPtr parentBrowser, @@ -114,6 +117,14 @@ public: CefRefPtr frame, CefRefPtr object) OVERRIDE; + // CefDragHandler methods. + virtual bool OnDragStart(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) OVERRIDE; + virtual bool OnDragEnter(CefRefPtr browser, + CefRefPtr dragData, + DragOperationsMask mask) OVERRIDE; + // DownloadListener methods virtual void NotifyDownloadComplete(const CefString& fileName) OVERRIDE; virtual void NotifyDownloadError(const CefString& fileName) OVERRIDE;