Changeset 65782 in webkit

Timestamp:

Aug 22, 2010 12:30:48 AM (14 years ago)

Author:

ariya@webkit.org

Message:

[Qt] Layer approach to support generic shadow handling
​https://bugs.webkit.org/show_bug.cgi?id=44380

Patch by Ariya Hidayat <​ariya@sencha.com> on 2010-08-22
Reviewed by Dirk Schulze.

The pair beginShadowLayer and endShadowLayer creates a temporary image
where the caller can draw onto, using the returned QPainter. When
endShadowLayer is called, the temporary image will be filtered, using
the specified shadow color and blur radius, and drawn to the graphics
context.

• platform/graphics/GraphicsContext.h:
• platform/graphics/qt/ContextShadow.cpp:

(WebCore::ContextShadow::beginShadowLayer):
(WebCore::ContextShadow::endShadowLayer):

• platform/graphics/qt/ContextShadow.h:
• platform/graphics/qt/GraphicsContextQt.cpp:

(WebCore::GraphicsContext::fillRect):
(WebCore::GraphicsContext::contextShadow):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/GraphicsContext.h (modified) (2 diffs)
• platform/graphics/qt/ContextShadow.cpp (modified) (1 diff)
• platform/graphics/qt/ContextShadow.h (modified) (1 diff)
• platform/graphics/qt/GraphicsContextQt.cpp (modified) (2 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-08-22  Ariya Hidayat  <ariya@sencha.com>
+
+        Reviewed by Dirk Schulze.
+
+        [Qt] Layer approach to support generic shadow handling
+        https://bugs.webkit.org/show_bug.cgi?id=44380
+
+        The pair beginShadowLayer and endShadowLayer creates a temporary image
+        where the caller can draw onto, using the returned QPainter. When
+        endShadowLayer is called, the temporary image will be filtered, using
+        the specified shadow color and blur radius, and drawn to the graphics
+        context.
+
+        * platform/graphics/GraphicsContext.h:
+        * platform/graphics/qt/ContextShadow.cpp:
+        (WebCore::ContextShadow::beginShadowLayer):
+        (WebCore::ContextShadow::endShadowLayer):
+        * platform/graphics/qt/ContextShadow.h:
+        * platform/graphics/qt/GraphicsContextQt.cpp:
+        (WebCore::GraphicsContext::fillRect):
+        (WebCore::GraphicsContext::contextShadow):
+
 2010-08-21  Eric Carlson  <eric.carlson@apple.com>
 

trunk/WebCore/platform/graphics/GraphicsContext.h

@@ -49 +49 @@
 #elif PLATFORM(QT)
 #include <QPainter>
+namespace WebCore {
+class ContextShadow;
+}
 typedef QPainter PlatformGraphicsContext;
 #elif PLATFORM(WX)
@@ -397 +400 @@
         QPen pen();
         static QPainter::CompositionMode toQtCompositionMode(CompositeOperator op);
+        ContextShadow* contextShadow();
 #endif
 

trunk/WebCore/platform/graphics/qt/ContextShadow.cpp

@@ -268 +268 @@
 }
 
