bool getVideoSizeAndFormatFromCaps(GstCaps* caps, WebCore::IntSize& size, GstVideoFormat& format, int& pixelAspectRatioNumerator, int& pixelAspectRatioDenominator, int& stride)
{
#ifdef GST_API_VERSION_1
GstVideoInfo info;
if (!gst_video_info_from_caps(&info, caps))
return false;
format = GST_VIDEO_INFO_FORMAT(&info);
size.setWidth(GST_VIDEO_INFO_WIDTH(&info));
size.setHeight(GST_VIDEO_INFO_HEIGHT(&info));
pixelAspectRatioNumerator = GST_VIDEO_INFO_PAR_N(&info);
pixelAspectRatioDenominator = GST_VIDEO_INFO_PAR_D(&info);
stride = GST_VIDEO_INFO_PLANE_STRIDE(&info, 0);
#else
gint width, height;
if (!GST_IS_CAPS(caps) || !gst_caps_is_fixed(caps)
|| !gst_video_format_parse_caps(caps, &format, &width, &height)
|| !gst_video_parse_caps_pixel_aspect_ratio(caps, &pixelAspectRatioNumerator,
&pixelAspectRatioDenominator))
return false;
size.setWidth(width);
size.setHeight(height);
stride = size.width() * 4;
#endif
return true;
}
void LayerTreeCoordinator::sizeDidChange(const WebCore::IntSize& newSize)
{
if (m_rootLayer->size() == newSize)
return;
m_rootLayer->setSize(newSize);
// If the newSize exposes new areas of the non-composited content a setNeedsDisplay is needed
// for those newly exposed areas.
FloatSize oldSize = m_nonCompositedContentLayer->size();
m_nonCompositedContentLayer->setSize(newSize);
if (newSize.width() > oldSize.width()) {
float height = std::min(static_cast<float>(newSize.height()), oldSize.height());
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));
}
if (newSize.height() > oldSize.height())
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));
if (m_pageOverlayLayer)
m_pageOverlayLayer->setSize(newSize);
scheduleLayerFlush();
}
void DumpRenderTreeSupportEfl::dumpConfigurationForViewport(Evas_Object* ewkView, int deviceDPI, const WebCore::IntSize& deviceSize, const WebCore::IntSize& availableSize)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page)
return;
WebCore::ViewportArguments arguments = page->mainFrame()->document()->viewportArguments();
WebCore::ViewportAttributes attributes = computeViewportAttributes(arguments,
/* default layout width for non-mobile pages */ 980,
deviceSize.width(), deviceSize.height(),
deviceDPI,
availableSize);
restrictMinimumScaleFactorToViewportSize(attributes, availableSize);
restrictScaleFactorToInitialScaleIfNotUserScalable(attributes);
fprintf(stdout, "viewport size %dx%d scale %f with limits [%f, %f] and userScalable %f\n", attributes.layoutSize.width(), attributes.layoutSize.height(), attributes.initialScale, attributes.minimumScale, attributes.maximumScale, attributes.userScalable);
}
bool getVideoSizeAndFormatFromCaps(GstCaps* caps, WebCore::IntSize& size, GstVideoFormat& format, int& pixelAspectRatioNumerator, int& pixelAspectRatioDenominator, int& stride)
{
GstVideoInfo info;
if (!gst_caps_is_fixed(caps) || !gst_video_info_from_caps(&info, caps))
return false;
format = GST_VIDEO_INFO_FORMAT(&info);
size.setWidth(GST_VIDEO_INFO_WIDTH(&info));
size.setHeight(GST_VIDEO_INFO_HEIGHT(&info));
pixelAspectRatioNumerator = GST_VIDEO_INFO_PAR_N(&info);
pixelAspectRatioDenominator = GST_VIDEO_INFO_PAR_D(&info);
stride = GST_VIDEO_INFO_PLANE_STRIDE(&info, 0);
return true;
}
void MoviePluginView::paint(GraphicsContext* pGraphicContext, const IntRect& viewRect)
{
EA::WebKit::View* const pView = EA::WebKit::GetView(GetPluginViewParentFrame());
ASSERT(pView);
WebCore::FrameView* const pFrameView = pView->GetFrameView();
ASSERT(pFrameView);
if((!getMovieSurface()) || (!pView) || (!pFrameView))
return;
// Build the source and target rects with scroll offset
EA::Raster::ISurface* pTargetSurface = pGraphicContext->platformContext();
WebCore::IntSize scrollOffset = pFrameView->scrollOffset();
EA::Raster::Rect targetRect(frameGeometry().x() - scrollOffset.width(),frameGeometry().y() - scrollOffset.height(), frameGeometry().width(), frameGeometry().height());
EA::Raster::Rect clipRect(viewRect.x(),viewRect.y(),viewRect.height(),viewRect.width());
targetRect.constrainRect(clipRect);
// Draw to the view surface
EA::WebKit::GetEARasterInstance()->Blit(getMovieSurface(), &getMovieRect(), pTargetSurface, &targetRect, NULL);
}
void LayerTreeRenderer::syncCanvas(WebLayerID id, const WebCore::IntSize& canvasSize, const GraphicsSurfaceToken& token, uint32_t frontBuffer)
{
if (canvasSize.isEmpty() || !m_textureMapper)
return;
ensureLayer(id);
GraphicsLayer* layer = layerByID(id);
RefPtr<TextureMapperSurfaceBackingStore> canvasBackingStore;
SurfaceBackingStoreMap::iterator it = m_surfaceBackingStores.find(id);
if (it == m_surfaceBackingStores.end()) {
canvasBackingStore = TextureMapperSurfaceBackingStore::create();
m_surfaceBackingStores.set(id, canvasBackingStore);
} else
canvasBackingStore = it->value;
canvasBackingStore->setGraphicsSurface(token, canvasSize, frontBuffer);
layer->setContentsToMedia(canvasBackingStore.get());
}
void LayerTreeRenderer::syncCanvas(WebLayerID id, const WebCore::IntSize& canvasSize, uint32_t graphicsSurfaceToken)
{
if (canvasSize.isEmpty() || !m_textureMapper)
return;
#if USE(GRAPHICS_SURFACE)
ensureLayer(id);
GraphicsLayer* layer = layerByID(id);
RefPtr<TextureMapperSurfaceBackingStore> canvasBackingStore;
SurfaceBackingStoreMap::iterator it = m_surfaceBackingStores.find(id);
if (it == m_surfaceBackingStores.end()) {
canvasBackingStore = TextureMapperSurfaceBackingStore::create();
m_surfaceBackingStores.set(id, canvasBackingStore);
} else
canvasBackingStore = it->second;
canvasBackingStore->setGraphicsSurface(graphicsSurfaceToken, canvasSize);
layer->setContentsToMedia(canvasBackingStore.get());
#endif
}
void wxWebView::OnPaint(wxPaintEvent& event)
{
if (m_beingDestroyed || !m_mainFrame)
return;
WebCore::Frame* frame = m_mainFrame->GetFrame();
if (!frame || !frame->view())
return;
wxAutoBufferedPaintDC dc(this);
if (IsShown() && frame->document()) {
#if USE(WXGC)
wxGCDC gcdc(dc);
#endif
if (dc.IsOk()) {
wxRect paintRect = GetUpdateRegion().GetBox();
WebCore::IntSize offset = frame->view()->scrollOffset();
#if USE(WXGC)
gcdc.SetDeviceOrigin(-offset.width(), -offset.height());
#endif
dc.SetDeviceOrigin(-offset.width(), -offset.height());
paintRect.Offset(offset.width(), offset.height());
#if USE(WXGC)
WebCore::GraphicsContext* gc = new WebCore::GraphicsContext(&gcdc);
#else
WebCore::GraphicsContext* gc = new WebCore::GraphicsContext((wxWindowDC*)&dc);
#endif
if (gc && frame->contentRenderer()) {
if (frame->view()->needsLayout())
frame->view()->layout();
frame->view()->paintContents(gc, paintRect);
}
delete gc;
}
}
}
bool MoviePluginView::notify(bool terminate)
{
bool responseFlag = false;
EA::WebKit::View* const pView = EA::WebKit::GetView(GetPluginViewParentFrame());
ASSERT(pView);
EA::WebKit::ViewNotification* const pVN = EA::WebKit::GetViewNotification();
ASSERT(pVN);
if((!pView) ||(!pVN))
return false;
// Get the windwo view rect with scroll offset
EA::Raster::Rect windowRect(0,0,frameGeometry().width(), frameGeometry().height());
WebCore::FrameView* const pFrameView = pView->GetFrameView();
ASSERT(pFrameView);
if(pFrameView)
{
WebCore::IntSize scrollOffset = pFrameView->scrollOffset();
windowRect.x = frameGeometry().x() - scrollOffset.width();
windowRect.y = frameGeometry().y() - scrollOffset.height();
}
// Call the notification
EA::WebKit::MovieUpdateInfo info ={
pView,
m_scrURI.charactersWithNullTermination(),
getMovieSurface(),
getMovieRect(),
windowRect,
m_triggerDelay,
terminate, // Terminate flag
m_removeSurfaceFlag,
isMovieLooping(),
isMoviePaused(),
isMovieAutoPlay(),
isMoviePreload()
};
responseFlag = pVN->MovieUpdate(info);
// Check if should remove the surface
if(info.mRemoveMovieSurfaceFlag)
{
if(getMovieSurface()) {
destroyMovieSurface();
m_removeSurfaceFlag = info.mRemoveMovieSurfaceFlag;
}
}
else if(responseFlag) {
// Trigger the paint by setting the dirty rect
WebCore::FrameView* const pFV = pView->GetFrameView();
ASSERT(pFV);
if(pFV) {
WebCore::IntSize scrollOffset = pFV->scrollOffset();
const WKAL::IntRect rect(frameGeometry().x() - scrollOffset.width(),frameGeometry().y() - scrollOffset.height(), frameGeometry().width(), frameGeometry().height());
if(pView->GetWebView()) {
pView->GetWebView()->addToDirtyRegion(rect);
pFV->SetDirty(true);
}
}
}
// Transfer/save time trigger
m_triggerDelay = info.mTriggerDelay;
return info.mTerminateCallbackFlag;
}
void PageClientLegacyImpl::didChangeContentsSize(const WebCore::IntSize& size)
{
#if USE(TILED_BACKING_STORE)
m_viewImpl->page()->drawingArea()->coordinatedLayerTreeHostProxy()->setContentsSize(FloatSize(size.width(), size.height()));
m_viewImpl->update();
#endif
m_viewImpl->smartCallback<ContentsSizeChanged>().call(size);
}
static inline PassRefPtr<cairo_surface_t> createSurfaceFromData(void* data, const WebCore::IntSize& size)
{
const int stride = cairo_format_stride_for_width(cairoFormat, size.width());
return adoptRef(cairo_image_surface_create_for_data(static_cast<unsigned char*>(data), cairoFormat, size.width(), size.height(), stride));
}
size_t ShareableBitmap::numBytesForSize(const WebCore::IntSize& size)
{
return cairo_format_stride_for_width(cairoFormat, size.width()) * size.height();
}
static GstFlowReturn webkitVideoSinkRender(GstBaseSink* baseSink, GstBuffer* buffer)
{
WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink);
WebKitVideoSinkPrivate* priv = sink->priv;
g_mutex_lock(priv->bufferMutex);
if (priv->unlocked) {
g_mutex_unlock(priv->bufferMutex);
return GST_FLOW_OK;
}
#if USE(NATIVE_FULLSCREEN_VIDEO)
// Ignore buffers if the video is already in fullscreen using
// another sink.
if (priv->gstGWorld->isFullscreen()) {
g_mutex_unlock(priv->bufferMutex);
return GST_FLOW_OK;
}
#endif
priv->buffer = gst_buffer_ref(buffer);
#ifndef GST_API_VERSION_1
// For the unlikely case where the buffer has no caps, the caps
// are implicitely the caps of the pad. This shouldn't happen.
if (UNLIKELY(!GST_BUFFER_CAPS(buffer))) {
buffer = priv->buffer = gst_buffer_make_metadata_writable(priv->buffer);
gst_buffer_set_caps(priv->buffer, GST_PAD_CAPS(GST_BASE_SINK_PAD(baseSink)));
}
GRefPtr<GstCaps> caps = GST_BUFFER_CAPS(buffer);
#else
GRefPtr<GstCaps> caps;
// The video info structure is valid only if the sink handled an allocation query.
if (GST_VIDEO_INFO_FORMAT(&priv->info) != GST_VIDEO_FORMAT_UNKNOWN)
caps = adoptGRef(gst_video_info_to_caps(&priv->info));
else
caps = priv->currentCaps;
#endif
GstVideoFormat format;
WebCore::IntSize size;
int pixelAspectRatioNumerator, pixelAspectRatioDenominator, stride;
if (!getVideoSizeAndFormatFromCaps(caps.get(), size, format, pixelAspectRatioNumerator, pixelAspectRatioDenominator, stride)) {
gst_buffer_unref(buffer);
g_mutex_unlock(priv->bufferMutex);
return GST_FLOW_ERROR;
}
// Cairo's ARGB has pre-multiplied alpha while GStreamer's doesn't.
// Here we convert to Cairo's ARGB.
if (format == GST_VIDEO_FORMAT_ARGB || format == GST_VIDEO_FORMAT_BGRA) {
// Because GstBaseSink::render() only owns the buffer reference in the
// method scope we can't use gst_buffer_make_writable() here. Also
// The buffer content should not be changed here because the same buffer
// could be passed multiple times to this method (in theory).
GstBuffer* newBuffer = createGstBuffer(buffer);
// Check if allocation failed.
if (UNLIKELY(!newBuffer)) {
g_mutex_unlock(priv->bufferMutex);
return GST_FLOW_ERROR;
}
// We don't use Color::premultipliedARGBFromColor() here because
// one function call per video pixel is just too expensive:
// For 720p/PAL for example this means 1280*720*25=23040000
// function calls per second!
#ifndef GST_API_VERSION_1
const guint8* source = GST_BUFFER_DATA(buffer);
guint8* destination = GST_BUFFER_DATA(newBuffer);
#else
GstMapInfo sourceInfo;
GstMapInfo destinationInfo;
gst_buffer_map(buffer, &sourceInfo, GST_MAP_READ);
const guint8* source = const_cast<guint8*>(sourceInfo.data);
gst_buffer_map(newBuffer, &destinationInfo, GST_MAP_WRITE);
guint8* destination = static_cast<guint8*>(destinationInfo.data);
#endif
for (int x = 0; x < size.height(); x++) {
for (int y = 0; y < size.width(); y++) {
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
unsigned short alpha = source[3];
destination[0] = (source[0] * alpha + 128) / 255;
destination[1] = (source[1] * alpha + 128) / 255;
destination[2] = (source[2] * alpha + 128) / 255;
destination[3] = alpha;
#else
unsigned short alpha = source[0];
destination[0] = alpha;
destination[1] = (source[1] * alpha + 128) / 255;
destination[2] = (source[2] * alpha + 128) / 255;
destination[3] = (source[3] * alpha + 128) / 255;
#endif
source += 4;
destination += 4;
}
}
#ifdef GST_API_VERSION_1
gst_buffer_unmap(buffer, &sourceInfo);
gst_buffer_unmap(newBuffer, &destinationInfo);
#endif
gst_buffer_unref(buffer);
buffer = priv->buffer = newBuffer;
}
// This should likely use a lower priority, but glib currently starves
// lower priority sources.
// See: https://bugzilla.gnome.org/show_bug.cgi?id=610830.
priv->timeoutId = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, webkitVideoSinkTimeoutCallback,
gst_object_ref(sink), reinterpret_cast<GDestroyNotify>(gst_object_unref));
g_cond_wait(priv->dataCondition, priv->bufferMutex);
g_mutex_unlock(priv->bufferMutex);
return GST_FLOW_OK;
}
BackingStoreScrollbar::BackingStoreScrollbar(const WebCore::IntSize& size)
: m_size(size)
{
m_image = new unsigned char[size.height() * imageStride()];
m_alphaImage = new unsigned char[size.height() * alphaImageStride()];
}
bool ViewNavigationDelegate::JumpToNearestElement(EA::WebKit::JumpDirection direction, bool scrollIfElementNotFound)
{
// Note by Arpit Baldeva:
// We have a problem here. mpModalInputClient object is supposed to be used for Modal input only however the only class using this object
// is html SELECT element(implemented as a popup). But in reality, html SELECT element is NOT modal. So it is little ill-conceived.
// For example, in all the browsers, if you scroll the mouse wheel on the frame, the SELECT element disappears and the actual frame scrolls.
// For any modal input needs on a web page, the users are advised to use the Z-layer technique with Javascript/CSS - http://jqueryui.com/demos/dialog/#modal-confirmation.
// The problem we want to solve here is have the SELECT element respond to the controller input correctly(select element one by one).
// But the button event information is lost by the time we are in the EA::WebKit::View. For the foreseeable future, there is no candidate
// other than html SELECT element which is implemented as a modal popup inside EAWebKit. So inside EA::WebKit::View, we create a dummy
// button event from the Jump direction and make SELECT respond to it. If any other object starts using the modal input, this would need to be
// revisited. But then, we'll need to solve a plethora of issues. So we do minimum work here to not break other things.
IOverlayInputClient* pOverlayInputClient = mView->GetOverlayInputClient();
bool handledByOverlayInputClient = false;
if(pOverlayInputClient)
{
EA::WebKit::ButtonEvent btnEvent;
switch(direction)
{
/*
case EA::WebKit::JumpLeft:
{
btnEvent.mID = EA::WebKit::kButton0;
handledByOverlayInputClient = pOverlayInputClient->OnButtonEvent(btnEvent);
}
*/
case EA::WebKit::JumpUp:
{
btnEvent.mID = EA::WebKit::kButton1;
handledByOverlayInputClient = pOverlayInputClient->OnButtonEvent(btnEvent);
break;
}
/*
case EA::WebKit::JumpRight:
{
btnEvent.mID = EA::WebKit::kButton2;
handledByOverlayInputClient = pOverlayInputClient->OnButtonEvent(btnEvent);
}
*/
case EA::WebKit::JumpDown:
{
btnEvent.mID = EA::WebKit::kButton3;
handledByOverlayInputClient = pOverlayInputClient->OnButtonEvent(btnEvent);
break;
}
default:
// We don't return and allow any other button press to go to the main View. At the same time, we make the SELECT element lose focus.
{
pOverlayInputClient->OnFocusChangeEvent(false);
break;
}
}
}
if(handledByOverlayInputClient)
return true;
int lastX, lastY;
mView->GetCursorPosition(lastX, lastY);
// Following is a shortcut to drive navigation from a page.
switch (direction)
{
case EA::WebKit::JumpRight:
if (GetFixedString(mCachedNavigationRightId)->compare(""))
{
if (!GetFixedString(mCachedNavigationRightId)->compare("ignore"))
{
return false;
}
if (JumpToId(GetFixedString(mCachedNavigationRightId)->c_str()))
{
return true;
}
}
break;
case EA::WebKit::JumpDown:
if (GetFixedString(mCachedNavigationDownId)->compare(""))
{
if (!GetFixedString(mCachedNavigationDownId)->compare("ignore"))
{
return false;
}
if (JumpToId(GetFixedString(mCachedNavigationDownId)->c_str()))
{
return true;
}
}
break;
case EA::WebKit::JumpLeft:
if (GetFixedString(mCachedNavigationLeftId)->compare(""))
{
if (!GetFixedString(mCachedNavigationLeftId)->compare("ignore"))
{
return false;
}
if (JumpToId(GetFixedString(mCachedNavigationLeftId)->c_str()))
{
return true;
}
}
break;
case EA::WebKit::JumpUp:
if (GetFixedString(mCachedNavigationUpId)->compare(""))
{
if (!GetFixedString(mCachedNavigationUpId)->compare("ignore"))
{
return false;
}
if (JumpToId(GetFixedString(mCachedNavigationUpId)->c_str()))
{
return true;
}
}
break;
default:
EAW_FAIL_MSG("Should not have got here\n");
}
// Iterate over all the frames and find the closest element in any of all the frames.
WebCore::Frame* pFrame = mView->GetFrame();
float currentRadialDistance = FLT_MAX; // A high value to start with so that the max distance between any two elements in the surface is under it.
WebCore::Node* currentBestNode = NULL;
while(pFrame)
{
WebCore::Document* document = pFrame->document();
EAW_ASSERT(document);
if(document)
{
WebCore::FrameView* pFrameView = document->view();
WebCore::IntPoint scrollOffset;
if(pFrameView)
{
scrollOffset.setX(pFrameView->scrollOffset().width());
scrollOffset.setY(pFrameView->scrollOffset().height());
}
// We figure out the start position(It is center of the currently hovered element almost all the time but can be slightly different
// due to scroll sometimes).
mCentreX = lastX + scrollOffset.x();
mCentreY = lastY + scrollOffset.y();
DocumentNavigator navigator(mView, document, direction, WebCore::IntPoint(mCentreX, mCentreY), mBestNodeX, mBestNodeY, mBestNodeWidth, mBestNodeHeight, mJumpNavigationParams.mNavigationTheta, mJumpNavigationParams.mStrictAxesCheck, currentRadialDistance);
navigator.FindBestNode(document);
if(navigator.GetBestNode())
{
currentBestNode = navigator.GetBestNode();
currentRadialDistance = navigator.GetBestNodeRadialDistance();
}
}
pFrame = pFrame->tree()->traverseNext();
}
bool foundSomething = false;
if (currentBestNode) //We found the node to navigate. Move the cursor and we are done.
{
foundSomething = true;
MoveMouseCursorToNode(currentBestNode, false);
}
else if(scrollIfElementNotFound)// Node is not found.
{
// Based on the intended direction of movement, scroll so that some newer elements are visible.
int cursorPosBeforeScrollX, cursorPosBeforeScrollY;
mView->GetCursorPosition(cursorPosBeforeScrollX, cursorPosBeforeScrollY);
switch(direction)
{
case EA::WebKit::JumpDown:
{
ScrollOnJump(true, -120, mJumpNavigationParams.mNumLinesToAutoScroll);
break;
}
case EA::WebKit::JumpUp:
{
ScrollOnJump(true, 120, mJumpNavigationParams.mNumLinesToAutoScroll);
break;
}
case EA::WebKit::JumpRight:
{
ScrollOnJump(false, -120, mJumpNavigationParams.mNumLinesToAutoScroll);
break;
}
case EA::WebKit::JumpLeft:
{
ScrollOnJump(false, 120, mJumpNavigationParams.mNumLinesToAutoScroll);
break;
}
default:
{
EAW_ASSERT_MSG(false, "Should not reach here\n");
}
}
// We move the mouse cursor back to the location where the last best node was found. This is so that we don't end up with the cursor being in no man's land. While that may work
// for ordinary sites, it may not work well with customized pages that leverage CSS to visually indicate current position rather than a cursor graphic.
// We don't call MoveMouseCursorToNode() with last cached node as there are edge cases where we may be holding an invalid node. Using a cached frame and checking against the
// current valid frames safeguards against that.
WebCore::IntSize scrollOffset;
WebCore::Frame* pFrame1 = mView->GetFrame();
while(pFrame1)
{
if(pFrame1 == mBestNodeFrame)//Find the frame where last best node existed.
{
if(pFrame1->view())
{
scrollOffset = pFrame1->view()->scrollOffset();//We read scroll offset here as it could have changed in the switch statement above.
break;
}
}
pFrame1 = pFrame1->tree()->traverseNext();
}
int targetcursorPosAfterScrollX, targetcursorPosAfterScrollY;
targetcursorPosAfterScrollX = mBestNodeX + mBestNodeWidth / 2 - scrollOffset.width();
targetcursorPosAfterScrollY = mBestNodeY + mBestNodeHeight/ 2 - scrollOffset.height();
EA::WebKit::MouseMoveEvent moveEvent;
memset( &moveEvent, 0, sizeof(moveEvent) );
const int cursorInset = 5;// Make cursor stay inside 5 pixels from boundaries. No known issues but added this as a safety measure so that we do not lose cursor ever.
int width = mView->GetSize().mWidth;
int height = mView->GetSize().mHeight;
moveEvent.mX = Clamp( cursorInset, targetcursorPosAfterScrollX, width - cursorInset );
moveEvent.mY = Clamp( cursorInset, targetcursorPosAfterScrollY, height - cursorInset );
mView->OnMouseMoveEvent(moveEvent);
// We intentionally don't call JumpToNearestElement(direction, false) here to avoid recursion. We do it in the overloaded function above.
}
return foundSomething;
}
static inline void _ewk_view_single_scroll_process_single(Ewk_View_Smart_Data* smartData, void* pixels, Evas_Coord width, Evas_Coord height, const WebCore::IntSize& scrollOffset, const WebCore::IntRect& rectToScroll)
{
int scrollX = rectToScroll.x();
int scrollY = rectToScroll.y();
int scrollWidth = rectToScroll.width();
int scrollHeight = rectToScroll.height();
DBG("%d,%d + %d,%d %+03d,%+03d, store: %p %dx%d",
scrollX, scrollY, scrollWidth, scrollHeight, scrollOffset.width(), scrollOffset.height(), pixels, width, height);
if (abs(scrollOffset.width()) >= scrollWidth || abs(scrollOffset.height()) >= scrollHeight) {
ewk_view_repaint_add(smartData->_priv, scrollX, scrollY, scrollWidth, scrollHeight);
return;
}
if (scrollX < 0) {
scrollWidth += scrollX;
scrollX = 0;
}
if (scrollY < 0) {
scrollHeight += scrollY;
scrollY = 0;
}
if (scrollX + scrollWidth > width)
scrollWidth = width - scrollX;
if (scrollY + scrollHeight > height)
scrollHeight = height - scrollY;
if (scrollWidth <= 0 || scrollHeight <= 0)
return;
int sourceX = scrollOffset.width() < 0 ? abs(scrollOffset.width()) : 0;
int sourceY = scrollOffset.height() < 0 ? abs(scrollOffset.height()) : 0;
int destinationX = scrollOffset.width() < 0 ? 0 : scrollOffset.width();
int destinationY = scrollOffset.height() < 0 ? 0 : scrollOffset.height();
int copyWidth = scrollWidth - abs(scrollOffset.width());
int copyHeight = scrollHeight - abs(scrollOffset.height());
if (scrollOffset.width() || scrollOffset.height()) {
_ewk_view_screen_move(static_cast<uint32_t*>(pixels), destinationX, destinationY, sourceX, sourceY, copyWidth, copyHeight, width);
evas_object_image_data_update_add(smartData->backing_store, destinationX, destinationY, copyWidth, copyHeight);
}
Eina_Rectangle verticalUpdate;
verticalUpdate.x = destinationX ? 0 : copyWidth - 1;
verticalUpdate.y = 0;
verticalUpdate.w = abs(scrollOffset.width());
verticalUpdate.h = scrollHeight;
if (verticalUpdate.w && verticalUpdate.h)
ewk_view_repaint_add(smartData->_priv, verticalUpdate.x, verticalUpdate.y, verticalUpdate.w, verticalUpdate.h);
Eina_Rectangle horizontalUpdate;
horizontalUpdate.x = destinationX;
horizontalUpdate.y = destinationY ? 0 : copyHeight - 1;
horizontalUpdate.w = copyWidth;
horizontalUpdate.h = abs(scrollOffset.height());
if (horizontalUpdate.w && horizontalUpdate.h)
ewk_view_repaint_add(smartData->_priv, horizontalUpdate.x, horizontalUpdate.y, horizontalUpdate.w, horizontalUpdate.h);
}
void EflViewportHandler::didChangeContentsSize(const WebCore::IntSize& size)
{
m_contentsSize = size;
setVisibleContentsRect(m_visibleContentRect.location(), m_scaleFactor, FloatPoint());
drawingArea()->layerTreeCoordinatorProxy()->setContentsSize(WebCore::FloatSize(size.width(), size.height()));
}