Changeset 26894 in webkit

Timestamp:

Oct 22, 2007 2:29:37 PM (16 years ago)

Author:

hyatt

Message:

Fix for bug 15624, make transforms work properly with opacity.

Make sure a unitless 0 is allowed as an angle argument to rotation/skew.

Reviewed by Mitz Pettel

fast/transforms/transforms-with-opacity.html
fast/transforms/skew-with-unitless-zero.html

• css/CSSParser.cpp: (WebCore::CSSParser::validUnit):
• rendering/RenderLayer.cpp: (WebCore::transparencyClipBox): (WebCore::RenderLayer::beginTransparencyLayers): (WebCore::RenderLayer::paintLayer): (WebCore::RenderLayer::calculateClipRects):
• rendering/RenderLayer.h: (WebCore::RenderLayer::transform):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSParser.cpp (modified) (1 diff)
• rendering/RenderLayer.cpp (modified) (10 diffs)
• rendering/RenderLayer.h (modified) (2 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2007-10-22  David Hyatt  <hyatt@apple.com>
+
+        Fix for bug 15624, make transforms work properly with opacity.
+
+        Make sure a unitless 0 is allowed as an angle argument to rotation/skew.
+
+        Reviewed by Mitz Pettel
+
+        fast/transforms/transforms-with-opacity.html
+        fast/transforms/skew-with-unitless-zero.html
+
+        * css/CSSParser.cpp:
+        (WebCore::CSSParser::validUnit):
+        * rendering/RenderLayer.cpp:
+        (WebCore::transparencyClipBox):
+        (WebCore::RenderLayer::beginTransparencyLayers):
+        (WebCore::RenderLayer::paintLayer):
+        (WebCore::RenderLayer::calculateClipRects):
+        * rendering/RenderLayer.h:
+        (WebCore::RenderLayer::transform):
+
 2007-10-22  Adam Roben  <aroben@apple.com>
 

trunk/WebCore/css/CSSParser.cpp

@@ -388 +388 @@
     case CSSPrimitiveValue::CSS_NUMBER:
         b = (unitflags & FNumber);
-        if (!b && ((unitflags & FLength) && (value->fValue == 0 || !strict))) {
-            value->unit = CSSPrimitiveValue::CSS_PX;
+        if (!b && ((unitflags & (FLength | FAngle)) && (value->fValue == 0 || !strict))) {
+            value->unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX : CSSPrimitiveValue::CSS_DEG;
             b = true;
         }

trunk/WebCore/rendering/RenderLayer.cpp

@@ -437 +437 @@
 }
 
-static IntRect transparencyClipBox(const RenderLayer* l, const RenderLayer* rootLayer)
-{
-    // FIXME: This function does not work properly with transforms.
-
-    // FIXME: Although this completely ignores clipping, we ultimately intersect with the
+static IntRect transparencyClipBox(const AffineTransform& enclosingTransform, const RenderLayer* l, const RenderLayer* rootLayer)
+{
+    // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
     // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
     // would be better to respect clips.
+    
+    AffineTransform* t = l->transform();
+    if (t) {
+        // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
+        // the transformed layer and all of its children.
+        int x = 0;
+        int y = 0;
+        l->convertToLayerCoords(rootLayer, x, y);
+        AffineTransform transform;
+        transform.translate(x, y);
+        transform = *t * transform;
+        transform = transform * enclosingTransform;
+       
+        // We now have a transform that will produce a rectangle in our view's space.
+        IntRect clipRect = transform.mapRect(l->boundingBox(l));
+        
+        // Now shift the root layer to be us and pass down the new enclosing transform.
+        for (RenderLayer* curr = l->firstChild(); curr; curr = curr->nextSibling())
+            clipRect.unite(transparencyClipBox(transform, curr, l));
+            
+        return clipRect;
+    }
+    
+    // Note: we don't have to walk z-order lists since transparent elements always establish
+    // a stacking context.  This means we can just walk the layer tree directly.
     IntRect clipRect = l->boundingBox(rootLayer);
-    
-    // Note: we don't have to walk z-order lists since transparent elements always establish
-    // a stacking context.  This means we can just walk the layer tree directly. 
     for (RenderLayer* curr = l->firstChild(); curr; curr = curr->nextSibling())
-        clipRect.unite(transparencyClipBox(curr, rootLayer));
+        clipRect.unite(transparencyClipBox(enclosingTransform, curr, rootLayer));
     
     return clipRect;
 }
 
-void RenderLayer::beginTransparencyLayers(GraphicsContext* p, const IntRect& paintDirtyRect, const RenderLayer* rootLayer)
+void RenderLayer::beginTransparencyLayers(GraphicsContext* p, const RenderLayer* rootLayer)
 {
     if (p->paintingDisabled() || (isTransparent() && m_usedTransparency))
@@ -461 +481 @@
     RenderLayer* ancestor = transparentAncestor();
     if (ancestor)
-        ancestor->beginTransparencyLayers(p, paintDirtyRect, rootLayer);
+        ancestor->beginTransparencyLayers(p, rootLayer);
     
     if (isTransparent()) {
         m_usedTransparency = true;
-        IntRect clipRect = transparencyClipBox(this, rootLayer);
-        clipRect.intersect(paintDirtyRect);
         p->save();
-        p->clip(clipRect);
+        p->clip(transparencyClipBox(AffineTransform(), this, rootLayer));
         p->beginTransparencyLayer(renderer()->opacity());
     }
@@ -1445 +1463 @@
         return;
     
+    // If this layer is totally invisible then there is nothing to paint.
+    if (!m_object->opacity())
+        return;
+
+    if (isTransparent())
+        haveTransparency = true;
+
     // Apply a transform if we have one.
     if (m_transform && rootLayer != this) {
@@ -1451 +1476 @@
             return;
 
+        // If we have a transparency layer enclosing us and we are the root of a transform, then we need to establish the transparency
+        // layer from the parent now.
+        if (haveTransparency)
+            parent()->beginTransparencyLayers(p, rootLayer);
+  
         // Make sure the parent's clip rects have been calculated.
         parent()->calculateClipRects(rootLayer);
@@ -1471 +1501 @@
         p->save();
         p->concatCTM(transform);
-        
+
         // Now do a paint with the root layer shifted to be us.
-        // FIXME: We aren't handling transparency correctly yet.  We need to aggressively begin the transparency layer
-        // now so that the clip box will be computed properly.
         rootLayer = this;
         paintLayer(this, p, transform.inverse().mapRect(paintDirtyRect), haveTransparency, paintRestriction, paintingRoot);
@@ -1498 +1526 @@
     updateOverflowList();
 
-    // If this layer is totally invisible then there is nothing to paint.
-    if (!m_object->opacity())
-        return;
-        
     bool selectionOnly = paintRestriction == PaintRestrictionSelectionOnly || paintRestriction == PaintRestrictionSelectionOnlyBlackText;
     bool forceBlackText = paintRestriction == PaintRestrictionSelectionOnlyBlackText;
-
-    if (isTransparent())
-        haveTransparency = true;
     
     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
@@ -1515 +1536 @@
     if (paintingRoot && !m_object->isDescendantOf(paintingRoot))
         paintingRootForRenderer = paintingRoot;
-    
+
     // We want to paint our layer, but only if we intersect the damage rect.
     bool shouldPaint = intersectsDamageRect(layerBounds, damageRect, rootLayer) && m_hasVisibleContent;
@@ -1521 +1542 @@
         // Begin transparency layers lazily now that we know we have to paint something.
         if (haveTransparency)
-            beginTransparencyLayers(p, paintDirtyRect, rootLayer);
+            beginTransparencyLayers(p, rootLayer);
         
         // Paint our background first, before painting any child layers.
@@ -1549 +1570 @@
         // Begin transparency layers lazily now that we know we have to paint something.
         if (haveTransparency)
-            beginTransparencyLayers(p, paintDirtyRect, rootLayer);
+            beginTransparencyLayers(p, rootLayer);
 
         // Set up the clip used when painting our children.
@@ -1743 +1764 @@
 
     if (rootLayer == this || !parent()) {
-        // The root layer's clip rect is always just its dimensions.
-        m_clipRects = new (m_object->renderArena()) ClipRects(IntRect(0,0,width(),height()));
+        // The root layer's clip rect is always infinite.
+        m_clipRects = new (m_object->renderArena()) ClipRects(IntRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX));
         m_clipRects->ref();
         return;

trunk/WebCore/rendering/RenderLayer.h

@@ -212 +212 @@
     bool isTransparent() const;
     RenderLayer* transparentAncestor();
-    void beginTransparencyLayers(GraphicsContext*, const IntRect&, const RenderLayer* rootLayer);
+    void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer);
 
     const RenderLayer* root() const
@@ -350 +350 @@
     void setStaticY(int staticY) { m_staticY = staticY; }
 
+    AffineTransform* transform() const { return m_transform.get(); }
+
     void destroy(RenderArena*);