void WebGraphicsLayer::setMasksToBounds(bool b)
{
if (masksToBounds() == b)
return;
GraphicsLayer::setMasksToBounds(b);
notifyChange();
}
void CoordinatedGraphicsLayer::syncLayerState()
{
if (!m_shouldSyncLayerState)
return;
m_shouldSyncLayerState = false;
m_layerState.childrenTransform = childrenTransform();
m_layerState.contentsRect = contentsRect();
m_layerState.mask = toCoordinatedLayerID(maskLayer());
m_layerState.opacity = opacity();
m_layerState.replica = toCoordinatedLayerID(replicaLayer());
m_layerState.transform = transform();
m_layerState.anchorPoint = m_adjustedAnchorPoint;
m_layerState.pos = m_adjustedPosition;
m_layerState.size = m_adjustedSize;
if (m_layerState.flagsChanged) {
m_layerState.drawsContent = drawsContent();
m_layerState.contentsVisible = contentsAreVisible();
m_layerState.backfaceVisible = backfaceVisibility();
m_layerState.masksToBounds = masksToBounds();
m_layerState.preserves3D = preserves3D();
m_layerState.fixedToViewport = fixedToViewport();
m_layerState.showDebugBorders = isShowingDebugBorder();
m_layerState.showRepaintCounter = isShowingRepaintCounter();
m_layerState.isScrollable = isScrollable();
}
if (m_layerState.showDebugBorders)
updateDebugIndicators();
}
void WebGraphicsLayer::setMasksToBounds(bool b)
{
if (masksToBounds() == b)
return;
GraphicsLayer::setMasksToBounds(b);
didChangeGeometry();
}
void GraphicsLayer::getDebugBorderInfo(Color& color, float& width) const
{
if (drawsContent()) {
if (m_usingTiledBacking) {
color = Color(255, 128, 0, 128); // tiled layer: orange
width = 2;
return;
}
color = Color(0, 128, 32, 128); // normal layer: green
width = 2;
return;
}
if (usesContentsLayer()) {
color = Color(255, 150, 255, 200); // non-painting layer with contents: pink
width = 2;
return;
}
if (masksToBounds()) {
color = Color(128, 255, 255, 48); // masking layer: pale blue
width = 20;
return;
}
color = Color(255, 255, 0, 192); // container: yellow
width = 2;
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::setMasksToBounds(bool value)
{
if (value == masksToBounds())
return;
GraphicsLayer::setMasksToBounds(value);
notifyChange(TextureMapperLayer::MasksToBoundsChange);
}
bool CanvasLayer::needsTexture()
{
MutexLocker locker(s_mutex);
CanvasLayerAndroid* gpuCanvas = CanvasLayer::getGpuCanvas(this);
if(gpuCanvas && gpuCanvas->isGpuCanvasEnabled())
return false;
else
return (m_bitmap && !masksToBounds()) || LayerAndroid::needsTexture();
}
void CoordinatedGraphicsLayer::setMasksToBounds(bool b)
{
if (masksToBounds() == b)
return;
GraphicsLayer::setMasksToBounds(b);
m_layerState.masksToBounds = b;
m_layerState.flagsChanged = true;
didChangeGeometry();
}
void CanvasLayer::contentDraw(SkCanvas* canvas, PaintStyle style)
{
LayerAndroid::contentDraw(canvas, style);
if (!m_bitmap || masksToBounds())
return;
SkBitmap& bitmap = m_bitmap->bitmap();
SkRect dst = SkRect::MakeXYWH(m_visibleContentRect.x() - m_offsetFromRenderer.width(),
m_visibleContentRect.y() - m_offsetFromRenderer.height(),
m_visibleContentRect.width(), m_visibleContentRect.height());
canvas->drawBitmapRect(bitmap, 0, dst, 0);
}
void CCLayerImpl::setBounds(const IntSize& bounds)
{
if (m_bounds == bounds)
return;
m_bounds = bounds;
if (masksToBounds())
noteLayerPropertyChangedForSubtree();
else
m_layerPropertyChanged = true;
}
void GraphicsLayer::updateDebugIndicators()
{
if (GraphicsLayer::showDebugBorders()) {
if (drawsContent()) {
if (m_usingTiledLayer)
setDebugBorder(Color(0, 255, 0, 204), 2.0f); // tiled layer: green
else
setDebugBorder(Color(255, 0, 0, 204), 2.0f); // normal layer: red
} else if (masksToBounds()) {
setDebugBorder(Color(128, 255, 255, 178), 2.0f); // masking layer: pale blue
if (GraphicsLayer::showDebugBorders())
setDebugBackgroundColor(Color(128, 255, 255, 52));
} else
setDebugBorder(Color(255, 255, 0, 204), 2.0f); // container: yellow
}
}
void GraphicsLayer::getDebugBorderInfo(Color& color, float& width) const
{
if (drawsContent()) {
color = Color(0, 128, 32, 128); // normal layer: green
width = 2;
return;
}
if (masksToBounds()) {
color = Color(128, 255, 255, 48); // masking layer: pale blue
width = 20;
return;
}
color = Color(255, 255, 0, 192); // container: yellow
width = 2;
}
void GraphicsLayer::updateDebugIndicators()
{
if (GraphicsLayer::showDebugBorders()) {
if (drawsContent()) {
// FIXME: It's weird to ask the client if this layer is a tile cache layer.
// Maybe we should just cache that information inside GraphicsLayer?
if (m_client->shouldUseTileCache(this)) // tile cache layer: dark blue
setDebugBorder(Color(0, 0, 128, 128), 0.5);
else if (m_usingTiledLayer)
setDebugBorder(Color(255, 128, 0, 128), 2); // tiled layer: orange
else
setDebugBorder(Color(0, 128, 32, 128), 2); // normal layer: green
} else if (masksToBounds()) {
setDebugBorder(Color(128, 255, 255, 48), 20); // masking layer: pale blue
} else
setDebugBorder(Color(255, 255, 0, 192), 2); // container: yellow
}
}
void WebGraphicsLayer::syncCompositingStateForThisLayerOnly()
{
if (!m_layerTreeTileClient)
m_layerTreeTileClient = layerTreeTileClient();
updateContentBuffers();
if (!m_modified)
return;
m_layerInfo.name = name();
m_layerInfo.anchorPoint = anchorPoint();
m_layerInfo.backfaceVisible = backfaceVisibility();
m_layerInfo.childrenTransform = childrenTransform();
m_layerInfo.contentsOpaque = contentsOpaque();
m_layerInfo.contentsRect = contentsRect();
m_layerInfo.drawsContent = drawsContent();
m_layerInfo.mask = toWebLayerID(maskLayer());
m_layerInfo.masksToBounds = masksToBounds();
m_layerInfo.opacity = opacity();
m_layerInfo.parent = toWebLayerID(parent());
m_layerInfo.pos = position();
m_layerInfo.preserves3D = preserves3D();
m_layerInfo.replica = toWebLayerID(replicaLayer());
m_layerInfo.size = size();
m_layerInfo.transform = transform();
m_contentNeedsDisplay = false;
m_layerInfo.children.clear();
for (size_t i = 0; i < children().size(); ++i)
m_layerInfo.children.append(toWebLayerID(children()[i]));
ASSERT(m_layerTreeTileClient);
if (m_layerInfo.imageIsUpdated && m_image && !m_layerInfo.imageBackingStoreID)
m_layerInfo.imageBackingStoreID = m_layerTreeTileClient->adoptImageBackingStore(m_image.get());
m_layerTreeTileClient->didSyncCompositingStateForLayer(m_layerInfo);
m_modified = false;
m_layerInfo.imageIsUpdated = false;
if (m_hasPendingAnimations)
notifyAnimationStarted(WTF::currentTime());
m_layerInfo.animations.clear();
m_hasPendingAnimations = false;
}
void WebGraphicsLayer::syncLayerState()
{
if (!m_shouldSyncLayerState)
return;
m_shouldSyncLayerState = false;
m_layerInfo.anchorPoint = anchorPoint();
m_layerInfo.backfaceVisible = backfaceVisibility();
m_layerInfo.childrenTransform = childrenTransform();
m_layerInfo.contentsOpaque = contentsOpaque();
m_layerInfo.contentsRect = contentsRect();
m_layerInfo.drawsContent = drawsContent();
m_layerInfo.mask = toWebLayerID(maskLayer());
m_layerInfo.masksToBounds = masksToBounds();
m_layerInfo.opacity = opacity();
m_layerInfo.parent = toWebLayerID(parent());
m_layerInfo.pos = position();
m_layerInfo.preserves3D = preserves3D();
m_layerInfo.replica = toWebLayerID(replicaLayer());
m_layerInfo.size = size();
m_layerInfo.transform = transform();
m_webGraphicsLayerClient->syncLayerState(m_id, m_layerInfo);
}
bool CanvasLayer::needsTexture()
{
return (m_bitmap && !masksToBounds()) || LayerAndroid::needsTexture();
}
void WKCACFLayer::printLayer(int indent) const
{
CGPoint layerPosition = position();
CGPoint layerAnchorPoint = anchorPoint();
CGRect layerBounds = bounds();
printIndent(indent);
fprintf(stderr, "(%s [%g %g %g] [%g %g %g %g] [%g %g %g]\n",
isTransformLayer() ? "transform-layer" : "layer",
layerPosition.x, layerPosition.y, zPosition(),
layerBounds.origin.x, layerBounds.origin.y, layerBounds.size.width, layerBounds.size.height,
layerAnchorPoint.x, layerAnchorPoint.y, anchorPointZ());
// Print name if needed
String layerName = name();
if (!layerName.isEmpty()) {
printIndent(indent + 1);
fprintf(stderr, "(name %s)\n", layerName.utf8().data());
}
// Print masksToBounds if needed
bool layerMasksToBounds = masksToBounds();
if (layerMasksToBounds) {
printIndent(indent + 1);
fprintf(stderr, "(masksToBounds true)\n");
}
// Print opacity if needed
float layerOpacity = opacity();
if (layerOpacity != 1) {
printIndent(indent + 1);
fprintf(stderr, "(opacity %hf)\n", layerOpacity);
}
// Print sublayerTransform if needed
CATransform3D layerTransform = sublayerTransform();
if (!CATransform3DIsIdentity(layerTransform)) {
printIndent(indent + 1);
fprintf(stderr, "(sublayerTransform ");
printTransform(layerTransform);
fprintf(stderr, ")\n");
}
// Print transform if needed
layerTransform = transform();
if (!CATransform3DIsIdentity(layerTransform)) {
printIndent(indent + 1);
fprintf(stderr, "(transform ");
printTransform(layerTransform);
fprintf(stderr, ")\n");
}
// Print contents if needed
CGImageRef layerContents = contents();
if (layerContents) {
printIndent(indent + 1);
fprintf(stderr, "(contents (image [%d %d]))\n",
CGImageGetWidth(layerContents), CGImageGetHeight(layerContents));
}
// Print sublayers if needed
int n = numSublayers();
if (n > 0) {
printIndent(indent + 1);
fprintf(stderr, "(sublayers\n");
for (int i = 0; i < n; ++i)
sublayerAtIndex(i)->printLayer(indent + 2);
printIndent(indent + 1);
fprintf(stderr, ")\n");
}
printIndent(indent);
fprintf(stderr, ")\n");
}
void GraphicsLayerTextureMapper::commitLayerChanges()
{
if (m_changeMask == NoChanges)
return;
if (m_changeMask & ChildrenChange) {
Vector<TextureMapperLayer*> textureMapperLayerChildren;
toTextureMapperLayerVector(children(), textureMapperLayerChildren);
m_layer->setChildren(textureMapperLayerChildren);
}
if (m_changeMask & MaskLayerChange)
m_layer->setMaskLayer(toTextureMapperLayer(maskLayer()));
if (m_changeMask & ReplicaLayerChange)
m_layer->setReplicaLayer(toTextureMapperLayer(replicaLayer()));
if (m_changeMask & PositionChange)
m_layer->setPosition(position());
if (m_changeMask & AnchorPointChange)
m_layer->setAnchorPoint(anchorPoint());
if (m_changeMask & SizeChange)
m_layer->setSize(size());
if (m_changeMask & TransformChange)
m_layer->setTransform(transform());
if (m_changeMask & ChildrenTransformChange)
m_layer->setChildrenTransform(childrenTransform());
if (m_changeMask & Preserves3DChange)
m_layer->setPreserves3D(preserves3D());
if (m_changeMask & ContentsRectChange)
m_layer->setContentsRect(contentsRect());
if (m_changeMask & MasksToBoundsChange)
m_layer->setMasksToBounds(masksToBounds());
if (m_changeMask & DrawsContentChange)
m_layer->setDrawsContent(drawsContent());
if (m_changeMask & ContentsVisibleChange)
m_layer->setContentsVisible(contentsAreVisible());
if (m_changeMask & ContentsOpaqueChange)
m_layer->setContentsOpaque(contentsOpaque());
if (m_changeMask & BackfaceVisibilityChange)
m_layer->setBackfaceVisibility(backfaceVisibility());
if (m_changeMask & OpacityChange)
m_layer->setOpacity(opacity());
if (m_changeMask & BackgroundColorChange)
m_layer->setSolidColor(solidColor());
#if ENABLE(CSS_FILTERS)
if (m_changeMask & FilterChange)
m_layer->setFilters(filters());
#endif
if (m_changeMask & BackingStoreChange)
m_layer->setBackingStore(m_backingStore);
if (m_changeMask & DebugVisualsChange)
m_layer->setDebugVisuals(isShowingDebugBorder(), debugBorderColor(), debugBorderWidth(), isShowingRepaintCounter());
if (m_changeMask & RepaintCountChange)
m_layer->setRepaintCount(repaintCount());
if (m_changeMask & ContentChange)
m_layer->setContentsLayer(platformLayer());
if (m_changeMask & AnimationChange)
m_layer->setAnimations(m_animations);
if (m_changeMask & AnimationStarted)
client()->notifyAnimationStarted(this, m_animationStartTime);
if (m_changeMask & FixedToViewporChange)
m_layer->setFixedToViewport(fixedToViewport());
if (m_changeMask & IsScrollableChange)
m_layer->setIsScrollable(isScrollable());
if (m_changeMask & CommittedScrollOffsetChange)
m_layer->didCommitScrollOffset(m_committedScrollOffset);
m_changeMask = NoChanges;
}
