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); } }