#include "DataObjectTizen.h"
#endif
+#if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_TEXT_SELECTION_MODE)
+#include "HTMLImageElement.h"
+#endif
+
using namespace JSC;
using namespace WebCore;
using namespace std;
#if ENABLE(PAGE_VISIBILITY_API)
, m_visibilityState(WebCore::PageVisibilityStateVisible)
#endif
-#if ENABLE(TIZEN_RECORDING_SURFACE_SET)
- , m_recordingSurfaceSetEnable(false)
- , m_recordingSurfaceSetLoadStart(false)
- , m_recordingSurfaceSetLoadFinished(false)
- , m_recordingSurfaceSetSettings(false)
-#endif
#if ENABLE(TIZEN_SYNC_REQUEST_ANIMATION_FRAME)
, m_suspendedAnimationController(false)
#endif
, m_inspectorClient(0)
+#if ENABLE(TIZEN_ISF_PORT)
+ , m_prepareKeyDownEvent(false)
+#endif
{
ASSERT(m_pageID);
// FIXME: This is a non-ideal location for this Setting and
result.hasComposition = frame->editor()->hasComposition();
result.shouldIgnoreCompositionSelectionChange = frame->editor()->ignoreCompositionSelectionChange();
-#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
- Element* selectionRoot = frame->selection()->rootEditableElement();
- if (selectionRoot)
- result.editorRect = frame->view()->contentsToWindow(selectionRoot->getPixelSnappedRect());
+#if ENABLE(TIZEN_WEBKIT2_GET_TEXT_STYLE_FOR_SELECTION)
+ if (!result.shouldIgnoreCompositionSelectionChange) {
+ result.underlineState = frame->editor()->selectionHasStyle(CSSPropertyWebkitTextDecorationsInEffect, "underline");
+ result.italicState = frame->editor()->selectionHasStyle(CSSPropertyFontStyle, "italic");
+ result.boldState = frame->editor()->selectionHasStyle(CSSPropertyFontWeight, "bold");
+ result.bgColor = frame->editor()->selectionStartCSSPropertyValue(CSSPropertyBackgroundColor);
+ result.color = frame->editor()->selectionStartCSSPropertyValue(CSSPropertyColor);
+ result.fontSize = frame->editor()->selectionStartCSSPropertyValue(CSSPropertyFontSize);
+ }
+#endif
+
+#if ENABLE(TIZEN_ISF_PORT) || ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+ Element* rootEditableElement = frame->selection()->rootEditableElement();
+ if (!rootEditableElement)
+ return result;
+
+ result.editorRect = nodeRect(rootEditableElement);
+#endif
+
+#if ENABLE(TIZEN_ISF_PORT)
+ if (!result.shouldIgnoreCompositionSelectionChange && result.isContentEditable) {
+ result.inputMethodContextID = reinterpret_cast<uintptr_t>(rootEditableElement);
+
+ Node* hostNode = rootEditableElement->shadowHost();
+ if (!hostNode)
+ hostNode = rootEditableElement;
+
+ HTMLTextFormControlElement* formControl = toTextFormControl(hostNode);
+ if (formControl) {
+ const AtomicString& type = formControl->type();
+
+ if (type == "number" && formControl->hasTagName(HTMLNames::inputTag)) {
+ StepRange stepRange = static_cast<HTMLInputElement*>(formControl)->createStepRange(RejectAny);
+ bool needsSigned = stepRange.minimum().isNegative();
+ bool needsDecimal = (stepRange.step().floor() != stepRange.step());
+
+ if (needsSigned && needsDecimal)
+ result.inputMethodHints = "signedDecimalNumber";
+ else if (needsSigned)
+ result.inputMethodHints = "signedNumber";
+ else if (needsDecimal)
+ result.inputMethodHints = "decimalNumber";
+ else
+ result.inputMethodHints = "number";
+ } else if (type == "text" && formControl->form() && equalIgnoringCase(formControl->form()->fastGetAttribute(HTMLNames::roleAttr), "search"))
+ result.inputMethodHints = "search";
+ else
+ result.inputMethodHints = type;
+
+ result.surroundingText = formControl->value();
+ }
+
+ Position base = frame->selection()->base();
+ Node* baseNode = base.containerNode();
+ if (baseNode)
+ result.cursorPosition = baseNode->isTextNode() ? base.offsetInContainerNode() : 0;
+ }
#endif
#if PLATFORM(QT)
void WebPage::loadURL(const String& url, const SandboxExtension::Handle& sandboxExtensionHandle)
{
-#if ENABLE(TIZEN_RECORDING_SURFACE_SET)
- recordingSurfaceSetEnableURL(url);
-#endif
loadURLRequest(ResourceRequest(KURL(KURL(), url)), sandboxExtensionHandle);
}
- #if ENABLE(TIZEN_RECORDING_SURFACE_SET)
-void WebPage::recordingSurfaceSetEnableURL(const String& url)
-{
- if (m_recordingSurfaceSetSettings && strstr(url.utf8().data(), "bubblemark.com")) {
- m_recordingSurfaceSetEnable = true;
- m_page->m_recordingSurfaceSetEnable = true;
- } else {
- m_recordingSurfaceSetEnable = false;
- m_page->m_recordingSurfaceSetEnable = false;
- }
-}
-#endif
-
void WebPage::loadURLRequest(const ResourceRequest& request, const SandboxExtension::Handle& sandboxExtensionHandle)
{
SendStopResponsivenessTimer stopper(this);
Settings* settings = m_page->settings();
#if OS(TIZEN)
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI(" args type: [%d], scale: [%.1f, %.1f, %.1f], layout: [%.1f, %.1f], userScalable: [%.1f]"
+ , static_cast<int>(m_page->viewportArguments().type), m_page->viewportArguments().initialScale
+ , m_page->viewportArguments().minimumScale, m_page->viewportArguments().maximumScale
+ , m_page->viewportArguments().width, m_page->viewportArguments().height, m_page->viewportArguments().userScalable);
+#endif
+
// As android and iphone does, we set layout width to 980 for desktop content
int minimumLayoutFallbackWidth = settings->layoutFallbackWidth();
#else
// On WebProcess, JS runs before visible content rect is updated by UIProcess
// In this case, JS returns incorrect inner size value because scale factor is not updated yet
// So, we update fixed visible content rect at here.
- // Fixed visible content rect should be updated for new page only
- // mainFrameView()->didFirstLayout() checks it's new page or not
- // ref 1. https://bugs.webkit.org/show_bug.cgi?id=105627
- // ref 2. https://bugs.webkit.org/show_bug.cgi?id=103737
- if (!mainFrameView()->didFirstLayout()) {
- FloatSize contentFixedSize = m_viewportSize;
- contentFixedSize.scale(1 / (attr.initialScale * attr.devicePixelRatio));
- mainFrameView()->setFixedVisibleContentRect(IntRect(mainFrameView()->scrollPosition(), roundedIntSize(contentFixedSize)));
- }
+ // FIXME: scale factor needs to be calculated and set fixed visible content rect
+
+ // if constrainsScrollingToContentEdge is true, scroll position will be adjusted with contents size.
+ // disable this to avoid adjust scroll position on setFixedVisibleContentRect() because contents size is not fixed yet.
+ bool constrainsScrollingToContentEdge = mainFrameView()->constrainsScrollingToContentEdge();
+ mainFrameView()->setConstrainsScrollingToContentEdge(false);
+
+ FloatSize contentFixedSize = m_viewportSize;
+ contentFixedSize.scale(1 / (attr.initialScale * attr.devicePixelRatio));
+ mainFrameView()->setFixedVisibleContentRect(IntRect(mainFrameView()->scrollPosition(), roundedIntSize(contentFixedSize)));
// If viewport meta tag is not defined or initial scale factor is not defined,
// initial scale factor can be defined by "Default View" setting of UIProcess.
setResizesToContentsUsingLayoutSize(IntSize(static_cast<int>(attr.layoutSize.width()), static_cast<int>(attr.layoutSize.height())));
+#if ENABLE(TIZEN_VIEWPORT_META_TAG)
+ // recover constrainsScrollingToContentEdge
+ mainFrameView()->setConstrainsScrollingToContentEdge(constrainsScrollingToContentEdge);
+#endif
+
send(Messages::WebPageProxy::DidChangeViewportProperties(attr));
}
if (m_viewportSize == size)
return;
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI(" viewportSize: [%d, %d]", size.width(), size.height());
+#endif
+
m_viewportSize = size;
sendViewportAttributesChanged();
void WebPage::selectLink(WebCore::IntPoint positionForSelection, bool& result)
{
result = false;
-
Frame* frame = m_page->focusController()->focusedOrMainFrame();
if (!frame)
return;
+
FrameView* frameView = frame->view();
if (!frameView)
return;
HitTestResult hitTestResult = frame->eventHandler()->hitTestResultAtPoint(frameView->windowToContents(positionForSelection), false);
- Element* URLElement = hitTestResult.URLElement();
- if (!URLElement)
- return;
-
RefPtr<Range> range;
- for (Node* childNode = URLElement->firstChild(); childNode; childNode = childNode->traverseNextNode(URLElement)) {
- if (childNode->isTextNode()) {
- if (!range)
- range = VisibleSelection::selectionFromContentsOfNode(childNode).toNormalizedRange();
- else {
- RefPtr<Range> extendedRange = VisibleSelection::selectionFromContentsOfNode(childNode).toNormalizedRange();
- range->setEnd(childNode, extendedRange->endOffset());
+ Element* URLElement = hitTestResult.URLElement();
+ if (URLElement) {
+ for (Node* childNode = URLElement->firstChild(); childNode; childNode = childNode->traverseNextNode(URLElement)) {
+ RenderObject* r = childNode->renderer();
+ if (r && (r->isText() || r->isImage())) {
+ if (!range)
+ range = VisibleSelection::selectionFromContentsOfNode(childNode).toNormalizedRange();
+ else if (!hitTestResult.image()) {
+ RefPtr<Range> extendedRange = VisibleSelection::selectionFromContentsOfNode(childNode).toNormalizedRange();
+ range->setEnd(childNode, extendedRange->endOffset());
+ }
}
}
- }
-
- if (!range)
- range = VisibleSelection::selectionFromContentsOfNode(URLElement).toNormalizedRange();
+ if(!range)
+ range = VisibleSelection::selectionFromContentsOfNode(URLElement).toNormalizedRange();
+ } else
+ range = VisibleSelection::selectionFromContentsOfNode(hitTestResult.innerNonSharedNode()).toNormalizedRange();
WebCore::FrameSelection* frameSelection = frame->selection();
if (!frameSelection)
return;
+
EAffinity affinity = frameSelection->affinity();
frameSelection->setSelectedRange(range.get(), affinity, true);
#if USE(TILED_BACKING_STORE)
void WebPage::pageDidRequestScroll(const IntPoint& point)
{
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI(" scroll position: [%d, %d]", point.x(), point.y());
+#endif
send(Messages::WebPageProxy::PageDidRequestScroll(point));
}
#endif
#if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
void WebPage::pageDidRequestRestoreVisibleContentRect(const IntPoint& point, float scale)
{
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI(" scale factor: [%.2f], scroll position: [%d, %d]", scale, point.x(), point.y());
+#endif
send(Messages::WebPageProxy::pageDidRequestRestoreVisibleContentRect(point, scale));
}
#endif
{
CurrentEvent currentEvent(keyboardEvent);
+#if ENABLE(TIZEN_ISF_PORT)
+ m_prepareKeyDownEvent = false;
+#endif
+
bool handled = handleKeyEvent(keyboardEvent, m_page.get());
// FIXME: Platform default behaviors should be performed during normal DOM event dispatch (in most cases, in default keydown event handler).
if (!handled)
#if ENABLE(TIZEN_INDEXED_DATABASE)
m_page->group().groupSettings()->setIndexedDBDatabasePath(WebProcess::shared().indexedDatabaseDirectory());
+ m_page->group().groupSettings()->setIndexedDBQuotaBytes(0x6400000); //100M
#endif
settings->setDiagnosticLoggingEnabled(store.getBoolValueForKey(WebPreferencesKey::diagnosticLoggingEnabledKey()));
settings->setTextAutosizingEnabled(store.getBoolValueForKey(WebPreferencesKey::textAutosizingEnabledKey()));
#endif
+#if ENABLE(TIZEN_FILE_SYSTEM)
+ m_page->group().groupSettings()->setLocalFileSystemQuotaBytes(0x6400000); //100M
+#endif
+
+#if ENABLE(TIZEN_WORKERS)
+ m_page->group().groupSettings()->setAllowUniversalAccessFromFileURLs(settings->allowUniversalAccessFromFileURLs());
+#endif
+
platformPreferencesDidChange(store);
if (m_drawingArea)
m_activeOpenPanelResultListener = 0;
}
+#if OS(TIZEN)
+void WebPage::cancelForOpenPanel()
+{
+ if (m_activeOpenPanelResultListener) {
+ m_activeOpenPanelResultListener->disconnectFromPage();
+ m_activeOpenPanelResultListener = 0;
+ }
+}
+#endif
+
#if ENABLE(WEB_PROCESS_SANDBOX)
void WebPage::extendSandboxForFileFromOpenPanel(const SandboxExtension::Handle& handle)
{
projects / framework / web / webkit-efl.git / blobdiff