PassRefPtr<WebKitPoint> Internals::touchPositionAdjustedToBestClickableNode(long x, long y, long width, long height, Document* document, ExceptionCode& ec)
{
if (!document || !document->frame()) {
ec = INVALID_ACCESS_ERR;
return 0;
}
IntSize radius(width / 2, height / 2);
IntPoint point(x + radius.width(), y + radius.height());
Node* targetNode;
IntPoint adjustedPoint;
bool foundNode = document->frame()->eventHandler()->bestClickableNodeForTouchPoint(point, radius, adjustedPoint, targetNode);
if (foundNode)
return WebKitPoint::create(adjustedPoint.x(), adjustedPoint.y());
return 0;
}
static FloatPoint convertHitPointToWindow(const Widget* widget, FloatPoint point)
{
float scale = 1;
IntSize offset;
IntPoint pinchViewport;
FloatSize overscrollOffset;
if (widget) {
FrameView* rootView = toFrameView(widget->root());
if (rootView) {
scale = rootView->inputEventsScaleFactor();
offset = rootView->inputEventsOffsetForEmulation();
pinchViewport = flooredIntPoint(rootView->page()->frameHost().pinchViewport().visibleRect().location());
overscrollOffset = rootView->elasticOverscroll();
}
}
return FloatPoint(
(point.x() - offset.width()) / scale + pinchViewport.x() + overscrollOffset.width(),
(point.y() - offset.height()) / scale + pinchViewport.y() + overscrollOffset.height());
}
void RenderMathMLFraction::paint(PaintInfo& info, const LayoutPoint& paintOffset)
{
RenderMathMLBlock::paint(info, paintOffset);
if (info.context().paintingDisabled() || info.phase != PaintPhaseForeground || style().visibility() != VISIBLE)
return;
RenderBox* denominatorWrapper = lastChildBox();
if (!denominatorWrapper || !m_lineThickness)
return;
IntPoint adjustedPaintOffset = roundedIntPoint(paintOffset + location() + denominatorWrapper->location() + LayoutPoint(0, m_lineThickness / 2));
GraphicsContextStateSaver stateSaver(info.context());
info.context().setStrokeThickness(m_lineThickness);
info.context().setStrokeStyle(SolidStroke);
info.context().setStrokeColor(style().visitedDependentColor(CSSPropertyColor));
info.context().drawLine(adjustedPaintOffset, roundedIntPoint(LayoutPoint(adjustedPaintOffset.x() + denominatorWrapper->offsetWidth(), adjustedPaintOffset.y())));
}
void EventTargetNode::dispatchWheelEvent(PlatformWheelEvent& e)
{
ASSERT(!eventDispatchForbidden());
if (e.deltaX() == 0 && e.deltaY() == 0)
return;
FrameView* view = document()->view();
if (!view)
return;
IntPoint pos = view->windowToContents(e.pos());
RefPtr<WheelEvent> we = WheelEvent::create(e.deltaX(), e.deltaY(),
document()->defaultView(), e.globalX(), e.globalY(), pos.x(), pos.y(),
e.ctrlKey(), e.altKey(), e.shiftKey(), e.metaKey());
ExceptionCode ec = 0;
if (!dispatchEvent(we.release(), ec, true))
e.accept();
}
void DeprecatedPaintLayerPainter::paintFragmentByApplyingTransform(GraphicsContext* context, const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& fragmentTranslation)
{
// This involves subtracting out the position of the layer in our current coordinate space, but preserving
// the accumulated error for sub-pixel layout.
LayoutPoint delta;
m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, delta);
delta.moveBy(fragmentTranslation);
TransformationMatrix transform(m_paintLayer.renderableTransform(paintingInfo.globalPaintFlags()));
IntPoint roundedDelta = roundedIntPoint(delta);
transform.translateRight(roundedDelta.x(), roundedDelta.y());
LayoutSize adjustedSubPixelAccumulation = paintingInfo.subPixelAccumulation + (delta - roundedDelta);
Transform3DRecorder transform3DRecorder(*context, *m_paintLayer.layoutObject(), DisplayItem::Transform3DElementTransform, transform);
// Now do a paint with the root layer shifted to be us.
DeprecatedPaintLayerPaintingInfo transformedPaintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(transform.inverse().mapRect(paintingInfo.paintDirtyRect))), paintingInfo.globalPaintFlags(),
adjustedSubPixelAccumulation, paintingInfo.paintingRoot);
paintLayerContentsAndReflection(context, transformedPaintingInfo, paintFlags, ForceSingleFragment);
}
/*
* Strategy to painting a Widget:
* 1.) do not paint if there is no GtkWidget set
* 2.) We assume that the widget has no window and that frameRectsChanged positioned
* the widget correctly. ATM we do not honor the GraphicsContext translation.
*/
void ScrollbarGtk::paint(GraphicsContext* context, const IntRect& rect)
{
if (!platformWidget())
return;
if (!context->gdkExposeEvent())
return;
GtkWidget* widget = platformWidget();
ASSERT(!gtk_widget_get_has_window(widget));
GdkEvent* event = gdk_event_new(GDK_EXPOSE);
event->expose = *context->gdkExposeEvent();
event->expose.area = static_cast<GdkRectangle>(rect);
IntPoint loc = getLocationInParentWindow(rect);
event->expose.area.x = loc.x();
event->expose.area.y = loc.y();
#ifdef GTK_API_VERSION_2
event->expose.region = gdk_region_rectangle(&event->expose.area);
#else
event->expose.region = cairo_region_create_rectangle(&event->expose.area);
#endif
/*
* This will be unref'ed by gdk_event_free.
*/
g_object_ref(event->expose.window);
/*
* If we are going to paint do the translation and GtkAllocation manipulation.
*/
#ifdef GTK_API_VERSION_2
if (!gdk_region_empty(event->expose.region))
#else
if (!cairo_region_is_empty(event->expose.region))
#endif
gtk_widget_send_expose(widget, event);
gdk_event_free(event);
}
void PluginView::setNPWindowRect(const IntRect& rect)
{
if (!m_isStarted)
return;
float scaleFactor = deviceScaleFactor();
IntPoint p = downcast<FrameView>(*parent()).contentsToWindow(rect.location());
p.scale(scaleFactor, scaleFactor);
IntSize s = rect.size();
s.scale(scaleFactor);
m_npWindow.x = p.x();
m_npWindow.y = p.y();
m_npWindow.width = s.width();
m_npWindow.height = s.height();
m_npWindow.clipRect.right = s.width();
m_npWindow.clipRect.bottom = s.height();
m_npWindow.clipRect.left = 0;
m_npWindow.clipRect.top = 0;
if (m_plugin->pluginFuncs()->setwindow) {
JSC::JSLock::DropAllLocks dropAllLocks(JSDOMWindowBase::commonVM());
setCallingPlugin(true);
m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
setCallingPlugin(false);
m_haveCalledSetWindow = true;
if (!m_isWindowed)
return;
ASSERT(platformPluginWidget());
WNDPROC currentWndProc = (WNDPROC)GetWindowLongPtr(platformPluginWidget(), GWLP_WNDPROC);
if (currentWndProc != PluginViewWndProc)
m_pluginWndProc = (WNDPROC)SetWindowLongPtr(platformPluginWidget(), GWLP_WNDPROC, (LONG_PTR)PluginViewWndProc);
}
}
void BackingStore::incorporateUpdate(ShareableBitmap* bitmap, const UpdateInfo& updateInfo)
{
if (m_pixmap.isNull())
m_pixmap = QPixmap(m_size);
scroll(updateInfo.scrollRect, updateInfo.scrollOffset);
IntPoint updateRectLocation = updateInfo.updateRectBounds.location();
QPainter painter(&m_pixmap);
GraphicsContext graphicsContext(&painter);
// Paint all update rects.
for (size_t i = 0; i < updateInfo.updateRects.size(); ++i) {
IntRect updateRect = updateInfo.updateRects[i];
IntRect srcRect = updateRect;
srcRect.move(-updateRectLocation.x(), -updateRectLocation.y());
bitmap->paint(graphicsContext, updateRect.location(), srcRect);
}
}
void PluginView::paint(GraphicsContext* context, const IntRect& dirtyRect)
{
if (context->paintingDisabled() || !m_plugin || !m_isInitialized)
return;
IntRect dirtyRectInWindowCoordinates = parent()->contentsToWindow(dirtyRect);
IntRect paintRectInWindowCoordinates = intersection(dirtyRectInWindowCoordinates, clipRectInWindowCoordinates());
if (paintRectInWindowCoordinates.isEmpty())
return;
// context is in document coordinates. Translate it to window coordinates.
IntPoint documentOriginInWindowCoordinates = parent()->contentsToWindow(IntPoint());
context->save();
context->translate(-documentOriginInWindowCoordinates.x(), -documentOriginInWindowCoordinates.y());
m_plugin->paint(context, paintRectInWindowCoordinates);
context->restore();
}
void GraphicsSurface::platformCopyToGLTexture(uint32_t target, uint32_t id, const IntRect& targetRect, const IntPoint& offset)
{
glPushAttrib(GL_ALL_ATTRIB_BITS);
if (!m_fbo)
glGenFramebuffers(1, &m_fbo);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
glBindTexture(target, id);
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo);
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, m_private->frontBufferTextureID(), 0);
glCopyTexSubImage2D(target, 0, targetRect.x(), targetRect.y(), offset.x(), offset.y(), targetRect.width(), targetRect.height());
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, 0, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
glPopAttrib();
// According to IOSurface's documentation, glBindFramebuffer is the one triggering an update of the surface's cache.
// If the web process starts rendering and unlocks the surface before this happens, we might copy contents
// of the currently rendering frame on our texture instead of the previously completed frame.
// Flush the command buffer to reduce the odds of this happening, this would not be necessary with double buffering.
glFlush();
}
void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(
const LayoutObject& object,
PaintPropertyTreeBuilderContext& context) {
if (object.isBoxModelObject() &&
context.current.paintOffset != LayoutPoint()) {
// TODO(trchen): Eliminate PaintLayer dependency.
PaintLayer* layer = toLayoutBoxModelObject(object).layer();
if (layer && layer->paintsWithTransform(GlobalPaintNormalPhase)) {
// We should use the same subpixel paint offset values for snapping
// regardless of whether a transform is present. If there is a transform
// we round the paint offset but keep around the residual fractional
// component for the transformed content to paint with. In spv1 this was
// called "subpixel accumulation". For more information, see
// PaintLayer::subpixelAccumulation() and
// PaintLayerPainter::paintFragmentByApplyingTransform.
IntPoint roundedPaintOffset =
roundedIntPoint(context.current.paintOffset);
LayoutPoint fractionalPaintOffset =
LayoutPoint(context.current.paintOffset - roundedPaintOffset);
context.current.transform =
object.getMutableForPainting()
.ensurePaintProperties()
.updatePaintOffsetTranslation(
context.current.transform,
TransformationMatrix().translate(roundedPaintOffset.x(),
roundedPaintOffset.y()),
FloatPoint3D(),
context.current.shouldFlattenInheritedTransform,
context.current.renderingContextID);
context.current.paintOffset = fractionalPaintOffset;
return;
}
}
if (object.isLayoutView())
return;
if (auto* properties = object.getMutableForPainting().paintProperties())
properties->clearPaintOffsetTranslation();
}
PlatformWheelEventBuilder::PlatformWheelEventBuilder(Widget* widget, const WebMouseWheelEvent& e)
{
float scale = widgetInputEventsScaleFactor(widget);
IntSize offset = widgetInputEventsOffset(widget);
IntPoint pinchViewport = pinchViewportOffset(widget);
m_position = widget->convertFromContainingWindow(
IntPoint((e.x - offset.width()) / scale + pinchViewport.x(), (e.y - offset.height()) / scale + pinchViewport.y()));
m_globalPosition = IntPoint(e.globalX, e.globalY);
m_deltaX = e.deltaX;
m_deltaY = e.deltaY;
m_wheelTicksX = e.wheelTicksX;
m_wheelTicksY = e.wheelTicksY;
m_granularity = e.scrollByPage ?
ScrollByPageWheelEvent : ScrollByPixelWheelEvent;
m_type = PlatformEvent::Wheel;
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;
m_hasPreciseScrollingDeltas = e.hasPreciseScrollingDeltas;
#if OS(MACOSX)
m_phase = static_cast<WebCore::PlatformWheelEventPhase>(e.phase);
m_momentumPhase = static_cast<WebCore::PlatformWheelEventPhase>(e.momentumPhase);
m_timestamp = e.timeStampSeconds;
m_scrollCount = 0;
m_unacceleratedScrollingDeltaX = e.deltaX;
m_unacceleratedScrollingDeltaY = e.deltaY;
m_canRubberbandLeft = e.canRubberbandLeft;
m_canRubberbandRight = e.canRubberbandRight;
#endif
}
IntRect PopupContainer::layoutAndCalculateWidgetRect(int targetControlHeight, const IntPoint& popupInitialCoordinate)
{
// Reset the max width and height to their default values, they will be recomputed below
// if necessary.
m_listBox->setMaxHeight(kMaxHeight);
m_listBox->setMaxWidth(std::numeric_limits<int>::max());
// Lay everything out to figure out our preferred size, then tell the view's
// WidgetClient about it. It should assign us a client.
int rtlOffset = layoutAndGetRTLOffset();
bool isRTL = this->isRTL();
int rightOffset = isRTL ? rtlOffset : 0;
// Assume m_listBox size is already calculated.
IntSize targetSize(m_listBox->width() + kBorderSize * 2,
m_listBox->height() + kBorderSize * 2);
IntRect widgetRectInScreen;
ChromeClientChromium* chromeClient = chromeClientChromium();
if (chromeClient) {
// If the popup would extend past the bottom of the screen, open upwards
// instead.
FloatRect screen = screenAvailableRect(m_frameView.get());
// Use popupInitialCoordinate.x() + rightOffset because RTL position
// needs to be considered.
widgetRectInScreen = chromeClient->rootViewToScreen(IntRect(popupInitialCoordinate.x() + rightOffset, popupInitialCoordinate.y(), targetSize.width(), targetSize.height()));
// If we have multiple screens and the browser rect is in one screen, we have
// to clip the window width to the screen width.
// When clipping, we also need to set a maximum width for the list box.
FloatRect windowRect = chromeClient->windowRect();
bool needToResizeView = false;
widgetRectInScreen = layoutAndCalculateWidgetRectInternal(widgetRectInScreen, targetControlHeight, windowRect, screen, isRTL, rtlOffset, m_listBox.get(), needToResizeView);
if (needToResizeView)
fitToListBox();
}
return widgetRectInScreen;
}
bool RenderThemeWinCE::paintSliderTrack(RenderObject* o, const PaintInfo& i, const IntRect& r)
{
bool rc = RenderTheme::paintSliderTrack(o, i, r);
IntPoint left = IntPoint(r.x() + 2, (r.y() + r.maxY()) / 2);
i.context->save();
i.context->setStrokeColor(Color::gray, ColorSpaceDeviceRGB);
i.context->setFillColor(Color::gray, ColorSpaceDeviceRGB);
i.context->fillRect(r);
#if ENABLE(VIDEO)
HTMLMediaElement* mediaElement = mediaElementParent(o->node());
if (mediaElement) {
i.context->setStrokeColor(Color(0, 0xff, 0));
IntPoint right = IntPoint(left.x() + mediaElement->percentLoaded() * (r.maxX() - r.x() - 4), (r.y() + r.maxY()) / 2);
i.context->drawLine(left, right);
left = right;
}
#endif
i.context->setStrokeColor(Color::black, ColorSpaceDeviceRGB);
i.context->drawLine(left, IntPoint(r.maxX() - 2, left.y()));
i.context->restore();
return rc;
}
void BackingStore::incorporateUpdate(ShareableBitmap* bitmap, const UpdateInfo& updateInfo)
{
if (!m_backingStore)
#if PLATFORM(EFL)
m_backingStore = WidgetBackingStoreCairo::create(EwkView::toEvasObject(toAPI(&m_webPageProxy)), size(), deviceScaleFactor());
#else
m_backingStore = createBackingStoreForGTK(m_webPageProxy.viewWidget(), size(), deviceScaleFactor());
#endif
scroll(updateInfo.scrollRect, updateInfo.scrollOffset);
// Paint all update rects.
IntPoint updateRectLocation = updateInfo.updateRectBounds.location();
RefPtr<cairo_t> context(adoptRef(cairo_create(m_backingStore->cairoSurface())));
GraphicsContext graphicsContext(context.get());
for (size_t i = 0; i < updateInfo.updateRects.size(); ++i) {
IntRect updateRect = updateInfo.updateRects[i];
IntRect srcRect = updateRect;
srcRect.move(-updateRectLocation.x(), -updateRectLocation.y());
bitmap->paint(graphicsContext, deviceScaleFactor(), updateRect.location(), srcRect);
}
}
DragOperation DragController::tryDocumentDrag(DragData* dragData, DragDestinationAction actionMask)
{
ASSERT(dragData);
if (!m_document)
return DragOperationNone;
DragOperation operation = DragOperationNone;
if (actionMask & DragDestinationActionDHTML)
operation = tryDHTMLDrag(dragData);
m_isHandlingDrag = operation != DragOperationNone;
RefPtr<FrameView> frameView = m_document->view();
if (!frameView)
return operation;
if ((actionMask & DragDestinationActionEdit) && !m_isHandlingDrag && canProcessDrag(dragData)) {
if (dragData->containsColor())
return DragOperationGeneric;
IntPoint dragPos = dragData->clientPosition();
IntPoint point = frameView->windowToContents(dragPos);
Element* element = m_document->elementFromPoint(point.x(), point.y());
ASSERT(element);
Frame* innerFrame = element->document()->frame();
ASSERT(innerFrame);
if (!asFileInput(element)) {
Selection dragCaret;
if (Frame* frame = m_document->frame())
dragCaret = frame->visiblePositionForPoint(point);
m_page->dragCaretController()->setSelection(dragCaret);
}
return dragIsMove(innerFrame->selection()) ? DragOperationMove : DragOperationCopy;
}
m_page->dragCaretController()->clear();
return operation;
}
IntPoint convertWidgetPointToScreenPoint(GtkWidget* widget, const IntPoint& point)
{
// FIXME: This is actually a very tricky operation and the results of this function should
// only be thought of as a guess. For instance, sometimes it may not correctly take into
// account window decorations.
GtkWidget* toplevelWidget = gtk_widget_get_toplevel(widget);
if (!toplevelWidget || !gtk_widget_is_toplevel(toplevelWidget) || !GTK_IS_WINDOW(toplevelWidget))
return point;
GdkWindow* gdkWindow = gtk_widget_get_window(toplevelWidget);
if (!gdkWindow)
return point;
int xInWindow, yInWindow;
gtk_widget_translate_coordinates(widget, toplevelWidget, point.x(), point.y(), &xInWindow, &yInWindow);
int windowOriginX, windowOriginY;
gdk_window_get_origin(gdkWindow, &windowOriginX, &windowOriginY);
return IntPoint(windowOriginX + xInWindow, windowOriginY + yInWindow);
}
void SliderThumbElement::setPositionFromPoint(const IntPoint& point)
{
HTMLInputElement* input = hostInput();
ASSERT(input);
if (!input->renderer() || !renderer())
return;
IntPoint offset = roundedIntPoint(input->renderer()->absoluteToLocal(point, false, true));
RenderStyle* sliderStyle = input->renderer()->style();
bool isVertical = sliderStyle->appearance() == SliderVerticalPart || sliderStyle->appearance() == MediaVolumeSliderPart;
int trackSize;
int position;
int currentPosition;
if (isVertical) {
trackSize = input->renderBox()->contentHeight() - renderBox()->height();
position = offset.y() - renderBox()->height() / 2;
currentPosition = renderBox()->y() - input->renderBox()->contentBoxRect().y();
} else {
trackSize = input->renderBox()->contentWidth() - renderBox()->width();
position = offset.x() - renderBox()->width() / 2;
currentPosition = renderBox()->x() - input->renderBox()->contentBoxRect().x();
}
position = max(0, min(position, trackSize));
if (position == currentPosition)
return;
StepRange range(input);
double fraction = static_cast<double>(position) / trackSize;
if (isVertical)
fraction = 1 - fraction;
double value = range.clampValue(range.valueFromProportion(fraction));
// FIXME: This is no longer being set from renderer. Consider updating the method name.
input->setValueFromRenderer(serializeForNumberType(value));
renderer()->setNeedsLayout(true);
input->dispatchFormControlChangeEvent();
}
void RenderFlowThread::paintFlowThreadPortionInRegion(PaintInfo& paintInfo, RenderRegion* region, LayoutRect flowThreadPortionRect, LayoutRect flowThreadPortionOverflowRect, const LayoutPoint& paintOffset) const
{
GraphicsContext* context = paintInfo.context;
if (!context)
return;
// Adjust the clipping rect for the region.
// paintOffset contains the offset where the painting should occur
// adjusted with the region padding and border.
LayoutRect regionClippingRect = computeRegionClippingRect(paintOffset, flowThreadPortionRect, flowThreadPortionOverflowRect);
PaintInfo info(paintInfo);
info.rect.intersect(pixelSnappedIntRect(regionClippingRect));
if (!info.rect.isEmpty()) {
context->save();
context->clip(regionClippingRect);
// RenderFlowThread should start painting its content in a position that is offset
// from the region rect's current position. The amount of offset is equal to the location of
// the flow thread portion in the flow thread's local coordinates.
IntPoint renderFlowThreadOffset;
if (style()->isFlippedBlocksWritingMode()) {
LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);
flipForWritingMode(flippedFlowThreadPortionRect);
renderFlowThreadOffset = roundedIntPoint(paintOffset - flippedFlowThreadPortionRect.location());
} else
renderFlowThreadOffset = roundedIntPoint(paintOffset - flowThreadPortionRect.location());
context->translate(renderFlowThreadOffset.x(), renderFlowThreadOffset.y());
info.rect.moveBy(-renderFlowThreadOffset);
layer()->paint(context, info.rect, 0, 0, region, RenderLayer::PaintLayerTemporaryClipRects);
context->restore();
}
}
void GraphicsContext::drawLineForText(const IntPoint& pt,
int width,
bool printing)
{
if (paintingDisabled())
return;
if (width <= 0)
return;
int thickness = SkMax32(static_cast<int>(strokeThickness()), 1);
SkRect r;
r.fLeft = SkIntToScalar(pt.x());
r.fTop = SkIntToScalar(pt.y());
r.fRight = r.fLeft + SkIntToScalar(width);
r.fBottom = r.fTop + SkIntToScalar(thickness);
SkPaint paint;
platformContext()->setupPaintForFilling(&paint);
// Text lines are drawn using the stroke color.
paint.setColor(platformContext()->effectiveStrokeColor());
platformContext()->canvas()->drawRect(r, paint);
}
void PrintContext::outputLinkedDestinations(SkCanvas* canvas, const IntRect& pageRect)
{
if (!m_linkedDestinationsValid) {
// Collect anchors in the top-level frame only because our PrintContext
// supports only one namespace for the anchors.
collectLinkedDestinations(frame()->document());
m_linkedDestinationsValid = true;
}
for (const auto& entry : m_linkedDestinations) {
LayoutObject* layoutObject = entry.value->layoutObject();
if (!layoutObject || !layoutObject->frameView())
continue;
IntRect boundingBox = layoutObject->absoluteBoundingBoxRect();
boundingBox = layoutObject->frameView()->convertToContainingWindow(boundingBox);
if (!pageRect.intersects(boundingBox))
continue;
IntPoint point = boundingBox.minXMinYCorner();
point.clampNegativeToZero();
SkAutoDataUnref nameData(SkData::NewWithCString(entry.key.utf8().data()));
SkAnnotateNamedDestination(canvas, SkPoint::Make(point.x(), point.y()), nameData);
}
}
WebMouseWheelEventBuilder::WebMouseWheelEventBuilder(const Widget* widget, const WheelEvent& event)
{
if (event.type() != eventNames().mousewheelEvent)
return;
type = WebInputEvent::MouseWheel;
timeStampSeconds = event.timeStamp() / millisPerSecond;
modifiers = getWebInputModifiers(event);
ScrollView* view = widget->parent();
IntPoint p = view->contentsToWindow(
IntPoint(event.absoluteLocation().x(), event.absoluteLocation().y()));
globalX = event.screenX();
globalY = event.screenY();
windowX = p.x();
windowY = p.y();
x = event.absoluteLocation().x() - widget->location().x();
y = event.absoluteLocation().y() - widget->location().y();
deltaX = static_cast<float>(event.rawDeltaX());
deltaY = static_cast<float>(event.rawDeltaY());
// The 120 is from WheelEvent::initWheelEvent().
wheelTicksX = static_cast<float>(event.wheelDeltaX()) / 120;
wheelTicksY = static_cast<float>(event.wheelDeltaY()) / 120;
scrollByPage = event.granularity() == WheelEvent::Page;
}
void BackingStore::incorporateUpdate(ShareableBitmap* bitmap, const UpdateInfo& updateInfo)
{
if (!m_backingStore)
m_backingStore = WidgetBackingStore::create(m_webPageProxy->viewWidget(), size());
scroll(updateInfo.scrollRect, updateInfo.scrollOffset);
// Paint all update rects.
IntPoint updateRectLocation = updateInfo.updateRectBounds.location();
RefPtr<cairo_t> context(adoptRef(cairo_create(m_backingStore->cairoSurface())));
GraphicsContext graphicsContext(context.get());
for (size_t i = 0; i < updateInfo.updateRects.size(); ++i) {
IntRect updateRect = updateInfo.updateRects[i];
IntRect srcRect = updateRect;
srcRect.move(-updateRectLocation.x(), -updateRectLocation.y());
bitmap->paint(graphicsContext, updateRect.location(), srcRect);
}
#if PLATFORM(EFL)
// Update ewk_view with new backingStore image.
ewk_view_image_data_set(m_webPageProxy->viewWidget(), cairo_image_surface_get_data(m_backingStore->cairoSurface()), m_size);
#endif
}
PaintLayerPainter::PaintResult PaintLayerPainter::paintFragmentByApplyingTransform(GraphicsContext& context, const PaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& fragmentTranslation)
{
// This involves subtracting out the position of the layer in our current coordinate space, but preserving
// the accumulated error for sub-pixel layout.
LayoutPoint delta;
m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, delta);
delta.moveBy(fragmentTranslation);
TransformationMatrix transform(m_paintLayer.renderableTransform(paintingInfo.globalPaintFlags()));
IntPoint roundedDelta = roundedIntPoint(delta);
transform.translateRight(roundedDelta.x(), roundedDelta.y());
LayoutSize adjustedSubPixelAccumulation = paintingInfo.subPixelAccumulation + (delta - roundedDelta);
// TODO(jbroman): Put the real transform origin here, instead of using a
// matrix with the origin baked in.
FloatPoint3D transformOrigin;
Transform3DRecorder transform3DRecorder(context, *m_paintLayer.layoutObject(), DisplayItem::Transform3DElementTransform, transform, transformOrigin);
// Now do a paint with the root layer shifted to be us.
PaintLayerPaintingInfo transformedPaintingInfo(&m_paintLayer, LayoutRect(enclosingIntRect(transform.inverse().mapRect(paintingInfo.paintDirtyRect))), paintingInfo.globalPaintFlags(),
adjustedSubPixelAccumulation);
transformedPaintingInfo.ancestorHasClipPathClipping = paintingInfo.ancestorHasClipPathClipping;
return paintLayerContentsAndReflection(context, transformedPaintingInfo, paintFlags, ForceSingleFragment);
}
// TODO(trchen): Remove this once we bake the paint offset into frameRect.
void PaintPropertyTreeBuilder::updateScrollbarPaintOffset(
const LayoutObject& object,
const PaintPropertyTreeBuilderContext& context) {
IntPoint roundedPaintOffset = roundedIntPoint(context.current.paintOffset);
if (roundedPaintOffset != IntPoint() && object.isBoxModelObject()) {
if (PaintLayerScrollableArea* scrollableArea =
toLayoutBoxModelObject(object).getScrollableArea()) {
if (scrollableArea->horizontalScrollbar() ||
scrollableArea->verticalScrollbar()) {
auto paintOffset = TransformationMatrix().translate(
roundedPaintOffset.x(), roundedPaintOffset.y());
object.getMutableForPainting()
.ensurePaintProperties()
.updateScrollbarPaintOffset(context.current.transform, paintOffset,
FloatPoint3D());
return;
}
}
}
if (auto* properties = object.getMutableForPainting().paintProperties())
properties->clearScrollbarPaintOffset();
}
void ImageBuffer::putByteArray(Multiply multiplied, Uint8ClampedArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, CoordinateSystem coordinateSystem)
{
if (!m_context->isAcceleratedContext()) {
m_data.putData(source, sourceSize, sourceRect, destPoint, internalSize(), m_context->isAcceleratedContext(), multiplied == Unmultiplied, coordinateSystem == LogicalCoordinateSystem ? m_resolutionScale : 1);
return;
}
#if USE(IOSURFACE_CANVAS_BACKING_STORE)
// Make a copy of the source to ensure the bits don't change before being drawn
IntSize sourceCopySize(sourceRect.width(), sourceRect.height());
OwnPtr<ImageBuffer> sourceCopy = ImageBuffer::create(sourceCopySize, 1, ColorSpaceDeviceRGB, Unaccelerated);
if (!sourceCopy)
return;
sourceCopy->m_data.putData(source, sourceSize, sourceRect, IntPoint(-sourceRect.x(), -sourceRect.y()), sourceCopy->internalSize(), sourceCopy->context()->isAcceleratedContext(), multiplied == Unmultiplied, 1);
// Set up context for using drawImage as a direct bit copy
CGContextRef destContext = context()->platformContext();
CGContextSaveGState(destContext);
if (coordinateSystem == LogicalCoordinateSystem)
CGContextConcatCTM(destContext, AffineTransform(wkGetUserToBaseCTM(destContext)).inverse());
else
CGContextConcatCTM(destContext, AffineTransform(CGContextGetCTM(destContext)).inverse());
wkCGContextResetClip(destContext);
CGContextSetInterpolationQuality(destContext, kCGInterpolationNone);
CGContextSetAlpha(destContext, 1.0);
CGContextSetBlendMode(destContext, kCGBlendModeCopy);
CGContextSetShadowWithColor(destContext, CGSizeZero, 0, 0);
// Draw the image in CG coordinate space
IntPoint destPointInCGCoords(destPoint.x() + sourceRect.x(), (coordinateSystem == LogicalCoordinateSystem ? logicalSize() : internalSize()).height() - (destPoint.y() + sourceRect.y()) - sourceRect.height());
IntRect destRectInCGCoords(destPointInCGCoords, sourceCopySize);
RetainPtr<CGImageRef> sourceCopyImage(AdoptCF, sourceCopy->copyNativeImage());
CGContextDrawImage(destContext, destRectInCGCoords, sourceCopyImage.get());
CGContextRestoreGState(destContext);
#endif
}
FloatRect Font::selectionRectForComplexText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
{
PangoLayout* layout = getDefaultPangoLayout(run);
setPangoAttributes(this, run, layout);
gchar* utf8 = convertUniCharToUTF8(run.characters(), run.length(), 0, run.length());
pango_layout_set_text(layout, utf8, -1);
char* start = g_utf8_offset_to_pointer(utf8, from);
char* end = g_utf8_offset_to_pointer(start, to - from);
if (run.ltr()) {
from = start - utf8;
to = end - utf8;
} else {
from = end - utf8;
to = start - utf8;
}
PangoLayoutLine* layoutLine = pango_layout_get_line_readonly(layout, 0);
int x_pos;
x_pos = 0;
if (from < layoutLine->length)
pango_layout_line_index_to_x(layoutLine, from, FALSE, &x_pos);
float beforeWidth = PANGO_PIXELS_FLOOR(x_pos);
x_pos = 0;
if (run.ltr() || to < layoutLine->length)
pango_layout_line_index_to_x(layoutLine, to, FALSE, &x_pos);
float afterWidth = PANGO_PIXELS(x_pos);
g_free(utf8);
g_object_unref(layout);
return FloatRect(point.x() + beforeWidth, point.y(), afterWidth - beforeWidth, h);
}
void ImageBufferData::putImageData(ImageData*& source, const IntRect& sourceRect, const IntPoint& destPoint, const IntSize& size, VGImageFormat format)
{
ASSERT(m_surface);
ASSERT(sourceRect.width() > 0);
ASSERT(sourceRect.height() > 0);
// We expect the sourceRect to be a subset of the given source image.
ASSERT(sourceRect.x() >= 0);
ASSERT(sourceRect.y() >= 0);
ASSERT(sourceRect.right() <= source->width());
ASSERT(sourceRect.bottom() <= source->height());
// The target origin point is the combined offset of sourceRect.location()
// and destPoint.
int destx = destPoint.x() + sourceRect.x();
int desty = destPoint.y() + sourceRect.y();
ASSERT(destx >= 0);
ASSERT(desty >= 0);
ASSERT(destx + sourceRect.width() <= size.width());
ASSERT(desty + sourceRect.height() <= size.height());
unsigned const char* data = source->data()->data()->data();
int dataOffset = (sourceRect.y() * source->width() * 4) + (sourceRect.x() * 4);
if (!m_tiledImage)
m_surface->makeCurrent();
if (m_surface->isCurrent()) {
vgWritePixels(data + dataOffset, source->width() * 4, format,
destx, desty, sourceRect.width(), sourceRect.height());
} else {
vgImageSubData(m_tiledImage->tile(0, 0), data + dataOffset, source->width() * 4, format,
destx, desty, sourceRect.width(), sourceRect.height());
}
ASSERT_VG_NO_ERROR();
}
void PluginView::eventPointToPluginCarbonPointUsingHIPoint(const IntPoint& eventPoint, WindowRef const carbonWindow, Point* carbonPoint)
{
ASSERT(carbonPoint);
IntRect const frameGeom(frameGeometry());
IntPoint const frameLocation(frameGeom.location());
IntSize const frameOffset(IntPoint(m_npWindow.x, m_npWindow.y) - frameLocation);
IntPoint const pluginPoint(eventPoint + frameOffset);
HIPoint mouseHIPoint;
mouseHIPoint.x = pluginPoint.x();
mouseHIPoint.y = pluginPoint.y();
if (m_isWindowed) {
ASSERT(carbonWindow);
if (carbonWindow) {
// ** EVIL **
// In apollo, the HTML rendering can be rotated,
// blurred, etc. This means the relation ship between
// the coordinate space of the plugin and the screen is not straight forward.
// Fortunately, we are already making the carbon event from whole cloth.
// The FlashPlayer uses HIPointConvert to convert the coordinates of the
// carbon event to the coordinates of the plugin by calling HIPointConvert.
// We just call HIPointConvert to convert the mouse point the opposite direction
// so the FlashPlayer will end up with the correct coordinates for the mouse point.
HIPointConvert(&mouseHIPoint
, kHICoordSpaceWindow
, carbonWindow
, kHICoordSpaceScreenPixel
, 0);
}
}
carbonPoint->h = static_cast<short>(mouseHIPoint.x);
carbonPoint->v = static_cast<short>(mouseHIPoint.y);
}
void AndroidHitTestResult::buildHighlightRects()
{
m_highlightRects.clear();
Node* node = m_hitTestResult.URLElement();
if (!node || !node->renderer())
node = m_hitTestResult.innerNode();
if (!node || !node->renderer())
return;
if (!WebViewCore::nodeIsClickableOrFocusable(node))
return;
Frame* frame = node->document()->frame();
IntPoint frameOffset = m_webViewCore->convertGlobalContentToFrameContent(IntPoint(), frame);
RenderObject* renderer = node->renderer();
Vector<FloatQuad> quads;
if (renderer->isInline())
renderer->absoluteFocusRingQuads(quads);
if (!quads.size())
renderer->absoluteQuads(quads); // No fancy rings, grab a bounding box
for (size_t i = 0; i < quads.size(); i++) {
IntRect boundingBox = quads[i].enclosingBoundingBox();
boundingBox.move(-frameOffset.x(), -frameOffset.y());
m_highlightRects.append(boundingBox);
}
}
