IntPoint RenderLayerScrollableArea::lastKnownMousePosition() const
{
return box().frame() ? box().frame()->eventHandler().lastKnownMousePosition() : IntPoint();
}
IntRect PluginProxy::pluginBounds()
{
return IntRect(IntPoint(), m_pluginSize);
}
void ScrollAnimator::notifyPositionChanged(const FloatSize& delta)
{
UNUSED_PARAM(delta);
m_scrollableArea.setScrollOffsetFromAnimation(IntPoint(m_currentPosX, m_currentPosY));
}
ScrollPosition ScrollableArea::scrollPositionFromOffset(ScrollOffset offset) const
{
return IntPoint(toIntSize(offset) - toIntSize(m_scrollOrigin));
}
void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int)
{
if (m_frameBufferCache.isEmpty())
return;
// Initialize the framebuffer if needed.
ImageFrame& buffer = m_frameBufferCache[0];
if (buffer.status() == ImageFrame::FrameEmpty) {
png_structp png = m_reader->pngPtr();
if (!buffer.setSize(scaledSize().width(), scaledSize().height())) {
longjmp(JMPBUF(png), 1);
return;
}
unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr())) {
m_reader->createInterlaceBuffer(colorChannels * size().width() * size().height());
if (!m_reader->interlaceBuffer()) {
longjmp(JMPBUF(png), 1);
return;
}
}
#if USE(QCMSLIB)
if (m_reader->colorTransform()) {
m_reader->createRowBuffer(colorChannels * size().width());
if (!m_reader->rowBuffer()) {
longjmp(JMPBUF(png), 1);
return;
}
}
#endif
buffer.setStatus(ImageFrame::FramePartial);
buffer.setHasAlpha(false);
buffer.setColorProfile(m_colorProfile);
// For PNGs, the frame always fills the entire image.
buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
}
/* libpng comments (here to explain what follows).
*
* this function is called for every row in the image. If the
* image is interlacing, and you turned on the interlace handler,
* this function will be called for every row in every pass.
* Some of these rows will not be changed from the previous pass.
* When the row is not changed, the new_row variable will be NULL.
* The rows and passes are called in order, so you don't really
* need the row_num and pass, but I'm supplying them because it
* may make your life easier.
*/
// Nothing to do if the row is unchanged, or the row is outside
// the image bounds: libpng may send extra rows, ignore them to
// make our lives easier.
if (!rowBuffer)
return;
int y = !m_scaled ? rowIndex : scaledY(rowIndex);
if (y < 0 || y >= scaledSize().height())
return;
/* libpng comments (continued).
*
* For the non-NULL rows of interlaced images, you must call
* png_progressive_combine_row() passing in the row and the
* old row. You can call this function for NULL rows (it will
* just return) and for non-interlaced images (it just does the
* memcpy for you) if it will make the code easier. Thus, you
* can just do this for all cases:
*
* png_progressive_combine_row(png_ptr, old_row, new_row);
*
* where old_row is what was displayed for previous rows. Note
* that the first pass (pass == 0 really) will completely cover
* the old row, so the rows do not have to be initialized. After
* the first pass (and only for interlaced images), you will have
* to pass the current row, and the function will combine the
* old row and the new row.
*/
bool hasAlpha = m_reader->hasAlpha();
unsigned colorChannels = hasAlpha ? 4 : 3;
png_bytep row = rowBuffer;
if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
row = interlaceBuffer + (rowIndex * colorChannels * size().width());
png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
}
#if USE(QCMSLIB)
if (qcms_transform* transform = m_reader->colorTransform()) {
qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width());
row = m_reader->rowBuffer();
}
#endif
// Write the decoded row pixels to the frame buffer.
ImageFrame::PixelData* address = buffer.getAddr(0, y);
int width = scaledSize().width();
unsigned char nonTrivialAlphaMask = 0;
#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
if (m_scaled) {
for (int x = 0; x < width; ++x) {
png_bytep pixel = row + m_scaledColumns[x] * colorChannels;
unsigned alpha = hasAlpha ? pixel[3] : 255;
buffer.setRGBA(address++, pixel[0], pixel[1], pixel[2], alpha);
nonTrivialAlphaMask |= (255 - alpha);
}
} else
#endif
{
png_bytep pixel = row;
if (hasAlpha) {
if (buffer.premultiplyAlpha()) {
for (int x = 0; x < width; ++x, pixel += 4)
setPixelPremultipliedRGBA(address++, pixel, nonTrivialAlphaMask);
} else {
for (int x = 0; x < width; ++x, pixel += 4)
setPixelRGBA(address++, pixel, nonTrivialAlphaMask);
}
} else {
for (int x = 0; x < width; ++x, pixel += 3)
setPixelRGB(address++, pixel);
}
}
if (nonTrivialAlphaMask && !buffer.hasAlpha())
buffer.setHasAlpha(true);
}
IntPoint ClipboardWx::dragLocation() const
{
notImplemented();
return IntPoint(0,0);
}
void NetscapePlugin::geometryDidChange(const IntSize& pluginSize, const IntRect& clipRect, const AffineTransform& pluginToRootViewTransform)
{
ASSERT(m_isStarted);
if (pluginSize == m_pluginSize && m_clipRect == clipRect && m_pluginToRootViewTransform == pluginToRootViewTransform) {
// Nothing to do.
return;
}
bool shouldCallSetWindow = true;
// If the plug-in doesn't want window relative coordinates, we don't need to call setWindow unless its size or clip rect changes.
if (m_hasCalledSetWindow && wantsPluginRelativeNPWindowCoordinates() && m_pluginSize == pluginSize && m_clipRect == clipRect)
shouldCallSetWindow = false;
m_pluginSize = pluginSize;
m_clipRect = clipRect;
m_pluginToRootViewTransform = pluginToRootViewTransform;
IntPoint frameRectLocationInWindowCoordinates = m_pluginToRootViewTransform.mapPoint(IntPoint());
m_frameRectInWindowCoordinates = IntRect(frameRectLocationInWindowCoordinates, m_pluginSize);
platformGeometryDidChange();
if (!shouldCallSetWindow)
return;
callSetWindow();
}
IntRect Image::rect() const
{
return IntRect(IntPoint(), size());
}
void PaintPropertyTreeBuilder::updateFramePropertiesAndContext(
FrameView& frameView,
PaintPropertyTreeBuilderContext& context) {
if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
// With root layer scrolling, the LayoutView (a LayoutObject) properties are
// updated like other objects (see updatePropertiesAndContextForSelf and
// updatePropertiesAndContextForChildren) instead of needing LayoutView-
// specific property updates here.
context.current.paintOffset.moveBy(frameView.location());
context.current.renderingContextID = 0;
context.current.shouldFlattenInheritedTransform = true;
context.absolutePosition = context.current;
context.containerForAbsolutePosition = nullptr;
context.fixedPosition = context.current;
return;
}
TransformationMatrix frameTranslate;
frameTranslate.translate(frameView.x() + context.current.paintOffset.x(),
frameView.y() + context.current.paintOffset.y());
updateFrameViewPreTranslation(frameView, context.current.transform,
frameTranslate, FloatPoint3D());
FloatRoundedRect contentClip(
IntRect(IntPoint(), frameView.visibleContentSize()));
updateFrameViewContentClip(frameView, context.current.clip,
frameView.preTranslation(), contentClip);
ScrollOffset scrollOffset = frameView.scrollOffset();
if (frameView.isScrollable() || !scrollOffset.isZero()) {
TransformationMatrix frameScroll;
frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
updateFrameViewScrollTranslation(frameView, frameView.preTranslation(),
frameScroll, FloatPoint3D());
IntSize scrollClip = frameView.visibleContentSize();
IntSize scrollBounds = frameView.contentsSize();
bool userScrollableHorizontal =
frameView.userInputScrollable(HorizontalScrollbar);
bool userScrollableVertical =
frameView.userInputScrollable(VerticalScrollbar);
updateFrameViewScroll(frameView, context.current.scroll,
frameView.scrollTranslation(), scrollClip,
scrollBounds, userScrollableHorizontal,
userScrollableVertical);
} else {
// Ensure pre-existing properties are cleared when there is no scrolling.
frameView.setScrollTranslation(nullptr);
frameView.setScroll(nullptr);
}
// Initialize the context for current, absolute and fixed position cases.
// They are the same, except that scroll translation does not apply to
// fixed position descendants.
const auto* fixedTransformNode = frameView.preTranslation()
? frameView.preTranslation()
: context.current.transform;
auto* fixedScrollNode = context.current.scroll;
DCHECK(frameView.preTranslation());
context.current.transform = frameView.preTranslation();
DCHECK(frameView.contentClip());
context.current.clip = frameView.contentClip();
if (const auto* scrollTranslation = frameView.scrollTranslation())
context.current.transform = scrollTranslation;
if (auto* scroll = frameView.scroll())
context.current.scroll = scroll;
context.current.paintOffset = LayoutPoint();
context.current.renderingContextID = 0;
context.current.shouldFlattenInheritedTransform = true;
context.absolutePosition = context.current;
context.containerForAbsolutePosition = nullptr;
context.fixedPosition = context.current;
context.fixedPosition.transform = fixedTransformNode;
context.fixedPosition.scroll = fixedScrollNode;
std::unique_ptr<PropertyTreeState> contentsState(
new PropertyTreeState(context.current.transform, context.current.clip,
context.currentEffect, context.current.scroll));
frameView.setTotalPropertyTreeStateForContents(std::move(contentsState));
}
void ScrollView::setPosition(int _left, int _top)
{
setPosition(IntPoint(_left, _top));
}
void ListMarkerPainter::paint(const PaintInfo& paintInfo,
const LayoutPoint& paintOffset) {
if (paintInfo.phase != PaintPhaseForeground)
return;
if (m_layoutListMarker.style()->visibility() != EVisibility::Visible)
return;
if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(
paintInfo.context, m_layoutListMarker, paintInfo.phase))
return;
LayoutPoint boxOrigin(paintOffset + m_layoutListMarker.location());
LayoutRect overflowRect(m_layoutListMarker.visualOverflowRect());
overflowRect.moveBy(boxOrigin);
IntRect pixelSnappedOverflowRect = pixelSnappedIntRect(overflowRect);
if (!paintInfo.cullRect().intersectsCullRect(overflowRect))
return;
LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutListMarker,
paintInfo.phase,
pixelSnappedOverflowRect);
LayoutRect box(boxOrigin, m_layoutListMarker.size());
IntRect marker = m_layoutListMarker.getRelativeMarkerRect();
marker.moveBy(roundedIntPoint(boxOrigin));
GraphicsContext& context = paintInfo.context;
if (m_layoutListMarker.isImage()) {
context.drawImage(m_layoutListMarker.image()
->image(m_layoutListMarker, marker.size(),
m_layoutListMarker.styleRef().effectiveZoom())
.get(),
marker);
if (m_layoutListMarker.getSelectionState() != SelectionNone) {
LayoutRect selRect = m_layoutListMarker.localSelectionRect();
selRect.moveBy(boxOrigin);
context.fillRect(
pixelSnappedIntRect(selRect),
m_layoutListMarker.listItem()->selectionBackgroundColor());
}
return;
}
LayoutListMarker::ListStyleCategory styleCategory =
m_layoutListMarker.getListStyleCategory();
if (styleCategory == LayoutListMarker::ListStyleCategory::None)
return;
Color color(m_layoutListMarker.resolveColor(CSSPropertyColor));
if (BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(
m_layoutListMarker.styleRef(),
m_layoutListMarker.listItem()->document()))
color = TextPainter::textColorForWhiteBackground(color);
// Apply the color to the list marker text.
context.setFillColor(color);
const EListStyleType listStyle = m_layoutListMarker.style()->listStyleType();
if (styleCategory == LayoutListMarker::ListStyleCategory::Symbol) {
paintSymbol(context, color, marker, listStyle);
return;
}
if (m_layoutListMarker.text().isEmpty())
return;
const Font& font = m_layoutListMarker.style()->font();
TextRun textRun = constructTextRun(font, m_layoutListMarker.text(),
m_layoutListMarker.styleRef());
GraphicsContextStateSaver stateSaver(context, false);
if (!m_layoutListMarker.style()->isHorizontalWritingMode()) {
marker.moveBy(roundedIntPoint(-boxOrigin));
marker = marker.transposedRect();
marker.moveBy(
IntPoint(roundToInt(box.x()),
roundToInt(box.y() - m_layoutListMarker.logicalHeight())));
stateSaver.save();
context.translate(marker.x(), marker.maxY());
context.rotate(static_cast<float>(deg2rad(90.)));
context.translate(-marker.x(), -marker.maxY());
}
TextRunPaintInfo textRunPaintInfo(textRun);
textRunPaintInfo.bounds = marker;
const SimpleFontData* fontData =
m_layoutListMarker.style()->font().primaryFont();
IntPoint textOrigin = IntPoint(
marker.x(),
marker.y() + (fontData ? fontData->getFontMetrics().ascent() : 0));
// Text is not arbitrary. We can judge whether it's RTL from the first
// character, and we only need to handle the direction RightToLeft for now.
bool textNeedsReversing =
WTF::Unicode::direction(m_layoutListMarker.text()[0]) ==
WTF::Unicode::RightToLeft;
StringBuilder reversedText;
if (textNeedsReversing) {
unsigned length = m_layoutListMarker.text().length();
reversedText.reserveCapacity(length);
for (int i = length - 1; i >= 0; --i)
reversedText.append(m_layoutListMarker.text()[i]);
DCHECK(reversedText.length() == length);
textRun.setText(reversedText.toString());
}
const UChar suffix =
ListMarkerText::suffix(listStyle, m_layoutListMarker.listItem()->value());
UChar suffixStr[2] = {suffix, static_cast<UChar>(' ')};
TextRun suffixRun =
constructTextRun(font, suffixStr, 2, m_layoutListMarker.styleRef(),
m_layoutListMarker.style()->direction());
TextRunPaintInfo suffixRunInfo(suffixRun);
suffixRunInfo.bounds = marker;
if (m_layoutListMarker.style()->isLeftToRightDirection()) {
context.drawText(font, textRunPaintInfo, textOrigin);
context.drawText(font, suffixRunInfo,
textOrigin + IntSize(font.width(textRun), 0));
} else {
context.drawText(font, suffixRunInfo, textOrigin);
context.drawText(font, textRunPaintInfo,
textOrigin + IntSize(font.width(suffixRun), 0));
}
}
void ScrollView::setContentPosition(const IntPoint& _point)
{
if (mRealClient != nullptr)
mRealClient->setPosition(IntPoint() - _point);
}
IntPoint ScrollView::getContentPosition()
{
return mRealClient == nullptr ? IntPoint() : (IntPoint() - mRealClient->getPosition());
}
IntPoint RenderTextLineBoxes::firstRunLocation() const
{
if (!m_first)
return IntPoint();
return IntPoint(m_first->topLeft());
}
IntPoint WebChromeClient::screenToWindow(const IntPoint&) const
{
notImplemented();
return IntPoint();
}
void CCCanvasLayerImpl::appendQuads(CCQuadCuller& quadList, const CCSharedQuadState* sharedQuadState)
{
IntRect quadRect(IntPoint(), bounds());
quadList.append(CCCanvasDrawQuad::create(sharedQuadState, quadRect, m_textureId, m_hasAlpha, m_premultipliedAlpha));
}
IntRect::IntRect(const RECT& r)
: m_location(IntPoint(r.left, r.top)), m_size(IntSize(r.right-r.left, r.bottom-r.top))
{
}
IntRect FilterEffect::drawingRegionOfInputImage(const IntRect& srcRect) const
{
return IntRect(IntPoint(srcRect.x() - m_absolutePaintRect.x(),
srcRect.y() - m_absolutePaintRect.y()), srcRect.size());
}
IntRect EllipsisBox::selectionRect()
{
RenderStyle* style = renderer().style(isFirstLineStyle());
const Font& font = style->font();
return enclosingIntRect(font.selectionRectForText(constructTextRun(&renderer(), font, m_str, style, TextRun::AllowTrailingExpansion), IntPoint(logicalLeft(), logicalTop() + root().selectionTopAdjustedForPrecedingBlock()), root().selectionHeightAdjustedForPrecedingBlock()));
}
void GraphicsContext::drawImageBuffer(ImageBuffer* image, ColorSpace styleColorSpace, const FloatRect& dest)
{
if (!image)
return;
drawImageBuffer(image, styleColorSpace, dest, FloatRect(IntRect(IntPoint(), image->logicalSize())));
}
IntRect TiledDrawingAreaProxy::contentsRect() const
{
return mapFromContents(IntRect(IntPoint(0, 0), m_viewSize));
}
void ScrollAnimator::notifyPositionChanged()
{
m_scrollableArea->setScrollOffsetFromAnimation(IntPoint(m_currentPosX, m_currentPosY));
}
ScrollOffset ScrollableArea::scrollOffsetFromPosition(ScrollPosition position) const
{
return IntPoint(toIntSize(position) + toIntSize(m_scrollOrigin));
}
void RenderFrameSet::positionFramesWithFlattening()
{
RenderBox* child = firstChildBox();
if (!child)
return;
int rows = frameSetElement().totalRows();
int cols = frameSetElement().totalCols();
int borderThickness = frameSetElement().border();
bool repaintNeeded = false;
// calculate frameset height based on actual content height to eliminate scrolling
bool out = false;
for (int r = 0; r < rows && !out; ++r) {
int extra = 0;
int height = m_rows.m_sizes[r];
for (int c = 0; c < cols; ++c) {
IntRect oldFrameRect = snappedIntRect(child->frameRect());
int width = m_cols.m_sizes[c];
bool fixedWidth = frameSetElement().colLengths() && frameSetElement().colLengths()[c].isFixed();
bool fixedHeight = frameSetElement().rowLengths() && frameSetElement().rowLengths()[r].isFixed();
// has to be resized and itself resize its contents
if (!fixedWidth)
child->setWidth(width ? width + extra / (cols - c) : 0);
else
child->setWidth(width);
child->setHeight(height);
child->setNeedsLayout();
if (is<RenderFrameSet>(*child))
downcast<RenderFrameSet>(*child).layout();
else
downcast<RenderFrame>(*child).layoutWithFlattening(fixedWidth, fixedHeight);
if (child->height() > m_rows.m_sizes[r])
m_rows.m_sizes[r] = child->height();
if (child->width() > m_cols.m_sizes[c])
m_cols.m_sizes[c] = child->width();
if (child->frameRect() != oldFrameRect)
repaintNeeded = true;
// difference between calculated frame width and the width it actually decides to have
extra += width - m_cols.m_sizes[c];
child = child->nextSiblingBox();
if (!child) {
out = true;
break;
}
}
}
int xPos = 0;
int yPos = 0;
out = false;
child = firstChildBox();
for (int r = 0; r < rows && !out; ++r) {
xPos = 0;
for (int c = 0; c < cols; ++c) {
// ensure the rows and columns are filled
IntRect oldRect = snappedIntRect(child->frameRect());
child->setLocation(IntPoint(xPos, yPos));
child->setHeight(m_rows.m_sizes[r]);
child->setWidth(m_cols.m_sizes[c]);
if (child->frameRect() != oldRect) {
repaintNeeded = true;
// update to final size
child->setNeedsLayout();
if (is<RenderFrameSet>(*child))
downcast<RenderFrameSet>(*child).layout();
else
downcast<RenderFrame>(*child).layoutWithFlattening(true, true);
}
xPos += m_cols.m_sizes[c] + borderThickness;
child = child->nextSiblingBox();
if (!child) {
out = true;
break;
}
}
yPos += m_rows.m_sizes[r] + borderThickness;
}
setWidth(xPos - borderThickness);
setHeight(yPos - borderThickness);
if (repaintNeeded)
repaint();
// all the remaining frames are hidden to avoid ugly spurious unflowed frames
for (; child; child = child->nextSiblingBox()) {
child->setWidth(0);
child->setHeight(0);
child->clearNeedsLayout();
}
}
IntPoint Plugin::convertToRootView(const IntPoint&) const
{
ASSERT_NOT_REACHED();
return IntPoint();
}
bool GIFImageDecoder::initFrameBuffer(unsigned frameIndex)
{
// Initialize the frame rect in our buffer.
const GIFFrameContext* frameContext = m_reader->frameContext();
IntRect frameRect(frameContext->xOffset, frameContext->yOffset, frameContext->width, frameContext->height);
// Make sure the frameRect doesn't extend outside the buffer.
if (frameRect.maxX() > size().width())
frameRect.setWidth(size().width() - frameContext->xOffset);
if (frameRect.maxY() > size().height())
frameRect.setHeight(size().height() - frameContext->yOffset);
ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
int left = upperBoundScaledX(frameRect.x());
int right = lowerBoundScaledX(frameRect.maxX(), left);
int top = upperBoundScaledY(frameRect.y());
int bottom = lowerBoundScaledY(frameRect.maxY(), top);
buffer->setOriginalFrameRect(IntRect(left, top, right - left, bottom - top));
if (!frameIndex) {
// This is the first frame, so we're not relying on any previous data.
if (!buffer->setSize(scaledSize().width(), scaledSize().height()))
return setFailed();
} else {
// The starting state for this frame depends on the previous frame's
// disposal method.
//
// Frames that use the DisposeOverwritePrevious method are effectively
// no-ops in terms of changing the starting state of a frame compared to
// the starting state of the previous frame, so skip over them. (If the
// first frame specifies this method, it will get treated like
// DisposeOverwriteBgcolor below and reset to a completely empty image.)
const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
ImageFrame::FrameDisposalMethod prevMethod = prevBuffer->disposalMethod();
while (frameIndex && (prevMethod == ImageFrame::DisposeOverwritePrevious)) {
prevBuffer = &m_frameBufferCache[--frameIndex];
prevMethod = prevBuffer->disposalMethod();
}
ASSERT(prevBuffer->status() == ImageFrame::FrameComplete);
if ((prevMethod == ImageFrame::DisposeNotSpecified) || (prevMethod == ImageFrame::DisposeKeep)) {
// Preserve the last frame as the starting state for this frame.
if (!buffer->copyBitmapData(*prevBuffer))
return setFailed();
} else {
// We want to clear the previous frame to transparent, without
// affecting pixels in the image outside of the frame.
const IntRect& prevRect = prevBuffer->originalFrameRect();
const IntSize& bufferSize = scaledSize();
if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
// Clearing the first frame, or a frame the size of the whole
// image, results in a completely empty image.
if (!buffer->setSize(bufferSize.width(), bufferSize.height()))
return setFailed();
} else {
// Copy the whole previous buffer, then clear just its frame.
if (!buffer->copyBitmapData(*prevBuffer))
return setFailed();
buffer->zeroFillFrameRect(prevRect);
}
}
}
// Update our status to be partially complete.
buffer->setStatus(ImageFrame::FramePartial);
// Reset the alpha pixel tracker for this frame.
m_currentBufferSawAlpha = false;
return true;
}
IntRect CCScrollbarLayerImpl::CCScrollbar::frameRect() const
{
return IntRect(IntPoint(), m_owner->contentBounds());
}
PlatformGestureEventBuilder::PlatformGestureEventBuilder(Widget* widget, const WebGestureEvent& e)
{
float scale = widgetScaleFactor(widget);
switch (e.type) {
case WebInputEvent::GestureScrollBegin:
m_type = PlatformEvent::GestureScrollBegin;
break;
case WebInputEvent::GestureScrollEnd:
m_type = PlatformEvent::GestureScrollEnd;
break;
case WebInputEvent::GestureScrollUpdate:
m_type = PlatformEvent::GestureScrollUpdate;
m_deltaX = e.data.scrollUpdate.deltaX / scale;
m_deltaY = e.data.scrollUpdate.deltaY / scale;
break;
case WebInputEvent::GestureScrollUpdateWithoutPropagation:
m_type = PlatformEvent::GestureScrollUpdateWithoutPropagation;
m_deltaX = e.data.scrollUpdate.deltaX / scale;
m_deltaY = e.data.scrollUpdate.deltaY / scale;
break;
case WebInputEvent::GestureTap:
m_type = PlatformEvent::GestureTap;
m_area = expandedIntSize(FloatSize(e.data.tap.width / scale, e.data.tap.height / scale));
// FIXME: PlatformGestureEvent deltaX is overloaded - wkb.ug/93123
m_deltaX = static_cast<int>(e.data.tap.tapCount);
break;
case WebInputEvent::GestureTapUnconfirmed:
m_type = PlatformEvent::GestureTapUnconfirmed;
m_area = expandedIntSize(FloatSize(e.data.tap.width / scale, e.data.tap.height / scale));
break;
case WebInputEvent::GestureTapDown:
m_type = PlatformEvent::GestureTapDown;
m_area = expandedIntSize(FloatSize(e.data.tapDown.width / scale, e.data.tapDown.height / scale));
break;
case WebInputEvent::GestureTapCancel:
m_type = PlatformEvent::GestureTapDownCancel;
break;
case WebInputEvent::GestureDoubleTap:
// DoubleTap gesture is now handled as PlatformEvent::GestureTap with tap_count = 2. So no
// need to convert to a Platfrom DoubleTap gesture. But in WebViewImpl::handleGestureEvent
// all WebGestureEvent are converted to PlatformGestureEvent, for completeness and not reach
// the ASSERT_NOT_REACHED() at the end, convert the DoubleTap to a NoType.
m_type = PlatformEvent::NoType;
break;
case WebInputEvent::GestureTwoFingerTap:
m_type = PlatformEvent::GestureTwoFingerTap;
m_area = expandedIntSize(FloatSize(e.data.twoFingerTap.firstFingerWidth / scale, e.data.twoFingerTap.firstFingerHeight / scale));
break;
case WebInputEvent::GestureLongPress:
m_type = PlatformEvent::GestureLongPress;
m_area = expandedIntSize(FloatSize(e.data.longPress.width / scale, e.data.longPress.height / scale));
break;
case WebInputEvent::GestureLongTap:
m_type = PlatformEvent::GestureLongTap;
m_area = expandedIntSize(FloatSize(e.data.longPress.width / scale, e.data.longPress.height / scale));
break;
case WebInputEvent::GesturePinchBegin:
m_type = PlatformEvent::GesturePinchBegin;
break;
case WebInputEvent::GesturePinchEnd:
m_type = PlatformEvent::GesturePinchEnd;
break;
case WebInputEvent::GesturePinchUpdate:
m_type = PlatformEvent::GesturePinchUpdate;
// FIXME: PlatformGestureEvent deltaX is overloaded - wkb.ug/93123
m_deltaX = e.data.pinchUpdate.scale;
break;
default:
ASSERT_NOT_REACHED();
}
m_position = widget->convertFromContainingWindow(IntPoint(e.x / scale, e.y / scale));
m_globalPosition = IntPoint(e.globalX, e.globalY);
m_timestamp = e.timeStampSeconds;
m_modifiers = 0;
if (e.modifiers & WebInputEvent::ShiftKey)
m_modifiers |= PlatformEvent::ShiftKey;
if (e.modifiers & WebInputEvent::ControlKey)
m_modifiers |= PlatformEvent::CtrlKey;
if (e.modifiers & WebInputEvent::AltKey)
m_modifiers |= PlatformEvent::AltKey;
if (e.modifiers & WebInputEvent::MetaKey)
m_modifiers |= PlatformEvent::MetaKey;
}
void InternalSettings::setPageScaleFactor(float scaleFactor, int x, int y, ExceptionCode& ec)
{
InternalSettingsGuardForPage();
page()->setPageScaleFactor(scaleFactor, IntPoint(x, y));
}
IntRect RenderLayerScrollableArea::visibleContentRect(IncludeScrollbarsInRect scrollbarInclusion) const
{
return IntRect(IntPoint(scrollXOffset(), scrollYOffset()),
IntSize(max(0, layer()->size().width()), max(0, layer()->size().height())));
}
