/
SkiaPathImplementation.cs
186 lines (155 loc) · 6.43 KB
/
SkiaPathImplementation.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
using System;
using PixiEditor.DrawingApi.Core.Bridge.NativeObjectsImpl;
using PixiEditor.DrawingApi.Core.Numerics;
using PixiEditor.DrawingApi.Core.Surface;
using PixiEditor.DrawingApi.Core.Surface.Vector;
using SkiaSharp;
namespace PixiEditor.DrawingApi.Skia.Implementations
{
public class SkiaPathImplementation : SkObjectImplementation<SKPath>, IVectorPathImplementation
{
public PathFillType GetFillType(VectorPath path)
{
return (PathFillType)ManagedInstances[path.ObjectPointer].FillType;
}
public void SetFillType(VectorPath path, PathFillType fillType)
{
ManagedInstances[path.ObjectPointer].FillType = (SKPathFillType)fillType;
}
public PathConvexity GetConvexity(VectorPath path)
{
return (PathConvexity)ManagedInstances[path.ObjectPointer].Convexity;
}
public void SetConvexity(VectorPath path, PathConvexity convexity)
{
ManagedInstances[path.ObjectPointer].Convexity = (SKPathConvexity)convexity;
}
public void Dispose(VectorPath path)
{
if (path.IsDisposed) return;
ManagedInstances[path.ObjectPointer].Dispose();
ManagedInstances.TryRemove(path.ObjectPointer, out _);
}
public bool IsPathOval(VectorPath path)
{
return ManagedInstances[path.ObjectPointer].IsOval;
}
public bool IsRoundRect(VectorPath path)
{
return ManagedInstances[path.ObjectPointer].IsRoundRect;
}
public bool IsLine(VectorPath path)
{
return ManagedInstances[path.ObjectPointer].IsLine;
}
public bool IsRect(VectorPath path)
{
return ManagedInstances[path.ObjectPointer].IsRect;
}
public PathSegmentMask GetSegmentMasks(VectorPath path)
{
return (PathSegmentMask)ManagedInstances[path.ObjectPointer].SegmentMasks;
}
public int GetVerbCount(VectorPath path)
{
return ManagedInstances[path.ObjectPointer].VerbCount;
}
public int GetPointCount(VectorPath path)
{
return ManagedInstances[path.ObjectPointer].PointCount;
}
public IntPtr Create()
{
SKPath path = new SKPath();
ManagedInstances[path.Handle] = path;
return path.Handle;
}
public IntPtr Clone(VectorPath other)
{
SKPath path = new SKPath(ManagedInstances[other.ObjectPointer]);
ManagedInstances[path.Handle] = path;
return path.Handle;
}
public RectD GetTightBounds(VectorPath vectorPath)
{
SKRect rect = ManagedInstances[vectorPath.ObjectPointer].TightBounds;
return new RectD(rect.Left, rect.Top, rect.Width, rect.Height);
}
public void Transform(VectorPath vectorPath, Matrix3X3 matrix)
{
ManagedInstances[vectorPath.ObjectPointer].Transform(matrix.ToSkMatrix());
}
public RectD GetBounds(VectorPath vectorPath)
{
SKRect rect = ManagedInstances[vectorPath.ObjectPointer].Bounds;
return RectD.FromSides(rect.Left, rect.Right, rect.Top, rect.Bottom);
}
public void Reset(VectorPath vectorPath)
{
ManagedInstances[vectorPath.ObjectPointer].Reset();
}
public void AddRect(VectorPath path, RectI rect, PathDirection direction)
{
ManagedInstances[path.ObjectPointer].AddRect(rect.ToSkRect(), (SKPathDirection)direction);
}
public void MoveTo(VectorPath vectorPath, Point point)
{
ManagedInstances[vectorPath.ObjectPointer].MoveTo(point.ToSkPoint());
}
public void LineTo(VectorPath vectorPath, Point point)
{
ManagedInstances[vectorPath.ObjectPointer].LineTo(point.ToSkPoint());
}
public void QuadTo(VectorPath vectorPath, Point mid, Point point)
{
ManagedInstances[vectorPath.ObjectPointer].QuadTo(mid.ToSkPoint(), point.ToSkPoint());
}
public void CubicTo(VectorPath vectorPath, Point mid1, Point mid2, Point point)
{
ManagedInstances[vectorPath.ObjectPointer].CubicTo(mid1.ToSkPoint(), mid2.ToSkPoint(), point.ToSkPoint());
}
public void ArcTo(VectorPath vectorPath, RectI oval, int startAngle, int sweepAngle, bool forceMoveTo)
{
ManagedInstances[vectorPath.ObjectPointer].ArcTo(oval.ToSkRect(), startAngle, sweepAngle, forceMoveTo);
}
public void AddOval(VectorPath vectorPath, RectI borders)
{
ManagedInstances[vectorPath.ObjectPointer].AddOval(borders.ToSkRect());
}
public void AddPath(VectorPath vectorPath, VectorPath other, AddPathMode mode)
{
ManagedInstances[vectorPath.ObjectPointer].AddPath(ManagedInstances[other.ObjectPointer], (SKPathAddMode)mode);
}
/// <summary>
/// Compute the result of a logical operation on two paths.
/// </summary>
/// <param name="vectorPath">Source operand</param>
/// <param name="ellipsePath">The second operand.</param>
/// <param name="pathOp">The logical operator.</param>
/// <returns>Returns the resulting path if the operation was successful, otherwise null.h</returns>
public VectorPath Op(VectorPath vectorPath, VectorPath ellipsePath, VectorPathOp pathOp)
{
SKPath skPath = ManagedInstances[vectorPath.ObjectPointer].Op(ManagedInstances[ellipsePath.ObjectPointer], (SKPathOp)pathOp);
ManagedInstances[skPath.Handle] = skPath;
return new VectorPath(skPath.Handle);
}
public VectorPath Simplify(VectorPath path)
{
SKPath skPath = ManagedInstances[path.ObjectPointer].Simplify();
ManagedInstances[skPath.Handle] = skPath;
return new VectorPath(skPath.Handle);
}
public void Close(VectorPath vectorPath)
{
ManagedInstances[vectorPath.ObjectPointer].Close();
}
public string ToSvgPathData(VectorPath vectorPath)
{
return ManagedInstances[vectorPath.ObjectPointer].ToSvgPathData();
}
public bool Contains(VectorPath vectorPath, float x, float y)
{
return ManagedInstances[vectorPath.ObjectPointer].Contains(x, y);
}
}
}