Lines Matching full:layer
264 // to our parent layer.
309 // Clear the IsCompositingUpdateRoot flag once we've found the first compositing layer in this update.
459 // layer may be hidden but still have some visible content, check for this
492 // This propagates up through preserve-3d hierarchies to the enclosing flattening layer.
500 // Return true if this layer or any preserve-3d descendants have 3d.
522 // If we live in a 3d hierarchy, then the layer at the root of that hierarchy needs
542 // nearest enclosing object with a layer.
573 // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
584 // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
650 RenderLayer* layer = parent();
657 while (layer && !layer->renderer()->isRoot() && !layer->isStackingContext())
659 while (layer && !layer->renderer()->isRenderView() && !layer->renderer()->isRoot() && layer->renderer()->style()->hasAutoZIndex())
661 layer = layer->parent();
662 return layer;
665 static inline bool isPositionedContainer(RenderLayer* layer)
667 RenderObject* o = layer->renderer();
668 return o->isRenderView() || o->isPositioned() || o->isRelPositioned() || layer->hasTransform();
671 static inline bool isFixedPositionedContainer(RenderLayer* layer)
673 RenderObject* o = layer->renderer();
674 return o->isRenderView() || layer->hasTransform();
695 static inline const RenderLayer* compositingContainer(const RenderLayer* layer)
697 return layer->isNormalFlowOnly() ? layer->parent() : layer->stackingContext();
782 // a stacking context. This means we can just walk the layer tree directly.
792 // size into the parent layer.
811 // the transformed layer and all of its children.
929 // reattachment process in removeOnlyThisLayer, the layer may already be disconnected
930 // from the main layer tree, so we need to null-check the |stackingContext| value.
950 // Mark that we are about to lose our layer. This makes render tree
951 // walks ignore this layer while we're removing it.
1008 if (position == FixedPosition && (!ancestorLayer || ancestorLayer == renderer()->view()->layer())) {
1009 // If the fixed layer's container is the root, just add in the offset of the view. We can obtain this by calling
1019 // (e.g. a transformed layer). It's an error to call convertToLayerCoords() across a layer with a transform,
1034 ASSERT(fixedPositionContainerLayer); // We should have hit the RenderView's layer at least.
1152 // If this layer can't do the scroll we ask the next layer up that can scroll to try
1214 // complicated (since it will involve testing whether our layer
1215 // is either occluded by another layer or clipped by an enclosing
1216 // layer or contains fixed backgrounds, etc.).
1281 // the end of the function since they could delete the layer or the layer's renderer().
1293 // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
1451 // This is necessary for textarea elements since the resizable layer is in the shadow content.
1542 static IntRect cornerRect(const RenderLayer* layer, const IntRect& bounds)
1546 if (!layer->verticalScrollbar() && !layer->horizontalScrollbar()) {
1551 } else if (layer->verticalScrollbar() && !layer->horizontalScrollbar()) {
1552 horizontalThickness = layer->verticalScrollbar()->width();
1554 } else if (layer->horizontalScrollbar() && !layer->verticalScrollbar()) {
1555 verticalThickness = layer->horizontalScrollbar()->height();
1558 horizontalThickness = layer->verticalScrollbar()->width();
1559 verticalThickness = layer->horizontalScrollbar()->height();
1561 return IntRect(bounds.right() - horizontalThickness - layer->renderer()->style()->borderRightWidth(),
1562 bounds.bottom() - verticalThickness - layer->renderer()->style()->borderBottomWidth(),
1566 static IntRect scrollCornerRect(const RenderLayer* layer, const IntRect& bounds)
1572 bool hasHorizontalBar = layer->horizontalScrollbar();
1573 bool hasVerticalBar = layer->verticalScrollbar();
1574 bool hasResizer = layer->renderer()->style()->resize() != RESIZE_NONE;
1576 return cornerRect(layer, bounds);
1580 static IntRect resizerCornerRect(const RenderLayer* layer, const IntRect& bounds)
1582 ASSERT(layer->renderer()->isBox());
1583 if (layer->renderer()->style()->resize() == RESIZE_NONE)
1585 return cornerRect(layer, bounds);
2179 static bool shouldDoSoftwarePaint(const RenderLayer* layer, bool paintingReflection)
2181 return paintingReflection && !layer->has3DTransform();
2209 // If this layer is totally invisible then there is nothing to paint.
2223 // If we have a transparency layer enclosing us and we are the root of a transform, then we need to establish the transparency
2224 // layer from the parent now.
2239 // This involves subtracting out the position of the layer in our current coordinate space.
2250 // Now do a paint with the root layer shifted to be us.
2286 // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
2297 // We want to paint our layer, but only if we intersect the damage rect.
2376 // End our transparency layer
2403 // We didn't hit any layer. If we are the root layer and the mouse is -- or just was -- down,
2420 // Now return whether we were inside this layer (this will always be true for the root
2421 // layer).
2488 // The hit layer is depth-sorting with other layers, so just say that it was hit.
2492 // We need to look at z-depth to decide if this layer was hit.
2508 // A 'flattening' layer is one preserves3D() == false.
2509 // transformState.m_accumulatedTransform holds the transform from the containing flattening layer.
2510 // transformState.m_lastPlanarPoint is the hitTestPoint in the plane of the containing flattening layer.
2511 // transformState.m_lastPlanarQuad is the hitTestRect as a quad in the plane of the containing flattening layer.
2514 // *zOffset on return is the z offset of the hit point relative to the containing flattening layer.
2539 // If the transform can't be inverted, then don't hit test this layer at all.
2543 // Compute the point and the hit test rect in the coords of this layer by using the values
2545 // layer, and the accumulated transform which lets up map through preserve-3d layers.
2553 // It doesn't make sense to project hitTestRect into the plane of this layer, so use the same bounds we use for painting.
2559 // Now do a hit test with the root layer shifted to be us.
2589 // This layer is flattening, so flatten the state passed to descendants.
2613 // Flattening layer with 3d children; use a local zOffset pointer to depth-test children and foreground.
2619 // Container needs us to give back a z offset for the hit layer.
2623 // This variable tracks which layer the mouse ends up being inside.
2657 // Next we want to see if the mouse pos is inside the child RenderObjects of the layer.
2686 // If we found a layer, return. Child layers, and foreground always render in front of background.
2714 // node by the time we get to the layer level, since none of
2715 // the content in the layer has an element. So just walk up
2735 // For transformed layers, the root layer was shifted to be us, so there is no need to
2757 // The root layer's clip rect is always infinite.
2762 // For transformed layers, the root layer was shifted to be us, so there is no need to
2790 // This layer establishes a clip of some kind.
2864 // This layer establishes a clip of some kind.
2876 // rect is intersected with our layer's bounds.
2897 RenderLayer* rootLayer = renderer()->view()->layer();
2906 RenderLayer* rootLayer = renderer()->view()->layer();
2951 // If we aren't an inline flow, and our layer bounds do intersect the damage rect, then we
2962 // Otherwise we need to compute the bounding box of this single layer and see if it intersects
2975 // (3) Floats. When a layer has overhanging floats that it paints, we need to make sure to include these overhanging floats
2976 // as part of our bounding box. We do this because we are the responsible layer for both hit testing and painting those
3313 // If we're trying to repaint the placeholder document layer, propagate the
3326 // If we're trying to repaint the placeholder document layer, propagate the
3454 return m_reflection ? m_reflection->layer() : 0;
3514 void showLayerTree(const WebCore::RenderLayer* layer)
3516 if (!layer)
3519 if (WebCore::Frame* frame = layer->renderer()->document()->frame()) {