-void ContextShadow::drawShadowRect(QPainter* p, const QRectF& rect)
-{
-    if (type == NoShadow)
-        return;
-
-    if (type == BlurShadow) {
-        QRectF shadowRect = rect.translated(offset);
-
-        // We expand the area by the blur radius * 2 to give extra space
-        // for the blur transition.
-        int extra = blurRadius * 2;
-        QRectF bufferRect = shadowRect.adjusted(-extra, -extra, extra, extra);
-        QRect alignedBufferRect = bufferRect.toAlignedRect();
-
-        QRect clipRect;
-        if (p->hasClipping())
+QPainter* ContextShadow::beginShadowLayer(QPainter* p, const QRectF &rect)
+{
+    // We expand the area by the blur radius * 2 to give extra space
+    // for the blur transition.
+    int extra = (type == BlurShadow) ? blurRadius * 2 : 0;
+
+    QRectF shadowRect = rect.translated(offset);
+    QRectF bufferRect = shadowRect.adjusted(-extra, -extra, extra, extra);
+    m_layerRect = bufferRect.toAlignedRect();
+
+    QRect clipRect;
+    if (p->hasClipping())
 #if QT_VERSION >= QT_VERSION_CHECK(4, 8, 0)
-            clipRect = p->clipBoundingRect();
+        clipRect = p->clipBoundingRect();
 #else
-            clipRect = p->clipRegion().boundingRect();
+        clipRect = p->clipRegion().boundingRect();
 #endif
-        else
-            clipRect = p->transform().inverted().mapRect(p->window());
-
-        if (!clipRect.contains(alignedBufferRect)) {
-
-            // No need to have the buffer larger that the clip.
-            alignedBufferRect = alignedBufferRect.intersected(clipRect);
-            if (alignedBufferRect.isEmpty())
-                return;
-
-            // We adjust again because the pixels at the borders are still
-            // potentially affected by the pixels outside the buffer.
-            alignedBufferRect.adjust(-extra, -extra, extra, extra);
-        }
-
-        ShadowBuffer* shadowBuffer = scratchShadowBuffer();
-        QImage* shadowImage = shadowBuffer->scratchImage(alignedBufferRect.size());
-        QPainter shadowPainter(shadowImage);
-
-        shadowPainter.fillRect(shadowRect.translated(-alignedBufferRect.topLeft()), color);
-        shadowPainter.end();
-
-        shadowBlur(*shadowImage, blurRadius, color);
-
-        p->drawImage(alignedBufferRect.topLeft(), *shadowImage);
-
-        shadowBuffer->schedulePurge();
-
-        return;
+    else
+        clipRect = p->transform().inverted().mapRect(p->window());
+
+    if (!clipRect.contains(m_layerRect)) {
+
+        // No need to have the buffer larger than the clip.
+        m_layerRect = m_layerRect.intersected(clipRect);
+        if (m_layerRect.isEmpty())
+            return 0;
+
+        // We adjust again because the pixels at the borders are still
+        // potentially affected by the pixels outside the buffer.
+        if (type == BlurShadow)
+            m_layerRect.adjust(-extra, -extra, extra, extra);
     }
 
-    p->fillRect(rect.translated(offset), color);
-}
-
-
-}
+    ShadowBuffer* shadowBuffer = scratchShadowBuffer();
+    QImage* shadowImage = shadowBuffer->scratchImage(m_layerRect.size());
+    m_layerImage = QImage(*shadowImage);
+
+    m_layerPainter = new QPainter;
+    m_layerPainter->begin(&m_layerImage);
+    m_layerPainter->translate(offset);
+
+    // The origin is now the top left corner of the scratch image.
+    m_layerPainter->translate(-m_layerRect.topLeft());
+
+    return m_layerPainter;
+}
+
+void ContextShadow::endShadowLayer(QPainter* p)
+{
+    m_layerPainter->end();
+    delete m_layerPainter;
+    m_layerPainter = 0;
+
+    if (type == BlurShadow)
+        shadowBlur(m_layerImage, blurRadius, color);
+
+    p->drawImage(m_layerRect.topLeft(), m_layerImage);
+
+    scratchShadowBuffer()->schedulePurge();
+}
+
+}

trunk/WebCore/platform/graphics/qt/ContextShadow.h

@@ -59 +59 @@
     void clear();
 
-    // Draws the shadow for colored rectangle (can't be filled with pattern
-    // or gradient) according to the shadow parameters.
-    // Note: 'rect' specifies the rectangle which casts the shadow,
-    // NOT the bounding box of the shadow.
-    void drawShadowRect(QPainter* p, const QRectF& rect);
+    // The pair beginShadowLayer and endShadowLayer creates a temporary image
+    // where the caller can draw onto, using the returned QPainter. This
+    // QPainter instance must be used only to draw between the call to
+    // beginShadowLayer and endShadowLayer.
+    //
+    // Note: multiple/nested shadow layer is NOT allowed.
+    //
+    // The current clip region will be used to optimize the size of the
+    // temporary image. Thus, the original painter should not change any
+    // clipping until endShadowLayer.
+    // If the shadow will be completely outside the clipping region,
+    // beginShadowLayer will return 0.
+    //
+    // The returned QPainter will have the transformation matrix and clipping
+    // properly initialized to start doing the painting (no need to account
+    // for the shadow offset), however it will not have the same render hints,
+    // pen, brush, etc as the passed QPainter. This is intentional, usually
+    // shadow has different properties than the shape which casts the shadow.
+    //
+    // Once endShadowLayer is called, the temporary image will be drawn
+    // with the original painter. If blur radius is specified, the shadow
+    // will be filtered first.
+    QPainter* beginShadowLayer(QPainter* p, const QRectF& rect);
+    void endShadowLayer(QPainter* p);
 
+private:
+    QRect m_layerRect;
+    QImage m_layerImage;
+    QPainter* m_layerPainter;
 };
 

trunk/WebCore/platform/graphics/qt/GraphicsContextQt.cpp

@@ -696 +696 @@
     m_data->solidColor.setColor(color);
     QPainter* p = m_data->p();
-
-    if (m_data->hasShadow())
-        m_data->shadow.drawShadowRect(p, rect);
-
-    p->fillRect(rect, m_data->solidColor);
+    QRectF normalizedRect = rect.normalized();
+
+    if (m_data->hasShadow()) {
+        ContextShadow* shadow = contextShadow();
+
+        if (shadow->type != ContextShadow::BlurShadow) {
+            // We do not need any layer for simple shadow.
+            p->fillRect(normalizedRect.translated(shadow->offset), shadow->color);
+        } else {
+            QPainter* shadowPainter = shadow->beginShadowLayer(p, normalizedRect);
+            if (shadowPainter) {
+                shadowPainter->setCompositionMode(QPainter::CompositionMode_Source);
+                shadowPainter->fillRect(normalizedRect, shadow->color);
+                shadow->endShadowLayer(p);
+            }
+        }
+    }
+
+    p->fillRect(normalizedRect, m_data->solidColor);
 }
 
@@ -740 +754 @@
 {
     return &m_data->currentPath;
+}
+
+ContextShadow* GraphicsContext::contextShadow()
+{
+    return &m_data->shadow;
 }