| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // @dart = 2.6 |
| part of engine; |
| |
| class LayerScene implements ui.Scene { |
| final LayerTree layerTree; |
| |
| LayerScene(Layer rootLayer) : layerTree = LayerTree() { |
| layerTree.rootLayer = rootLayer; |
| } |
| |
| @override |
| void dispose() {} |
| |
| @override |
| Future<ui.Image> toImage(int width, int height) => null; |
| |
| html.Element get webOnlyRootElement => null; |
| } |
| |
| class LayerSceneBuilder implements ui.SceneBuilder { |
| Layer rootLayer; |
| ContainerLayer currentLayer; |
| |
| @override |
| void addChildScene({ |
| ui.Offset offset = ui.Offset.zero, |
| double width = 0.0, |
| double height = 0.0, |
| ui.SceneHost sceneHost, |
| bool hitTestable = true, |
| }) { |
| throw UnimplementedError(); |
| } |
| |
| @override |
| void addPerformanceOverlay(int enabledOptions, ui.Rect bounds) { |
| // We don't plan to implement this on the web. |
| throw UnimplementedError(); |
| } |
| |
| @override |
| void addPicture( |
| ui.Offset offset, |
| ui.Picture picture, { |
| bool isComplexHint = false, |
| bool willChangeHint = false, |
| }) { |
| currentLayer.add(PictureLayer(picture, offset, isComplexHint, willChangeHint)); |
| } |
| |
| @override |
| void addRetained(ui.EngineLayer retainedLayer) { |
| if (currentLayer == null) { |
| return; |
| } |
| currentLayer.add(retainedLayer); |
| } |
| |
| @override |
| void addTexture( |
| int textureId, { |
| ui.Offset offset = ui.Offset.zero, |
| double width = 0.0, |
| double height = 0.0, |
| bool freeze = false, |
| }) { |
| // TODO(b/128315641): implement addTexture. |
| } |
| |
| @override |
| void addPlatformView( |
| int viewId, { |
| ui.Offset offset = ui.Offset.zero, |
| double width = 0.0, |
| double height = 0.0, |
| Object webOnlyPaintedBy, |
| }) { |
| currentLayer.add(PlatformViewLayer(viewId, offset, width, height)); |
| } |
| |
| @override |
| ui.Scene build() { |
| return LayerScene(rootLayer); |
| } |
| |
| @override |
| void pop() { |
| if (currentLayer == null) { |
| return; |
| } |
| currentLayer = currentLayer.parent; |
| } |
| |
| @override |
| ui.BackdropFilterEngineLayer pushBackdropFilter( |
| ui.ImageFilter filter, { |
| ui.EngineLayer oldLayer, |
| }) { |
| pushLayer(BackdropFilterLayer(filter)); |
| return null; |
| } |
| |
| @override |
| ui.ClipPathEngineLayer pushClipPath( |
| ui.Path path, { |
| ui.Clip clipBehavior = ui.Clip.antiAlias, |
| ui.EngineLayer oldLayer, |
| }) { |
| pushLayer(ClipPathLayer(path, clipBehavior)); |
| return null; |
| } |
| |
| @override |
| ui.ClipRRectEngineLayer pushClipRRect( |
| ui.RRect rrect, { |
| ui.Clip clipBehavior, |
| ui.EngineLayer oldLayer, |
| }) { |
| pushLayer(ClipRRectLayer(rrect, clipBehavior)); |
| return null; |
| } |
| |
| @override |
| ui.ClipRectEngineLayer pushClipRect( |
| ui.Rect rect, { |
| ui.Clip clipBehavior = ui.Clip.antiAlias, |
| ui.EngineLayer oldLayer, |
| }) { |
| pushLayer(ClipRectLayer(rect, clipBehavior)); |
| return null; |
| } |
| |
| @override |
| ui.ColorFilterEngineLayer pushColorFilter( |
| ui.ColorFilter filter, { |
| ui.ColorFilterEngineLayer oldLayer, |
| }) { |
| assert(filter != null); |
| throw UnimplementedError(); |
| } |
| |
| ui.ImageFilterEngineLayer pushImageFilter( |
| ui.ImageFilter filter, { |
| ui.ImageFilterEngineLayer oldLayer, |
| }) { |
| assert(filter != null); |
| pushLayer(ImageFilterLayer(filter)); |
| return null; |
| } |
| |
| @override |
| ui.OffsetEngineLayer pushOffset( |
| double dx, |
| double dy, { |
| ui.EngineLayer oldLayer, |
| }) { |
| final Matrix4 matrix = Matrix4.translationValues(dx, dy, 0.0); |
| final TransformLayer layer = TransformLayer(matrix); |
| pushLayer(layer); |
| return layer; |
| } |
| |
| @override |
| ui.OpacityEngineLayer pushOpacity( |
| int alpha, { |
| ui.EngineLayer oldLayer, |
| ui.Offset offset = ui.Offset.zero, |
| }) { |
| final OpacityLayer layer = OpacityLayer(alpha, offset); |
| pushLayer(layer); |
| return layer; |
| } |
| |
| @override |
| ui.PhysicalShapeEngineLayer pushPhysicalShape({ |
| ui.Path path, |
| double elevation, |
| ui.Color color, |
| ui.Color shadowColor, |
| ui.Clip clipBehavior = ui.Clip.none, |
| ui.EngineLayer oldLayer, |
| }) { |
| final PhysicalShapeLayer layer = |
| PhysicalShapeLayer(elevation, color, shadowColor, path, clipBehavior); |
| pushLayer(layer); |
| return layer; |
| } |
| |
| @override |
| ui.ShaderMaskEngineLayer pushShaderMask( |
| ui.Shader shader, |
| ui.Rect maskRect, |
| ui.BlendMode blendMode, { |
| ui.EngineLayer oldLayer, |
| }) { |
| throw UnimplementedError(); |
| } |
| |
| @override |
| ui.TransformEngineLayer pushTransform( |
| Float64List matrix4, { |
| ui.EngineLayer oldLayer, |
| }) { |
| final Matrix4 matrix = Matrix4.fromFloat32List(toMatrix32(matrix4)); |
| pushLayer(TransformLayer(matrix)); |
| return null; |
| } |
| |
| @override |
| void setCheckerboardOffscreenLayers(bool checkerboard) { |
| // TODO: implement setCheckerboardOffscreenLayers |
| } |
| |
| @override |
| void setCheckerboardRasterCacheImages(bool checkerboard) { |
| // TODO: implement setCheckerboardRasterCacheImages |
| } |
| |
| @override |
| void setRasterizerTracingThreshold(int frameInterval) { |
| // TODO: implement setRasterizerTracingThreshold |
| } |
| |
| void pushLayer(ContainerLayer layer) { |
| if (rootLayer == null) { |
| rootLayer = currentLayer = layer; |
| return; |
| } |
| |
| if (currentLayer == null) { |
| return; |
| } |
| |
| currentLayer.add(layer); |
| currentLayer = layer; |
| } |
| |
| @override |
| void setProperties( |
| double width, |
| double height, |
| double insetTop, |
| double insetRight, |
| double insetBottom, |
| double insetLeft, |
| bool focusable, |
| ) { |
| throw UnimplementedError(); |
| } |
| } |