internal CompositionLayer(LottieDrawable lottieDrawable, Layer layerModel, List <Layer> layerModels, LottieComposition composition) : base(lottieDrawable, layerModel)
{
var timeRemapping = layerModel.TimeRemapping;
if (timeRemapping != null)
{
_timeRemapping = timeRemapping.CreateAnimation();
AddAnimation(_timeRemapping);
_timeRemapping.ValueChanged += OnValueChanged;
}
else
{
_timeRemapping = null;
}
var layerMap = new Dictionary <long, BaseLayer>(composition.Layers.Count);
BaseLayer mattedLayer = null;
for (var i = layerModels.Count - 1; i >= 0; i--)
{
var lm = layerModels[i];
var layer = ForModel(lm, lottieDrawable, composition);
if (layer == null)
{
continue;
}
layerMap.Add(layer.LayerModel.Id, layer);
if (mattedLayer != null)
{
mattedLayer.MatteLayer = layer;
mattedLayer = null;
}
else
{
_layers.Insert(0, layer);
switch (lm.GetMatteType())
{
case Layer.MatteType.Add:
case Layer.MatteType.Invert:
mattedLayer = layer;
break;
}
}
}
foreach (var layer in layerMap)
{
var layerView = layer.Value;
if (layerMap.TryGetValue(layerView.LayerModel.ParentId, out BaseLayer parentLayer))
{
layerView.ParentLayer = parentLayer;
}
}
}
internal EllipseContent(LottieDrawable lottieDrawable, BaseLayer layer, CircleShape circleShape)
{
Name = circleShape.Name;
_lottieDrawable = lottieDrawable;
_sizeAnimation = circleShape.Size.CreateAnimation();
_positionAnimation = circleShape.Position.CreateAnimation();
layer.AddAnimation(_sizeAnimation);
layer.AddAnimation(_positionAnimation);
_sizeAnimation.ValueChanged += OnValueChanged;
_positionAnimation.ValueChanged += OnValueChanged;
}
internal BaseStrokeContent(LottieDrawable lottieDrawable, BaseLayer layer, PenLineCap cap, PenLineJoin join, AnimatableIntegerValue opacity, AnimatableFloatValue width, IList <AnimatableFloatValue> dashPattern, AnimatableFloatValue offset)
{
_lottieDrawable = lottieDrawable;
Paint.Style = Paint.PaintStyle.Stroke;
Paint.StrokeCap = cap;
Paint.StrokeJoin = join;
_opacityAnimation = opacity.CreateAnimation();
_widthAnimation = width.CreateAnimation();
if (offset == null)
{
_dashPatternOffsetAnimation = null;
}
else
{
_dashPatternOffsetAnimation = offset.CreateAnimation();
}
_dashPatternAnimations = new List <IBaseKeyframeAnimation <float?> >(dashPattern.Count);
_dashPatternValues = new double[dashPattern.Count];
for (var i = 0; i < dashPattern.Count; i++)
{
_dashPatternAnimations.Add(dashPattern[i].CreateAnimation());
}
layer.AddAnimation(_opacityAnimation);
layer.AddAnimation(_widthAnimation);
for (var i = 0; i < _dashPatternAnimations.Count; i++)
{
layer.AddAnimation(_dashPatternAnimations[i]);
}
if (_dashPatternOffsetAnimation != null)
{
layer.AddAnimation(_dashPatternOffsetAnimation);
}
_opacityAnimation.ValueChanged += OnValueChanged;
_widthAnimation.ValueChanged += OnValueChanged;
for (var i = 0; i < dashPattern.Count; i++)
{
_dashPatternAnimations[i].ValueChanged += OnValueChanged;
}
if (_dashPatternOffsetAnimation != null)
{
_dashPatternOffsetAnimation.ValueChanged += OnValueChanged;
}
}
private static List <IContent> ContentsFromModels(LottieDrawable drawable, BaseLayer layer, List <IContentModel> contentModels)
{
var contents = new List <IContent>(contentModels.Count);
for (var i = 0; i < contentModels.Count; i++)
{
var content = contentModels[i].ToContent(drawable, layer);
if (content != null)
{
contents.Add(content);
}
}
return(contents);
}
internal RectangleContent(LottieDrawable lottieDrawable, BaseLayer layer, RectangleShape rectShape)
{
Name = rectShape.Name;
_lottieDrawable = lottieDrawable;
_positionAnimation = rectShape.Position.CreateAnimation();
_sizeAnimation = rectShape.Size.CreateAnimation();
_cornerRadiusAnimation = rectShape.CornerRadius.CreateAnimation();
layer.AddAnimation(_positionAnimation);
layer.AddAnimation(_sizeAnimation);
layer.AddAnimation(_cornerRadiusAnimation);
_positionAnimation.ValueChanged += OnValueChanged;
_sizeAnimation.ValueChanged += OnValueChanged;
_cornerRadiusAnimation.ValueChanged += OnValueChanged;
}
internal RepeaterContent(LottieDrawable lottieDrawable, BaseLayer layer, Repeater repeater)
{
_lottieDrawable = lottieDrawable;
_layer = layer;
Name = repeater.Name;
_copies = repeater.Copies.CreateAnimation();
layer.AddAnimation(_copies);
_copies.ValueChanged += OnValueChanged;
_offset = repeater.Offset.CreateAnimation();
layer.AddAnimation(_offset);
_offset.ValueChanged += OnValueChanged;
_transform = repeater.Transform.CreateAnimation();
_transform.AddAnimationsToLayer(layer);
_transform.ValueChanged += OnValueChanged;
}
internal GradientStrokeContent(LottieDrawable lottieDrawable, BaseLayer layer, GradientStroke stroke) : base(lottieDrawable, layer, ShapeStroke.LineCapTypeToPaintCap(stroke.CapType), ShapeStroke.LineJoinTypeToPaintLineJoin(stroke.JoinType), stroke.Opacity, stroke.Width, stroke.LineDashPattern, stroke.DashOffset)
{
Name = stroke.Name;
_type = stroke.GradientType;
_cacheSteps = (int)(lottieDrawable.Composition.Duration / CacheStepsMs);
_colorAnimation = (KeyframeAnimation <GradientColor>)stroke.GradientColor.CreateAnimation();
_colorAnimation.ValueChanged += OnValueChanged;
layer.AddAnimation(_colorAnimation);
_startPointAnimation = (KeyframeAnimation <PointF>)stroke.StartPoint.CreateAnimation();
_startPointAnimation.ValueChanged += OnValueChanged;
layer.AddAnimation(_startPointAnimation);
_endPointAnimation = (KeyframeAnimation <PointF>)stroke.EndPoint.CreateAnimation();
_endPointAnimation.ValueChanged += OnValueChanged;
layer.AddAnimation(_endPointAnimation);
}
internal PolystarContent(LottieDrawable lottieDrawable, BaseLayer layer, PolystarShape polystarShape)
{
_lottieDrawable = lottieDrawable;
Name = polystarShape.Name;
_type = polystarShape.GetType();
_pointsAnimation = polystarShape.Points.CreateAnimation();
_positionAnimation = polystarShape.Position.CreateAnimation();
_rotationAnimation = polystarShape.Rotation.CreateAnimation();
_outerRadiusAnimation = polystarShape.OuterRadius.CreateAnimation();
_outerRoundednessAnimation = polystarShape.OuterRoundedness.CreateAnimation();
if (_type == PolystarShape.Type.Star)
{
_innerRadiusAnimation = polystarShape.InnerRadius.CreateAnimation();
_innerRoundednessAnimation = polystarShape.InnerRoundedness.CreateAnimation();
}
else
{
_innerRadiusAnimation = null;
_innerRoundednessAnimation = null;
}
layer.AddAnimation(_pointsAnimation);
layer.AddAnimation(_positionAnimation);
layer.AddAnimation(_rotationAnimation);
layer.AddAnimation(_outerRadiusAnimation);
layer.AddAnimation(_outerRoundednessAnimation);
if (_type == PolystarShape.Type.Star)
{
layer.AddAnimation(_innerRadiusAnimation);
layer.AddAnimation(_innerRoundednessAnimation);
}
_pointsAnimation.ValueChanged += OnValueChanged;
_positionAnimation.ValueChanged += OnValueChanged;
_rotationAnimation.ValueChanged += OnValueChanged;
_outerRadiusAnimation.ValueChanged += OnValueChanged;
_outerRoundednessAnimation.ValueChanged += OnValueChanged;
if (_type == PolystarShape.Type.Star)
{
_outerRadiusAnimation.ValueChanged += OnValueChanged;
_outerRoundednessAnimation.ValueChanged += OnValueChanged;
}
}
internal TextLayer(LottieDrawable lottieDrawable, Layer layerModel) : base(lottieDrawable, layerModel)
{
_lottieDrawable = lottieDrawable;
_composition = layerModel.Composition;
_textAnimation = layerModel.Text.CreateAnimation();
_textAnimation.ValueChanged += OnValueChanged;
AddAnimation(_textAnimation);
var textProperties = layerModel.TextProperties;
if (textProperties?._color != null)
{
_colorAnimation = textProperties._color.CreateAnimation();
_colorAnimation.ValueChanged += OnValueChanged;
AddAnimation(_colorAnimation);
}
if (textProperties?._stroke != null)
{
_strokeAnimation = textProperties._stroke.CreateAnimation();
_strokeAnimation.ValueChanged += OnValueChanged;
AddAnimation(_strokeAnimation);
}
if (textProperties?._strokeWidth != null)
{
_strokeWidthAnimation = textProperties._strokeWidth.CreateAnimation();
_strokeWidthAnimation.ValueChanged += OnValueChanged;
AddAnimation(_strokeWidthAnimation);
}
if (textProperties?._tracking != null)
{
_trackingAnimation = textProperties._tracking.CreateAnimation();
_trackingAnimation.ValueChanged += OnValueChanged;
AddAnimation(_trackingAnimation);
}
}
internal GradientFillContent(LottieDrawable lottieDrawable, BaseLayer layer, GradientFill fill)
{
Name = fill.Name;
_lottieDrawable = lottieDrawable;
_type = fill.GradientType;
_path.FillType = fill.FillType;
_cacheSteps = (int)(lottieDrawable.Composition.Duration / CacheStepsMs);
_colorAnimation = (KeyframeAnimation <GradientColor>)fill.GradientColor.CreateAnimation();
_colorAnimation.ValueChanged += OnValueChanged;
layer.AddAnimation(_colorAnimation);
_opacityAnimation = (KeyframeAnimation <int?>)fill.Opacity.CreateAnimation();
_opacityAnimation.ValueChanged += OnValueChanged;
layer.AddAnimation(_opacityAnimation);
_startPointAnimation = (KeyframeAnimation <PointF>)fill.StartPoint.CreateAnimation();
_startPointAnimation.ValueChanged += OnValueChanged;
layer.AddAnimation(_startPointAnimation);
_endPointAnimation = (KeyframeAnimation <PointF>)fill.EndPoint.CreateAnimation();
_endPointAnimation.ValueChanged += OnValueChanged;
layer.AddAnimation(_endPointAnimation);
}
internal BaseLayer(LottieDrawable lottieDrawable, Layer layerModel)
{
LottieDrawable = lottieDrawable;
LayerModel = layerModel;
_drawTraceName = layerModel.Name + ".Draw";
_clearPaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.Clear);
_maskPaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.DstIn);
if (layerModel.GetMatteType() == Layer.MatteType.Invert)
{
_mattePaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.DstOut);
}
else
{
_mattePaint.Xfermode = new PorterDuffXfermode(PorterDuff.Mode.DstIn);
}
Transform = layerModel.Transform.CreateAnimation();
Transform.ValueChanged += OnValueChanged;
Transform.AddAnimationsToLayer(this);
if (layerModel.Masks != null && layerModel.Masks.Count > 0)
{
_mask = new MaskKeyframeAnimation(layerModel.Masks);
foreach (var animation in _mask.MaskAnimations)
{
AddAnimation(animation);
animation.ValueChanged += OnValueChanged;
}
foreach (var animation in _mask.OpacityAnimations)
{
AddAnimation(animation);
animation.ValueChanged += OnValueChanged;
}
}
SetupInOutAnimations();
}
public IContent ToContent(LottieDrawable drawable, BaseLayer layer)
{
return(new TrimPathContent(layer, this));
}
public IContent ToContent(LottieDrawable drawable, BaseLayer layer)
{
return(new StrokeContent(drawable, layer, this));
}
internal ImageLayer(LottieDrawable lottieDrawable, Layer layerModel, float density) : base(lottieDrawable, layerModel)
{
_density = density;
}
/// <summary>
/// This normally needs to be able to invalidate the view/drawable but not for the test.
/// </summary>
internal TextDelegate()
{
_animationView = null;
_drawable = null;
}
public TextDelegate(LottieAnimationView animationView)
{
_animationView = animationView;
_drawable = null;
}
public IContent ToContent(LottieDrawable drawable, BaseLayer layer)
{
return(new GradientFillContent(drawable, layer, this));
}
public TextDelegate(LottieDrawable drawable)
{
_drawable = drawable;
_animationView = null;
}
internal ContentGroup(LottieDrawable lottieDrawable, BaseLayer layer, ShapeGroup shapeGroup)
: this(lottieDrawable, layer, shapeGroup.Name,
ContentsFromModels(lottieDrawable, layer, shapeGroup.Items),
FindTransform(shapeGroup.Items))
{
}
public IContent ToContent(LottieDrawable drawable, BaseLayer layer)
{
return(null);
}
internal NullLayer(LottieDrawable lottieDrawable, Layer layerModel) : base(lottieDrawable, layerModel)
{
}
public IContent ToContent(LottieDrawable drawable, BaseLayer layer)
{
return(new ContentGroup(drawable, layer, this));
}
internal ContentGroup(LottieDrawable lottieDrawable, BaseLayer layer, ShapeGroup shapeGroup)
{
Name = shapeGroup.Name;
var items = shapeGroup.Items;
if (items.Count == 0)
{
return;
}
if (items[items.Count - 1] is AnimatableTransform animatableTransform)
{
_transformAnimation = animatableTransform.CreateAnimation();
_transformAnimation.AddAnimationsToLayer(layer);
_transformAnimation.ValueChanged += (sender, args) =>
{
lottieDrawable.InvalidateSelf();
};
}
for (var i = 0; i < items.Count; i++)
{
var item = items[i];
if (item is ShapeFill)
{
_contents.Add(new FillContent(lottieDrawable, layer, (ShapeFill)item));
}
else if (item is GradientFill)
{
_contents.Add(new GradientFillContent(lottieDrawable, layer, (GradientFill)item));
}
else if (item is ShapeStroke)
{
_contents.Add(new StrokeContent(lottieDrawable, layer, (ShapeStroke)item));
}
else if (item is GradientStroke)
{
_contents.Add(new GradientStrokeContent(lottieDrawable, layer, (GradientStroke)item));
}
else if (item is ShapeGroup)
{
_contents.Add(new ContentGroup(lottieDrawable, layer, (ShapeGroup)item));
}
else if (item is RectangleShape)
{
_contents.Add(new RectangleContent(lottieDrawable, layer, (RectangleShape)item));
}
else if (item is CircleShape)
{
_contents.Add(new EllipseContent(lottieDrawable, layer, (CircleShape)item));
}
else if (item is ShapePath)
{
_contents.Add(new ShapeContent(lottieDrawable, layer, (ShapePath)item));
}
else if (item is PolystarShape)
{
_contents.Add(new PolystarContent(lottieDrawable, layer, (PolystarShape)item));
}
else if (item is ShapeTrimPath)
{
_contents.Add(new TrimPathContent(layer, (ShapeTrimPath)item));
}
else
{
if (item is MergePaths mergePaths)
{
if (lottieDrawable.EnableMergePathsForKitKatAndAbove())
{
_contents.Add(new MergePathsContent(mergePaths));
}
else
{
Debug.WriteLine("Animation contains merge paths but they are disabled.", Tag);
}
}
}
}
IList <IContent> contentsToRemove = new List <IContent>();
MergePathsContent currentMergePathsContent = null;
for (var i = _contents.Count - 1; i >= 0; i--)
{
var content = _contents[i];
if (content is MergePathsContent mergePathsContent)
{
currentMergePathsContent = mergePathsContent;
}
if (currentMergePathsContent != null && content != currentMergePathsContent)
{
currentMergePathsContent.AddContentIfNeeded(content);
contentsToRemove.Add(content);
}
}
for (var i = _contents.Count - 1; i >= 0; i--)
{
if (contentsToRemove.Contains(_contents[i]))
{
_contents.RemoveAt(i);
}
}
}
