This patch brings up DnD feature to M108.
Between M85 and M94, due to upstream refactoring,
the DragEnter notification IPC call is done through
mojom::blink::PageBroadcast (WebViewImpl).
Reference: https://review.tizen.org/gerrit/c/278386
Change-Id: I9aeb92ad80485f28434065c3cd582e9468497991
Signed-off-by: Bakka Uday Kiran <b.kiran@samsung.com>
broadcast->SetHistoryOffsetAndLength(history_offset, history_length);
}
+#if BUILDFLAG(IS_TIZEN)
+void WebContentsImpl::EnterDragState(RenderViewHost* render_view_host) {
+ if (auto& broadcast = static_cast<RenderViewHostImpl*>(render_view_host)
+ ->GetAssociatedPageBroadcast()) {
+ broadcast->EnterDragState();
+ }
+}
+#endif
+
void WebContentsImpl::ReloadFocusedFrame() {
OPTIONAL_TRACE_EVENT0("content", "WebContentsImpl::ReloadFocusedFrame");
RenderFrameHost* focused_frame = GetFocusedFrame();
void LoadingStateChanged(bool should_show_loading_ui,
LoadNotificationDetails* details);
+#if BUILDFLAG(IS_TIZEN)
+ // Notifes the delegate to enter into drag state.
+ void EnterDragState(RenderViewHost* render_view_host);
+#endif
+
// Misc non-view stuff -------------------------------------------------------
// Sets the history for a specified RenderViewHost to |history_length|
wcva_helper_ = std::make_unique<WebContentsViewAuraHelperEfl>(
this, web_contents_, delegate_.get());
+ if (wcva_helper_)
+ wcva_helper_->SetViewDelegate(delegate_.get());
#endif
}
}
DropData* WebContentsViewAura::GetDropData() const {
+#if BUILDFLAG(IS_EFL)
+ if (wcva_helper())
+ return wcva_helper()->GetDropData();
+#endif
return current_drop_data_.get();
}
InstallOverscrollControllerDelegate(view);
}
+#if BUILDFLAG(IS_EFL)
+ if (wcva_helper()) {
+ RenderViewHost* render_view_host = web_contents_->GetRenderViewHost();
+ wcva_helper()->UpdateDragDest(render_view_host);
+ }
+#endif
+
return view;
}
const gfx::Rect& drag_obj_rect,
const blink::mojom::DragEventSourceInfo& event_info,
RenderWidgetHostImpl* source_rwh) {
+#if BUILDFLAG(IS_EFL)
+ if (wcva_helper()) {
+ wcva_helper()->StartDragging(drop_data, operations, image, cursor_offset,
+ event_info, source_rwh);
+ return;
+ }
+#endif
aura::Window* root_window = GetNativeView()->GetRootWindow();
if (!aura::client::GetDragDropClient(root_window)) {
web_contents_->SystemDragEnded(source_rwh);
// Returns the current drop data, if any.
virtual DropData* GetDropData() = 0;
+#if BUILDFLAG(IS_TIZEN)
+ virtual void EnterDragState(RenderViewHost* render_view_host) = 0;
+#endif
+
// Sets focus to the native widget for this tab.
virtual void Focus() = 0;
void TestPageBroadcast::SetScrollOffset(float x, float y) {}
#endif
+#if BUILDFLAG(IS_TIZEN)
+void TestPageBroadcast::EnterDragState() {}
+#endif
+
void TestPageBroadcast::SetPageBaseBackgroundColor(
absl::optional<SkColor> color) {}
void ScrollFocusedNodeIntoView() override;
void SetScrollOffset(float x, float y) override;
#endif
+
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState() override;
+#endif
+
void SetPageBaseBackgroundColor(absl::optional<SkColor> color) override;
void CreateRemoteMainFrame(
const blink::RemoteFrameToken& token,
"is_tizen=true" \
"data_dir=\"%{CHROMIUM_DATA_DIR}\"" \
"edje_dir=\"%{CHROMIUM_DATA_DIR}/themes\"" \
+ "image_dir=\"%{CHROMIUM_DATA_DIR}/images\"" \
"exe_dir=\"%{CHROMIUM_EXE_DIR}\"" \
"tizen_version=%{tizen_version}" \
"tizen_version_major=%{tizen_version_major}" \
install -d "%{buildroot}%{CHROMIUM_EXE_DIR}"
install -d "%{buildroot}%{CHROMIUM_EXE_DIR}"/locales
install -d "%{buildroot}%{CHROMIUM_DATA_DIR}"/themes
+install -d "%{buildroot}"%{CHROMIUM_DATA_DIR}/images
install -d "%{buildroot}"%{_libdir}/../local/lib/
%if %{__use_clang} == 1
install -m 0755 "%{OUTPUT_FOLDER}"/snapshot_blob.bin "%{buildroot}%{CHROMIUM_EXE_DIR}"
install -m 0644 "%{OUTPUT_FOLDER}"/content_shell.pak "%{buildroot}%{CHROMIUM_EXE_DIR}"
install -m 0644 "%{OUTPUT_FOLDER}"/resources/*.edj "%{buildroot}%{CHROMIUM_DATA_DIR}"/themes
+install -m 0644 "%{OUTPUT_FOLDER}"/images/*.png "%{buildroot}%{CHROMIUM_DATA_DIR}"/images/
install -d "%{OUTPUT_FOLDER}"/packages
install -d %{buildroot}%{_xmldir}
%{CHROMIUM_EXE_DIR}/content_shell.pak
%{CHROMIUM_EXE_DIR}/locales/*.pak
%{CHROMIUM_DATA_DIR}/themes/*.edj
+%{CHROMIUM_DATA_DIR}/images/*.png
%if %{__build_chrome} == 1
%{CHROMIUM_EXE_DIR}/chrome_100_percent.pak
#if BUILDFLAG(IS_EFL)
out->is_text_node = data.is_text_node();
#endif
+
+#if BUILDFLAG(IS_TIZEN)
+ out->is_draggable = data.is_draggable();
+#endif
+
out->writing_direction_default = data.writing_direction_default();
out->writing_direction_left_to_right = data.writing_direction_left_to_right();
out->writing_direction_right_to_left = data.writing_direction_right_to_left();
#if BUILDFLAG(IS_EFL)
params.is_text_node = data.is_text_node;
#endif
+
+#if BUILDFLAG(IS_TIZEN)
+ params.is_draggable = data.is_draggable;
+#endif
+
params.writing_direction_default = data.writing_direction_default;
params.writing_direction_left_to_right = data.writing_direction_left_to_right;
params.writing_direction_right_to_left = data.writing_direction_right_to_left;
#if BUILDFLAG(IS_EFL)
is_text_node = other.is_text_node;
#endif
+
+#if BUILDFLAG(IS_TIZEN)
+ is_draggable = other.is_draggable;
+#endif
+
writing_direction_default = other.writing_direction_default;
writing_direction_left_to_right = other.writing_direction_left_to_right;
writing_direction_right_to_left = other.writing_direction_right_to_left;
bool is_text_node;
#endif
+#if BUILDFLAG(IS_TIZEN)
+ // Whether element is draggable.
+ bool is_draggable;
+#endif
+
// If this node is an input field, the type of that field.
blink::mojom::ContextMenuDataInputFieldType input_field_type;
}
#endif
+#if BUILDFLAG(IS_TIZEN)
+ static bool is_draggable(const blink::UntrustworthyContextMenuParams& r) {
+ return r.is_draggable;
+ }
+#endif
+
static int writing_direction_default(
const blink::UntrustworthyContextMenuParams& r) {
return r.writing_direction_default;
bool is_text_node;
#endif
+#if BUILDFLAG(IS_TIZEN)
+ // Whether element is draggable.
+ bool is_draggable;
+#endif
+
// Writing direction menu items.
int writing_direction_default;
int writing_direction_left_to_right;
]
enabled_features = []
+
+ if (is_tizen) {
+ enabled_features += [ "is_tizen" ]
+ }
+
if (use_efl) {
enabled_features += [ "is_efl" ]
}
[EnableIf=is_efl]
bool is_text_node;
+ // Whether element is draggable
+ [EnableIf=is_tizen]
+ bool is_draggable;
+
// Writing direction menu items.
int32 writing_direction_default;
int32 writing_direction_left_to_right;
[EnableIf=is_efl]
SetScrollOffset(float x, float y);
+ // Notifies webivew to enter into drag state.
+ [EnableIf=is_tizen]
+ EnterDragState();
+
// Sent to whole page, but should only be used by the main frame.
SetPageBaseBackgroundColor(skia.mojom.SkColor? color);
// RemoteFrame <--> RenderFrameProxyHost in the browser process.
const FrameToken& GetFrameToken() const { return frame_token_; }
+#if BUILDFLAG(IS_TIZEN)
+ // Enters web drag and drop state.
+ virtual void EnterDragState() {}
+#endif
+
#if INSIDE_BLINK
static WebFrame* FromCoreFrame(Frame*);
static Frame* ToCoreFrame(const WebFrame&);
ApplyCommandLineToSettings(SettingsImpl());
}
+#if BUILDFLAG(IS_TIZEN)
+void WebViewImpl::EnterDragState() {
+ if (MainFrameImpl())
+ MainFrameImpl()->EnterDragState();
+}
+#endif
+
void WebViewImpl::AddObserver(WebViewObserver* observer) {
observers_.AddObserver(observer);
}
const RendererPreferences& preferences) override;
void SetHistoryOffsetAndLength(int32_t history_offset,
int32_t history_length) override;
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState() override;
+#endif
void SetPageBaseBackgroundColor(absl::optional<SkColor> color) override;
void CreateRemoteMainFrame(
const RemoteFrameToken& frame_token,
ToPixelSnappedRect(GetFrameView()->GetLayoutView()->DocumentRect())
.size());
}
+
+void WebLocalFrameImpl::EnterDragState() {
+ if (GetFrame())
+ GetFrame()->GetEventHandler().EnterDragState();
+}
#endif
void WebLocalFrameImpl::DeleteSurroundingTextInCodePoints(int before,
gfx::Size ScrollableContentSize() const override;
#endif
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState() override;
+#endif
+
// WebNavigationControl overrides:
bool DispatchBeforeUnloadEvent(bool) override;
void CommitNavigation(
return result;
}
+#if BUILDFLAG(IS_TIZEN)
+void EventHandler::EnterDragState() {
+ gesture_manager_->EnterDragState();
+}
+#endif
+
void EventHandler::ClearDragState() {
scroll_manager_->StopAutoscroll();
drag_target_ = nullptr;
void ContextMenuEventForWordOrLinkSelection(const WebGestureEvent&);
#endif
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState();
+#endif
+
// Clears drag target and related states. It is called when drag is done or
// canceled.
void ClearDragState();
return gesture_context_menu_deferred_;
}
+#if BUILDFLAG(IS_TIZEN)
+void GestureManager::EnterDragState() {
+ mouse_event_manager_->EnterDragState(last_gesture_event_);
+}
+#endif
+
WebInputEventResult GestureManager::HandleGestureTapDown(
const GestureEventWithHitTestResults& targeted_event) {
suppress_mouse_events_from_gestures_ =
const GestureEventWithHitTestResults& targeted_event) {
const WebGestureEvent& gesture_event = targeted_event.Event();
+#if BUILDFLAG(IS_TIZEN)
+ last_gesture_event_ = gesture_event;
+#endif
+
// FIXME: Ideally we should try to remove the extra mouse-specific hit-tests
// here (re-using the supplied HitTestResult), but that will require some
// overhaul of the touch drag-and-drop code and LongPress is such a special
// This must be called from local root frame.
void NotifyPointerEventHandled(const WebPointerEvent& web_pointer_event);
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState();
+#endif
+
private:
WebInputEventResult HandleGestureShowPress();
WebInputEventResult HandleGestureTapDown(
Member<MouseEventManager> mouse_event_manager_;
Member<PointerEventManager> pointer_event_manager_;
+#if BUILDFLAG(IS_TIZEN)
+ WebGestureEvent last_gesture_event_;
+#endif
+
// Set on GestureTapDown if the |pointerdown| event corresponding to the
// triggering |touchstart| event was canceled. This suppresses mouse event
// firing for the current gesture sequence (i.e. until next GestureTapDown).
#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/geometry/quad_f.h"
+#if BUILDFLAG(IS_TIZEN)
+#include "tizen/system_info.h"
+#endif
+
namespace blink {
namespace {
bool MouseEventManager::HandleDragDropIfPossible(
const GestureEventWithHitTestResults& targeted_event) {
+#if BUILDFLAG(IS_TIZEN)
+ if (IsMobileProfile())
+ return false;
+#endif
const WebGestureEvent& gesture_event = targeted_event.Event();
unsigned modifiers = gesture_event.GetModifiers();
return HandleDrag(mev, DragInitiator::kTouch);
}
+#if BUILDFLAG(IS_TIZEN)
+void MouseEventManager::EnterDragState(
+ const WebGestureEvent& last_gesture_event) {
+ if (frame_->GetSettings() &&
+ frame_->GetSettings()->GetTouchDragDropEnabled() && frame_->View()) {
+ mouse_down_ = WebMouseEvent(
+ WebInputEvent::Type::kMouseDown, last_gesture_event,
+ WebPointerProperties::Button::kLeft, 1,
+ WebInputEvent::Modifiers::kLeftButtonDown, base::TimeTicks::Now());
+
+ WebMouseEvent mouse_drag_event(
+ WebInputEvent::Type::kMouseMove, last_gesture_event,
+ WebPointerProperties::Button::kLeft, 1,
+ WebInputEvent::Modifiers::kLeftButtonDown, base::TimeTicks::Now());
+
+ HitTestRequest request(HitTestRequest::kReadOnly);
+ MouseEventWithHitTestResults mev =
+ event_handling_util::PerformMouseEventHitTest(frame_, request,
+ mouse_drag_event);
+ mouse_down_may_start_drag_ = true;
+ ResetDragSource();
+ mouse_down_pos_ = frame_->View()->ConvertFromRootFrame(
+ gfx::ToFlooredPoint(mouse_drag_event.PositionInRootFrame()));
+ HandleDrag(mev, DragInitiator::kTouch);
+ }
+}
+#endif
+
void MouseEventManager::FocusDocumentView() {
Page* page = frame_->GetPage();
if (!page)
DragState& GetDragState();
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState(const WebGestureEvent&);
+#endif
+
void FocusDocumentView();
// Resets the state that indicates the next events could cause a drag. It is
auto* html_element = DynamicTo<HTMLElement>(result.InnerNode());
if (html_element) {
+#if BUILDFLAG(IS_TIZEN)
+ data.is_draggable = html_element->draggable();
+#endif
data.title_text = html_element->title().Utf8();
data.alt_text = html_element->AltText().Utf8();
}
edje_dir = "/usr/share/chromium-efl/themes/"
tizen_data_dir = "/usr/share/chromium-efl/"
locale_dir = "/usr/share/chromium-efl/locale/"
+ image_dir = "/usr/share/chromium-efl/images/"
chromium_impl_lib_name = "libchromium-ewk.so"
tizen_version = 0
const blink::mojom::DragEventSourceInfo& event_info,
RenderWidgetHostImpl* source_rwh) {
if (drag_dest_) {
- drag_dest_->SetDropData(drop_data);
- drag_dest_->SetAction(allowed_ops);
+ if (drag_dest_.get()) {
+ drag_dest_->SetDropData(drop_data);
+ drag_dest_->SetAction(allowed_ops);
+ }
}
if (!drag_source_) {
}
if (!drag_source_->StartDragging(drop_data, allowed_ops, event_info.location,
- *image.bitmap(), image_offset)) {
+ *image.bitmap(), image_offset, source_rwh)) {
web_contents_->SystemDragEnded(source_rwh);
}
}
DropData* WebContentsViewAuraHelperEfl::GetDropData() const {
if (drag_dest_)
- return drag_dest_->GetDropData();
+ if (drag_dest_.get())
+ return drag_dest_->GetDropData();
return nullptr;
}
}
}
+void WebContentsViewAuraHelperEfl::SetViewDelegate(
+ WebContentsViewDelegate* delegate) {
+ delegate = view_delegate_;
+}
+
} // namespace content
#include "mojo/public/cpp/bindings/remote.h"
#include "third_party/blink/public/common/page/drag_operation.h"
#include "third_party/blink/public/mojom/choosers/popup_menu.mojom.h"
+#include "third_party/blink/public/mojom/drag/drag.mojom.h"
+#include "tizen_src/chromium_impl/content/public/browser/web_contents_efl_delegate.h"
#include "ui/gfx/image/image_skia.h"
namespace content {
void SetEflDelegate(WebContentsEflDelegate*);
WebContentsEflDelegate* GetEflDelegate();
+ void SetViewDelegate(WebContentsViewDelegate* delegate);
void UpdateDragDest(RenderViewHost* host);
void StartDragging(const DropData& drop_data,
blink::DragOperationsMask allowed_ops,
#include "build/tizen_version.h"
#include "content/browser/web_contents/web_contents_impl.h"
-#include "content/public/browser/web_drag_dest_delegate.h"
#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/web_drag_dest_delegate.h"
#include "ui/display/screen.h"
namespace content {
delegate_(nullptr),
web_contents_(web_contents),
page_scale_factor_(1.0f),
+ drag_action_(blink::kDragOperationNone),
drag_initialized_(false) {
-#if defined(USE_AURA)
- parent_view_ = nullptr;
-#else
- parent_view_ = static_cast<Evas_Object*>(web_contents->GetNativeView());
-#endif
device_scale_factor_ = display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
+ parent_view_ =
+ static_cast<WebContentsImpl*>(web_contents)->GetEflNativeView();
SetDragCallbacks();
}
}
void WebDragDestEfl::DragStateLeave() {
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- // FIXME: EWK_BRINGUP definition should be removed.
- GetRenderViewHost()->DragTargetDragLeave();
-#endif // !defined(EWK_BRINGUP)
if (delegate_)
delegate_->OnDragLeave();
}
void WebDragDestEfl::DragPos(
Evas_Coord x, Evas_Coord y, Elm_Xdnd_Action action) {
- gfx::Point screen_pt = gfx::Point(x / device_scale_factor_,
- y / device_scale_factor_);
+ if (!drop_data_)
+ return;
+
+ auto screen_pt =
+ gfx::PointF(x / device_scale_factor_, y / device_scale_factor_);
last_pointer_pos_ = screen_pt;
- gfx::Point client_pt = gfx::Point(screen_pt.x() / page_scale_factor_,
- screen_pt.y() / page_scale_factor_);
+ auto client_pt = gfx::PointF(screen_pt.x() / page_scale_factor_,
+ screen_pt.y() / page_scale_factor_);
if (!drag_initialized_) {
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- // FIXME: EWK_BRINGUP definition should be removed.
- GetRenderViewHost()->DragTargetDragEnter(
- *drop_data_,
- client_pt,
- screen_pt,
- drag_action_,
- modifier_flags_);
-#endif // !defined(EWK_BRINGUP)
+ GetRenderWidgetHost()->DragTargetDragEnter(
+ *drop_data_, client_pt, screen_pt, drag_action_, modifier_flags_,
+ base::DoNothing());
if (delegate_)
delegate_->OnDragEnter();
drag_initialized_ = true;
}
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- // FIXME: EWK_BRINGUP definition should be removed.
- GetRenderViewHost()->DragTargetDragOver(
- client_pt,
- screen_pt,
- drag_action_,
- modifier_flags_);
-#endif // !defined(EWK_BRINGUP)
+ GetRenderWidgetHost()->DragTargetDragOver(client_pt, screen_pt, drag_action_,
+ modifier_flags_, base::DoNothing());
if (!delegate_)
return;
}
Eina_Bool WebDragDestEfl::DragDrop(Elm_Selection_Data* data) {
- gfx::Point client_pt =
- gfx::Point(last_pointer_pos_.x() / page_scale_factor_,
- last_pointer_pos_.y() / page_scale_factor_);
-
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- // FIXME: EWK_BRINGUP definition should be removed.
- GetRenderViewHost()->FilterDropData(drop_data_.get());
- GetRenderViewHost()->DragTargetDrop(
- *drop_data_,
- client_pt,
- last_pointer_pos_,
- modifier_flags_);
-#endif // !defined(EWK_BRINGUP)
+ if (!drag_initialized_)
+ return EINA_FALSE;
+
+ auto client_pt = gfx::PointF(last_pointer_pos_.x() / page_scale_factor_,
+ last_pointer_pos_.y() / page_scale_factor_);
+
+ GetRenderWidgetHost()->FilterDropData(drop_data_.get());
+ GetRenderWidgetHost()->DragTargetDrop(*drop_data_, client_pt,
+ last_pointer_pos_, modifier_flags_,
+ base::DoNothing());
if (delegate_)
delegate_->OnDrop();
drag_initialized_ = false;
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- // FIXME: EWK_BRINGUP definition should be removed.
- // Invoking via message loop to not mess around with target
- // from within one of its callbacks.
- base::MessageLoop::current()->PostTask(
+
+ base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&WebDragDestEfl::ResetDragCallbacks,
base::Unretained(this)));
-#endif // !defined(EWK_BRINGUP)
return EINA_TRUE;
}
void WebDragDestEfl::DragLeave() {
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- // FIXME: EWK_BRINGUP definition should be removed.
- GetRenderViewHost()->DragTargetDragLeave();
-#endif // !defined(EWK_BRINGUP)
+ GetRenderWidgetHost()->DragTargetDragLeave(gfx::PointF(), gfx::PointF());
if (delegate_)
delegate_->OnDragLeave();
page_scale_factor_ = scale;
}
-RenderViewHost* WebDragDestEfl::GetRenderViewHost() const {
- return web_contents_->GetRenderViewHost();
+RenderWidgetHost* WebDragDestEfl::GetRenderWidgetHost() const {
+ return web_contents_->GetRenderViewHost()->GetWidget();
}
} // namespace content
#include "content/public/common/drop_data.h"
#include "third_party/blink/public/common/page/drag_operation.h"
-#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_f.h"
namespace content {
class WebContents;
class WebDragDestDelegate;
-class RenderViewHost;
+class RenderWidgetHost;
class WebDragDestEfl {
public:
blink::DragOperationsMask GetAction() { return drag_action_; }
WebDragDestDelegate* GetDelegate() const { return delegate_; }
DropData* GetDropData() { return drop_data_.get(); }
- RenderViewHost* GetRenderViewHost() const;
+ RenderWidgetHost* GetRenderWidgetHost() const;
WebContents* GetWebContents() { return web_contents_; }
void ResetDropData() { drop_data_.reset(); }
float device_scale_factor_;
float page_scale_factor_;
- gfx::Point last_pointer_pos_;
+ gfx::PointF last_pointer_pos_;
bool drag_initialized_;
#include "content/browser/web_contents/web_drag_source_efl.h"
+#include "base/files/file_path.h"
+#include "base/path_service.h"
+#include "base/strings/utf_string_conversions.h"
#include "content/browser/download/drag_download_util.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/paths_efl.h"
#include "content/public/common/drop_data.h"
#include "third_party/skia/include/core/SkPixelRef.h"
#include "ui/base/dragdrop/drag_drop_types.h"
namespace {
+const char* const kDefaultDragIcon = "broken_image.png";
+const int kDefaultDragIconWidth = 105;
+const int kDefaultDragIconHeight = 120;
+
DragOperation GetDragOperationFromMask(blink::DragOperationsMask operations) {
if (operations & ui::DragDropTypes::DRAG_COPY)
return DragOperation::kCopy;
WebDragSourceEfl::WebDragSourceEfl(WebContents* web_contents)
: web_contents_(static_cast<WebContentsImpl*>(web_contents)),
+ source_rwh_(nullptr),
drag_failed_(false),
drag_started_(false),
+ drag_action_(blink::kDragOperationNone),
page_scale_factor_(1.0f) {
-#if !defined(USE_AURA)
- parent_view_ = static_cast<Evas_Object*>(web_contents->GetNativeView());
-#endif
+ parent_view_ =
+ static_cast<WebContentsImpl*>(web_contents)->GetEflNativeView();
device_scale_factor_ =
display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
}
blink::DragOperationsMask allowed_ops,
const gfx::Point& root_location,
const SkBitmap& image,
- const gfx::Vector2d& image_offset) {
+ const gfx::Vector2d& image_offset,
+ RenderWidgetHostImpl* source_rwh) {
// Guard against re-starting before previous drag completed.
if (drag_started_) {
NOTREACHED();
return false;
}
+ std::u16string elm_drag_data;
int targets_mask = 0;
- drop_data_.reset(new DropData(drop_data));
initial_position_ = root_location;
- if (drop_data.text && !drop_data.text->empty())
+ if (drop_data.text && !drop_data.text->empty()) {
+ elm_drag_data = *drop_data.text;
targets_mask |= ELM_SEL_FORMAT_TEXT;
- if (drop_data.url.is_valid())
+ }
+ if (drop_data.url.is_valid()) {
+ elm_drag_data = base::UTF8ToUTF16(drop_data.url.spec());
targets_mask |= ELM_SEL_FORMAT_TEXT;
- if (drop_data.html && !drop_data.html->empty())
+ }
+ if (drop_data.html && !drop_data.html->empty()) {
+ elm_drag_data = *drop_data.html;
targets_mask |= ELM_SEL_FORMAT_HTML;
+ }
if (!drop_data.file_contents.empty()) {
+ GURL parsed_url;
#if defined(ENABLE_WRT_JS) && !defined(WRT_JS_BRINGUP)
- GURL parsed_url = wrt::ParseURL(drop_data.file_contents_source_url);
+ parsed_url = wrt::ParseURL(drop_data.file_contents_source_url);
if ((parsed_url.is_valid() && !parsed_url.IsAboutBlank()))
drop_data_.file_contents_source_url = parsed_url;
#endif
+ elm_drag_data =
+ (parsed_url.is_valid() && !parsed_url.IsAboutBlank())
+ ? base::UTF8ToUTF16(parsed_url.spec())
+ : base::UTF8ToUTF16(drop_data.file_contents_source_url.spec());
targets_mask |= ELM_SEL_FORMAT_IMAGE;
}
if (!drop_data.download_metadata.empty() &&
ParseDownloadMetadata(drop_data.download_metadata,
&wide_download_mime_type_, &download_file_name_,
- &download_url_))
+ &download_url_)) {
+ elm_drag_data = drop_data.download_metadata;
targets_mask |= ELM_SEL_FORMAT_IMAGE;
- if (!drop_data.custom_data.empty())
+ }
+ if (!drop_data.custom_data.empty()) {
+ elm_drag_data = drop_data.custom_data.begin()->first;
targets_mask |= ELM_SEL_FORMAT_NONE;
+ }
int action = 0;
image_offset_ = image_offset;
drag_action_ = allowed_ops;
drag_failed_ = false;
+ source_rwh_ = source_rwh;
drag_started_ = elm_drag_start(
parent_view_, static_cast<Elm_Sel_Format>(targets_mask),
- reinterpret_cast<char*>(drop_data_.get()),
+ base::UTF16ToUTF8(elm_drag_data).c_str(),
static_cast<Elm_Xdnd_Action>(action), DragIconCreateCb, this, DragPosCb,
this, DragAcceptCb, this, DragStateCb, this);
if (!drag_started_) {
LOG(WARNING) << "Failed to start drag and drop";
drag_failed_ = true;
- drop_data_.reset();
return false;
}
*yoff = initial_position_.y();
Evas* evas = evas_object_evas_get(win);
Evas_Object* icon = evas_object_image_add(evas);
- evas_object_image_size_set(icon, w, h);
+ if (w > 0 && h > 0) {
+ evas_object_image_size_set(icon, w, h);
+ evas_object_image_data_copy_set(icon, image_.pixelRef()->pixels());
+ } else {
+ w = kDefaultDragIconWidth;
+ h = kDefaultDragIconHeight;
+ base::FilePath path;
+ base::PathService::Get(PathsEfl::IMAGE_RESOURCE_DIR, &path);
+ path = path.Append(FILE_PATH_LITERAL(kDefaultDragIcon));
+ evas_object_image_file_set(icon, path.AsUTF8Unsafe().c_str(), nullptr);
+ }
+ evas_object_image_fill_set(icon, 0, 0, w, h);
evas_object_image_alpha_set(icon, EINA_TRUE);
- evas_object_image_data_copy_set(icon, image_.pixelRef()->pixels());
evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_move(icon, initial_position_.x(), initial_position_.y());
- evas_object_image_fill_set(icon, 0, 0, w, h);
evas_object_resize(icon, w, h);
evas_object_show(icon);
blink::DragOperationsMask allowed_ops,
const gfx::Point& root_location,
const SkBitmap& image,
- const gfx::Vector2d& image_offset);
+ const gfx::Vector2d& image_offset,
+ RenderWidgetHostImpl* source_rwh);
void Reset() { drag_started_ = false; }
void SetLastPoint(gfx::Point point) { last_point_ = point; }
// Browser side IPC handler.
RenderWidgetHostImpl* source_rwh_;
- // The drop data for the current drag (for drags that originate in the render
- // view). Non-NULL iff there is a current drag.
- std::unique_ptr<DropData> drop_data_;
-
// The image used for depicting the drag, and the offset between the cursor
// and the top left pixel.
SkBitmap image_;
outdir = rebase_path("$root_out_dir")
defines += [
"EDJE_DIR=\"$outdir/resources\"",
+ "IMAGE_DIR=\"$image_dir\"",
"LOCALE_DIR=\"$outdir/locale\"",
]
}
const base::FilePath::CharType kChromiumLibPath[] =
FILE_PATH_LITERAL("lib/" CHROMIUM_IMPL_LIB_FILE);
const base::FilePath::CharType kNotificationIconDir[] = FILE_PATH_LITERAL("noti");
+const base::FilePath::CharType kImageDir[] = FILE_PATH_LITERAL("images");
+#else
+const base::FilePath::CharType kImagePath[] = FILE_PATH_LITERAL(IMAGE_DIR);
#endif
#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
cur = cur.Append(kNotificationIconDir);
break;
#endif
+ case IMAGE_RESOURCE_DIR:
+#if BUILDFLAG(IS_TIZEN)
+ if (!base::PathService::Get(DIR_USER_DATA, &cur))
+ return false;
+ cur = cur.Append(kImageDir);
+ break;
+#else
+ *result = base::FilePath(kImagePath);
+ return true;
+#endif
default:
return false;
}
]
}
deps += [ "resource:edje_resources_ewk" ]
+ deps += [ ":broken_image" ]
}
executable("efl_webprocess") {
sources = [ "launch_exec.sh" ]
outputs = [ "$root_out_dir/{{source_file_part}}" ]
}
+
+copy("broken_image") {
+ sources = [ "./resource/images/broken_image.png" ]
+ outputs = [ "$root_out_dir/images/{{source_file_part}}" ]
+}
\ No newline at end of file
#endif
}
+ if (IsMobileProfile())
+ p_command_line->AppendSwitch(switches::kEnableTouchDragDrop);
+
#if !defined(EWK_BRINGUP)
if (p_command_line->HasSwitch(switches::kDisableIpcSandbox))
p_command_line->AppendSwitch(switches::kDisableRendererZygote);
#include "common/web_contents_utils.h"
#include "content/browser/renderer_host/render_widget_host_view_aura.h"
#include "content/browser/selection/selection_controller_efl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
#include "content/common/paths_efl.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/download_manager.h"
ContextMenuControllerEfl::ContextMenuControllerEfl(EWebView* wv,
WebContents& web_contents)
: webview_(wv),
-#if !defined(USE_AURA)
- native_view_(static_cast<Evas_Object*>(web_contents.GetNativeView())),
-#endif
popup_(nullptr),
menu_items_(nullptr),
web_contents_(web_contents),
is_text_selection_(false),
weak_ptr_factory_(this) {
+ native_view_ =
+ static_cast<WebContentsImpl*>(&web_contents_)->GetEflNativeView();
}
ContextMenuControllerEfl::~ContextMenuControllerEfl() {
}
#endif
}
-#if !defined(EWK_BRINGUP)
- if (params_.is_draggable) {
- AddItemToProposedList(EWK_CONTEXT_MENU_ITEM_TYPE_ACTION, EWK_CONTEXT_MENU_ITEM_TAG_DRAG,
- std::string(dgettext("WebKit", "IDS_WEBVIEW_OPT_DRAG_AND_DROP")));
+#if BUILDFLAG(IS_TIZEN)
+ if (IsMobileProfile() && params_.is_draggable &&
+ params_.media_type == ContextMenuDataMediaType::kImage) {
+ AddItemToProposedList(
+ EWK_CONTEXT_MENU_ITEM_TYPE_ACTION, EWK_CONTEXT_MENU_ITEM_TAG_DRAG,
+ std::string(dgettext("WebKit", "IDS_WEBVIEW_OPT_DRAG_AND_DROP_ABB")));
}
#endif
break;
}
case EWK_CONTEXT_MENU_ITEM_TAG_DRAG: {
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- RenderViewHost* rvh = web_contents_.GetRenderViewHost();
- rvh->StartDragging();
- context_menu_show_pos_.SetPoint(params_.x, params_.y);
-#else
- NOTIMPLEMENTED();
+#if BUILDFLAG(IS_TIZEN)
+ if (IsMobileProfile()) {
+ webview_->EnterDragState();
+ context_menu_show_pos_.SetPoint(params_.x, params_.y);
+ } else {
+ NOTIMPLEMENTED();
+ }
#endif
break;
}
}
}
+#if BUILDFLAG(IS_TIZEN)
+void EWebView::EnterDragState() {
+ if (IsMobileProfile()) {
+ if (RenderViewHost* render_view_host = web_contents_->GetRenderViewHost())
+ web_contents_->EnterDragState(render_view_host);
+ }
+}
+#endif
+
void EWebView::SetOrientation(int orientation) {
if (GetOrientation() == orientation)
return;
double GetPageZoomFactor() const;
void SetPageZoomFactor(double page_zoom_factor);
void ExecuteEditCommand(const char* command, const char* value);
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState();
+#endif
void SetOrientation(int orientation);
int GetOrientation();
bool TouchEventsEnabled() const;