WebCompositorInputHandlerImpl::EventDisposition WebCompositorInputHandlerImpl::handleGestureFling(const WebGestureEvent& gestureEvent)
{
WebInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(WebPoint(gestureEvent.x, gestureEvent.y), WebInputHandlerClient::ScrollInputTypeGesture);
switch (scrollStatus) {
case WebInputHandlerClient::ScrollStatusStarted: {
if (gestureEvent.data.flingStart.sourceDevice == WebGestureEvent::Touchpad)
m_inputHandlerClient->scrollEnd();
m_flingCurve = adoptPtr(Platform::current()->createFlingAnimationCurve(gestureEvent.data.flingStart.sourceDevice, WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY), WebSize()));
TRACE_EVENT_ASYNC_BEGIN0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::started", this);
m_flingParameters.delta = WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY);
m_flingParameters.point = WebPoint(gestureEvent.x, gestureEvent.y);
m_flingParameters.globalPoint = WebPoint(gestureEvent.globalX, gestureEvent.globalY);
m_flingParameters.modifiers = gestureEvent.modifiers;
m_flingParameters.sourceDevice = gestureEvent.data.flingStart.sourceDevice;
m_inputHandlerClient->scheduleAnimation();
return DidHandle;
}
case WebInputHandlerClient::ScrollStatusOnMainThread: {
TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::scrollOnMainThread");
m_flingActiveOnMainThread = true;
return DidNotHandle;
}
case WebInputHandlerClient::ScrollStatusIgnored: {
TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::ignored");
if (gestureEvent.data.flingStart.sourceDevice == WebGestureEvent::Touchpad) {
// We still pass the curve to the main thread if there's nothing scrollable, in case something
// registers a handler before the curve is over.
return DidNotHandle;
}
return DropEvent;
}
}
return DidNotHandle;
}
WebCompositorInputHandlerImpl::EventDisposition WebCompositorInputHandlerImpl::handleGestureFling(const WebGestureEvent& gestureEvent)
{
CCInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(IntPoint(gestureEvent.x, gestureEvent.y), CCInputHandlerClient::Gesture);
switch (scrollStatus) {
case CCInputHandlerClient::ScrollStarted: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::started");
OwnPtr<PlatformGestureCurve> flingCurve = TouchpadFlingPlatformGestureCurve::create(FloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY));
m_wheelFlingAnimation = CCActiveGestureAnimation::create(PlatformGestureToCCGestureAdapter::create(flingCurve.release()), this);
m_wheelFlingParameters.delta = WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY);
m_wheelFlingParameters.point = WebPoint(gestureEvent.x, gestureEvent.y);
m_wheelFlingParameters.globalPoint = WebPoint(gestureEvent.globalX, gestureEvent.globalY);
m_wheelFlingParameters.modifiers = gestureEvent.modifiers;
m_inputHandlerClient->scheduleAnimation();
return DidHandle;
}
case CCInputHandlerClient::ScrollOnMainThread: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::scrollOnMainThread");
return DidNotHandle;
}
case CCInputHandlerClient::ScrollIgnored: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::ignored");
// We still pass the curve to the main thread if there's nothing scrollable, in case something
// registers a handler before the curve is over.
return DidNotHandle;
}
}
return DidNotHandle;
}
WebCompositorInputHandlerImpl::EventDisposition WebCompositorInputHandlerImpl::handleGestureFling(const WebGestureEvent& gestureEvent)
{
WebInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(WebPoint(gestureEvent.x, gestureEvent.y), WebInputHandlerClient::ScrollInputTypeGesture);
switch (scrollStatus) {
case WebInputHandlerClient::ScrollStatusStarted: {
m_inputHandlerClient->scrollEnd();
m_wheelFlingCurve = PlatformGestureCurveFactory::get()->createCurve(gestureEvent.data.flingStart.sourceDevice, FloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY));
TRACE_EVENT_ASYNC_BEGIN1("cc", "WebCompositorInputHandlerImpl::handleGestureFling::started", this, "curve", m_wheelFlingCurve->debugName());
m_wheelFlingParameters.delta = WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY);
m_wheelFlingParameters.point = WebPoint(gestureEvent.x, gestureEvent.y);
m_wheelFlingParameters.globalPoint = WebPoint(gestureEvent.globalX, gestureEvent.globalY);
m_wheelFlingParameters.modifiers = gestureEvent.modifiers;
m_wheelFlingParameters.sourceDevice = gestureEvent.data.flingStart.sourceDevice;
m_inputHandlerClient->scheduleAnimation();
return DidHandle;
}
case WebInputHandlerClient::ScrollStatusOnMainThread: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::scrollOnMainThread");
return DidNotHandle;
}
case WebInputHandlerClient::ScrollStatusIgnored: {
TRACE_EVENT_INSTANT0("cc", "WebCompositorInputHandlerImpl::handleGestureFling::ignored");
// We still pass the curve to the main thread if there's nothing scrollable, in case something
// registers a handler before the curve is over.
return DidNotHandle;
}
}
return DidNotHandle;
}
Response InspectorEmulationAgent::forceViewport(double x,
double y,
double scale) {
if (x < 0 || y < 0)
return Response::Error("Coordinates must be non-negative");
if (scale <= 0)
return Response::Error("Scale must be positive");
m_state->setBoolean(EmulationAgentState::forcedViewportEnabled, true);
m_state->setDouble(EmulationAgentState::forcedViewportX, x);
m_state->setDouble(EmulationAgentState::forcedViewportY, y);
m_state->setDouble(EmulationAgentState::forcedViewportScale, scale);
webViewImpl()->devToolsEmulator()->forceViewport(WebFloatPoint(x, y), scale);
return Response::OK();
}
static void addTouchPoints(const Widget* widget, const AtomicString& touchType, TouchList* touches, WebTouchPoint* touchPoints, unsigned* touchPointsLength, const WebCore::RenderObject* renderObject)
{
unsigned numberOfTouches = std::min(touches->length(), static_cast<unsigned>(WebTouchEvent::touchesLengthCap));
for (unsigned i = 0; i < numberOfTouches; ++i) {
const Touch* touch = touches->item(i);
WebTouchPoint point;
point.id = touch->identifier();
point.screenPosition = WebFloatPoint(touch->screenX(), touch->screenY());
point.position = convertAbsoluteLocationForRenderObject(touch->absoluteLocation(), *renderObject);
point.radiusX = touch->webkitRadiusX();
point.radiusY = touch->webkitRadiusY();
point.rotationAngle = touch->webkitRotationAngle();
point.force = touch->webkitForce();
point.state = toWebTouchPointState(touchType);
touchPoints[i] = point;
}
*touchPointsLength = numberOfTouches;
}
void WebDevToolsAgentImpl::setDeviceMetricsOverride(int width, int height, float deviceScaleFactor, bool mobile, bool fitWindow, float scale, float offsetX, float offsetY)
{
if (!m_deviceMetricsEnabled) {
m_deviceMetricsEnabled = true;
m_webViewImpl->setBackgroundColorOverride(Color::darkGray);
}
if (mobile)
enableMobileEmulation();
else
disableMobileEmulation();
WebDeviceEmulationParams params;
params.screenPosition = mobile ? WebDeviceEmulationParams::Mobile : WebDeviceEmulationParams::Desktop;
params.deviceScaleFactor = deviceScaleFactor;
params.viewSize = WebSize(width, height);
params.fitToView = fitWindow;
params.scale = scale;
params.offset = WebFloatPoint(offsetX, offsetY);
m_client->enableDeviceEmulation(params);
}
LinkHighlight::LinkHighlight(Node* node, WebViewImpl* owningWebViewImpl)
: m_node(node)
, m_owningWebViewImpl(owningWebViewImpl)
, m_currentGraphicsLayer(0)
, m_geometryNeedsUpdate(false)
{
ASSERT(m_node);
ASSERT(owningWebViewImpl);
WebCompositorSupport* compositorSupport = Platform::current()->compositorSupport();
m_contentLayer = adoptPtr(compositorSupport->createContentLayer(this));
m_clipLayer = adoptPtr(compositorSupport->createLayer());
m_clipLayer->setAnchorPoint(WebFloatPoint());
m_clipLayer->addChild(m_contentLayer->layer());
m_contentLayer->layer()->setDrawsContent(false);
// We don't want to show the highlight until startAnimation is called, even though the highlight
// layer may be added to the tree immediately.
m_contentLayer->layer()->setOpacity(0);
m_contentLayer->layer()->setAnimationDelegate(this);
}
LinkHighlight::LinkHighlight(Node* node, WebViewImpl* owningWebViewImpl)
: m_node(node)
, m_owningWebViewImpl(owningWebViewImpl)
, m_currentGraphicsLayer(0)
, m_geometryNeedsUpdate(false)
, m_isAnimating(false)
, m_startTime(monotonicallyIncreasingTime())
{
ASSERT(m_node);
ASSERT(owningWebViewImpl);
WebCompositorSupport* compositorSupport = Platform::current()->compositorSupport();
m_contentLayer = adoptPtr(compositorSupport->createContentLayer(this));
m_clipLayer = adoptPtr(compositorSupport->createLayer());
m_clipLayer->setAnchorPoint(WebFloatPoint());
m_clipLayer->addChild(m_contentLayer->layer());
m_contentLayer->layer()->setAnimationDelegate(this);
m_contentLayer->layer()->setDrawsContent(true);
m_contentLayer->layer()->setOpacity(1);
m_geometryNeedsUpdate = true;
updateGeometry();
}
void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin)
{
if (!haveScrollLayer())
return;
bool visibleRectChanged = m_viewportSize != viewportSize;
m_viewportSize = viewportSize;
WebLayer* layer = scrollLayer();
layer->setScrollPosition(scrollPosition + scrollOrigin);
layer->setPosition(WebFloatPoint(-scrollPosition));
// Due to the possibility of pinch zoom, the noncomposited layer is always
// assumed to be scrollable.
layer->setScrollable(true);
m_graphicsLayer->setSize(contentsSize);
// In RTL-style pages, the origin of the initial containing block for the
// root layer may be positive; translate the layer to avoid negative
// coordinates.
m_layerAdjust = -toSize(scrollOrigin);
if (m_graphicsLayer->transform().m41() != m_layerAdjust.width() || m_graphicsLayer->transform().m42() != m_layerAdjust.height()) {
WebCore::TransformationMatrix transform = m_graphicsLayer->transform();
transform.setM41(m_layerAdjust.width());
transform.setM42(m_layerAdjust.height());
m_graphicsLayer->setTransform(transform);
// If a tiled layer is shifted left or right, the content that goes into
// each tile will change. Invalidate the entire layer when this happens.
m_graphicsLayer->setNeedsDisplay();
} else if (visibleRectChanged)
m_graphicsLayer->setNeedsDisplay();
WebCore::GraphicsLayer* clipLayer = m_graphicsLayer->parent()->parent();
WebCore::GraphicsLayer* rootLayer = clipLayer;
while (rootLayer->parent())
rootLayer = rootLayer->parent();
setScrollbarBoundsContainPageScale(rootLayer, clipLayer);
}
bool LinkHighlight::computeHighlightLayerPathAndPosition(RenderLayer* compositingLayer)
{
if (!m_node || !m_node->renderer())
return false;
bool pathHasChanged = false;
FloatRect boundingRect = m_node->pixelSnappedBoundingBox();
// FIXME: If we ever use a more sophisticated highlight path, we'll need
// to devise a way of detecting when it changes.
if (boundingRect.size() != m_path.boundingRect().size()) {
FloatSize rectRoundingRadii(3, 3);
m_path.clear();
m_path.addRoundedRect(boundingRect, rectRoundingRadii);
// Always treat the path as being at the origin of this layer.
m_path.translate(FloatPoint() - boundingRect.location());
pathHasChanged = true;
}
FloatRect nodeBounds = boundingRect;
// This is a simplified, but basically correct, transformation of the target location, converted
// from its containing frame view to window coordinates and then back to the containing frame view
// of the composited layer.
// FIXME: We also need to transform the target's size in case of scaling. This can be done by also transforming
// the full rects in the xToY calls, and transforming both the upper-left and lower right corners
// to local coordinates at the end..
ASSERT(compositingLayer);
IntPoint targetWindow = m_node->renderer()->frame()->view()->contentsToWindow(enclosingIntRect(nodeBounds).location());
IntPoint targetCompositorAbsolute = compositingLayer->renderer()->frame()->view()->windowToContents(targetWindow);
FloatPoint targetCompositorLocal = compositingLayer->renderer()->absoluteToLocal(targetCompositorAbsolute, false, true);
m_contentLayer->layer()->setBounds(WebSize(enclosingIntRect(nodeBounds).size()));
m_contentLayer->layer()->setPosition(WebFloatPoint(targetCompositorLocal));
return pathHasChanged;
}
void InspectorFrontendClientImpl::moveWindowBy(float x, float y)
{
m_client->moveWindowBy(WebFloatPoint(x, y));
}
WebFloatPoint WebLayer::position() const
{
return WebFloatPoint(m_private->position());
}
WebFloatPoint WebLayer::anchorPoint() const
{
return WebFloatPoint(m_private->anchorPoint());
}
WebFloatPoint WebHistoryItem::visualViewportScrollOffset() const {
ScrollOffset offset = m_private->visualViewportScrollOffset();
return WebFloatPoint(offset.width(), offset.height());
}
