WebWheelEvent WebEventFactory::createWebWheelEvent(QWheelEvent* e, const QTransform& fromItemTransform)
{
float deltaX = 0;
float deltaY = 0;
float wheelTicksX = 0;
float wheelTicksY = 0;
WebWheelEvent::Granularity granularity = WebWheelEvent::ScrollByPixelWheelEvent;
WebEvent::Modifiers modifiers = modifiersForEvent(e->modifiers());
double timestamp = currentTimeForEvent(e);
if (e->orientation() == Qt::Horizontal) {
deltaX = e->delta();
wheelTicksX = deltaX / 120.0f;
} else {
deltaY = e->delta();
wheelTicksY = deltaY / 120.0f;
}
// Since we report the scroll by the pixel, convert the delta to pixel distance using standard scroll step.
// Use the same single scroll step as QTextEdit (in QTextEditPrivate::init [h,v]bar->setSingleStep)
static const float cDefaultQtScrollStep = 20.f;
// ### FIXME: Default from QtGui. Should use Qt platform theme API once configurable.
const int wheelScrollLines = 3;
deltaX = wheelTicksX * wheelScrollLines * cDefaultQtScrollStep;
deltaY = wheelTicksY * wheelScrollLines * cDefaultQtScrollStep;
// Transform the position and the pixel scrolling distance.
QLineF transformedScroll = fromItemTransform.map(QLineF(e->posF(), e->posF() + QPointF(deltaX, deltaY)));
IntPoint transformedPoint = transformedScroll.p1().toPoint();
IntPoint globalPoint = e->globalPosF().toPoint();
FloatSize transformedDelta(transformedScroll.dx(), transformedScroll.dy());
FloatSize wheelTicks(wheelTicksX, wheelTicksY);
return WebWheelEvent(WebEvent::Wheel, transformedPoint, globalPoint, transformedDelta, wheelTicks, granularity, modifiers, timestamp);
}
WebWheelEvent WebEventFactory::createWebWheelEvent(const Evas_Event_Mouse_Wheel* event, const AffineTransform& toWebContent, const AffineTransform& toDeviceScreen)
{
float deltaX = 0;
float deltaY = 0;
float wheelTicksX = 0;
float wheelTicksY = 0;
// A negative z value means (in EFL) that we are scrolling down, so we need
// to invert the value.
if (event->direction == VerticalScrollDirection) {
deltaX = 0;
deltaY = - event->z;
} else if (event->direction == HorizontalScrollDirection) {
deltaX = - event->z;
deltaY = 0;
}
wheelTicksX = deltaX;
wheelTicksY = deltaY;
deltaX *= static_cast<float>(Scrollbar::pixelsPerLineStep());
deltaY *= static_cast<float>(Scrollbar::pixelsPerLineStep());
IntPoint pos(event->canvas.x, event->canvas.y);
return WebWheelEvent(WebEvent::Wheel,
toWebContent.mapPoint(pos),
toDeviceScreen.mapPoint(pos),
FloatSize(deltaX, deltaY),
FloatSize(wheelTicksX, wheelTicksY),
WebWheelEvent::ScrollByPixelWheelEvent,
modifiersForEvent(event->modifiers),
convertMillisecondToSecond(event->timestamp));
}
WebWheelEvent WebEventFactory::createWebWheelEvent(QWheelEvent* e)
{
float deltaX = 0;
float deltaY = 0;
float wheelTicksX = 0;
float wheelTicksY = 0;
WebWheelEvent::Granularity granularity = WebWheelEvent::ScrollByPixelWheelEvent;
WebEvent::Modifiers modifiers = modifiersForEvent(e->modifiers());
double timestamp = currentTimeForEvent(e);
// A delta that is not mod 120 indicates a device that is sending
// fine-resolution scroll events, so use the delta as number of wheel ticks
// and number of pixels to scroll.See also webkit.org/b/29601
bool fullTick = !(e->delta() % 120);
if (e->orientation() == Qt::Horizontal) {
deltaX = (fullTick) ? e->delta() / 120.0f : e->delta();
wheelTicksX = deltaX;
} else {
deltaY = (fullTick) ? e->delta() / 120.0f : e->delta();
wheelTicksY = deltaY;
}
// Use the same single scroll step as QTextEdit
// (in QTextEditPrivate::init [h,v]bar->setSingleStep)
static const float cDefaultQtScrollStep = 20.f;
deltaX *= (fullTick) ? QApplication::wheelScrollLines() * cDefaultQtScrollStep : 1;
deltaY *= (fullTick) ? QApplication::wheelScrollLines() * cDefaultQtScrollStep : 1;
return WebWheelEvent(WebEvent::Wheel, e->posF().toPoint(), e->globalPosF().toPoint(), FloatSize(deltaX, deltaY), FloatSize(wheelTicksX, wheelTicksY), granularity, modifiers, timestamp);
}
WebWheelEvent WebEventFactory::createWebWheelEvent(WPE::Input::AxisEvent&& event)
{
// FIXME: We shouldn't hard-code this.
enum Axis {
Vertical,
Horizontal
};
WebCore::FloatSize wheelTicks;
switch (event.axis) {
case Vertical:
wheelTicks = WebCore::FloatSize(0, 1);
break;
case Horizontal:
wheelTicks = WebCore::FloatSize(1, 0);
break;
default:
ASSERT_NOT_REACHED();
};
WebCore::FloatSize delta = wheelTicks;
delta.scale(event.value / std::abs(event.value) * WebCore::Scrollbar::pixelsPerLineStep());
WebCore::IntPoint position(event.x, event.y);
return WebWheelEvent(WebEvent::Wheel, position, position,
delta, wheelTicks, WebWheelEvent::ScrollByPixelWheelEvent, static_cast<WebEvent::Modifiers>(0), event.time);
}
WebWheelEvent WebEventFactory::createWebWheelEvent(const NIXWheelEvent& event)
{
WebEvent::Type type = convertToWebEventType(event.type);
IntPoint position = IntPoint(event.x, event.y);
IntPoint globalPosition = IntPoint(event.globalX, event.globalY);
FloatSize delta = event.orientation == kNIXWheelEventOrientationVertical ? FloatSize(0, event.delta) : FloatSize(event.delta, 0);
WebEvent::Modifiers modifiers = convertToWebEventModifiers(event.modifiers);
double timestamp = event.timestamp;
const float ticks = event.delta / float(Scrollbar::pixelsPerLineStep());
FloatSize wheelTicks = event.orientation == kNIXWheelEventOrientationVertical ? FloatSize(0, ticks) : FloatSize(ticks, 0);
return WebWheelEvent(type, position, globalPosition, delta, wheelTicks, WebWheelEvent::ScrollByPixelWheelEvent, modifiers, timestamp);
}
WebWheelEvent WebEventFactory::createWebWheelEvent(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
// Taken from WebCore
static const float cScrollbarPixelsPerLine = 100.0f / 3.0f;
POINT globalPosition = point(lParam);
POINT position = globalPosition;
::ScreenToClient(hWnd, &position);
WebWheelEvent::Granularity granularity = WebWheelEvent::ScrollByPixelWheelEvent;
WebEvent::Modifiers modifiers = modifiersForEvent(wParam);
double timestamp = ::GetTickCount() * 0.001; // ::GetTickCount returns milliseconds (Chrome uses GetMessageTime() / 1000.0)
int deltaX = 0;
int deltaY = 0;
int wheelTicksX = 0;
int wheelTicksY = 0;
float delta = GET_WHEEL_DELTA_WPARAM(wParam) / static_cast<float>(WHEEL_DELTA);
bool isMouseHWheel = (message == WM_VISTA_MOUSEHWHEEL);
if (isMouseHWheel) {
wheelTicksX = delta;
wheelTicksY = 0;
delta = -delta;
} else {
wheelTicksX = 0;
wheelTicksY = delta;
}
if (isMouseHWheel || (modifiers & WebEvent::ShiftKey)) {
deltaX = delta * static_cast<float>(horizontalScrollChars()) * cScrollbarPixelsPerLine;
deltaY = 0;
granularity = WebWheelEvent::ScrollByPixelWheelEvent;
} else {
deltaX = 0;
deltaY = delta;
int verticalMultiplier = verticalScrollLines();
if (verticalMultiplier == WHEEL_PAGESCROLL)
granularity = WebWheelEvent::ScrollByPageWheelEvent;
else {
granularity = WebWheelEvent::ScrollByPixelWheelEvent;
deltaY *= static_cast<float>(verticalMultiplier) * cScrollbarPixelsPerLine;
}
}
return WebWheelEvent(WebEvent::Wheel, position, globalPosition, FloatSize(deltaX, deltaY), FloatSize(wheelTicksX, wheelTicksY), granularity, modifiers, timestamp);
}
WebWheelEvent WebEventFactory::createWebWheelEvent(const GdkEvent* event)
{
double x, y, xRoot, yRoot;
gdk_event_get_coords(event, &x, &y);
gdk_event_get_root_coords(event, &xRoot, &yRoot);
FloatSize wheelTicks;
switch (event->scroll.direction) {
case GDK_SCROLL_UP:
wheelTicks = FloatSize(0, 1);
break;
case GDK_SCROLL_DOWN:
wheelTicks = FloatSize(0, -1);
break;
case GDK_SCROLL_LEFT:
wheelTicks = FloatSize(1, 0);
break;
case GDK_SCROLL_RIGHT:
wheelTicks = FloatSize(-1, 0);
break;
#if GTK_CHECK_VERSION(3, 3, 18)
case GDK_SCROLL_SMOOTH: {
double deltaX, deltaY;
gdk_event_get_scroll_deltas(event, &deltaX, &deltaY);
wheelTicks = FloatSize(-deltaX, -deltaY);
}
break;
#endif
default:
ASSERT_NOT_REACHED();
}
// FIXME: [GTK] Add a setting to change the pixels per line used for scrolling
// https://bugs.webkit.org/show_bug.cgi?id=54826
float step = static_cast<float>(Scrollbar::pixelsPerLineStep());
FloatSize delta(wheelTicks.width() * step, wheelTicks.height() * step);
return WebWheelEvent(WebEvent::Wheel,
IntPoint(x, y),
IntPoint(xRoot, yRoot),
delta,
wheelTicks,
WebWheelEvent::ScrollByPixelWheelEvent,
modifiersForEvent(event),
gdk_event_get_time(event));
}
