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