private TransformSession(CanvasDrawingSession session, Matrix3x2 oldTransform, SvgMatrix multiply)
{
this.Session = session;
this.OldTransform = oldTransform;
var transform = new Matrix3x2((float)multiply.A, (float)multiply.B, (float)multiply.C, (float)multiply.D, (float)multiply.E, (float)multiply.F);
session.Transform = transform * session.Transform;
}
private Matrix GetTransformMatrix(RectangleF bounds)
{
SvgMatrix svgMatrix = ((SvgTransformList)_patternElement.PatternTransform.AnimVal).TotalMatrix;
Matrix transformMatrix = new Matrix((float)svgMatrix.A, (float)svgMatrix.B, (float)svgMatrix.C,
(float)svgMatrix.D, (float)svgMatrix.E, (float)svgMatrix.F);
float translateX = CalcPatternUnit(_patternElement.X.AnimVal as SvgLength,
SvgLengthDirection.Horizontal, bounds);
float translateY = CalcPatternUnit(_patternElement.Y.AnimVal as SvgLength,
SvgLengthDirection.Vertical, bounds);
transformMatrix.Translate(translateX, translateY, MatrixOrder.Prepend);
return(transformMatrix);
}
protected void SetTransform(GdiGraphics gr)
{
if (_svgElement is ISvgTransformable)
{
if (_transformMatrix == null)
{
ISvgTransformable transElm = (ISvgTransformable)_svgElement;
SvgTransformList svgTList = (SvgTransformList)transElm.Transform.AnimVal;
SvgMatrix svgMatrix = ((SvgTransformList)transElm.Transform.AnimVal).TotalMatrix;
_transformMatrix = new Matrix((float)svgMatrix.A, (float)svgMatrix.B, (float)svgMatrix.C,
(float)svgMatrix.D, (float)svgMatrix.E, (float)svgMatrix.F);
}
gr.Transform = _transformMatrix;
}
}
public static Matrix GetTransformMatrix(SvgElement element)
{
ISvgTransformable transElm = element as ISvgTransformable;
if (transElm == null)
{
return(Matrix.Identity);
}
SvgTransformList svgTList = (SvgTransformList)transElm.Transform.AnimVal;
SvgTransform svgTransform = (SvgTransform)svgTList.Consolidate();
SvgMatrix svgMatrix = ((SvgTransformList)transElm.Transform.AnimVal).TotalMatrix;
return(new Matrix(svgMatrix.A, svgMatrix.B, svgMatrix.C,
svgMatrix.D, svgMatrix.E, svgMatrix.F));
}
public void TestMatrixTransformIdentity()
{
SvgMatrix m = new SvgMatrix(1, 2, 3, 4, 5, 6);
ISvgPoint p2 = p.MatrixTransform(m);
Assert.AreEqual(10, p.X);
Assert.AreEqual(20, p.Y);
Assert.AreEqual(75, p2.X);
Assert.AreEqual(106, p2.Y);
}
private MatrixTransform GetTransformMatrix(Rect bounds)
{
SvgMatrix svgMatrix =
((SvgTransformList)_patternElement.PatternTransform.AnimVal).TotalMatrix;
MatrixTransform transformMatrix = new MatrixTransform(svgMatrix.A, svgMatrix.B, svgMatrix.C,
svgMatrix.D, svgMatrix.E, svgMatrix.F);
double translateX = CalcPatternUnit(_patternElement.X.AnimVal as SvgLength,
SvgLengthDirection.Horizontal, bounds);
double translateY = CalcPatternUnit(_patternElement.Y.AnimVal as SvgLength,
SvgLengthDirection.Vertical, bounds);
transformMatrix.Matrix.TranslatePrepend(translateX, translateY);
return(transformMatrix);
}
public override PageElement VisitSvgElement(SvgSvgElement element)
{
if (element.IsOutermost)
{
return(EstablishViewportThen(element, element.ViewWidth, element.ViewHeight, VisitStructuralElement, element));
}
var tx = element.X?.Value ?? 0;
var ty = element.Y?.Value ?? 0;
PushMatrix(SvgMatrix.CreateTranslate(tx, ty));
var viewportWidth = element.Width ?? 0;
var viewportHeight = element.Height ?? 0;
var result = EstablishViewportThen(element, viewportWidth, viewportHeight, VisitStructuralElement, element);
PopMatrix();
return(result);
}
protected void Transform(GraphicsWrapper gr)
{
if (element is ISvgTransformable)
{
if (TransformMatrix == null)
{
ISvgTransformable transElm = (ISvgTransformable)element;
SvgTransformList svgTList = (SvgTransformList)transElm.Transform.AnimVal;
//SvgTransform svgTransform = (SvgTransform)svgTList.Consolidate();
SvgMatrix svgMatrix = ((SvgTransformList)transElm.Transform.AnimVal).TotalMatrix;
TransformMatrix = new Matrix(
(float)svgMatrix.A,
(float)svgMatrix.B,
(float)svgMatrix.C,
(float)svgMatrix.D,
(float)svgMatrix.E,
(float)svgMatrix.F);
}
gr.Transform = TransformMatrix;
}
}
private MatrixTransform GetTransformMatrix(Rect bounds, bool isUserSpace)
{
SvgMatrix svgMatrix = ((SvgTransformList)_patternElement.PatternTransform.AnimVal).TotalMatrix;
MatrixTransform transformMatrix = new MatrixTransform((float)svgMatrix.A, (float)svgMatrix.B, (float)svgMatrix.C,
(float)svgMatrix.D, (float)svgMatrix.E, (float)svgMatrix.F);
//Matrix transformMatrix = new Matrix(svgMatrix.A, svgMatrix.B, svgMatrix.C,
// svgMatrix.D, svgMatrix.E, svgMatrix.F);
//double translateX = CalcPatternUnit(_patternElement.X.AnimVal as SvgLength,
// SvgLengthDirection.Horizontal, bounds);
//double translateY = CalcPatternUnit(_patternElement.Y.AnimVal as SvgLength,
// SvgLengthDirection.Vertical, bounds);
//transformMatrix.TranslatePrepend(translateX, translateY);
////transformMatrix.Value.TranslatePrepend(translateX, translateY);
//return new MatrixTransform(transformMatrix);
return(transformMatrix);
}
public static Matrix GetTransformMatrix(SvgElement element, TransformGroup transform)
{
ISvgTransformable transElm = element as ISvgTransformable;
if (transElm == null)
{
return(Matrix.Identity);
}
SvgTransformList svgTList = (SvgTransformList)transElm.Transform.AnimVal;
SvgTransform svgTransform = (SvgTransform)svgTList.Consolidate();
SvgMatrix svgMatrix = ((SvgTransformList)transElm.Transform.AnimVal).TotalMatrix;
var matrix = new Matrix(svgMatrix.A, svgMatrix.B, svgMatrix.C,
svgMatrix.D, svgMatrix.E, svgMatrix.F);
if (!matrix.IsIdentity)
{
transform.Children.Add(new MatrixTransform(matrix));
}
return(matrix);
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
//add all elements to each group
if (FInput.IsChanged || FTransformIn.IsChanged || FModeIn.IsChanged)
{
//assign size and clear group list
FOutput.SliceCount = FTransformIn.SliceCount;
FGroups.Clear();
//create groups and add matrix to it
for (int i = 0; i < FTransformIn.SliceCount; i++)
{
var g = new SvgGroup();
g.Transforms = new SvgTransformCollection();
var m = FTransformIn[i];
var mat = new SvgMatrix(new List <float>()
{
m.M11, m.M12, m.M21, m.M22, m.M41, m.M42
});
g.Children.Clear();
for (int j = 0; j < FInput.SliceCount; j++)
{
var elem = FInput[j];
if (elem != null)
{
g.Children.Add(elem);
}
}
var b = FModeIn[i] == SvgNormalizeMode.None ? new RectangleF() : g.Path.GetBounds();
switch (FModeIn[i])
{
case SvgNormalizeMode.Both:
if (b.Height > 0 && b.Width > 0)
{
var sx = 1 / b.Width;
var sy = 1 / b.Height;
var ox = -b.X * sx - 0.5f;
var oy = -b.Y * sy - 0.5f;
g.Transforms.Add(new SvgMatrix(new List <float>()
{
sx, 0, 0, sy, ox, oy
}));
}
break;
case SvgNormalizeMode.Width:
if (b.Width > 0)
{
var sx = 1 / b.Width;
var ox = -b.X * sx - 0.5f;
g.Transforms.Add(new SvgMatrix(new List <float>()
{
sx, 0, 0, 1, ox, 0
}));
}
break;
case SvgNormalizeMode.Height:
if (b.Height > 0)
{
var sy = 1 / b.Height;
var oy = -b.Y * sy - 0.5f;
g.Transforms.Add(new SvgMatrix(new List <float>()
{
1, 0, 0, sy, 0, oy
}));
}
break;
default:
break;
}
g.Transforms.Add(mat);
//add to group list
FGroups.Add(g);
}
//write groups to output
FOutput.AssignFrom(FGroups);
}
}
public SvgClipPathPageElement(PageElement child, SvgClipPathElement clipPath, SvgMatrix clipPathParentTransform, PdfSpotColor spotColorOverride)
{
_spotColorOverride = spotColorOverride;
_child = child ?? throw new ArgumentNullException(nameof(child));
_clipPath = clipPath ?? throw new ArgumentNullException(nameof(clipPath));
_clipPathParentTransform = clipPathParentTransform ?? throw new ArgumentNullException(nameof(clipPathParentTransform));
}
protected void SetTransform(WpfDrawingContext context)
{
_transformMatrix = null;
ISvgTransformable transElm = _svgElement as ISvgTransformable;
if (transElm != null)
{
SvgTransformList transformList = (SvgTransformList)transElm.Transform.AnimVal;
if (transformList.NumberOfItems > 1 && _combineTransforms == false)
{
TransformGroup transformGroup = new TransformGroup();
List <Transform> transforms = new List <Transform>();
for (uint i = 0; i < transformList.NumberOfItems; i++)
{
ISvgTransform transform = transformList.GetItem(i);
double[] values = transform.InputValues;
switch (transform.TransformType)
{
case SvgTransformType.Translate:
if (values.Length == 1)
{
// SetTranslate(values[0], 0);
//transformGroup.Children.Add(new TranslateTransform(values[0], 0));
transforms.Add(new TranslateTransform(values[0], 0));
}
else if (values.Length == 2)
{
// SetTranslate(values[0], values[1]);
//transformGroup.Children.Add(new TranslateTransform(values[0], values[1]));
transforms.Add(new TranslateTransform(values[0], values[1]));
}
break;
case SvgTransformType.Rotate:
if (values.Length == 1)
{
// SetRotate(values[0]);
//transformGroup.Children.Add(new RotateTransform(values[0]));
transforms.Add(new RotateTransform(values[0]));
}
else if (values.Length == 3)
{
// SetRotate(values[0], values[1], values[2]);
//transformGroup.Children.Add(new RotateTransform(values[0], values[1], values[2]));
transforms.Add(new RotateTransform(values[0], values[1], values[2]));
}
break;
case SvgTransformType.Scale:
if (values.Length == 1)
{
//SetScale(values[0], values[0]);
transformGroup.Children.Add(new ScaleTransform(values[0], values[0]));
}
else if (values.Length == 2)
{
//SetScale(values[0], values[1]);
//transformGroup.Children.Add(new ScaleTransform(values[0], values[1]));
transforms.Add(new ScaleTransform(values[0], values[1]));
}
break;
case SvgTransformType.SkewX:
if (values.Length == 1)
{
//SetSkewX(values[0]);
//transformGroup.Children.Add(new SkewTransform(values[0], 0));
transforms.Add(new SkewTransform(values[0], 0));
}
break;
case SvgTransformType.SkewY:
if (values.Length == 1)
{
//SetSkewY(values[0]);
//transformGroup.Children.Add(new SkewTransform(0, values[0]));
transforms.Add(new SkewTransform(0, values[0]));
}
break;
case SvgTransformType.Matrix:
if (values.Length == 6)
{
//SetMatrix(new SvgMatrix(values[0], values[1], values[2], values[3], values[4], values[5]));
//transformGroup.Children.Add(new MatrixTransform(values[0], values[1], values[2], values[3], values[4], values[5]));
transforms.Add(new MatrixTransform(values[0], values[1], values[2], values[3], values[4], values[5]));
}
break;
}
}
transforms.Reverse();
transformGroup.Children = new TransformCollection(transforms);
_transformMatrix = transformGroup;
//_transformMatrix = new MatrixTransform(transformGroup.Value);
return;
}
SvgMatrix svgMatrix = transformList.TotalMatrix;
if (svgMatrix.IsIdentity)
{
return;
}
_transformMatrix = new MatrixTransform(Math.Round(svgMatrix.A, 4), Math.Round(svgMatrix.B, 4),
Math.Round(svgMatrix.C, 4), Math.Round(svgMatrix.D, 4),
Math.Round(svgMatrix.E, 4), Math.Round(svgMatrix.F, 4));
}
}
internal SvgTransform(SvgTransformType type, SvgMatrix matrix, SvgAngle angle)
{
this.Type = type;
this.Matrix = matrix;
this.Angle = angle;
}
public override SvgPathSeg VisitCurvetoQuadraticSmoothAbs(SvgPathSegCurvetoQuadraticSmoothAbs segment)
{
SvgMatrix.Multiply(_matrix, segment.X, segment.Y, out var tx, out var ty);
return(new SvgPathSegCurvetoQuadraticSmoothAbs(tx, ty));
}
public SvgPathSegMatrixTransformer(SvgMatrix matrix)
{
_matrix = matrix ?? throw new ArgumentNullException(nameof(matrix));
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
FDocs.Clear();
foreach (var element in FSVGIn)
{
if (element.Document != null)
{
FDocs.Add(element);
}
}
SpreadMax = FDocs.Count;
SetSliceCount(SpreadMax);
if (FSVGIn.IsChanged || FTransformIn.IsChanged || FSizeIn.IsChanged)
{
FSizes.Clear();
if (FBitmaps.Count > SpreadMax)
{
//dispose unused
for (int i = SpreadMax; i < FBitmaps.Count; i++)
{
FBitmaps[i].Dispose();
}
//remove from list
FBitmaps.RemoveRange(SpreadMax, FBitmaps.Count - SpreadMax);
}
for (int i = 0; i < SpreadMax; i++)
{
var doc = FDocs[i].Document;
//calc size
var size = new Size((int)FSizeIn[0].X, (int)FSizeIn[0].Y);
if (size == Size.Empty && doc != null)
{
var s = doc.GetDimensions();
size = new Size((int)s.Width, (int)s.Height);
}
//store size for texture creation
FSizes.Add(size);
if (doc != null)
{
//get bitmap
Bitmap bm;
if (FBitmaps.Count > i)
{
bm = FBitmaps[i];
if (bm.Size != size)
{
bm.Dispose();
bm = new Bitmap(size.Width, size.Height);
FBitmaps[i] = bm;
Reinitialize();
}
}
else //create a new bm
{
bm = new Bitmap(size.Width, size.Height);
FBitmaps.Add(bm);
Reinitialize();
}
//clear bitmap
var g = Graphics.FromImage(bm);
g.Clear(FDocs[i].BackgroundColor);
g.Dispose();
//save old values
var oldW = doc.Width;
var oldH = doc.Height;
if (doc.Transforms == null)
{
doc.Transforms = new SvgTransformCollection();
}
var m = FTransformIn[i];
if (m.M11 != 0 && m.M22 != 0)
{
var mat = new SvgMatrix(new List <float>()
{
m.M11, m.M12, m.M21, m.M22, m.M41, m.M42
});
doc.Transforms.Add(mat);
doc.Width = new SvgUnit(SvgUnitType.Pixel, size.Width);
doc.Height = new SvgUnit(SvgUnitType.Pixel, size.Height);
//draw into bitmap
doc.Draw(bm);
doc.Width = oldW;
doc.Height = oldH;
doc.Transforms.Remove(mat);
}
Update();
}
}
}
}
public override SvgPathSeg VisitLinetoVerticalAbs(SvgPathSegLinetoVerticalAbs segment)
{
SvgMatrix.Multiply(_matrix, 0, segment.Y, out var _, out var ty);
return(new SvgPathSegLinetoVerticalAbs(ty));
}
public static Matrix3x2 AsMatrix3x2(this SvgMatrix matrix)
{
return(new Matrix3x2(matrix.A, matrix.B, matrix.C, matrix.D, matrix.E, matrix.F));
}
private void PushMatrix(SvgMatrix matrix) => _matrixStack.Push(SvgMatrix.Multiply(_matrixStack.Peek(), matrix));
public RulerView(TLRuler ruler, TimelineView tv)
: base(ruler, tv)
{
Model = ruler;
Parent = tv;
PanZoomMatrix = new SvgMatrix(FView.Elements.ToList());
MainGroup.Transforms = new SvgTransformCollection();
MainGroup.Transforms.Add(new SvgTranslate(0, 0));
var width = new SvgUnit(SvgUnitType.Percentage, 100);
Background.Width = width;
Background.Height = 25;
Background.ID = "bg";
Background.CustomAttributes["class"] = "ruler";
//register event handlers
Background.MouseDown += Background_MouseDown;
Background.MouseUp += Background_MouseUp;
Background.MouseMove += Background_MouseMove;
var caller = Parent.Document.Mapper.Map <ISvgEventCaller>();
PlayButton = SvgDocumentWidget.Load(Path.Combine(TimelineView.ResourcePath, "PlayButton.svg"), caller, 2);
StopButton = SvgDocumentWidget.Load(Path.Combine(TimelineView.ResourcePath, "StopButton.svg"), caller, 1);
StopButton.X = 25;
PlayButton.Click += PlayButton_Click;
StopButton.Click += StopButton_Click;
TimeCodeLabelBackground.Width = CLeftOffset;
TimeCodeLabelBackground.Height = Background.Height;
TimeCodeLabelBackground.CustomAttributes["class"] = "ruler";
TimeCodeLabelBackground.MouseDown += Background_MouseDown;
TimeCodeLabel.FontSize = 20;
TimeCodeLabel.X = 55;
TimeCodeLabel.Y = TimeCodeLabel.FontSize;
TimeCodeLabel.CustomAttributes["class"] = "time";
TimeCodeLabel.ID = Model.GetID() + "_label";
TimeCodeLabel.Text = "00:00:00:000";
TimeCodeLabel.CustomAttributes["class"] = "time";
TimeCodeLabel.MouseDown += Background_MouseDown;
SizeBar.Width = Background.Width;
SizeBar.Height = 10;
SizeBar.ID = "SizeBar";
SizeBar.Y = Background.Height;
SizeBar.MouseDown += Background_MouseDown;
SizeBar.MouseMove += Background_MouseMove;
SizeBar.MouseUp += Background_MouseUp;
MouseTimeLabel.ID = "MouseTimeLabel";
MouseTimeLabel.Y = Height;
MouseTimeLabel.FontSize = 14;
ClipRect.Width = width;
ClipRect.Height = Height;
ClipRect.ID = "ClipRect";
//document roots id is "svg". this is where the trackclips are added to
RulerClipPath.ID = "svg_clip" + IDGenerator.NewID;
RulerClipPath.Children.Add(ClipRect);
var uri = new Uri("url(#" + RulerClipPath.ID + ")", UriKind.Relative);
MainGroup.ClipPath = uri;
NumberGroup.ID = "Ticks";
NumberGroup.Transforms = new SvgTransformCollection();
NumberGroup.Transforms.Add(PanZoomMatrix);
PanZoomGroup.ID = "PanZoom";
PanZoomGroup.Transforms = new SvgTransformCollection();
PanZoomGroup.Transforms.Add(PanZoomMatrix);
for (int i = 0; i < 70; i++)
{
var num = new SvgText(i.ToString());
num.FontSize = 20;
num.Y = num.FontSize;
num.CustomAttributes["class"] = "time hair";
num.Transforms = new SvgTransformCollection();
num.Transforms.Add(new SvgTranslate(i));
num.Transforms.Add(new SvgScale(1 / Timer.PPS, 1));
NumberGroup.Children.Add(num);
}
LoopRegion.ID = "LoopRegion";
LoopRegion.Y = Background.Height / 4;
LoopRegion.Height = Background.Height / 2;
LoopRegion.FillOpacity = 0.7f;
LoopRegion.CustomAttributes["pointer-events"] = "fill";
LoopRegion.CustomAttributes["class"] = "loop";
LoopRegion.MouseDown += Background_MouseDown;
LoopRegion.MouseUp += Parent.Default_MouseUp;
LoopRegion.MouseMove += Parent.Default_MouseMove;
PanZoomGroup.Children.Add(LoopRegion);
LoopStart.ID = "LoopStart";
LoopStart.Width = 1 / Timer.PPS * CHandlerWidth;
LoopStart.Height = Background.Height;
PanZoomGroup.Children.Add(LoopStart);
LoopStart.MouseDown += Background_MouseDown;
LoopStart.MouseUp += Parent.Default_MouseUp;
LoopStart.MouseMove += Parent.Default_MouseMove;
LoopStart.CustomAttributes["pointer-events"] = "fill";
LoopStart.CustomAttributes["class"] = "loopcap";
LoopEnd.ID = "LoopEnd";
LoopEnd.Width = 1 / Timer.PPS * CHandlerWidth;
LoopEnd.Height = Background.Height;
PanZoomGroup.Children.Add(LoopEnd);
LoopEnd.MouseDown += Background_MouseDown;
LoopEnd.MouseUp += Parent.Default_MouseUp;
LoopEnd.MouseMove += Parent.Default_MouseMove;
LoopEnd.CustomAttributes["pointer-events"] = "fill";
LoopEnd.CustomAttributes["class"] = "loopcap";
CreateMenu();
//init scalings
PanZoom(0, 0, 0);
UpdateScene();
}
internal SvgTransform(SvgTransformType type, SvgMatrix matrix)
{
this.Type = type;
this.Matrix = matrix;
}
internal static SvgTransform CreateMatrix(SvgMatrix matrix)
{
return new SvgTransform(SvgTransformType.Matrix, matrix);
}
public void TestRotateFromVectorZeroY()
{
ISvgMatrix m1 = new SvgMatrix(1, 2, 3, 6, 0, 0);
ISvgMatrix m2 = m1.RotateFromVector(1, 0);
}
public void TestNoInverse()
{
ISvgMatrix m1 = new SvgMatrix(1, 2, 3, 6, 0, 0);
ISvgMatrix m2 = m1.Inverse();
}
private PageElement CheckAndApplyClipPath(SvgGraphicsElement element, PageElement result, SvgMatrix matrix)
{
if (result == null)
{
return(null);
}
var clipPathRef = element.PresentationStyleData.ClipPath.Value?.FragmentIdentifier;
var clipPath = _rootSvgElement.GetElementById(clipPathRef) as SvgClipPathElement;
if (clipPath != null)
{
if (clipPath.Children.Count == 0)
{
// clipPath defines the area to be rendered, no children, nothing to render
return(null);
}
return(new SvgClipPathPageElement(result, clipPath, matrix, _spotColorOverride));
}
return(result);
}
private TransformSession(CanvasDrawingSession session, Matrix3x2 oldTransform, SvgMatrix multiply)
{
this.Session = session;
this.OldTransform = oldTransform;
var transform = new Matrix3x2((float)multiply.A, (float)multiply.B, (float)multiply.C, (float)multiply.D, (float)multiply.E, (float)multiply.F);
session.Transform = transform * session.Transform;
}
public static TransformSession CreateTransformSession(CanvasDrawingSession session, SvgMatrix multiply)
{
return(new TransformSession(session, session.Transform, multiply));
}
public override SvgPathSeg VisitArcAbs(SvgPathSegArcAbs segment)
{
SvgMatrix.Multiply(_matrix, segment.X, segment.Y, out var tx, out var ty);
return(new SvgPathSegArcAbs(
segment.RadiusX, segment.RadiusY, segment.Angle, segment.LargeArcFlag, segment.SweepFlag, tx, ty));
}
private void RenderGeometory(CanvasDrawingSession session, CanvasGeometry geometry, SvgMatrix transform, CssStyleDeclaration style)
{
bool change = false;
var geometry2 = geometry;
CanvasSolidColorBrush opacityBrush = null;
try
{
using (var t = TransformSession.CreateTransformSession(session, transform))
{
var clipPath = style.ClipPath;
if (clipPath != null)
{
if (clipPath.Uri[0] != '#')
{
throw new ArgumentException();
}
var clipPathElement = (SvgClipPathElement)this.TargetDocument.GetElementById(clipPath.Uri.Substring(1));
var clipGeometory = this.CreateClipPath(session, clipPathElement);
geometry2 = geometry.CombineWith(
clipGeometory,
new Matrix3x2 {
M11 = 1.0F, M12 = 0.0F, M21 = 0.0F, M22 = 1.0F, M31 = 0.0F, M32 = 0.0F
},
CanvasGeometryCombine.Intersect,
CanvasGeometry.ComputeFlatteningTolerance(session.Dpi, 1.0F, session.Transform));
change = true;
}
var area = geometry2.ComputeBounds();
var opacity = style.Opacity;
if (opacity != null)
{
opacityBrush = this.CreateOpacity(session, opacity.Value);
}
var fill = style.Fill;
if (fill == null || fill != null && fill.PaintType != SvgPaintType.None)
{
var pen = this.CreatePaint(session, area, fill, style.FillOpacity);
if (opacityBrush == null)
{
session.FillGeometry(geometry2, pen);
}
else
{
session.FillGeometry(geometry2, pen, opacityBrush);
}
}
var stroke = style.Stroke;
if (stroke != null && stroke.PaintType != SvgPaintType.None)
{
var pen = this.CreatePaint(session, area, stroke, style.StrokeOpacity);
var strokeWidth = style.StrokeWidth;
session.DrawGeometry(geometry2, pen, strokeWidth.HasValue ? this.LengthConverter.Convert(strokeWidth.Value) : 1.0F);
}
}
}
finally
{
if (change)
{
geometry2.Dispose();
}
if (opacityBrush != null)
{
opacityBrush.Dispose();
}
}
}
public override SvgPathSeg VisitLinetoHorizontalAbs(SvgPathSegLinetoHorizontalAbs segment)
{
SvgMatrix.Multiply(_matrix, segment.X, 0, out var tx, out var _);
return(new SvgPathSegLinetoHorizontalAbs(tx));
}
public static TransformSession CreateTransformSession(CanvasDrawingSession session, SvgMatrix multiply)
{
return new TransformSession(session, session.Transform, multiply);
}
public override SvgPathSeg VisitMovetoAbs(SvgPathSegMovetoAbs segment)
{
SvgMatrix.Multiply(_matrix, segment.X, segment.Y, out var tx, out var ty);
return(new SvgPathSegMovetoAbs(tx, ty));
}
//called when data for any output pin is requested
public override void Evaluate(int SpreadMax)
{
//check transforms
if (FTransformIn.IsChanged)
{
//assign size and clear group list
FOutput.SliceCount = FTransformIn.SliceCount;
FGroups.Clear();
//create groups and add matrix to it
for (int i = 0; i < FTransformIn.SliceCount; i++)
{
var g = new SvgGroup();
g.Transforms = new SvgTransformCollection();
var m = FTransformIn[i];
var mat = new SvgMatrix(new List <float>()
{
m.M11, m.M12, m.M21, m.M22, m.M41, m.M42
});
g.Transforms.Add(mat);
FGroups.Add(g);
}
}
//add all elements to each group
var pinsChanged = FInput.IsChanged || FTransformIn.IsChanged || FEnabledIn.IsChanged;
if (pinsChanged)
{
foreach (var g in FGroups)
{
g.Children.Clear();
if (FEnabledIn[0])
{
for (int i = 0; i < FInput.SliceCount; i++)
{
var pin = FInput[i];
for (int j = 0; j < pin.SliceCount; j++)
{
var elem = pin[j];
if (elem != null)
{
g.Children.AddAndFixID(elem, true, true, LogIDFix);
}
}
}
}
}
//write groups to output
FOutput.AssignFrom(FGroups);
}
//set id and class to elements
if (pinsChanged || FIDIn.IsChanged || FClassIn.IsChanged)
{
base.SetIDs();
}
}
