// Reimpl rather than rely on GLVideoDrawable for speed on older hardware AND for speed in the editor void GLRectDrawable::paint(QPainter * painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/) { if(!painter->isActive()) return; paintChildren(true, painter, 0,0); painter->setOpacity(opacity()); QRectF target = QRectF(QPointF(0,0),rect().size()); if(m_borderWidth > 0.0) { painter->setPen(QPen(m_borderColor,m_borderWidth)); painter->setBrush(m_fillColor); double v = m_borderWidth / 2; target = target.adjusted(v,v,-v,-v); painter->drawRect(target); } else { painter->fillRect(target, m_fillColor); } paintChildren(false, painter, 0,0); }
void QWindowCompositor::paintChildren(QWaylandSurface *surface, QWaylandSurface *window, const QSize &windowSize) { if (surface->subSurfaces().size() == 0) return; QLinkedListIterator<QWaylandSurface *> i(surface->subSurfaces()); while (i.hasNext()) { QWaylandSurface *subSurface = i.next(); QPointF p = subSurface->mapTo(window,QPointF(0,0)); QSize subSize = subSurface->size(); subSurface->advanceBufferQueue(); if (subSize.isValid()) { GLuint texture = 0; if (subSurface->type() == QWaylandSurface::Texture) { texture = subSurface->texture(QOpenGLContext::currentContext()); } else if (surface->type() == QWaylandSurface::Shm ) { texture = m_textureCache->bindTexture(QOpenGLContext::currentContext(),surface->image()); } QRect geo(p.toPoint(),subSize); if (texture > 0) m_textureBlitter->drawTexture(texture,geo,windowSize,0,window->isYInverted(),subSurface->isYInverted()); if (surface->type() == QWaylandSurface::Shm) glDeleteTextures(1, &texture); } paintChildren(subSurface,window,windowSize); } }
GLuint QWindowCompositor::composeSurface(QWaylandSurface *surface) { GLuint texture = 0; QSize windowSize = surface->size(); surface->advanceBufferQueue(); QOpenGLFunctions *functions = QOpenGLContext::currentContext()->functions(); functions->glBindFramebuffer(GL_FRAMEBUFFER, m_surface_fbo); if (surface->type() == QWaylandSurface::Shm) { texture = m_textureCache->bindTexture(QOpenGLContext::currentContext(),surface->image()); } else if (surface->type() == QWaylandSurface::Texture) { texture = surface->texture(QOpenGLContext::currentContext()); } functions->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); paintChildren(surface, surface,windowSize); functions->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,0, 0); functions->glBindFramebuffer(GL_FRAMEBUFFER, 0); return texture; }
void TextFrame::paint(QPainter* p, int, int, int, int) { if (_lastPageOnly && !Grid::lastPage() || text().isEmpty()) return; // Figure out proper alignment int flags = Qt::AlignVCenter; if (_justify == ALIGN_LEFT) flags |= Qt::AlignLeft; if (_justify == ALIGN_RIGHT) flags |= Qt::AlignRight; if (_justify == ALIGN_CENTER) flags |= Qt::AlignHCenter; int padX = _padX; int padY = _padY; if (Grid::painter() != NULL) { QPaintDeviceMetrics metrics(Grid::painter()->device()); padX = int(padX * metrics.logicalDpiX() / 72.0 + .5); padY = int(padY * metrics.logicalDpiY() / 72.0 + .5); } // Save state and setup pen, font, ... p->save(); p->setFont(_font.getFont()); if (!_color.isEmpty()) p->setPen(QColor(_color)); p->drawText(padX, padY, _width.toInt(), _height.toInt(), flags, text()); p->restore(); paintChildren(p); }
void FrameSetPainter::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) { if (paintInfo.phase != PaintPhaseForeground) return; LayoutObject* child = m_layoutFrameSet.firstChild(); if (!child) return; LayoutPoint adjustedPaintOffset = paintOffset + m_layoutFrameSet.location(); paintChildren(paintInfo, adjustedPaintOffset); paintBorders(paintInfo, adjustedPaintOffset); }
void Moveable::paintEvent( PaintEvent& , GFX& gfx ) { int w, h; size( w, h ); gfx.color().set( 0.2f, 0.2f, 0.2f, 0.8f ); gfx.fillRoundRect( 0, 0, w, h, 10.0f ); gfx.color().set( 0.6f, 0.6f, 0.6f, 1.0f ); Recti rtitle( 10, 2, w - 20, 18 ); gfx.drawText( rtitle, ALIGN_LEFT | ALIGN_VCENTER, _title.c_str() ); Recti r = rect(); paintChildren( gfx, r ); if( !_togglebutton.state() ) { gfx.color().set( 0.6f, 0.6f, 0.6f, 1.0f ); gfx.drawIcon( w - 18, h - 18, GFX::ICON_CORNER ); } }
void QtwaylandSurfaceNode::paintChildren(QWaylandSurface *surface, QWaylandSurface *window, OpenGLData *glData) { if (surface->subSurfaces().size() == 0) return; QLinkedListIterator<QWaylandSurface *> i(surface->subSurfaces()); while (i.hasNext()) { QWaylandSurface *subSurface = i.next(); QPointF p = subSurface->mapTo(window,QPointF(0,0)); if (subSurface->size().isValid()) { GLuint texture = 0; if (subSurface->type() == QWaylandSurface::Texture) { texture = subSurface->texture(QOpenGLContext::currentContext()); } else if (surface->type() == QWaylandSurface::Shm ) { texture = glData->m_textureCache->bindTexture(QOpenGLContext::currentContext(),surface->image()); } QRect geo(p.toPoint(),subSurface->size()); glData->m_textureBlitter->drawTexture(texture,geo,window->size(),0,window->isYInverted(),subSurface->isYInverted()); } paintChildren(subSurface,window, glData); } }
GLuint QtwaylandSurfaceNode::composeSurface(QWaylandSurface *surface, OpenGLData *glData) { glData->m_textureBlitter->bind(); GLuint texture = 0; QOpenGLFunctions *functions = QOpenGLContext::currentContext()->functions(); functions->glBindFramebuffer(GL_FRAMEBUFFER, glData->m_surface_fbo); if (surface->type() == QWaylandSurface::Shm) { texture = glData->m_textureCache->bindTexture(QOpenGLContext::currentContext(),surface->image()); } else if (surface->type() == QWaylandSurface::Texture) { texture = surface->texture(QOpenGLContext::currentContext()); } functions->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); paintChildren(surface,surface, glData); functions->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,0, 0); functions->glBindFramebuffer(GL_FRAMEBUFFER, 0); glData->m_textureBlitter->release(); return texture; }
void Container::paintChildren(Graphics& g) const { paintChildren(this,g); }
void Component::paint(Graphics& g) const { g.pushMatrix(); g.translate(getBounds().x,getBounds().y); if(rotation != 0.0f) { int x = getBounds().width /2; int y = getBounds().height/2; g.translate(x,y); g.rotate(rotation); g.translate(-x,-y); } // we only paint if its state is visible. if(isVisible() && rec.width > 0 && rec.height > 0) { bool storeDepth = false; if(isContainer()) { // we need to store the current depth value, // so that it affects all children of this Component. storeDepth = g.pushDepth(depth); } // if this Component is currently not valid, validate it. if(!isValid()) { validate(); } if(SelectionManager::getInstance().getRenderMode() == SelectionManager::NORMAL) { // we're in the normal render mode, so check for transparency, // and paint everything bool storeTransparency = false; storeTransparency = g.pushTransparency(transparency); //displayList = g. //if(!isDisplayListCompiled) //{ // util::DisplayList compile(displayList); // first paint the background paintComponent(g); // then any custom painting, // which can be done by overloading // paintComponent. // then paint the borders paintBorder(g); // isDisplayListCompiled = true; //} //else //{ // util::DisplayList::call(displayList); //} // then paint the children paintChildren(g); if(storeTransparency) { // restore transparency g.popTransparency(); } } else { // this is the Picking render mode, we only do special painting // here, which helps to speed up this step. if(hasMouseListener()) { paintSelectionComponent(g); } paintChildren(g); } if(isContainer()) { if(storeDepth) { // restore depth values g.popDepth(depth); } } } g.popMatrix(); //g.translate(-getBounds().x,-getBounds().y); }
PaintLayerPainter::PaintResult PaintLayerPainter::paintLayerContentsInternal(GraphicsContext* context, const PaintLayerPaintingInfo& paintingInfoArg, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy) { ASSERT(m_paintLayer.isSelfPaintingLayer() || m_paintLayer.hasSelfPaintingLayerDescendant()); ASSERT(!(paintFlags & PaintLayerAppliedTransform)); bool isSelfPaintingLayer = m_paintLayer.isSelfPaintingLayer(); bool isPaintingOverlayScrollbars = paintFlags & PaintLayerPaintingOverlayScrollbars; bool isPaintingScrollingContent = paintFlags & PaintLayerPaintingCompositingScrollingPhase; bool isPaintingCompositedForeground = paintFlags & PaintLayerPaintingCompositingForegroundPhase; bool isPaintingCompositedBackground = paintFlags & PaintLayerPaintingCompositingBackgroundPhase; bool isPaintingOverflowContents = paintFlags & PaintLayerPaintingOverflowContents; // Outline always needs to be painted even if we have no visible content. Also, // the outline is painted in the background phase during composited scrolling. // If it were painted in the foreground phase, it would move with the scrolled // content. When not composited scrolling, the outline is painted in the // foreground phase. Since scrolled contents are moved by paint invalidation in this // case, the outline won't get 'dragged along'. bool shouldPaintOutline = isSelfPaintingLayer && !isPaintingOverlayScrollbars && ((isPaintingScrollingContent && isPaintingCompositedBackground) || (!isPaintingScrollingContent && isPaintingCompositedForeground)); bool shouldPaintContent = m_paintLayer.hasVisibleContent() && isSelfPaintingLayer && !isPaintingOverlayScrollbars; PaintResult result = FullyPainted; if (paintFlags & PaintLayerPaintingRootBackgroundOnly && !m_paintLayer.layoutObject()->isLayoutView() && !m_paintLayer.layoutObject()->isDocumentElement()) return result; PaintLayerPaintingInfo paintingInfo = paintingInfoArg; // Ensure our lists are up-to-date. m_paintLayer.stackingNode()->updateLayerListsIfNeeded(); LayoutPoint offsetFromRoot; m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot); if (m_paintLayer.compositingState() == PaintsIntoOwnBacking) offsetFromRoot.move(m_paintLayer.subpixelAccumulation()); else offsetFromRoot.move(paintingInfo.subPixelAccumulation); LayoutRect bounds = m_paintLayer.physicalBoundingBox(offsetFromRoot); if (!paintingInfo.paintDirtyRect.contains(bounds)) result = MaybeNotFullyPainted; LayoutRect rootRelativeBounds; bool rootRelativeBoundsComputed = false; if (paintingInfo.ancestorHasClipPathClipping && m_paintLayer.layoutObject()->style()->position() != StaticPosition) UseCounter::count(m_paintLayer.layoutObject()->document(), UseCounter::ClipPathOfPositionedElement); // These helpers output clip and compositing operations using a RAII pattern. Stack-allocated-varibles are destructed in the reverse order of construction, // so they are nested properly. ClipPathHelper clipPathHelper(context, m_paintLayer, paintingInfo, rootRelativeBounds, rootRelativeBoundsComputed, offsetFromRoot, paintFlags); Optional<CompositingRecorder> compositingRecorder; // Blending operations must be performed only with the nearest ancestor stacking context. // Note that there is no need to composite if we're painting the root. // FIXME: this should be unified further into PaintLayer::paintsWithTransparency(). bool shouldCompositeForBlendMode = (!m_paintLayer.layoutObject()->isDocumentElement() || m_paintLayer.layoutObject()->isSVGRoot()) && m_paintLayer.stackingNode()->isStackingContext() && m_paintLayer.hasNonIsolatedDescendantWithBlendMode(); if (shouldCompositeForBlendMode || m_paintLayer.paintsWithTransparency(paintingInfo.globalPaintFlags())) { FloatRect compositingBounds = FloatRect(m_paintLayer.paintingExtent(paintingInfo.rootLayer, paintingInfo.subPixelAccumulation, paintingInfo.globalPaintFlags())); compositingRecorder.emplace(*context, *m_paintLayer.layoutObject(), WebCoreCompositeToSkiaComposite(CompositeSourceOver, m_paintLayer.layoutObject()->style()->blendMode()), m_paintLayer.layoutObject()->opacity(), &compositingBounds); } PaintLayerPaintingInfo localPaintingInfo(paintingInfo); if (m_paintLayer.compositingState() == PaintsIntoOwnBacking) localPaintingInfo.subPixelAccumulation = m_paintLayer.subpixelAccumulation(); PaintLayerFragments layerFragments; if (shouldPaintContent || shouldPaintOutline || isPaintingOverlayScrollbars) { // Collect the fragments. This will compute the clip rectangles and paint offsets for each layer fragment. ClipRectsCacheSlot cacheSlot = (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects : PaintingClipRects; ShouldRespectOverflowClip respectOverflowClip = shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject()); if (fragmentPolicy == ForceSingleFragment) m_paintLayer.appendSingleFragmentIgnoringPagination(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation); else m_paintLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer, localPaintingInfo.paintDirtyRect, cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot, localPaintingInfo.subPixelAccumulation); if (shouldPaintContent) { // TODO(wangxianzhu): This is for old slow scrolling. Implement similar optimization for slimming paint v2. shouldPaintContent = atLeastOneFragmentIntersectsDamageRect(layerFragments, localPaintingInfo, paintFlags, offsetFromRoot); if (!shouldPaintContent) result = MaybeNotFullyPainted; } } bool selectionOnly = localPaintingInfo.globalPaintFlags() & GlobalPaintSelectionOnly; // If this layer's layoutObject is a child of the paintingRoot, we paint unconditionally, which // is done by passing a nil paintingRoot down to our layoutObject (as if no paintingRoot was ever set). // Else, our layout tree may or may not contain the painting root, so we pass that root along // so it will be tested against as we descend through the layoutObjects. LayoutObject* paintingRootForLayoutObject = 0; if (localPaintingInfo.paintingRoot && !m_paintLayer.layoutObject()->isDescendantOf(localPaintingInfo.paintingRoot)) paintingRootForLayoutObject = localPaintingInfo.paintingRoot; { // Begin block for the lifetime of any filter. FilterPainter filterPainter(m_paintLayer, context, offsetFromRoot, layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect, localPaintingInfo, paintFlags, rootRelativeBounds, rootRelativeBoundsComputed); bool shouldPaintBackground = isPaintingCompositedBackground && shouldPaintContent && !selectionOnly; bool shouldPaintNegZOrderList = (isPaintingScrollingContent && isPaintingOverflowContents) || (!isPaintingScrollingContent && isPaintingCompositedBackground); bool shouldPaintOwnContents = isPaintingCompositedForeground && shouldPaintContent; bool shouldPaintNormalFlowAndPosZOrderLists = isPaintingCompositedForeground; bool shouldPaintOverlayScrollbars = isPaintingOverlayScrollbars; if (shouldPaintBackground) { paintBackgroundForFragments(layerFragments, context, paintingInfo.paintDirtyRect, localPaintingInfo, paintingRootForLayoutObject, paintFlags); } if (shouldPaintNegZOrderList) { if (paintChildren(NegativeZOrderChildren, context, paintingInfo, paintFlags) == MaybeNotFullyPainted) result = MaybeNotFullyPainted; } if (shouldPaintOwnContents) { paintForegroundForFragments(layerFragments, context, paintingInfo.paintDirtyRect, localPaintingInfo, paintingRootForLayoutObject, selectionOnly, paintFlags); } if (shouldPaintOutline) paintOutlineForFragments(layerFragments, context, localPaintingInfo, paintingRootForLayoutObject, paintFlags); if (shouldPaintNormalFlowAndPosZOrderLists) { if (paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags) == MaybeNotFullyPainted) result = MaybeNotFullyPainted; } if (shouldPaintOverlayScrollbars) paintOverflowControlsForFragments(layerFragments, context, localPaintingInfo, paintFlags); } // FilterPainter block bool shouldPaintMask = (paintFlags & PaintLayerPaintingCompositingMaskPhase) && shouldPaintContent && m_paintLayer.layoutObject()->hasMask() && !selectionOnly; bool shouldPaintClippingMask = (paintFlags & PaintLayerPaintingChildClippingMaskPhase) && shouldPaintContent && !selectionOnly; if (shouldPaintMask) paintMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForLayoutObject, paintFlags); if (shouldPaintClippingMask) { // Paint the border radius mask for the fragments. paintChildClippingMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForLayoutObject, paintFlags); } m_paintLayer.setPreviousScrollOffsetAccumulationForPainting(paintingInfoArg.scrollOffsetAccumulation); return result; }