#include "PageClientImpl.h"
#include "EwkViewImpl.h"
+#include "InputMethodContextEfl.h"
#include "NativeWebKeyboardEvent.h"
#include "NotImplemented.h"
#include "TransformationMatrix.h"
#include "WebContext.h"
#include "WebContextMenuProxy.h"
#include "WebPageProxy.h"
+#include "WebPopupMenuProxyEfl.h"
#include "ewk_context.h"
#include "ewk_context_private.h"
#include "ewk_download_job.h"
#include "ewk_download_job_private.h"
-#include "ewk_view_private.h"
+#include "ewk_view.h"
#if OS(TIZEN)
#include "DrawingAreaProxyImpl.h"
#include "WebLayerTreeRenderer.h"
#include "WebPageGroup.h"
#include "WebPageMessages.h"
-#include "WebPopupMenuProxyTizen.h"
+#include "WebPopupMenuProxyEfl.h"
#include "WebPreferences.h"
#include "ewk_view.h"
#include <Ecore_Evas.h>
namespace WebKit {
-PageClientImpl::PageClientImpl(WebContext* context, WebPageGroup* pageGroup, Evas_Object* viewWidget)
- : m_viewWidget(viewWidget)
+PageClientImpl::PageClientImpl(EwkViewImpl* viewImpl)
+ : m_viewImpl(viewImpl)
#if OS(TIZEN)
, m_viewportConstraints()
, m_viewFocused(false)
, m_viewWindowActive(true)
- , m_pageDidRendered(false)
+ , m_pageDidRendered(true)
+ , m_viewportAngle(0)
+ , m_viewportFitsToContent(false)
#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
, m_visibleContentRect(IntRect())
- , m_scaleFactor(1.0f)
- , m_visibleContentRectForDrawContents(IntRect())
- , m_scaleFactorForDrawContents(1.0f)
+ , m_scaleFactor(0)
+ , m_hasSuspendedContent(false)
#endif
#if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
- , m_didRestoreVisibleContentRect(false)
+ , m_restoredScaleFactor(0)
+#endif
+#if ENABLE(TIZEN_WEBKIT2_BEFORE_PAGE_RENDERED_SCROLL_POSITION)
+ , m_scrollPositionBeforePageRendered(IntPoint())
#endif
, m_isVisible(true)
+ , m_deferUpdateViewportSize(false)
, m_isScrollableLayerFocused(false)
, m_isScrollableNodeFocused(false)
#if ENABLE(TIZEN_WEBKIT2_TILED_AC_SHARED_PLATFORM_SURFACE_BACKUP_IMAGE)
#if ENABLE(TIZEN_CONTEXT_MENU_WEBKIT_2)
, m_isContextMenuVisible(false)
#endif
+#if ENABLE(TIZEN_PRERENDERING_FOR_ROTATION)
+ , m_waitFrameOfNewViewortSize(false)
+#endif
+ , m_nonemptyLayoutRendered(false)
#endif // #if OS(TIZEN)
{
-#if ENABLE(TIZEN_WEBKIT2) && ENABLE(TIZEN_CANVAS_CAIRO_GLES_RENDERING)
+#if ENABLE(TIZEN_CANVAS_CAIRO_GLES_RENDERING)
setenv("CAIRO_GL_COMPOSITOR", "msaa", 1);
setenv("CAIRO_GL_LAZY_FLUSHING", "yes", 1);
#endif
- m_page = context->createWebPage(this, pageGroup);
-
-#if OS(TIZEN)
- m_page->pageGroup()->preferences()->setAcceleratedCompositingEnabled(true);
- m_page->pageGroup()->preferences()->setForceCompositingMode(true);
- m_page->pageGroup()->preferences()->setFrameFlatteningEnabled(true);
- m_page->pageGroup()->preferences()->setAllowUniversalAccessFromFileURLs(true);
-
- if (m_viewWidget) {
- int deviceWidth, deviceHeight;
- ecore_evas_screen_geometry_get(ecore_evas_ecore_evas_get(evas_object_evas_get(m_viewWidget)), 0, 0, &deviceWidth, &deviceHeight);
- m_page->pageGroup()->preferences()->setDeviceWidth(deviceWidth);
- m_page->pageGroup()->preferences()->setDeviceHeight(deviceHeight);
- }
-
-#endif
-
- m_page->initializeWebPage();
-
-#if ENABLE(TIZEN_VIEWPORT_META_TAG)
- m_page->setCustomDeviceScaleFactor((float)getMobileDPI() / 160);
-#else
- m_page->setCustomDeviceScaleFactor((float)getDPI() / 160);
-#endif
#if OS(TIZEN)
#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
- m_textSelection = TextSelection::create(viewWidget, m_page.get(), this);
+ m_textSelection = TextSelection::create(m_viewImpl);
+#endif
+#if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
+ m_offlinePageSave = OfflinePageSave::create(m_viewImpl);
#endif
#if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
- m_clipboardHelper = ClipboardHelper::create(viewWidget, this);
+ m_clipboardHelper = ClipboardHelper::create(m_viewImpl);
#endif
#if ENABLE(TIZEN_DRAG_SUPPORT)
- m_drag = Drag::create(m_page.get());
-#endif
+ m_drag = Drag::create(m_viewImpl);
#endif
-
-#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE) && !ENABLE(TIZEN_WEBKIT2_EFL_WTR)
- m_page->setUseFixedLayout(true);
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+ m_formDataCandidate = FormDataCandidate::create(m_viewImpl);
#endif
-#if ENABLE(FULLSCREEN_API)
- m_page->fullScreenManager()->setWebView(viewWidget);
+ Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_viewImpl->view()));
+ m_viewportAngle = ecore_evas_rotation_get(ee);
#endif
setBackgroundColor(1, 1, 1, 1);
-
-#if OS(TIZEN)
- m_viewImpl = EwkViewImpl::fromEvasObject(m_viewWidget);
-#endif
}
PageClientImpl::~PageClientImpl()
{
- m_page->close();
+ if (m_viewImpl && m_viewImpl->page())
+ m_viewImpl->page()->close();
}
#if OS(TIZEN)
constraints.maximumScale = attributes.maximumScale * attributes.devicePixelRatio;
constraints.userScalable = attributes.userScalable;
constraints.layoutSize = attributes.layoutSize;
+ constraints.contentsDefinedInitialScale = (ViewportArguments::ValueAuto != attributes.initialScale);
- double defaultViewLevel = m_page->pageGroup()->preferences()->defaultViewLevel();
- // If defaultViewLevel is 1, "Default View" is set as "Readable"
- // if not, "Default View" is set as "Fit to width"
- if (defaultViewLevel) {
+ bool autoFittingEnabled = m_viewImpl->page()->pageGroup()->preferences()->autoFittingEnabled();
+ if (autoFittingEnabled)
+ constraints.initialScale = attributes.minimumScale * attributes.devicePixelRatio;
+ else {
// if content doesn't set initial scale value, set readable scale factor
// if not, set initial scale factor of viewport attribute
if (attributes.initialScale == ViewportArguments::ValueAuto)
- constraints.initialScale = m_page->deviceScaleFactor();
+ constraints.initialScale = m_viewImpl->page()->deviceScaleFactor();
else
constraints.initialScale = attributes.initialScale * attributes.devicePixelRatio;
- } else {
- // Minimize initial scale factor
- constraints.initialScale = attributes.minimumScale * attributes.devicePixelRatio;
}
// adjust scale with both minimum and maximum scale factor
- if (constraints.initialScale < constraints.minimumScale)
- constraints.initialScale = constraints.minimumScale;
- if (constraints.initialScale > constraints.maximumScale)
- constraints.initialScale = constraints.maximumScale;
+ constraints.initialScale = adjustScaleWithViewport(constraints.initialScale);
+
return constraints;
}
double PageClientImpl::adjustScaleWithViewport(double scale)
{
- if (scale < m_viewportConstraints.minimumScale)
- scale = m_viewportConstraints.minimumScale;
- if (scale > m_viewportConstraints.maximumScale)
- scale = m_viewportConstraints.maximumScale;
- return scale;
+ double minimumScale = min(m_viewportConstraints.minimumScale, m_viewportConstraints.maximumScale);
+ return clampTo(scale, minimumScale, m_viewportConstraints.maximumScale);
}
#if USE(TILED_BACKING_STORE) && ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
-void PageClientImpl::updateViewportSize(const IntSize& viewportSize)
+void PageClientImpl::updateViewportSize(const IntSize& viewportSize, const int angle)
{
- // update device width & height
- int deviceWidth = WebCore::getDefaultScreenResolution().width();
- int deviceHeight = WebCore::getDefaultScreenResolution().height();
- Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_viewWidget));
- int angle = ecore_evas_rotation_get(ee);
- if (angle == 90 || angle == 270) {
- int tempWidth = deviceWidth;
- deviceWidth = deviceHeight;
- deviceHeight = tempWidth;
- }
- m_page->pageGroup()->preferences()->setDeviceWidth(deviceWidth);
- m_page->pageGroup()->preferences()->setDeviceHeight(deviceHeight);
-
- m_visibleContentRectForDrawContents.setSize(viewSize());
- if (m_visibleContentRect.size() == viewportSize) {
- // We should call setVisibleContentRect() explicitly,
- // because visible content rect can be exceeded over contents size by resized visibleContentRect by hidden IME
- setVisibleContentRect(m_visibleContentRectForDrawContents, scaleFactor());
- return;
- }
-
- Ecore_IMF_Context* imfContext = ewk_view_imf_context_get(m_viewWidget);
-
- // Resize by IME operations of webkit.
- // Imfconext is null, when the operation is not caused by webkit
- if (imfContext && !(m_clipboardHelper && m_clipboardHelper->isClipboardWindowOpened())) {
- // For webkit IME operaions viewport size can change in below cases
- // 1)viewport size is changed when IME is hidden
- // 2)viewport height is larger than before
- Ecore_IMF_Input_Panel_State imeState = ecore_imf_context_input_panel_state_get(imfContext);
- if ((imeState == ECORE_IMF_INPUT_PANEL_STATE_HIDE && m_visibleContentRect.size() != viewportSize)
- || (imeState != ECORE_IMF_INPUT_PANEL_STATE_HIDE && m_visibleContentRect.height() < viewportSize.height())) {
- m_visibleContentRect.setSize(viewportSize);
- m_page->setViewportSize(viewportSize);
- return;
- }
- }
- // Viewport width is changed, resize by rotate or app tile's resize
- if (m_visibleContentRect.width() != viewportSize.width()) {
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI(" view size: [%d, %d], angle: [%d]", viewportSize.width(), viewportSize.height(), angle);
+#endif
+#if ENABLE(TIZEN_WEBKIT2_VIEW_VISIBILITY)
+ if (m_deferUpdateViewportSize) {
m_visibleContentRect.setSize(viewportSize);
- m_page->setViewportSize(viewportSize);
+ m_viewImpl->page()->setViewportSize(viewportSize);
+ m_deferUpdateViewportSize = false;
return;
}
- // Input field zoom if viewport size is not changed
- if (!ewk_view_focused_node_adjust(m_viewWidget))
- setVisibleContentRect(m_visibleContentRectForDrawContents, scaleFactor());
+#endif
+
+ // update viewport size of webkit
+ m_viewImpl->page()->setViewportSize(viewportSize);
+}
+
+void PageClientImpl::updateVisibleContentRectSize(const IntSize& size)
+{
+ // update visible content rect's size
+ m_visibleContentRect.setSize(size);
}
#endif
+void PageClientImpl::prepareRestoredVisibleContectRect()
+{
+ m_restoredScaleFactor = scaleFactor();
+ m_restoredScrollPosition = scrollPosition();
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI("scroll position: [%d, %d], scale factor: [%.2f]", m_restoredScrollPosition.x(), m_restoredScrollPosition.y(), m_restoredScaleFactor);
+#endif
+}
+
void PageClientImpl::initializeVisibleContentRect()
{
- _ewk_view_resume_painting(m_viewWidget);
+ _ewk_view_resume_painting(m_viewImpl->view());
#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
- // Call setVisibleContentRect() with current scroll position.
- // Because scroll position can be changed by HistoryController when we go back and foward
+ IntPoint initialScrollPosition;
+ float initialScaleFactor = m_viewportConstraints.initialScale;
+#if ENABLE(TIZEN_WEBKIT2_BEFORE_PAGE_RENDERED_SCROLL_POSITION)
+ initialScrollPosition = m_scrollPositionBeforePageRendered;
+ m_scrollPositionBeforePageRendered = IntPoint();
+#endif
#if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
- if (m_didRestoreVisibleContentRect)
- setVisibleContentRect(m_visibleContentRect, scaleFactor());
- else
- setVisibleContentRect(IntRect(IntPoint(), viewSize()), m_viewportConstraints.initialScale);
-#else
- if (!m_didRestoreVisibleContentRect)
- setVisibleContentRect(IntRect(IntPoint(), viewSize()), m_viewportConstraints.initialScale);
+ // if scroll position and scale factor are restored by history controller,
+ // move scroll position and scale factor with them
+ if (m_restoredScaleFactor) {
+ initialScrollPosition = m_restoredScrollPosition;
+ initialScaleFactor = m_restoredScaleFactor;
+ }
+#if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
+ m_restoredScaleFactor = 0;
+#endif
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI("scroll position: [%d, %d], scale factor: [%.2f]", initialScrollPosition.x(), initialScrollPosition.y(), initialScaleFactor);
+#endif
#endif
+ setVisibleContentRect(IntRect(initialScrollPosition, m_visibleContentRect.size()), initialScaleFactor);
#else
// Set initial scale.
- m_page->scalePage(m_viewportConstraints.initialScale, IntPoint(0, 0));
+ m_viewImpl->page()->scalePage(m_viewportConstraints.initialScale, IntPoint(0, 0));
#endif
-#if !ENABLE(TIZEN_WEBKIT2_TILED_AC)
- m_scaleFactorForDrawContents = m_scaleFactor;
+}
+
+double PageClientImpl::availableMinimumScale()
+{
+ // recalculate minimum scale factor if contents' width exceeds viewport layout width and userScalable is true.
+ // minimum scale factor shouldn't be smaller than 0.25(minimum zoom level)
+ IntSize contentsSize = m_viewImpl->page()->contentsSize();
+ double horizontalMinScale = max(((double)viewSize().width() / contentsSize.width()), 0.25);
+ double verticalMinScale = max(((double)viewSize().height() / contentsSize.height()), 0.25);
+ // If there's only a bit ignorable difference between horizontalMinScale and verticalMinScale,
+ // ignore verticalMinScale to fit content's width to view
+ const double ignorableThreshold = 0.01;
+ if (fabs(horizontalMinScale - verticalMinScale) < ignorableThreshold)
+ verticalMinScale = horizontalMinScale;
+ return min(max(horizontalMinScale, verticalMinScale), m_viewportConstraints.maximumScale);
+}
+
+void PageClientImpl::fitViewportToContent()
+{
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI("scroll position: [%d, %d], scale factor: [%.2f]", m_visibleContentRect.x(), m_visibleContentRect.y(), m_viewportConstraints.minimumScale);
#endif
+ setVisibleContentRect(m_visibleContentRect, m_viewportConstraints.minimumScale);
}
void PageClientImpl::setFocusedNodeRect(const IntRect& focusedNodeRect)
// in the actual scale.
IntSize scaledScrollOffset = m_viewImpl->transformFromScene().mapSize(scrollOffset);
if ((m_isScrollableLayerFocused || m_isScrollableNodeFocused)
- && page()->scrollOverflow(FloatPoint(scaledScrollOffset.width(), scaledScrollOffset.height()))) {
+ && m_viewImpl->page()->scrollOverflow(FloatPoint(scaledScrollOffset.width(), scaledScrollOffset.height()))) {
displayViewport();
return false;
}
#endif
IntPoint oldScrollPosition = scrollPosition();
- setVisibleContentRect(IntRect(oldScrollPosition + scrollOffset, viewSize()), scaleFactor(), FloatPoint(scrollOffset.width(), scrollOffset.height()));
- IntPoint newScrollPosition = scrollPosition();
- if (oldScrollPosition != newScrollPosition)
- displayViewport();
+ setVisibleContentRect(IntRect(oldScrollPosition + scrollOffset, m_visibleContentRect.size()), scaleFactor(), FloatPoint(scrollOffset.width(), scrollOffset.height()));
return true;
}
void PageClientImpl::scrollTo(IntPoint requestedScrollPosition)
{
- IntPoint oldScrollPosition = scrollPosition();
- setVisibleContentRect(IntRect(requestedScrollPosition, viewSize()), scaleFactor());
- IntPoint newScrollPosition = scrollPosition();
-
- if (oldScrollPosition != newScrollPosition)
- displayViewport();
+ setVisibleContentRect(IntRect(requestedScrollPosition, m_visibleContentRect.size()), scaleFactor());
}
#endif // #if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
#endif // #if OS(TIZEN)
+EwkViewImpl* PageClientImpl::viewImpl() const
+{
+ return m_viewImpl;
+}
+
// PageClient
PassOwnPtr<DrawingAreaProxy> PageClientImpl::createDrawingAreaProxy()
{
- return DrawingAreaProxyImpl::create(m_page.get());
+ return DrawingAreaProxyImpl::create(m_viewImpl->page());
}
void PageClientImpl::setViewNeedsDisplay(const WebCore::IntRect& rect)
{
- ewk_view_mark_for_sync(m_viewWidget);
+#if OS(TIZEN)
+ ewk_view_mark_for_sync(m_viewImpl->view());
+#else
+ m_viewImpl->redrawRegion(rect);
+#endif
}
void PageClientImpl::displayView()
WebCore::IntSize PageClientImpl::viewSize()
{
- return ewk_view_size_get(m_viewWidget);
+ return m_viewImpl->size();
}
bool PageClientImpl::isViewVisible()
{
+#if OS(TIZEN)
return m_isVisible;
+#else
+ return m_viewImpl->isVisible();
+#endif
}
bool PageClientImpl::isViewInWindow()
void PageClientImpl::processDidCrash()
{
- notImplemented();
+ // Check if loading was ongoing, when web process crashed.
+ double loadProgress = ewk_view_load_progress_get(m_viewImpl->view());
+ if (loadProgress >= 0 && loadProgress < 1)
+ m_viewImpl->informLoadProgress(1);
+
+ m_viewImpl->informWebProcessCrashed();
}
void PageClientImpl::didRelaunchProcess()
{
- const char* themePath = ewk_view_theme_get(m_viewWidget);
+ const char* themePath = m_viewImpl->themePath();
if (themePath)
- ewk_view_page_get(m_viewWidget)->setThemePath(themePath);
+ m_viewImpl->page()->setThemePath(themePath);
}
void PageClientImpl::pageClosed()
notImplemented();
}
-void PageClientImpl::toolTipChanged(const String&, const String&)
+void PageClientImpl::toolTipChanged(const String&, const String& newToolTip)
{
- notImplemented();
+ m_viewImpl->informTooltipTextChange(newToolTip);
}
void PageClientImpl::setCursor(const Cursor& cursor)
{
- ewk_view_cursor_set(m_viewWidget, cursor);
+ m_viewImpl->setCursor(cursor);
}
void PageClientImpl::setCursorHiddenUntilMouseMoves(bool hiddenUntilMouseMoves)
void PageClientImpl::didChangeViewportProperties(const WebCore::ViewportAttributes& attributes)
{
- float prevMinimumScale = m_viewportConstraints.minimumScale;
+ double scaleRatioBeforeRotation = m_scaleFactor / m_viewportConstraints.minimumScale;
m_viewportConstraints = computeViewportConstraints(attributes);
- // setVisibleContentRect() is called to adjust visible content rect after device rotation
- // In below cases, it shouldn't be called
- // 1. page is not rendered yet
- // 2. viewport attributes are changed by WebCore's empty document(progress == 0.1)
- // 3. there's no input field zoom(device rotation without IME)
- if (m_pageDidRendered && page()->estimatedProgress() > 0.1 && !ewk_view_focused_node_adjust(m_viewWidget)) {
- float newScale = scaleFactor();
- // If zoom was fitted to width before the rotation, newScale should be fitted to width again.
- if (fabs(scaleFactor() - prevMinimumScale) < numeric_limits<double>::epsilon())
+
+#if ENABLE(TIZEN_GESTURE)
+ m_viewImpl->setDoubleTapEnabled(userScalable());
+#endif
+
+ // Initially, m_scaleFactor is not decided yet.
+ // So, we should update visible content rect at here.
+ if (!m_scaleFactor) {
+ setVisibleContentRect(m_visibleContentRect, m_viewportConstraints.initialScale);
+ return;
+ }
+
+ // if content is reloaded, contents size will not be changed
+ // so, we need to calculate minimum scale here.
+ // if content size is changed later, minimum scale will be re-calculated on didChangeContentsSize()
+ if (m_viewportConstraints.userScalable) {
+ if (fabs(m_viewportConstraints.initialScale - m_viewportConstraints.minimumScale) < numeric_limits<float>::epsilon())
+ m_viewportConstraints.initialScale = availableMinimumScale();
+ m_viewportConstraints.minimumScale = availableMinimumScale();
+ }
+
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI("layout size: [%d, %d], scale: [%.2f, %.2f, %.2f], user scalable: [%s]",
+ m_viewportConstraints.layoutSize.width(), m_viewportConstraints.layoutSize.height(),
+ m_viewportConstraints.initialScale, m_viewportConstraints.minimumScale, m_viewportConstraints.maximumScale,
+ m_viewportConstraints.userScalable ? "TRUE" : "FALSE");
+#endif
+
+ // setVisibleContentRect() should be called to adjust visible content rect only when view is resized
+ if (!m_pageDidRendered || m_viewImpl->page()->estimatedProgress() <= 0.1)
+ return;
+
+ // if IME is opened, visible content rect will be updated by ewk_view_focused_node_adjust()
+ if (ewk_view_focused_node_adjust(m_viewImpl->view()))
+ return;
+
+ float newScale = scaleFactor();
+ IntPoint newScrollPosition = m_visibleContentRect.location();
+ Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_viewImpl->view()));
+ int angle = ecore_evas_rotation_get(ee);
+ bool isRotated = (angle != m_viewportAngle);
+
+ // if it's rotated, we need to fit content to viewport by minimize the scale
+ if (isRotated) {
+ m_viewportAngle = angle;
+ newScale = m_viewportConstraints.minimumScale * scaleRatioBeforeRotation;
+ if (m_viewportFitsToContent)
newScale = m_viewportConstraints.minimumScale;
+ newScrollPosition.scale(newScale / m_scaleFactor, newScale / m_scaleFactor);
+ }
+
+#if ENABLE(TIZEN_PRERENDERING_FOR_ROTATION)
+ if (m_waitFrameOfNewViewortSize)
+ ewk_view_resume(m_viewImpl->view());
+#endif
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI("scroll position: [%d, %d], scale factor: [%.2f], rotated: [%s]", m_visibleContentRect.x(), m_visibleContentRect.y(), newScale, isRotated ? "Rotated" : "Not rotated");
+#endif
+
#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
- setVisibleContentRect(IntRect(m_visibleContentRect.location(), viewSize()), newScale);
+ setVisibleContentRect(IntRect(newScrollPosition, m_visibleContentRect.size()), newScale);
#else
- m_page->scalePage(newScale, m_visibleContentRect.location());
+ m_viewImpl->page()->scalePage(newScale, newScrollPosition);
#endif
- }
-#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
- updateTextSelectionHandlesAndContextMenu(true);
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+ Ewk_View_Smart_Data* smartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(m_viewImpl->view()));
+ if (smartData->api->formdata_candidate_is_showing(smartData))
+ smartData->api->formdata_candidate_hide(smartData);
+#endif
+
+#if ENABLE(TIZEN_FULLSCREEN_API)
+ if (m_viewImpl->page()->fullScreenManager()->isFullScreen())
+ m_viewImpl->page()->fullScreenManager()->updateMediaControlsStyle();
#endif
}
#if OS(TIZEN)
void PageClientImpl::registerEditCommand(PassRefPtr<WebEditCommandProxy> command, WebPageProxy::UndoOrRedo undoOrRedo)
{
- if (undoOrRedo == WebPageProxy::Undo)
+ if (undoOrRedo == WebPageProxy::Undo) {
m_undoCommands.append(command);
- else
+
+ int undoSize = m_undoCommands.size();
+ evas_object_smart_callback_call(m_viewImpl->view(), "undo,size", &undoSize);
+ }
+ else {
m_redoCommands.append(command);
+
+ int redoSize = m_redoCommands.size();
+ evas_object_smart_callback_call(m_viewImpl->view(), "redo,size", &redoSize);
+ }
}
void PageClientImpl::clearAllEditCommands()
{
m_undoCommands.clear();
m_redoCommands.clear();
+
+ int undoSize = m_undoCommands.size();
+ evas_object_smart_callback_call(m_viewImpl->view(), "undo,size", &undoSize);
+
+ int redoSize = m_redoCommands.size();
+ evas_object_smart_callback_call(m_viewImpl->view(), "redo,size", &redoSize);
}
bool PageClientImpl::canUndoRedo(WebPageProxy::UndoOrRedo undoOrRedo)
if (undoOrRedo == WebPageProxy::Undo) {
m_undoCommands.last()->unapply();
m_undoCommands.removeLast();
+
+ int undoSize = m_undoCommands.size();
+ evas_object_smart_callback_call(m_viewImpl->view(), "undo,size", &undoSize);
} else {
m_redoCommands.last()->reapply();
m_redoCommands.removeLast();
+
+ int redoSize = m_redoCommands.size();
+ evas_object_smart_callback_call(m_viewImpl->view(), "redo,size", &redoSize);
}
}
#else
void PageClientImpl::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled)
{
#if OS(TIZEN)
- ewk_view_touch_event_handler_result_set(m_viewWidget, event.type(), wasEventHandled);
+ ewk_view_touch_event_handler_result_set(m_viewImpl->view(), event.type(), wasEventHandled);
#else
notImplemented();
#endif // #if OS(TIZEN)
PassRefPtr<WebPopupMenuProxy> PageClientImpl::createPopupMenuProxy(WebPageProxy* page)
{
-#if ENABLE(TIZEN_WEBKIT2_POPUP)
- return WebPopupMenuProxyTizen::create(m_viewWidget, page);
-#endif
+ return WebPopupMenuProxyEfl::create(m_viewImpl, page);
}
PassRefPtr<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy* page)
{
#if ENABLE(TIZEN_CONTEXT_MENU_WEBKIT_2)
- return WebContextMenuProxyTizen::create(m_viewWidget, page, this);
+ return WebContextMenuProxyTizen::create(m_viewImpl->view(), page, this);
#else
notImplemented();
return 0;
#if USE(ACCELERATED_COMPOSITING)
void PageClientImpl::enterAcceleratedCompositingMode(const LayerTreeContext&)
{
- ewk_view_accelerated_compositing_mode_enter(m_viewWidget);
+ m_viewImpl->enterAcceleratedCompositingMode();
}
void PageClientImpl::exitAcceleratedCompositingMode()
{
- ewk_view_accelerated_compositing_mode_exit(m_viewWidget);
+ m_viewImpl->exitAcceleratedCompositingMode();
}
void PageClientImpl::updateAcceleratedCompositingMode(const LayerTreeContext&)
}
#if OS(TIZEN)
-void PageClientImpl::didStartProgress()
-{
- notImplemented();
-}
-
void PageClientImpl::didFirstVisuallyNonEmptyLayoutForMainFrame()
{
+ m_nonemptyLayoutRendered = true;
#if ENABLE(TIZEN_WEBKIT2_TILED_AC_SHARED_PLATFORM_SURFACE_BACKUP_IMAGE)
m_initialViewRect.setSize(viewSize());
#endif
}
-void PageClientImpl::didFinishLoadForMainFrame()
-{
- notImplemented();
-}
-
-void PageClientImpl::didFinishProgress()
-{
- notImplemented();
-}
-
void PageClientImpl::didChangeContentsSize(const WebCore::IntSize size)
{
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI(" [%d, %d]", size.width(), size.height());
+#endif
+#if USE(TILED_BACKING_STORE)
if (size.isEmpty())
return;
-#if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
- IntSize scaledSize = size;
- scaledSize.scale(scaleFactor());
-
- if (m_horizontalScrollbar)
- m_horizontalScrollbar->setProportion(viewSize().width(), scaledSize.width());
- if (m_verticalScrollbar)
- m_verticalScrollbar->setProportion(viewSize().height(), scaledSize.height());
-#endif
-
#if ENABLE(TIZEN_WEBKIT2_TILED_AC)
if (drawingArea()->layerTreeCoordinatorProxy())
drawingArea()->layerTreeCoordinatorProxy()->setContentsSize(WebCore::FloatSize(size.width(), size.height()));
#endif
- // FIXME: Currently minimum scale is recalculated by contents' width
- // if contents' width exceeds viewport layout width and userScalable is true.
- // But we should recalculate this when viewport argument's minimum scale is not fixed.
- // And minimumScaleByContentWidth shouldn't be smaller than 0.25(minimum zoom level)
- double previousMinimumScale = m_viewportConstraints.minimumScale;
- double minimumScaleByContentWidth = max(((double)viewSize().width() / size.width()), 0.25);
- double defaultViewLevel = m_page->pageGroup()->preferences()->defaultViewLevel();
-
- // If contents width exceeds viewport layout width and content is userScalable,
- // update minimumScale.
+ // if minimum scale factor is changed, update minimumScale.
if (m_viewportConstraints.userScalable) {
- m_viewportConstraints.minimumScale = minimumScaleByContentWidth;
+ double minimumScale = availableMinimumScale();
// Sometimes initializeVisibleContentRect can be called after content size change.
- // So, if initialScale is same to minimumScale, update initialScale too.
- if (fabs(m_viewportConstraints.initialScale - previousMinimumScale) < numeric_limits<float>::epsilon())
- m_viewportConstraints.initialScale = minimumScaleByContentWidth;
+ // So, if initialScale is not set explicitly in content's meta viewport tag and is same to minimumScale, update initialScale too.
+ if (!m_viewportConstraints.contentsDefinedInitialScale
+ && fabs(m_viewportConstraints.initialScale - m_viewportConstraints.minimumScale) < numeric_limits<float>::epsilon())
+ m_viewportConstraints.initialScale = minimumScale;
+ m_viewportConstraints.minimumScale = minimumScale;
}
-
- // If current scale factor was minimized, minimize new scale factor
- double newScaleFactor = scaleFactor();
- if (fabs(scaleFactor() - previousMinimumScale) < numeric_limits<float>::epsilon()
- && m_viewportConstraints.userScalable && !defaultViewLevel && m_pageDidRendered) {
- newScaleFactor = m_viewportConstraints.minimumScale;
-
-#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
-#if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
- if (!m_didRestoreVisibleContentRect)
- setVisibleContentRect(IntRect(m_visibleContentRect.location(), viewSize()), newScaleFactor);
#else
- setVisibleContentRect(IntRect(m_visibleContentRect.location(), viewSize()), newScaleFactor);
+ m_viewImpl->informContentsSizeChange(size);
#endif
-#else
- m_page->scalePage(newScaleFactor, m_visibleContentRect.location());
+ if (!m_pageDidRendered || m_viewImpl->page()->estimatedProgress() <= 0.1)
+ return;
+
+ // FIXME: Do we really need to adjust visible content rect at here?
+ // if contents size is changed smaller and visible content rect is outside of content area,
+ // adjust visible content rect
+ bool needScrollAdjustment = (adjustVisibleContentRect(m_visibleContentRect, scaleFactor()) != m_visibleContentRect);
+ bool needScaleAdjustment = (fabs(adjustScaleWithViewport(scaleFactor()) - scaleFactor()) > numeric_limits<float>::epsilon());
+ if (needScrollAdjustment || needScaleAdjustment) {
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI(" setVisibleContentRect: [%d, %d], [%.2f]", m_visibleContentRect.x(), m_visibleContentRect.y(), scaleFactor());
#endif
+ setVisibleContentRect(m_visibleContentRect, scaleFactor());
}
-
- // FIXME: If content's size is changed after calling setVisibleContentRect(),
- // we should call it again to adjust visible content rect.
- IntRect rect = m_visibleContentRect;
- adjustVisibleContentRect(rect, scaleFactor());
- if (m_pageDidRendered && rect != m_visibleContentRect)
- setVisibleContentRect(IntRect(m_visibleContentRect.location(), viewSize()), newScaleFactor);
-
- // After contents size is changed, update scroll bar.
- displayViewport();
-}
-
-void PageClientImpl::setRequestedScaleFactor(double scale)
-{
- m_requestedScaleFactor = scale;
}
void PageClientImpl::pageScaleFactorDidChange()
{
- ewk_view_focused_node_adjust(m_viewWidget);
-}
-
-#if ENABLE(TOUCH_EVENTS) && ENABLE(TIZEN_GESTURE)
-void PageClientImpl::cancelTouchEvent()
-{
- ewkViewHandleTouchEvent(m_viewWidget, EWK_TOUCH_CANCEL);
+ ewk_view_focused_node_adjust(m_viewImpl->view());
}
-#endif
#endif // #if OS(TIZEN)
void PageClientImpl::didCommitLoadForMainFrame(bool)
{
#if OS(TIZEN)
m_pageDidRendered = false;
-#if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
- m_didRestoreVisibleContentRect = false;
-#endif
+ m_viewportFitsToContent = false;
+ m_nonemptyLayoutRendered = false;
return;
#endif
notImplemented();
notImplemented();
}
+void PageClientImpl::updateTextInputState()
+{
+#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+ m_textSelection->update();
+ if (isTextSelectionMode() && isTextSelectionHandleDowned())
+ return;
+#endif
+
+ InputMethodContextEfl* inputMethodContext = m_viewImpl->inputMethodContext();
+ if (inputMethodContext)
+ inputMethodContext->updateTextInputState();
+}
+
void PageClientImpl::handleDownloadRequest(DownloadProxy* download)
{
- Ewk_Download_Job* ewkDownload = ewk_download_job_new(download, m_viewWidget);
- // For now we only support one default context, but once we support
- // multiple contexts, we will need to retrieve the context from the
- // view.
- ewk_context_download_job_add(ewk_context_default_get(), ewkDownload);
- ewk_download_job_unref(ewkDownload);
+ Ewk_Context* context = m_viewImpl->ewkContext();
+ context->downloadManager()->registerDownload(download, m_viewImpl);
}
#if USE(TILED_BACKING_STORE)
void PageClientImpl::pageDidRequestScroll(const IntPoint& point)
{
-#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
- // If requested point is same to current point, ignore this.
- IntPoint currentPoint(m_visibleContentRect.location().x() / scaleFactor(), m_visibleContentRect.location().y() / scaleFactor());
- if (point == currentPoint)
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+ Ewk_View_Smart_Data* smartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(m_viewImpl->view()));
+ if (smartData->api->formdata_candidate_is_showing(smartData))
return;
-
+#endif
+#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
IntPoint newPoint = point;
newPoint.scale(scaleFactor(), scaleFactor());
- setVisibleContentRect(IntRect(newPoint, viewSize()), scaleFactor());
- displayViewport();
+#if ENABLE(TIZEN_WEBKIT2_BEFORE_PAGE_RENDERED_SCROLL_POSITION)
+ if (!m_pageDidRendered)
+ m_scrollPositionBeforePageRendered = newPoint;
+ else
+ setVisibleContentRect(IntRect(newPoint, m_visibleContentRect.size()), scaleFactor());
+#else
+ setVisibleContentRect(IntRect(newPoint, m_visibleContentRect.size()), scaleFactor());
#endif
-#if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
- updateScrollbar();
#endif
}
#endif
#if ENABLE(TIZEN_WEBKIT2_HISTORICAL_RESTORE_VISIBLE_CONTENT_RECT)
void PageClientImpl::pageDidRequestRestoreVisibleContentRect(const IntPoint& point, float scale)
{
- IntPoint scaledPoint = point;
- scaledPoint.scale(scale, scale);
- setVisibleContentRect(IntRect(scaledPoint, viewSize()), scale);
- m_didRestoreVisibleContentRect = true;
-}
+ m_restoredScrollPosition = point;
+ m_restoredScrollPosition.scale(scale, scale);
+ m_restoredScaleFactor = scale;
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI("scroll position: [%d, %d], scale factor: [%.2f]", m_restoredScrollPosition.x(), m_restoredScrollPosition.y(), m_restoredScaleFactor);
#endif
-#if ENABLE(TIZEN_ISF_PORT)
-void PageClientImpl::updateTextInputState()
-{
-#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
- m_textSelection->update();
-#endif
+ // Before contents size is fixed, just update visible content rect's position
+ m_visibleContentRect.setLocation(m_restoredScrollPosition);
}
#endif
-#if ENABLE(TIZEN_ISF_PORT)
-void PageClientImpl::setInputMethodState(bool active, const String& type, const String& value)
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+void PageClientImpl::textChangeInTextField(const String& name, const String& value)
{
- if (!active) {
- ewk_view_imf_context_hide(m_viewWidget);
- LOG(ISF, "- Keypad status : hide\n");
- return;
- }
-
- Ewk_Settings* settings = ewk_view_settings_get(m_viewWidget);
- bool defaultKeypadEnabled = ewk_settings_default_keypad_enabled_get(settings);
-
-#if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
- if (m_clipboardHelper->isClipboardWindowOpened()) {
- LOG(ISF, "[FAIL] Clipboard\n");
- return;
- }
-#endif
-
- LOG(ISF, "- Type (%s), Value (%s)\n", type.utf8().data(), value.utf8().data());
-
-#if ENABLE(TIZEN_INPUT_TAG_EXTENSION)
- if (type == "date") {
- ewkViewInputPickerRequest(m_viewWidget, EWK_INPUT_TYPE_DATE, value);
- return;
- } else if (type == "datetime") {
- ewkViewInputPickerRequest(m_viewWidget, EWK_INPUT_TYPE_DATETIME, value);
- return;
- } else if (type == "datetime-local") {
- ewkViewInputPickerRequest(m_viewWidget, EWK_INPUT_TYPE_DATETIMELOCAL, value);
- return;
- } else if (type == "month") {
- ewkViewInputPickerRequest(m_viewWidget, EWK_INPUT_TYPE_MONTH, value);
- return;
- } else if (type == "time") {
- ewkViewInputPickerRequest(m_viewWidget, EWK_INPUT_TYPE_TIME, value);
- return;
- } else if (type == "week") {
- ewkViewInputPickerRequest(m_viewWidget, EWK_INPUT_TYPE_WEEK, value);
- return;
- }
-
-#if ENABLE(TIZEN_DATALIST_ELEMENT)
- Vector<String> optionList = page()->getFocusedInputElementDataList();
- if (optionList.size() > 0) {
- if (type == "tel")
- ewkViewDataListShowRequest(m_viewWidget, EWK_INPUT_TYPE_TELEPHONE, optionList);
- else if (type == "number")
- ewkViewDataListShowRequest(m_viewWidget, EWK_INPUT_TYPE_NUMBER, optionList);
- else if (type == "email")
- ewkViewDataListShowRequest(m_viewWidget, EWK_INPUT_TYPE_EMAIL, optionList);
- else if (type == "url")
- ewkViewDataListShowRequest(m_viewWidget, EWK_INPUT_TYPE_URL, optionList);
- else
- ewkViewDataListShowRequest(m_viewWidget, EWK_INPUT_TYPE_TEXT, optionList);
-
- return;
- }
-#endif // ENABLE(TIZEN_DATALIST_ELEMENT)
-#endif // ENABLE(TIZEN_INPUT_TAG_EXTENSION)
-
- bool hasFocus = evas_object_focus_get(m_viewWidget);
-
- if (!defaultKeypadEnabled) {
- ewk_view_imf_context_destroy(m_viewWidget);
- if (hasFocus) {
- Eina_Rectangle dummyRectForCustomKeypadCallback;
- memset(&dummyRectForCustomKeypadCallback, 0, sizeof(Eina_Rectangle));
- evas_object_smart_callback_call(m_viewWidget, "inputmethod,changed", &dummyRectForCustomKeypadCallback);
- }
+ if (value == m_formDataCandidate->getCandidateValue()) {
+ m_formDataCandidate->updateCandidateValue(emptyString());
return;
}
- Ecore_IMF_Input_Panel_Layout layout;
- if (type == "number")
- layout = ECORE_IMF_INPUT_PANEL_LAYOUT_NUMBER;
- else if (type == "email")
- layout = ECORE_IMF_INPUT_PANEL_LAYOUT_EMAIL;
- else if (type == "url")
- layout = ECORE_IMF_INPUT_PANEL_LAYOUT_URL;
- else if (type == "tel")
- layout = ECORE_IMF_INPUT_PANEL_LAYOUT_PHONENUMBER;
- else if (type == "password")
- layout = ECORE_IMF_INPUT_PANEL_LAYOUT_PASSWORD;
- else
- layout = ECORE_IMF_INPUT_PANEL_LAYOUT_NORMAL;
-
- Ecore_IMF_Context* imfContext = ewk_view_imf_context_set(m_viewWidget, layout);
- if (!imfContext)
- return;
-
- if (type == "password")
- ecore_imf_context_prediction_allow_set(imfContext, false);
- else
- ecore_imf_context_prediction_allow_set(imfContext, true);
-
- if (type.isEmpty() || type == "textarea")
- ecore_imf_context_autocapital_type_set(imfContext, ECORE_IMF_AUTOCAPITAL_TYPE_SENTENCE);
- else
- ecore_imf_context_autocapital_type_set(imfContext, ECORE_IMF_AUTOCAPITAL_TYPE_NONE);
-
- Evas* evas = evas_object_evas_get(m_viewWidget);
- ecore_imf_context_client_window_set(imfContext, (void*)ecore_evas_window_get(ecore_evas_ecore_evas_get(evas)));
- ecore_imf_context_client_canvas_set(imfContext, evas);
-
- if (!hasFocus)
- return;
-
- ecore_imf_context_focus_in(imfContext);
- ecore_imf_context_input_panel_show(imfContext);
- setCursorPosition();
-
- // input field zoom for external keyboard
- ewk_view_focused_node_adjust(m_viewWidget, EINA_TRUE);
-
- LOG(ISF, "- Keypad status : show\n");
-}
-#else
-void PageClientImpl::setInputMethodState(bool active)
-{
+ m_formDataCandidate->updateCandidateValue(value);
+ ewk_view_text_change_in_textfield(m_viewImpl->view(), name, value);
}
-#endif // #if ENABLE(TIZEN_ISF_PORT)
+#endif
-#if ENABLE(TIZEN_ISF_PORT)
-void PageClientImpl::setCursorPosition(int preeditPosition)
+void PageClientImpl::updateFormNavigation(int length, int offset)
{
- Ecore_IMF_Context* imfContext = ewk_view_imf_context_get(m_viewWidget);
- if (!imfContext)
- return;
-
- int offset = page()->getCursorOffsetPosition();
- ecore_imf_context_cursor_position_set(imfContext, offset);
- LOG(ISF, "Cursor position : offset %d + preeditPosition %d\n", offset, preeditPosition);
+ notImplemented();
}
-void PageClientImpl::imContextCommitted(Ecore_IMF_Context* context, char* event)
+#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
+#if ENABLE(TIZEN_WEBKIT2_TILED_AC)
+DrawingAreaProxy* PageClientImpl::drawingArea() const
{
- LOG(ISF, "%s\n", __func__);
-
- if (!page()->focusedFrame() || !event)
- return;
-
- page()->confirmComposition(String::fromUTF8(event));
- LOG(ISF, "confirmComposition : (%s)\n", event);
-
- setCursorPosition();
+ return m_viewImpl->page()->drawingArea();
}
+#endif
-void PageClientImpl::imContextPreeditChanged(Ecore_IMF_Context* context)
+// Before rendering, scale factor and scroll position is different from m_viewImpl.
+float PageClientImpl::scaleFactor()
{
- LOG(ISF, "%s\n", __func__);
-
- if (!page()->focusedFrame())
- return;
-
- char* preeditStr = 0;
- int cursorPosition = 0;
-
- ecore_imf_context_preedit_string_get(context, &preeditStr, &cursorPosition);
- if (!preeditStr)
- return;
-
- if (!cursorPosition) {
- free(preeditStr);
- return;
- }
-
- IntRect caretRect(0, 0, 0, 0);
- page()->getCaretPosition(caretRect);
- caretRect.scale(scaleFactor());
-
- int viewX, viewY;
- evas_object_geometry_get(m_viewWidget, &viewX, &viewY, 0, 0);
-
- int x = caretRect.x() - scrollPosition().x() + viewX;
- int y = caretRect.y() - scrollPosition().y() + viewY;
- int w = caretRect.width();
- int h = caretRect.height();
- ecore_imf_context_cursor_location_set(context, x, y, w, h);
-
- int offset = page()->getCursorOffsetPosition();
-
- String preeditString = String::fromUTF8(preeditStr);
- free(preeditStr);
-
- Vector<CompositionUnderline> underlines;
- underlines.append(CompositionUnderline(0, preeditString.length(), Color(0, 0, 0), false));
- page()->setComposition(preeditString, underlines, offset + cursorPosition);
- LOG(ISF, "setComposition : %s\n", preeditStr);
-
- setCursorPosition(cursorPosition);
+ return m_pageDidRendered ? m_viewImpl->scaleFactor() : (m_restoredScaleFactor ? m_restoredScaleFactor : m_viewportConstraints.initialScale);
}
-#endif // #if ENABLE(TIZEN_ISF_PORT)
-void PageClientImpl::updateFormNavigation(int length, int offset)
+const IntPoint PageClientImpl::scrollPosition()
{
- notImplemented();
+ return m_pageDidRendered ? m_viewImpl->scrollPosition() : (m_restoredScaleFactor ? m_restoredScrollPosition : IntPoint());
}
-#if ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
-void PageClientImpl::adjustVisibleContentRect(IntRect& visibleContentRect, float targetScale)
+IntRect PageClientImpl::adjustVisibleContentRect(IntRect visibleContentRect, float targetScale)
{
- IntSize contentsSize = page()->contentsSize();
+ IntSize contentsSize = m_viewImpl->page()->contentsSize();
contentsSize.scale(targetScale);
- if (visibleContentRect.x() > contentsSize.width() - visibleContentRect.width())
- visibleContentRect.setX(contentsSize.width() - visibleContentRect.width());
- if (visibleContentRect.x() < 0)
+ if (contentsSize.width() < visibleContentRect.width())
visibleContentRect.setX(0);
- if (visibleContentRect.y() > contentsSize.height() - visibleContentRect.height())
- visibleContentRect.setY(contentsSize.height() - visibleContentRect.height());
- if (visibleContentRect.y() < 0)
+ else
+ visibleContentRect.setX(clampTo(visibleContentRect.x(), 0, contentsSize.width() - visibleContentRect.width()));
+
+ if (contentsSize.height() < visibleContentRect.height())
visibleContentRect.setY(0);
+ else
+ visibleContentRect.setY(clampTo(visibleContentRect.y(), 0, contentsSize.height() - visibleContentRect.height()));
+ return visibleContentRect;
}
void PageClientImpl::setVisibleContentRect(const IntRect& newRect, float newScale, const FloatPoint& trajectory)
{
- newScale = adjustScaleWithViewport(newScale);
- if (fabs(m_scaleFactor - newScale) >= numeric_limits<double>::epsilon()) {
- m_scaleFactor = newScale;
- if (m_pageDidRendered)
- m_scaleFactorForDrawContents = m_scaleFactor;
- m_viewImpl->setScaleFactor(newScale);
- }
+#if OS(TIZEN)
+ IntPoint previousScrollPosition(scrollPosition());
+ float previousScale = m_scaleFactor;
+#endif
+
+ m_scaleFactor = adjustScaleWithViewport(newScale);
+ m_viewportFitsToContent = fabs(m_scaleFactor - m_viewportConstraints.minimumScale) < numeric_limits<float>::epsilon();
+ m_visibleContentRect.setLocation(newRect.location());
+ m_visibleContentRect = adjustVisibleContentRect(m_visibleContentRect, m_scaleFactor);
+ // update both drawing scale factor and scroll position after page is rendered
if (m_pageDidRendered) {
- m_visibleContentRectForDrawContents = newRect;
- adjustVisibleContentRect(m_visibleContentRectForDrawContents, newScale);
- m_viewImpl->setScrollPosition(m_visibleContentRectForDrawContents.location());
+ if (!m_hasSuspendedContent) {
+ // FIXME: We have to update EwkViewImpl's scale and position here because we use them to draw contents.
+ // PageViewport's values are updated when resuming content in the webkit opensource,
+ // but we have to update viewImpl's values here to sync with PageClient's values.
+ // However, We should not update them when hasSuspendedContent is true in order to maintain last values.
+ // The values will be updated when resuming content.
+ // Below codes should be refactored when PageViewportController codes are merged into Tizen.
+ m_viewImpl->setScaleFactor(m_scaleFactor);
+ m_viewImpl->setScrollPosition(m_visibleContentRect.location());
+ }
}
- m_visibleContentRect.setLocation(m_visibleContentRectForDrawContents.location());
// enclosingIntRect produces inconsistent width and height when scale factor is not 1.
// So we removed enclosingIntRect and replaced with floorf and ceilf.
- IntRect mapToContentsVisibleContentRect = IntRect(floorf(m_visibleContentRect.x() / newScale),
- floorf(m_visibleContentRect.y() / newScale),
- ceilf(m_visibleContentRect.width() / newScale),
- ceilf(m_visibleContentRect.height() / newScale));
-
+ IntRect mapToContentsVisibleContentRect = IntRect(floorf(m_visibleContentRect.x() / m_scaleFactor),
+ floorf(m_visibleContentRect.y() / m_scaleFactor),
+ ceilf(m_visibleContentRect.width() / m_scaleFactor),
+ ceilf(m_visibleContentRect.height() / m_scaleFactor));
if (!drawingArea())
return;
-
- drawingArea()->setVisibleContentsRect(mapToContentsVisibleContentRect, newScale, trajectory, FloatPoint(m_visibleContentRectForDrawContents.location()));
+ drawingArea()->setVisibleContentsRect(mapToContentsVisibleContentRect, m_scaleFactor, trajectory, FloatPoint(m_viewImpl->scrollPosition()));
#if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
// FIXME: We need to calculate exact visibleRect size here instead of mapToContentsVisibleContentRect.
drawingArea()->setVisibleContentsRectForScrollingContentsLayers(mapToContentsVisibleContentRect);
#endif
-#if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
- updateScrollbar();
+ displayViewport();
+
+#if OS(TIZEN)
+ if (scrollPosition() != previousScrollPosition || m_scaleFactor != previousScale)
+ m_viewImpl->didChangeScrollAndScale(previousScrollPosition, previousScale);
+#endif
+
+#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
+ if (!isClipboardWindowOpened())
+ updateTextSelectionHandlesAndContextMenu(true);
#endif
}
void PageClientImpl::drawContents(BackingStore::PlatformGraphicsContext context)
{
- m_visibleContentRectForDrawContents.setSize(viewSize());
-
cairo_save(context);
- cairo_translate(context, -m_visibleContentRectForDrawContents.x(), -m_visibleContentRectForDrawContents.y());
- cairo_scale(context, m_scaleFactorForDrawContents, m_scaleFactorForDrawContents);
+ const cairo_matrix_t matrix = cairo_matrix_t(m_viewImpl->transformToView());
+ cairo_transform(context, &matrix);
if (drawingArea()) {
if (drawingArea()->layerTreeCoordinatorProxy()) {
WebLayerTreeRenderer* renderer = drawingArea()->layerTreeCoordinatorProxy()->layerTreeRenderer();
- renderer->paintToGraphicsContext(context);
+ renderer->paintToGraphicsContext(context, m_bgColor);
}
}
{
#if OS(TIZEN) && ENABLE(FULLSCREEN_API)
// We don't want to process scaling in the FullScreen mode.
- if (page()->fullScreenManager()->isFullScreen())
+ if (m_viewImpl->page()->fullScreenManager()->isFullScreen())
return;
#endif
// Adjust scaleFactor.
#if ENABLE(TIZEN_WEBKIT2_TEXT_ZOOM)
- if (!page()->pageGroup()->preferences()->textZoomEnabled())
+ if (!m_viewImpl->page()->pageGroup()->preferences()->textZoomEnabled())
scaleFactor = adjustScaleWithViewport(scaleFactor);
#else
scaleFactor = adjustScaleWithViewport(scaleFactor);
{
#if OS(TIZEN) && ENABLE(FULLSCREEN_API)
// We don't want to process scaling in the FullScreen mode.
- if (page()->fullScreenManager()->isFullScreen())
+ if (m_viewImpl->page()->fullScreenManager()->isFullScreen())
return;
#endif
scaleFactor = adjustScaleWithViewport(scaleFactor);
- setVisibleContentRect(IntRect(origin, viewSize()), scaleFactor);
+ setVisibleContentRect(IntRect(origin, m_visibleContentRect.size()), scaleFactor);
+}
+
+// FIXME: The concept of suspending content comes from webkit opensource's PageViewportController,
+// so below code should be replaced when PageViewportController codes are merged.
+// Please do not use below codes. They are only for scaling contents.
+void PageClientImpl::suspendContent()
+{
+ if (m_hasSuspendedContent)
+ return;
+
+ m_hasSuspendedContent = true;
+}
+
+void PageClientImpl::resumeContent()
+{
+ if (!m_hasSuspendedContent)
+ return;
+
+#if ENABLE(TIZEN_DLOG_SUPPORT)
+ TIZEN_LOGI("scroll position: [%d, %d], scale factor: [%.2f]", m_viewImpl->scrollPosition().x(), m_viewImpl->scrollPosition().y(), m_viewImpl->scaleFactor());
+#endif
+
+ // FIXME: Update visibleContentRect with m_viewImpl after resuming content.
+ // The concept is that the values of EwkViewImpl and PageClient can be different
+ // during suspending content and they become same when content is resumed.
+ // Below codes should be refactored when PageViewportController codes are merged into Tizen.
+ setVisibleContentRect(IntRect(m_viewImpl->scrollPosition(), m_visibleContentRect.size()), m_viewImpl->scaleFactor());
+ m_hasSuspendedContent = false;
+}
+
+FloatPoint PageClientImpl::boundContentsPositionAtScale(const FloatPoint& framePosition, float scale)
+{
+ // We need to floor the viewport here as to allow aligning the content in device units. If not,
+ // it might not be possible to scroll the last pixel and that affects fixed position elements.
+ FloatRect bounds;
+ const IntSize& contentsSize = m_viewImpl->page()->contentsSize();
+ bounds.setWidth(std::max(0.f, contentsSize.width() - floorf(viewSize().width() / scale)));
+ bounds.setHeight(std::max(0.f, contentsSize.height() - floorf(viewSize().height() / scale)));
+
+ FloatPoint position;
+ // Unfortunately it doesn't seem to be enough, so just always allow one pixel more.
+ position.setX(clampTo(framePosition.x(), bounds.x(), bounds.width() + 1));
+ position.setY(clampTo(framePosition.y(), bounds.y(), bounds.height() + 1));
+
+ return position;
}
#if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
{
// create if needed.
if (horizontalBar && !m_horizontalScrollbar) {
- m_horizontalScrollbar = MainFrameScrollbarTizen::createNativeScrollbar(m_viewWidget, HorizontalScrollbar);
+ m_horizontalScrollbar = MainFrameScrollbarTizen::createNativeScrollbar(m_viewImpl->view(), HorizontalScrollbar);
IntRect hBarRect(0, viewSize().height(), viewSize().width(), 0);
m_horizontalScrollbar->setFrameRect(hBarRect);
} else if (!horizontalBar && m_horizontalScrollbar)
m_horizontalScrollbar = 0;
if (verticalBar && !m_verticalScrollbar) {
- m_verticalScrollbar = MainFrameScrollbarTizen::createNativeScrollbar(m_viewWidget, VerticalScrollbar);
+ m_verticalScrollbar = MainFrameScrollbarTizen::createNativeScrollbar(m_viewImpl->view(), VerticalScrollbar);
IntRect vBarRect(viewSize().width(), 0, 0, viewSize().height());
m_verticalScrollbar->setFrameRect(vBarRect);
} else if (!verticalBar && m_verticalScrollbar)
void PageClientImpl::updateScrollbar()
{
- IntSize scaledContentsSize = m_page->contentsSize();
+ IntSize scaledContentsSize = m_viewImpl->page()->contentsSize();
scaledContentsSize.scale(scaleFactor());
bool newHasHorizontalScrollbar = false;
if (m_horizontalScrollbar) {
m_horizontalScrollbar->setProportion(viewSize().width(), scaledContentsSize.width());
- m_horizontalScrollbar->setPosition(m_visibleContentRectForDrawContents.x());
+ m_horizontalScrollbar->setPosition(m_viewImpl->scrollPosition().x());
}
if (m_verticalScrollbar) {
m_verticalScrollbar->setProportion(viewSize().height(), scaledContentsSize.height());
- m_verticalScrollbar->setPosition(m_visibleContentRectForDrawContents.y());
+ m_verticalScrollbar->setPosition(m_viewImpl->scrollPosition().y());
}
}
#endif // ENABLE(TIZEN_WEBKIT2_TILED_BACKING_STORE)
#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
-bool PageClientImpl::isTextSelectionEnable()
-{
- return m_textSelection->isTextSelectionEnable();
-}
-
-void PageClientImpl::setIsTextSelectionEnable(bool isTextSelectionEnable)
-{
- m_textSelection->setIsTextSelectionEnable(isTextSelectionEnable);
-}
-
bool PageClientImpl::isTextSelectionDowned()
{
return m_textSelection->isTextSelectionDowned();
m_textSelection->setIsTextSelectionMode(isTextSelectionMode);
}
-bool PageClientImpl::autoClearTextSelectionMode()
-{
- return m_textSelection->autoClearTextSelectionMode();
-}
-
-void PageClientImpl::setAutoClearTextSelectionMode(bool autoClearTextSelectionMode)
-{
- m_textSelection->setAutoClearTextSelectionMode(autoClearTextSelectionMode);
-}
-
void PageClientImpl::updateTextSelectionHandlesAndContextMenu(bool isShow, bool isScrolling)
{
- if (m_textSelection->isTextSelectionMode() && evas_object_focus_get(m_viewWidget))
+ if (m_textSelection->isTextSelectionMode() && evas_object_focus_get(m_viewImpl->view()))
m_textSelection->updateHandlesAndContextMenu(isShow, isScrolling);
}
-bool PageClientImpl::textSelectionDown(const WebCore::IntPoint& point, bool isStartedTextSelectionFromOutside)
+bool PageClientImpl::textSelectionDown(const WebCore::IntPoint& point)
{
-#if ENABLE(TOUCH_EVENTS) && ENABLE(TIZEN_GESTURE)
- cancelTouchEvent();
-#endif
-
- if (!evas_object_focus_get(m_viewWidget)) {
- Ecore_IMF_Context* imfContext = ewk_view_imf_context_get(m_viewWidget);
- if (imfContext && (ecore_imf_context_input_panel_state_get(imfContext) == ECORE_IMF_INPUT_PANEL_STATE_HIDE))
- ewk_view_imf_context_hide(m_viewWidget);
+ if (!evas_object_focus_get(m_viewImpl->view())) {
+ InputMethodContextEfl* inputMethodContext = m_viewImpl->inputMethodContext();
+ if (inputMethodContext)
+ inputMethodContext->hideIMFContext();
- evas_object_focus_set(m_viewWidget, true);
+ evas_object_focus_set(m_viewImpl->view(), true);
}
- return m_textSelection->textSelectionDown(point, isStartedTextSelectionFromOutside);
+ return m_textSelection->textSelectionDown(point);
}
-void PageClientImpl::textSelectionMove(const WebCore::IntPoint& point, bool isStartedTextSelectionFromOutside)
+void PageClientImpl::textSelectionMove(const WebCore::IntPoint& point)
{
- m_textSelection->textSelectionMove(point, isStartedTextSelectionFromOutside);
+ m_textSelection->textSelectionMove(point);
}
void PageClientImpl::textSelectionUp(const WebCore::IntPoint& point, bool isStartedTextSelectionFromOutside)
m_textSelection->textSelectionHandleUp();
}
#endif
+
+void PageClientImpl::requestToShowTextSelectionHandlesAndContextMenu()
+{
+ m_textSelection->requestToShow();
+}
+
+void PageClientImpl::initTextSelectionHandlesMouseDownedStatus()
+{
+ m_textSelection->initHandlesMouseDownedStatus();
+}
+
+void PageClientImpl::changeContextMenuPosition(IntPoint& point)
+{
+ m_textSelection->changeContextMenuPosition(point);
+}
#endif
-#if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
-static void clipboarDataCallbackForContextMenu(const String& data, const String& type, void* context)
+#if ENABLE(TIZEN_OFFLINE_PAGE_SAVE)
+void PageClientImpl::saveSerializedHTMLDataForMainPage(const String& serializedData, const String& fileName)
+{
+ m_offlinePageSave->saveSerializedHTMLDataForMainPage(serializedData, fileName);
+}
+
+void PageClientImpl::saveSubresourcesData(Vector<WebSubresourceTizen>& subresourceData)
+{
+ m_offlinePageSave->saveSubresourcesData(subresourceData);
+}
+
+void PageClientImpl::startOfflinePageSave(String& path, String& url, String& title)
{
- PageClientImpl* pageClient = static_cast<PageClientImpl*>(context);
- pageClient->page()->didSelectPasteMenuFromContextMenu(data, type);
+ m_offlinePageSave->startOfflinePageSave(path, url, title);
}
+#endif
+#if ENABLE(TIZEN_WEBKIT2_CLIPBOARD_HELPER)
void PageClientImpl::pasteContextMenuSelected()
{
- m_clipboardHelper->requestData(this, clipboarDataCallbackForContextMenu);
+ m_clipboardHelper->pasteClipboardLastItem(m_viewImpl->page()->editorState().isContentRichlyEditable);
}
#endif
#if ENABLE(TIZEN_WEBKIT2_CONTEXT_MENU_CLIPBOARD)
void PageClientImpl::clipboardContextMenuSelected()
{
- if(page()->editorState().isContentEditable)
- m_clipboardHelper->openClipboardWindow(page()->editorState().isContentRichlyEditable);
+ m_clipboardHelper->openClipboardWindow(m_viewImpl->page()->editorState().isContentRichlyEditable);
}
bool PageClientImpl::isClipboardWindowOpened()
return m_clipboardHelper->isClipboardWindowOpened();
}
-void PageClientImpl::clearClipboardSelectionClearHandler()
+void PageClientImpl::closeClipboardWindow()
{
- m_clipboardHelper->clearClipboardSelectionClearHandler();
+ m_clipboardHelper->closeClipboardWindow();
}
#endif
void PageClientImpl::setIsVisible(bool isVisible)
{
#if ENABLE(TIZEN_WEBKIT2_TILED_AC_SHARED_PLATFORM_SURFACE_BACKUP_IMAGE)
- if (m_isVisible != isVisible && m_viewWidget && m_pageDidRendered) {
+ if (m_isVisible != isVisible && m_viewImpl->view() && m_pageDidRendered) {
if (!isVisible && (drawingArea() && drawingArea()->layerTreeCoordinatorProxy()) && !m_shouldShowBackupTexture) {
- m_shouldMakeBackupTexture = true;
- m_shouldShowBackupTexture = true;
- drawContents();
+ Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_viewImpl->view()));
+ int angle = ecore_evas_rotation_get(ee);
+ if (angle == 0 || angle == 180) {
+ m_shouldMakeBackupTexture = true;
+ m_shouldShowBackupTexture = true;
+ drawContents();
+ }
}
}
#endif
m_isVisible = isVisible;
- if (m_page)
- m_page->viewStateDidChange(WebPageProxy::ViewIsVisible);
+ WebPageProxy* pageProxy = m_viewImpl->page();
+ if (pageProxy)
+ pageProxy->viewStateDidChange(WebPageProxy::ViewIsVisible);
#if ENABLE(TIZEN_CACHE_MEMORY_OPTIMIZATION)
if (!m_isVisible)
- ewk_context_decoded_data_clear_all(ewk_view_context_get(m_viewWidget));
+ ewk_view_context_get(m_viewImpl->view())->clearAllDecodedData();
#endif
}
#endif
m_drag->getDragPoint(), dragData.draggingSourceOperationMask(), dragData.flags());
String dragStorageName("Drag");
- m_page->dragEntered(dragInfo, dragStorageName);
+ m_viewImpl->page()->dragEntered(dragInfo, dragStorageName);
setDragMode(true);
- m_drag->setDragData(dragInfo);
+ m_drag->setDragData(dragInfo, dragImage);
m_drag->Show();
}
#endif
+#if ENABLE(TIZEN_WEBKIT2_FORM_DATABASE)
+bool PageClientImpl::isShowingFormDataCandidate()
+{
+ return m_formDataCandidate->isShowing();
+}
+
+void PageClientImpl::updateFormDataCandidate(const Vector<String>& data)
+{
+ m_formDataCandidate->updateFormData(data);
+}
+
+void PageClientImpl::hideFormDataCandidate()
+{
+ m_formDataCandidate->hide();
+}
+
+void PageClientImpl::showFormDataCandidate(const WebCore::IntRect& rect)
+{
+ m_formDataCandidate->show(rect);
+}
+#endif
+
#if ENABLE(TIZEN_REGISTER_PROTOCOL_HANDLER)
void PageClientImpl::registerProtocolHandler(const String& scheme, const String& baseURL, const String& url, const String& title)
{
- ewkViewRegisterProtocolHandlers(m_viewWidget, scheme.utf8().data(), baseURL.utf8().data(), url.utf8().data(), title.utf8().data());
+ ewkViewRegisterProtocolHandlers(m_viewImpl->view(), scheme.utf8().data(), baseURL.utf8().data(), url.utf8().data(), title.utf8().data());
}
#endif
#if ENABLE(TIZEN_CUSTOM_SCHEME_HANDLER)
unsigned int PageClientImpl::isProtocolHandlerRegistered(const String& scheme, const String& baseURL, const String& url)
{
- return ewkViewIsProtocolHandlerRegistered(m_viewWidget, scheme.utf8().data(), baseURL.utf8().data(), url.utf8().data());
+ return ewkViewIsProtocolHandlerRegistered(m_viewImpl->view(), scheme.utf8().data(), baseURL.utf8().data(), url.utf8().data());
}
void PageClientImpl::unregisterProtocolHandler(const String& scheme, const String& baseURL, const String& url)
{
- ewkViewUnregisterProtocolHandlers(m_viewWidget, scheme.utf8().data(), baseURL.utf8().data(), url.utf8().data());
+ ewkViewUnregisterProtocolHandlers(m_viewImpl->view(), scheme.utf8().data(), baseURL.utf8().data(), url.utf8().data());
}
#endif
#if ENABLE(TIZEN_REGISTER_CONTENT_HANDLER)
void PageClientImpl::registerContentHandler(const String& mimeType, const String& baseURL, const String& url, const String& title)
{
- ewkViewRegisterContentHandlers(m_viewWidget, mimeType.utf8().data(), baseURL.utf8().data(), url.utf8().data(), title.utf8().data());
+ ewkViewRegisterContentHandlers(m_viewImpl->view(), mimeType.utf8().data(), baseURL.utf8().data(), url.utf8().data(), title.utf8().data());
}
unsigned int PageClientImpl::isContentHandlerRegistered(const String& mimeType, const String& baseURL, const String& url)
{
- return ewkViewIsContentHandlerRegistered(m_viewWidget, mimeType.utf8().data(), baseURL.utf8().data(), url.utf8().data());
+ return ewkViewIsContentHandlerRegistered(m_viewImpl->view(), mimeType.utf8().data(), baseURL.utf8().data(), url.utf8().data());
}
void PageClientImpl::unregisterContentHandler(const String& mimeType, const String& baseURL, const String& url)
{
- ewkViewUnregisterContentHandlers(m_viewWidget, mimeType.utf8().data(), baseURL.utf8().data(), url.utf8().data());
+ ewkViewUnregisterContentHandlers(m_viewImpl->view(), mimeType.utf8().data(), baseURL.utf8().data(), url.utf8().data());
}
#endif
#if ENABLE(TIZEN_SEARCH_PROVIDER)
void PageClientImpl::addSearchProvider(const String& baseURL, const String& engineURL)
{
- ewkViewAddSearchProvider(m_viewWidget, baseURL.utf8().data(), engineURL.utf8().data());
+ ewkViewAddSearchProvider(m_viewImpl->view(), baseURL.utf8().data(), engineURL.utf8().data());
}
unsigned long PageClientImpl::isSearchProviderInstalled(const String& baseURL, const String& engineURL)
{
- return ewkViewIsSearchProviderInstalled(m_viewWidget, baseURL.utf8().data(), engineURL.utf8().data());
+ return ewkViewIsSearchProviderInstalled(m_viewImpl->view(), baseURL.utf8().data(), engineURL.utf8().data());
}
#endif
#if ENABLE(TIZEN_SUPPORT_WEBAPP_META_TAG)
bool PageClientImpl::getStandaloneStatus()
{
- return ewkViewGetStandaloneStatus(m_viewWidget);
+ return ewkViewGetStandaloneStatus(m_viewImpl->view());
}
#endif
#if ENABLE(SCREEN_ORIENTATION_SUPPORT) && ENABLE(TIZEN_SCREEN_ORIENTATION_SUPPORT)
bool PageClientImpl::lockOrientation(int willLockOrientation)
{
- return ewk_view_orientation_lock(m_viewWidget, willLockOrientation);
+ return ewk_view_orientation_lock(m_viewImpl->view(), willLockOrientation);
}
void PageClientImpl::unlockOrientation()
{
- ewk_view_orientation_unlock(m_viewWidget);
+ ewk_view_orientation_unlock(m_viewImpl->view());
}
#endif
m_shouldShowBackupTexture = false;
#endif
if (!m_pageDidRendered) {
- m_visibleContentRectForDrawContents.setLocation(m_visibleContentRect.location());
- m_viewImpl->setScrollPosition(m_visibleContentRectForDrawContents.location());
- m_scaleFactorForDrawContents = m_scaleFactor;
- // adjustPositionForFixedLayers is calclulated based on m_visibleContentRectForDrawContents values which initially set.
- // We need to set this values here, otherwise while navigating to new page, m_accurateVisibleContentsPosition will be having the previous scrolled position
- // which makes positioning of the FixedLayer on wrong place
- drawingArea()->setAccurateVisibleContentsPosition(FloatPoint(m_visibleContentRectForDrawContents.location()));
-
m_pageDidRendered = true;
initializeVisibleContentRect();
}
+
+#if ENABLE(TIZEN_PRERENDERING_FOR_ROTATION)
+ if (m_waitFrameOfNewViewortSize) {
+ m_waitFrameOfNewViewortSize = false;
+ ewkViewRotatePrepared(m_viewImpl->view());
+ }
+#endif
}
#if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION)
if (pressed) {
if (webLayerID) {
setIsScrollableLayerFocused(true);
- m_page->drawingArea()->layerTreeCoordinatorProxy()->layerTreeRenderer()->setFocusedLayerID(webLayerID);
+ m_viewImpl->page()->drawingArea()->layerTreeCoordinatorProxy()->layerTreeRenderer()->setFocusedLayerID(webLayerID);
} else {
setIsScrollableNodeFocused(true);
}
void PageClientImpl::findScrollableNode(const IntPoint& point)
{
- if (m_page && m_page->isLoadingFinished() && m_page->askOverflow()) {
+ WebPageProxy* pageProxy = m_viewImpl->page();
+ if (pageProxy && pageProxy->isLoadingFinished() && pageProxy->askOverflow()) {
IntPoint pointForPress(m_viewImpl->transformFromScene().mapPoint(point));
WebLayerID webLayerID = 0;
bool checkOverflowLayer = false;
#if ENABLE(TIZEN_CSS_OVERFLOW_SCROLL_ACCELERATION_ON_UI_SIDE)
- DrawingAreaProxy* drawingArea = m_page->drawingArea();
+ DrawingAreaProxy* drawingArea = pageProxy->drawingArea();
checkOverflowLayer = drawingArea && drawingArea->layerTreeCoordinatorProxy() && drawingArea->layerTreeCoordinatorProxy()->hasOverflowLayer();
#endif
- setOverflowResult(m_page->setPressedNodeAtPoint(pointForPress, checkOverflowLayer, webLayerID), webLayerID);
- }
-}
-#endif
-
-#if ENABLE(TIZEN_WEBKIT2_GET_TEXT_STYLE_FOR_SELECTION)
-void PageClientImpl::didGetTextStyleStateForSelection(int underlineState, int italicState, int boldState)
-{
- WebCore::IntPoint startPoint, endPoint;
- WebCore::IntRect leftRect, rightRect;
-
- WebCore::IntRect caretRect;
- page()->getCaretPosition(caretRect);
- if (!caretRect.isEmpty()) {
- startPoint.setX(caretRect.x());
- startPoint.setY(caretRect.y() + caretRect.height());
-
- endPoint.setX(caretRect.x() + caretRect.width());
- endPoint.setY(caretRect.y() + caretRect.height());
+ setOverflowResult(pageProxy->setPressedNodeAtPoint(pointForPress, checkOverflowLayer, webLayerID), webLayerID);
}
-#if ENABLE(TIZEN_WEBKIT2_TEXT_SELECTION)
- else if (page()->getSelectionHandlers(leftRect, rightRect)) {
- startPoint.setX(leftRect.x());
- startPoint.setY(leftRect.y() + leftRect.height());
-
- endPoint.setX(rightRect.x() + rightRect.width());
- endPoint.setY(rightRect.y() + rightRect.height());
- }
-#endif
-
- startPoint.scale(scaleFactor(), scaleFactor());
- endPoint.scale(scaleFactor(), scaleFactor());
-
- int viewPositionX, viewPositionY;
- evas_object_geometry_get(m_viewWidget, &viewPositionX, &viewPositionY, NULL, NULL);
-
- startPoint.move(-scrollPosition().x(), -scrollPosition().y());
- startPoint.move(viewPositionX, viewPositionY);
-
- endPoint.move(-scrollPosition().x(), -scrollPosition().y());
- endPoint.move(viewPositionX, viewPositionY);
-
- ewkViewDidGetTextStyleStateForSelection(m_viewWidget, underlineState, italicState, boldState, startPoint, endPoint);
}
#endif
void PageClientImpl::didFindZoomableArea(const IntPoint& target, const IntRect& area)
{
- ewk_view_zoomable_area_set(m_viewWidget, target, area);
+ ewk_view_zoomable_area_set(m_viewImpl->view(), target, area);
}
#if ENABLE(TIZEN_ICON_DATABASE)
void PageClientImpl::didReceiveIcon()
{
- ewkViewIconReceived(viewWidget());
+ ewkViewIconReceived(m_viewImpl->view());
+}
+#endif
+
+#if ENABLE(TIZEN_WEBKIT2_FOCUS_RING)
+void PageClientImpl::hideFocusRing()
+{
+ ewkViewFocusRingHide(m_viewImpl->view());
}
#endif
#endif // #if OS(TIZEN)
#if ENABLE(TIZEN_WEBKIT2_TILED_AC) && ENABLE(TIZEN_RUNTIME_BACKEND_SELECTION)
-PageClientEvasGL::PageClientEvasGL(WebContext* context, WebPageGroup* pageGroup, Evas_Object* viewWidget)
- : PageClientImpl(context, pageGroup, viewWidget)
+PageClientEvasGL::PageClientEvasGL(EwkViewImpl* viewImpl)
+ : PageClientImpl(viewImpl)
, m_evasGL(0)
, m_evasGlApi(0)
, m_context(0)
PageClientEvasGL::~PageClientEvasGL()
{
- m_page->close();
+ if (m_viewImpl && m_viewImpl->page())
+ m_viewImpl->page()->close();
+}
+
+void PageClientEvasGL::updateViewportSize(const WebCore::IntSize& viewportSize, const int angle)
+{
+ PageClientImpl::updateViewportSize(viewportSize, angle);
}
-void PageClientEvasGL::updateViewportSize(const WebCore::IntSize& viewportSize)
+void PageClientEvasGL::updateVisibleContentRectSize(const WebCore::IntSize& size)
{
if (m_surface) {
evas_gl_surface_destroy(m_evasGL, m_surface);
}
setTargetSurface();
- PageClientImpl::updateViewportSize(viewportSize);
+ PageClientImpl::updateVisibleContentRectSize(size);
}
void PageClientEvasGL::setViewNeedsDisplay(const WebCore::IntRect& rect)
{
-#if !ENABLE(TIZEN_WEBKIT2_DIRECT_RENDERING)
- drawContents();
+#if ENABLE(TIZEN_WEBKIT2_DIRECT_RENDERING)
+ if (!isDirectRendering())
#endif
- ewk_view_display(viewWidget(), rect);
+ drawContents();
+ m_viewImpl->redrawRegion(rect);
}
void PageClientEvasGL::displayViewport()
#if ENABLE(TIZEN_WEBKIT2_DIRECT_RENDERING)
// We should not draw here when Direct Rendering is enabled.
// Because we will draw directly when evas is updated - on_pixels_for_accelerated_compositing().
- ewk_view_mark_for_sync(m_viewWidget);
-#else
- setViewNeedsDisplay(IntRect(IntPoint(), viewSize()));
+ if (isDirectRendering())
+ ewk_view_mark_for_sync(m_viewImpl->view());
+ else
#endif
+ setViewNeedsDisplay(IntRect(IntPoint(), viewSize()));
#if ENABLE(TIZEN_WEBKIT2_TILED_SCROLLBAR)
updateScrollbar();
void PageClientEvasGL::drawContents()
{
- if (!ewk_view_image_get(m_viewWidget))
+ if (!drawingArea() || !(drawingArea()->layerTreeCoordinatorProxy()) || !m_isVisible)
+ return;
+
+ WebLayerTreeRenderer* renderer = drawingArea()->layerTreeCoordinatorProxy()->layerTreeRenderer();
+ if (!renderer)
return;
- if (evas_gl_make_current(m_evasGL, m_surface, m_context) != EINA_TRUE)
+ if (!makeContextCurrent())
return;
WebCore::TransformationMatrix matrix;
IntRect clipRect;
-
- m_visibleContentRectForDrawContents.setSize(viewSize());
+ IntSize ewkViewSize = viewSize();
#if ENABLE(TIZEN_WEBKIT2_DIRECT_RENDERING)
- Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_viewWidget));
- int angle = ecore_evas_rotation_get(ee);
- m_angle = angle;
- if (drawingArea())
- drawingArea()->setAngle(m_angle);
- matrix.makeIdentity();
- matrix.rotate3d(0.0, 0.0, 1.0, 360 - m_angle);
- if (m_angle == 90 || m_angle == 270) {
- glViewport(0, 0, m_visibleContentRectForDrawContents.height(), m_visibleContentRectForDrawContents.width());
- if (m_angle == 90)
- matrix.translate(-m_visibleContentRectForDrawContents.x() -m_visibleContentRectForDrawContents.width(), -m_visibleContentRectForDrawContents.y());
- else if (m_angle == 270)
- matrix.translate(-m_visibleContentRectForDrawContents.x(), -m_visibleContentRectForDrawContents.y() - m_visibleContentRectForDrawContents.height());
- matrix.scale(m_scaleFactorForDrawContents);
- clipRect = IntRect(0, 0, m_visibleContentRectForDrawContents.size().height(), m_visibleContentRectForDrawContents.size().width());
- } else {
- glViewport(0, 0, m_visibleContentRectForDrawContents.width(), m_visibleContentRectForDrawContents.height());
- if (m_angle == 180) {
- matrix.translate(-m_visibleContentRectForDrawContents.x() - m_visibleContentRectForDrawContents.width(), -m_visibleContentRectForDrawContents.y() - m_visibleContentRectForDrawContents.height());
- matrix.scale(m_scaleFactorForDrawContents);
- } else
- matrix.setMatrix(m_scaleFactorForDrawContents, 0, 0, m_scaleFactorForDrawContents, -m_visibleContentRectForDrawContents.x(), -m_visibleContentRectForDrawContents.y());
- clipRect = IntRect(IntPoint(), m_visibleContentRectForDrawContents.size());
- }
-#else
- glViewport(0, 0, m_visibleContentRectForDrawContents.width(), m_visibleContentRectForDrawContents.height());
- matrix.setMatrix(m_scaleFactorForDrawContents, 0, 0, m_scaleFactorForDrawContents, -m_visibleContentRectForDrawContents.x(), -m_visibleContentRectForDrawContents.y());
- clipRect = IntRect(IntPoint(), m_visibleContentRectForDrawContents.size());
+ if (isDirectRendering()) {
+ Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_object_evas_get(m_viewImpl->view()));
+ m_angle = ecore_evas_rotation_get(ee);
+ renderer->setAngle(m_angle);
+ matrix.rotate3d(0.0, 0.0, 1.0, 360 - m_angle);
+
+ if (m_angle == 90 || m_angle == 270) {
+ glViewport(0, 0, ewkViewSize.height(), ewkViewSize.width());
+ if (m_angle == 90)
+ matrix.translate(-ewkViewSize.width(), 0);
+ else if (m_angle == 270)
+ matrix.translate(0, -ewkViewSize.height());
+ clipRect = IntRect(IntPoint(), ewkViewSize.transposedSize());
+ } else {
+ glViewport(0, 0, ewkViewSize.width(), ewkViewSize.height());
+ if (m_angle == 180)
+ matrix.translate(-ewkViewSize.width(), -ewkViewSize.height());
+ clipRect = IntRect(IntPoint(), ewkViewSize);
+ }
+ } else
#endif
+ {
+ glViewport(0, 0, ewkViewSize.width(), ewkViewSize.height());
+ clipRect = IntRect(IntPoint(), ewkViewSize);
+ }
+
+ matrix *= m_viewImpl->transformToView().toTransformationMatrix();
- if (drawingArea()) {
- if (drawingArea()->layerTreeCoordinatorProxy()) {
- WebLayerTreeRenderer* renderer = drawingArea()->layerTreeCoordinatorProxy()->layerTreeRenderer();
#if ENABLE(TIZEN_WEBKIT2_TILED_AC_SHARED_PLATFORM_SURFACE_BACKUP_IMAGE)
- if (m_shouldMakeBackupTexture) {
- glViewport(0, 0, m_initialViewRect.width(), m_initialViewRect.height());
- glClearColor(1, 1, 1, 1);
- glClear(GL_COLOR_BUFFER_BIT);
- renderer->paintToBackupTexture(matrix, 1.0f, m_initialViewRect, m_bgColor);
- m_shouldMakeBackupTexture = false;
- } else if (m_shouldShowBackupTexture) {
- matrix.makeIdentity();
- glViewport(0, 0, m_initialViewRect.width(), m_initialViewRect.height());
- renderer->showBackupTexture(matrix, 1.0f, m_initialViewRect);
- } else
-#endif
- renderer->paintToCurrentGLContext(matrix, 1.0f, clipRect, m_bgColor);
- }
- }
+ if (m_shouldMakeBackupTexture) {
+ glViewport(0, 0, m_initialViewRect.width(), m_initialViewRect.height());
+ glClearColor(1, 1, 1, 1);
+ glClear(GL_COLOR_BUFFER_BIT);
+ renderer->paintToBackupTexture(matrix, 1.0f, m_initialViewRect, m_bgColor);
+ m_shouldMakeBackupTexture = false;
+ } else if (m_shouldShowBackupTexture) {
+ matrix.makeIdentity();
+ glViewport(0, 0, m_initialViewRect.width(), m_initialViewRect.height());
+ renderer->showBackupTexture(matrix, 1.0f, m_initialViewRect);
+ } else
+#endif
+ renderer->paintToCurrentGLContext(matrix, 1.0f, clipRect, m_bgColor);
}
void PageClientEvasGL::didRenderFrame()
{
- ewkViewFrameRendered(m_viewWidget);
+ ewkViewFrameRendered(m_viewImpl->view());
PageClientImpl::didRenderFrame();
}
void PageClientEvasGL::initializeAcceleratedCompositingMode()
{
- Evas* evas = evas_object_evas_get(viewWidget());
+ Evas* evas = evas_object_evas_get(m_viewImpl->view());
m_config = evas_gl_config_new();
#if ENABLE(TIZEN_WEBKIT2_DIRECT_RENDERING)
- setenv("EVAS_GL_DIRECT_OVERRIDE", "1", 1);
- m_config->options_bits = EVAS_GL_OPTIONS_DIRECT;
+ char* directRenderingEnv = getenv("TIZEN_WEBKIT_DIRECT_RENDERING");
+ if (!directRenderingEnv || atoi(directRenderingEnv)) {
+ setenv("EVAS_GL_DIRECT_OVERRIDE", "1", 1);
+ m_config->options_bits = EVAS_GL_OPTIONS_DIRECT;
+ }
#endif
m_config->color_format = EVAS_GL_RGBA_8888;
m_config->depth_bits = EVAS_GL_DEPTH_BIT_24;
if (!m_evasGL) {
evas_gl_config_free(m_config);
m_config = 0;
+ TIZEN_LOGE("failed to create evas_gl");
return;
}
m_evasGL = 0;
evas_gl_config_free(m_config);
m_config = 0;
+ TIZEN_LOGE("failed to get evas_gl_api");
return;
}
WebCore::EvasGlApiInterface::shared().initialize(evasGlApi);
m_evasGL = 0;
evas_gl_config_free(m_config);
m_config = 0;
+ TIZEN_LOGE("failed to create evas_gl_context");
return;
}
return;
int width, height;
- evas_object_geometry_get(viewWidget(), 0, 0, &width, &height);
+ evas_object_geometry_get(m_viewImpl->view(), 0, 0, &width, &height);
if (width == 0 || height == 0)
return;
m_surface = evas_gl_surface_create(m_evasGL, m_config, width, height);
if (!m_surface) {
- fprintf(stderr, "[%p] PageClientEvasGL::%s() - failed to create Evas_GL_Surface\n", this, __FUNCTION__);
+ TIZEN_LOGE("failed to create Evas_GL_Surface");
return;
}
#if ENABLE(TIZEN_WEBKIT2_DIRECT_RENDERING)
- makeContextCurrent();
-#else
- if (makeContextCurrent()) {
- glViewport(0, 0, width, height);
- glClearColor(1.0, 1.0, 1.0, 1.0);
- glClear(GL_COLOR_BUFFER_BIT);
- glFinish();
- }
+ if (isDirectRendering())
+ makeContextCurrent();
+ else
#endif
+ {
+ if (makeContextCurrent()) {
+ glViewport(0, 0, width, height);
+ glClearColor(1.0, 1.0, 1.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+ glFinish();
+ }
+ }
Evas_Native_Surface nativeSurface;
if (evas_gl_native_surface_get(m_evasGL, m_surface, &nativeSurface))
- ewk_view_image_native_surface_set(viewWidget(), &nativeSurface);
+ ewk_view_image_native_surface_set(m_viewImpl->view(), &nativeSurface);
}
#endif