void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) {
last_pointer_type_ = event->details().primary_pointer_type();
+#if BUILDFLAG(IS_EFL)
+ // Gesture event will be processed and forwarded via offscreen helper.
+ if (offscreen_helper_) {
+ offscreen_helper_->OnGestureEvent(event);
+ return;
+ }
+#endif
event_handler_->OnGestureEvent(event);
}
#include "tizen_src/chromium_impl/tizen/system_info.h"
#include "ui/base/ui_base_switches_util.h"
+#if BUILDFLAG(IS_EFL)
+#include "tizen/system_info.h"
+#endif
+
namespace {
bool IsTouchDragDropEnabled() {
shrinks_viewport_contents_to_fit = true;
link_effect_enabled = true;
}
+
+ if (IsMobileProfile() || IsDesktopProfile()) {
+ text_zoom_enabled = true;
+ selection_magnifier_enabled = true;
+ long_press_enabled = true;
+ }
#endif
}
bool link_effect_enabled = false;
bool atk_enabled;
bool force_enable_zoom = false;
+ bool text_zoom_enabled = false;
+ bool selection_magnifier_enabled = false;
+ bool long_press_enabled = false;
#endif
bool double_tap_to_zoom_enabled;
#include <Elementary.h>
#include "base/base_switches.h"
+#include "content/browser/renderer_host/edge_effect.h"
#include "content/browser/renderer_host/render_widget_host_view_aura.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/browser/web_contents/web_contents_view_aura.h"
namespace content {
+namespace {
+
+blink::WebGestureEvent MakeWebGestureEventFromUIEvent(
+ const ui::GestureEvent& event) {
+ return ui::CreateWebGestureEvent(
+ event.details(), event.time_stamp(), event.location_f(),
+ event.root_location_f(), event.flags(), event.unique_touch_event_id());
+}
+
+ui::LatencyInfo CreateLatencyInfo(const blink::WebInputEvent& event) {
+ if (!event.TimeStamp().since_origin().InMicroseconds())
+ return ui::LatencyInfo();
+
+ // The latency number should only be added if the timestamp is valid.
+ ui::LatencyInfo latency_info;
+ const int64_t time_micros = event.TimeStamp().since_origin().InMicroseconds();
+ latency_info.AddLatencyNumberWithTimestamp(
+ ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
+ base::TimeTicks() + base::Microseconds(time_micros));
+ return latency_info;
+}
+
+} // namespace
+
// If the first frame is not prepared after load is finished,
// delay getting the snapshot by 100ms.
static const int kSnapshotProcessDelay = 100;
selection_start, selection_end);
}
- bool ExistsSelectedText() override { return false; }
+ bool ExistsSelectedText() override {
+ auto* controller = rwhv_helper_->GetSelectionController();
+ if (!controller)
+ return false;
+
+ return controller->ExistsSelectedText();
+ }
bool ImeHandleKeyEventEnabled() override { return true; }
return false;
}
+EdgeEffect& RWHVAuraOffscreenHelperEfl::EnsureEdgeEffect() {
+ if (!edge_effect_)
+ edge_effect_ = base::WrapUnique(new EdgeEffect(content_image_));
+ return *edge_effect_.get();
+}
+
+void RWHVAuraOffscreenHelperEfl::HandleGestureBegin() {
+ EnsureEdgeEffect().Enable();
+}
+
+void RWHVAuraOffscreenHelperEfl::HandleGestureEnd() {
+ // Edge effect should be disabled upon scroll end/fling start.
+ // Gesture end comes just after those events, so it's disabled here.
+ EnsureEdgeEffect().Disable();
+}
+
+void RWHVAuraOffscreenHelperEfl::OnGestureEvent(ui::GestureEvent* event) {
+ if (event->type() == ui::ET_GESTURE_BEGIN)
+ HandleGestureBegin();
+ else if (event->type() == ui::ET_GESTURE_END)
+ HandleGestureEnd();
+
+ blink::WebGestureEvent gesture_event = MakeWebGestureEventFromUIEvent(*event);
+ gesture_event.SetPositionInWidget(event->location_f());
+ gesture_event.SetPositionInScreen(event->root_location_f());
+ SendGestureEvent(gesture_event);
+
+ event->SetHandled();
+}
+
+void RWHVAuraOffscreenHelperEfl::SendGestureEvent(
+ blink::WebGestureEvent& event) {
+ HandleGesture(event);
+ blink::WebInputEvent::Type event_type = event.GetType();
+ if (event_type == blink::WebInputEvent::Type::kGestureScrollUpdate)
+ return;
+
+ if (event_type != blink::WebInputEvent::Type::kUndefined) {
+ rwhv_aura_->host()->ForwardGestureEventWithLatencyInfo(
+ event, CreateLatencyInfo(event));
+ }
+}
+
+void RWHVAuraOffscreenHelperEfl::HandleGesture(blink::WebGestureEvent& event) {
+ SelectionControllerEfl* controller = GetSelectionController();
+ if (controller)
+ controller->HandleGesture(event);
+
+ blink::WebInputEvent::Type event_type = event.GetType();
+ RenderWidgetHostOwnerDelegate* owner_delegate =
+ rwhv_aura_->host()->owner_delegate();
+ if (!owner_delegate)
+ return;
+
+ if (!owner_delegate->GetWebkitPreferencesForWidget().text_zoom_enabled &&
+ (event_type == blink::WebInputEvent::Type::kGesturePinchBegin ||
+ event_type == blink::WebInputEvent::Type::kGesturePinchEnd)) {
+ return;
+ }
+
+ if (!owner_delegate->GetWebkitPreferencesForWidget()
+ .double_tap_to_zoom_enabled &&
+ event_type == blink::WebInputEvent::Type::kGestureDoubleTap) {
+ return;
+ }
+
+ if (event_type == blink::WebInputEvent::Type::kGestureTap ||
+ event_type == blink::WebInputEvent::Type::kGestureTapCancel) {
+ float size = 32.0f; // Default value
+
+#if BUILDFLAG(IS_TIZEN)
+ if (IsMobileProfile())
+ size = elm_config_finger_size_get() / device_scale_factor_;
+#endif
+
+ event.data.tap.width = size;
+ event.data.tap.height = size;
+ }
+
+ if (event_type == blink::WebInputEvent::Type::kGestureTapDown) {
+ // Webkit does not stop a fling-scroll on tap-down. So explicitly send an
+ // event to stop any in-progress flings.
+ blink::WebGestureEvent fling_cancel = event;
+ fling_cancel.SetType(blink::WebInputEvent::Type::kGestureFlingCancel);
+ fling_cancel.SetSourceDevice(blink::WebGestureDevice::kTouchscreen);
+ SendGestureEvent(fling_cancel);
+ } else if (event_type == blink::WebInputEvent::Type::kGestureScrollUpdate) {
+ if (event.data.scroll_update.delta_x < 0)
+ EnsureEdgeEffect().Hide("edge,left");
+ else if (event.data.scroll_update.delta_x > 0)
+ EnsureEdgeEffect().Hide("edge,right");
+ if (event.data.scroll_update.delta_y < 0)
+ EnsureEdgeEffect().Hide("edge,top");
+ else if (event.data.scroll_update.delta_y > 0)
+ EnsureEdgeEffect().Hide("edge,bottom");
+ } else if (event_type == blink::WebInputEvent::Type::kGesturePinchBegin) {
+ EnsureEdgeEffect().Disable();
+ } else if (event_type == blink::WebInputEvent::Type::kGesturePinchEnd) {
+ EnsureEdgeEffect().Enable();
+ }
+}
+
} // namespace content
class ScreenshotCapturedCallback;
class WebContents;
class WebContentsDelegate;
+class EdgeEffect;
class CONTENT_EXPORT RWHVAuraOffscreenHelperEfl {
public:
void DidGetContentSnapshot(const SkBitmap& bitmap, int request_id);
RenderWidgetHostViewAura* rwhva() { return rwhv_aura_; }
+ void OnGestureEvent(ui::GestureEvent* event);
+ EdgeEffect& EnsureEdgeEffect();
+ void HandleGestureBegin();
+ void HandleGestureEnd();
+ void SendGestureEvent(blink::WebGestureEvent& event);
+ void HandleGesture(blink::WebGestureEvent& event);
void OnMouseOrTouchEvent(ui::Event* event);
void DidHandleKeyEvent(blink::WebInputEvent::Type input_event_type,
bool processed);
OnFocusCallback on_focus_out_callback_;
bool is_content_editable_ = false;
+ std::unique_ptr<EdgeEffect> edge_effect_;
};
} // namespace content
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/browser/web_contents/web_contents_impl_efl.h"
#include "content/public/browser/context_menu_params.h"
-#include "content/public/browser/render_view_host.h"
#include "content/public/browser/web_contents.h"
#include "ui/base/clipboard/clipboard_helper_efl.h"
+#include "ui/display/device_display_info_efl.h"
#include "ui/display/screen.h"
#include "ui/gfx/geometry/dip_util.h"
#if BUILDFLAG(IS_TIZEN)
void SelectionControllerEfl::PlatformLanguageChanged(keynode_t* keynode, void* data) {
SelectionControllerEfl* selection_controller = static_cast<SelectionControllerEfl*>(data);
- if (!selection_controller)
+ if (!selection_controller || !selection_controller->rwhva_)
return;
if (selection_controller->GetSelectionStatus())
truncated_end = gfx::ToEnclosingRect(
gfx::ConvertRectToPixels(truncated_end, device_scale_factor));
- if (handle_being_dragged_ &&
+ if (handle_being_dragged_ && dragging_handle_ &&
dragging_handle_->Type() != SelectionHandleEfl::HANDLE_TYPE_INPUT) {
dragging_handle_->MoveObject(selection_data_->GetIsAnchorFirst()
? truncated_end.bottom_right()
input_handle_->Move(left.bottom_right());
input_handle_->Show();
}
- start_handle_->Hide();
- end_handle_->Hide();
bool show_context_menu =
IsAnyHandleVisible() &&
void* /*loop_data*/,
int type,
void* event_info) {
- if (type == ECORE_EVENT_MOUSE_MOVE) {
- auto controller = static_cast<SelectionControllerEfl*>(user_data);
- if (!controller || !controller->dragged_handle_)
- return ECORE_CALLBACK_PASS_ON;
-
- auto event = static_cast<Ecore_Event_Mouse_Move*>(event_info);
- controller->dragged_handle_->UpdatePosition(gfx::Point(event->x, event->y));
- return ECORE_CALLBACK_CANCEL;
+ if (type != ECORE_EVENT_MOUSE_MOVE)
+ return ECORE_CALLBACK_PASS_ON;
+
+ auto controller = static_cast<SelectionControllerEfl*>(user_data);
+ if (!controller || !controller->dragged_handle_)
+ return ECORE_CALLBACK_PASS_ON;
+
+ // Point from Ecore_Event_Mouse_Move event is not rotation aware, so
+ // we have to rotate it manually. We use display dimensions here,
+ // because both point from the event, and selection handle's position
+ // are in display coordinates (not webview).
+ auto event = static_cast<Ecore_Event_Mouse_Move*>(event_info);
+ display::DeviceDisplayInfoEfl display_info;
+ int rotation = display_info.GetRotationDegrees();
+ int display_width = display_info.GetDisplayWidth();
+ int display_height = display_info.GetDisplayHeight();
+ gfx::Point converted_point;
+ switch (rotation) {
+ case 0:
+ converted_point = gfx::Point(event->x, event->y);
+ break;
+ case 90:
+ converted_point = gfx::Point(display_height - event->y, event->x);
+ break;
+ case 180:
+ converted_point =
+ gfx::Point(display_width - event->x, display_height - event->y);
+ break;
+ case 270:
+ converted_point = gfx::Point(event->y, display_width - event->x);
+ break;
+ default:
+ LOG(ERROR) << "Unexpected rotation value: " << rotation;
+ converted_point = gfx::Point(event->x, event->y);
}
+ controller->dragged_handle_->UpdatePosition(converted_point);
- return ECORE_CALLBACK_PASS_ON;
+ LOG(INFO) << __PRETTY_FUNCTION__
+ << " : ECORE_EVENT_MOUSE_MOVE has been captured.";
+ return ECORE_CALLBACK_CANCEL;
}
void SelectionControllerEfl::HandleDragBeginNotification(
void SelectionControllerEfl::HandleGesture(blink::WebGestureEvent& event) {
blink::WebInputEvent::Type event_type = event.GetType();
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
- if (event_type == blink::WebInputEvent::kGestureTap) {
- HandlePostponedGesture(event.x, event.y, ui::ET_GESTURE_TAP);
- } else if (event_type == blink::WebInputEvent::kGestureShowPress) {
- HandlePostponedGesture(
- event.x, event.y, ui::ET_GESTURE_SHOW_PRESS);
- } else if (event_type == blink::WebInputEvent::kGestureLongPress) {
- HandlePostponedGesture(
- event.x, event.y, ui::ET_GESTURE_LONG_PRESS);
+ if (event_type == blink::WebInputEvent::Type::kGestureTap) {
+ HandlePostponedGesture(event.PositionInWidget().x(),
+ event.PositionInWidget().y(), ui::ET_GESTURE_TAP);
+ } else if (event_type == blink::WebInputEvent::Type::kGestureShowPress) {
+ HandlePostponedGesture(event.PositionInWidget().x(),
+ event.PositionInWidget().y(),
+ ui::ET_GESTURE_SHOW_PRESS);
+ } else if (event_type == blink::WebInputEvent::Type::kGestureLongPress) {
+ selection_change_reason_ = Reason::LongPressStarted;
+ HandlePostponedGesture(event.PositionInWidget().x(),
+ event.PositionInWidget().y(),
+ ui::ET_GESTURE_LONG_PRESS);
long_mouse_press_ = true;
}
-#endif
+
+ RenderWidgetHostOwnerDelegate* owner_delegate =
+ rwhva_->host()->owner_delegate();
+ if (!owner_delegate)
+ return;
+
+ if (!owner_delegate->GetWebkitPreferencesForWidget().text_zoom_enabled &&
+ (event_type == blink::WebInputEvent::Type::kGesturePinchBegin ||
+ event_type == blink::WebInputEvent::Type::kGesturePinchEnd)) {
+ return;
+ }
+
if (event_type == blink::WebInputEvent::Type::kGestureScrollBegin ||
event_type == blink::WebInputEvent::Type::kGesturePinchBegin) {
SetControlsTemporarilyHidden(true);
if (params.is_editable) {
// If one long press on an empty form, do not enter selection mode.
// Instead, context menu will be shown if needed for clipboard actions.
-#if !defined(USE_AURA)
- RenderWidgetHostViewEfl* rwhv =
- static_cast<RenderWidgetHostViewEfl*>(web_contents_.GetRenderWidgetHostView());
if (params.selection_text.empty() &&
- !(rwhv && !rwhv->IsLastAvailableTextEmpty()) &&
+ !(rwhva_ && !rwhva_->offscreen_helper()->HasSelectableText()) &&
!ClipboardHelperEfl::GetInstance()->CanPasteFromSystemClipboard()) {
long_mouse_press_ = false;
+ selection_change_reason_ = Reason::Irrelevant;
return false;
}
-#endif
SetSelectionStatus(true);
SetSelectionEditable(true);
if (selection_mode_ == None)
return false;
}
+bool SelectionControllerEfl::ExistsSelectedText() {
+ // Is in edit field and text is selected.
+ return selection_data_->IsInEditField() &&
+ (selection_data_->GetLeftRect() != selection_data_->GetRightRect());
+}
}
bool TextSelectionDown(int x, int y);
bool TextSelectionUp(int x, int y);
- bool GetIsSelectionVisible() const { return is_selection_visible_; }
- void SetIsSelectionVisible(const bool isVisible) { is_selection_visible_ = isVisible; }
-
// 'Reason' enum class enumerates all reasons that can cause
// text selection changes that require changes on the status
// of selection controls (handles and context menu).
ScrollOrZoomGestureEnded = 0,
HandleDragged,
HandleReleased,
+ LongPressStarted,
LongPressMoved,
LongPressEnded,
Tap,
RenderWidgetHostViewAura* rwhva() const { return rwhva_; }
content::WebContents* web_contents() const;
+ bool ExistsSelectedText();
+
private:
enum SelectionMode {
None = 0,
std::unique_ptr<SelectionMagnifierEfl> magnifier_;
// Helper pointer to the handle being dragged.
- SelectionHandleEfl* dragging_handle_;
+ SelectionHandleEfl* dragging_handle_ = nullptr;
// Helper pointer to the stationary handle (during dragging).
- SelectionHandleEfl* stationary_handle_;
+ SelectionHandleEfl* stationary_handle_ = nullptr;
gfx::Rect custom_visible_view_rect_;
- bool is_selection_visible_ = false;
-
bool handle_being_dragged_ = false;
bool is_caret_mode_forced_ = false;
#include "base/files/file_path.h"
#include "base/path_service.h"
+#include "content/browser/renderer_host/render_widget_host_owner_delegate.h"
#include "content/browser/renderer_host/render_widget_host_view_aura.h"
#include "content/browser/selection/selection_controller_efl.h"
#include "content/common/paths_efl.h"
#include "content/public/browser/browser_thread.h"
+#include "third_party/blink/public/common/web_preferences/web_preferences.h"
namespace content {
}
void SelectionMagnifierEfl::Show() {
+ RenderWidgetHostOwnerDelegate* owner_delegate =
+ controller_->rwhva()->host()->owner_delegate();
+ if (!owner_delegate || !owner_delegate->GetWebkitPreferencesForWidget()
+ .selection_magnifier_enabled) {
+ return;
+ }
+
shown_ = true;
evas_object_show(container_);
#if !defined(USE_AURA)
#include <Eina.h>
#include <Evas.h>
+#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/geometry/point.h"
// Do not request ImeSetComposition to prevent delivering empty string
// if text is selected status.
bool text_selected = composition_text.text.length() == 0;
-#if !defined(EWK_BRINGUP)
if (rwh_helper_) {
text_selected =
- text_selected && rwh_helper_->GetSelectionController() &&
- rwh_helper_->GetSelectionController()->ExistsSelectedText();
+ text_selected && rwh_helper_ && rwh_helper_->ExistsSelectedText();
}
-#endif
if (!text_selected) {
if (HasRenderWidgetHostImpl()) {
const std::vector<ImeTextSpan>& underlines =
// This menu is created in renderer process and it does not now anything about
// view scaling factor and it has another calling sequence, so coordinates is
// not updated.
+ if (settings_ && !settings_->getPreferences().long_press_enabled)
+ return;
+
content::ContextMenuParams convertedParams = params;
gfx::Point convertedPoint =
rwhva()->offscreen_helper()->ConvertPointInViewPix(
}
void EWebView::ShowContextMenu(const content::ContextMenuParams& params) {
-#if !defined(USE_AURA)
+ if (!rwhva())
+ return;
+
// This menu is created in renderer process and it does not now anything about
// view scaling factor and it has another calling sequence, so coordinates is
// not updated.
content::ContextMenuParams convertedParams = params;
gfx::Point convertedPoint =
- rwhv()->ConvertPointInViewPix(gfx::Point(params.x, params.y));
+ rwhva()->offscreen_helper()->ConvertPointInViewPix(
+ gfx::Point(params.x, params.y));
convertedParams.x = convertedPoint.x();
convertedParams.y = convertedPoint.y();
context_menu_position_ = gfx::Point(convertedParams.x, convertedParams.y);
ShowContextMenuInternal(convertedParams);
-#endif
}
void EWebView::ShowContextMenuInternal(
#include "net/http/http_stream_factory.h"
+Ewk_Settings::Ewk_Settings(Evas_Object* evas_object,
+ const WebPreferences& preferences)
+ : m_preferences(preferences),
+ m_currentLegacyFontSizeMode(
+ EWK_LEGACY_FONT_SIZE_MODE_ONLY_IF_PIXEL_VALUES_MATCH),
+ m_evas_object(evas_object) {}
+
void Ewk_Settings::setCurrentLegacyFontSizeMode(Ewk_Legacy_Font_Size_Mode mode) {
m_currentLegacyFontSizeMode = mode;
}
class Ewk_Settings {
public:
- Ewk_Settings(Evas_Object* evas_object, WebPreferences preferences)
- : m_preferences(preferences),
- m_autofillPasswordForm(false),
- m_formCandidateData(false),
- m_autofillProfileForm(false),
- m_textSelectionEnabled(true),
- m_autoClearTextSelection(true),
- m_autoSelectWord(false),
- m_edgeEffectEnabled(true),
- m_textZoomEnabled(true),
- m_loadRemoteImages(true),
- m_currentLegacyFontSizeMode(
- EWK_LEGACY_FONT_SIZE_MODE_ONLY_IF_PIXEL_VALUES_MATCH),
- m_pasteImageUriEnabled(true),
- m_defaultKeypadEnabled(true),
- m_useKeyPadWithoutUserAction(true),
- m_textStyleState(true),
- m_detectContentsAutomatically(true),
- m_evas_object(evas_object),
- m_cacheBuilderEnabled(false),
- m_longPressEnabled(true),
- m_linkMagnifierEnabled(false),
- m_detectContentsEnabled(false),
- m_webLoginEnabled(false),
- m_doubleTapEnabled(true),
- m_zoomEnabled(true),
- m_openPanelEnabled(true),
- m_allowRestrictedURL(true),
- m_URLBarHide(false) {}
+ Ewk_Settings(Evas_Object* evas_object, const WebPreferences& preferences);
+
+ ~Ewk_Settings() = default;
+
+ Ewk_Settings(const Ewk_Settings&) = delete;
+ Ewk_Settings& operator=(const Ewk_Settings&) = delete;
const char* defaultTextEncoding() const {
return m_preferences.default_encoding.c_str();
void setAutoSelectWord(bool enable) { m_autoSelectWord = enable; }
bool edgeEffectEnabled() const { return m_edgeEffectEnabled; }
void setEdgeEffectEnabled(bool enable);
- void setTextZoomEnabled(bool enable) { m_textZoomEnabled = enable; }
- bool textZoomEnabled() const { return m_textZoomEnabled; }
+ void setTextZoomEnabled(bool enable) {
+ m_preferences.text_zoom_enabled = enable;
+ }
+ bool textZoomEnabled() const { return m_preferences.text_zoom_enabled; }
void setLoadRemoteImages(bool loadRemoteImages) { m_loadRemoteImages = loadRemoteImages; }
bool loadRemoteImages() const { return m_loadRemoteImages; }
void setCurrentLegacyFontSizeMode(Ewk_Legacy_Font_Size_Mode mode);
WebPreferences m_preferences;
WebPreferencesEfl m_preferences_efl;
- bool m_autofillPasswordForm;
- bool m_formCandidateData;
- bool m_autofillProfileForm;
- bool m_textSelectionEnabled;
- bool m_autoClearTextSelection;
- bool m_autoSelectWord;
- bool m_edgeEffectEnabled;
- bool m_textZoomEnabled;
- bool m_loadRemoteImages;
+ bool m_autofillPasswordForm = false;
+ bool m_formCandidateData = false;
+ bool m_autofillProfileForm = false;
+ bool m_textSelectionEnabled = true;
+ bool m_autoClearTextSelection = true;
+ bool m_autoSelectWord = false;
+ bool m_edgeEffectEnabled = true;
+ bool m_loadRemoteImages = true;
Ewk_Legacy_Font_Size_Mode m_currentLegacyFontSizeMode;
- bool m_pasteImageUriEnabled;
- bool m_defaultKeypadEnabled;
- bool m_useKeyPadWithoutUserAction;
- bool m_textStyleState;
- bool m_detectContentsAutomatically;
+ bool m_pasteImageUriEnabled = true;
+ bool m_defaultKeypadEnabled = true;
+ bool m_useKeyPadWithoutUserAction = true;
+ bool m_textStyleState = true;
+ bool m_detectContentsAutomatically = true;
Evas_Object* m_evas_object;
- bool m_cacheBuilderEnabled;
+ bool m_cacheBuilderEnabled = false;
/* ewk_extra_features related */
- bool m_longPressEnabled;
- bool m_linkMagnifierEnabled;
- bool m_detectContentsEnabled;
- bool m_webLoginEnabled;
- bool m_doubleTapEnabled;
- bool m_zoomEnabled;
- bool m_openPanelEnabled;
- bool m_allowRestrictedURL;
- bool m_URLBarHide;
+ bool m_longPressEnabled = true;
+ bool m_linkMagnifierEnabled = false;
+ bool m_detectContentsEnabled = false;
+ bool m_webLoginEnabled = false;
+ bool m_doubleTapEnabled = true;
+ bool m_zoomEnabled = true;
+ bool m_openPanelEnabled = true;
+ bool m_allowRestrictedURL = true;
+ bool m_URLBarHide = false;
};
#endif // ewk_settings_private_h
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-
#include "ewk_settings_product.h"
+#include "base/strings/string_util.h"
#include "eweb_view.h"
-#include "ui/events/gesture_detection/gesture_configuration.h"
-#include "text_encoding_map_efl.h"
#include "private/ewk_private.h"
#include "private/ewk_settings_private.h"
#include "private/ewk_view_private.h"
+#include "text_encoding_map_efl.h"
#include "tizen/system_info.h"
+#include "ui/events/gesture_detection/gesture_configuration.h"
namespace {
return EINA_FALSE;
#endif
}
-
- typedef struct {
- const char* name;
- void (*set)(Ewk_Settings*, Eina_Bool enable);
- Eina_Bool (*get)(const Ewk_Settings*);
- } Ewk_Extra_Feature;
-
- static Ewk_Extra_Feature extra_features[] = {
- EWK_EXTRA_FEATURE("longpress,enable", LongPress),
- EWK_EXTRA_FEATURE("link,magnifier", LinkMagnifier),
- EWK_EXTRA_FEATURE("detect,contents", DetectContents),
- EWK_EXTRA_FEATURE("web,login", WebLogin),
- EWK_EXTRA_FEATURE("doubletap,enable", DoubleTap),
- EWK_EXTRA_FEATURE("zoom,enable", Zoom),
- EWK_EXTRA_FEATURE("openpanel,enable", OpenPanel),
- EWK_EXTRA_FEATURE("allow,restrictedurl", AllowRestrictedURL),
- EWK_EXTRA_FEATURE("urlbar,hide", URLBarHide),
- EWK_EXTRA_FEATURE("wrt,viewport,quirk", ViewportQuirk),
- {NULL, NULL, NULL}
- };
-
- Ewk_Extra_Feature* find_extra_feature(const char*feature)
- {
- for(Ewk_Extra_Feature *feat = extra_features; feat->name != NULL; feat++) {
- if (strcasecmp(feat->name, feature) == 0) {
- return feat;
- }
- }
-
- return NULL;
- }
}
Eina_Bool ewk_settings_extra_feature_get(const Ewk_Settings* settings, const char* feature)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(settings, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(feature, EINA_FALSE);
- Ewk_Extra_Feature *feat = find_extra_feature(feature);
- EINA_SAFETY_ON_NULL_RETURN_VAL(feat, EINA_FALSE);
- return feat->get(settings);
+
+ std::string feature_name(feature);
+ if (base::EqualsCaseInsensitiveASCII(feature_name, "edge,enable"))
+ return settings->edgeEffectEnabled();
+ else if (base::EqualsCaseInsensitiveASCII(feature_name, "zoom,enable"))
+ return settings->textZoomEnabled();
+ else if (base::EqualsCaseInsensitiveASCII(feature_name,
+ "selection,magnifier"))
+ return settings->getPreferences().selection_magnifier_enabled;
+ else if (base::EqualsCaseInsensitiveASCII(feature_name, "longpress,enable"))
+ return settings->getPreferences().long_press_enabled;
+ else if (base::EqualsCaseInsensitiveASCII(feature_name, "doubletap,enable"))
+ return settings->getPreferences().double_tap_to_zoom_enabled;
+ return EINA_FALSE;
}
void ewk_settings_extra_feature_set(Ewk_Settings* settings, const char* feature, Eina_Bool enable)
{
EINA_SAFETY_ON_NULL_RETURN(settings);
EINA_SAFETY_ON_NULL_RETURN(feature);
- Ewk_Extra_Feature *feat = find_extra_feature(feature);
- EINA_SAFETY_ON_NULL_RETURN(feat);
- feat->set(settings, enable);
+
+ std::string feature_name(feature);
+ if (base::EqualsCaseInsensitiveASCII(feature_name, "edge,enable"))
+ settings->setEdgeEffectEnabled(enable);
+ else if (base::EqualsCaseInsensitiveASCII(feature_name, "zoom,enable"))
+ settings->setTextZoomEnabled(enable);
+ else if (base::EqualsCaseInsensitiveASCII(feature_name,
+ "selection,magnifier"))
+ settings->getPreferences().selection_magnifier_enabled = enable;
+ else if (base::EqualsCaseInsensitiveASCII(feature_name, "longpress,enable"))
+ settings->getPreferences().long_press_enabled = enable;
+ else if (base::EqualsCaseInsensitiveASCII(feature_name, "doubletap,enable"))
+ settings->getPreferences().double_tap_to_zoom_enabled = enable;
}
Eina_Bool ewk_settings_tizen_compatibility_mode_set(Ewk_Settings* settings, unsigned major, unsigned minor, unsigned release)
projects / platform / framework / web / chromium-efl.git / commitdiff