public RotateTransform(Angle angle)
{
Angle = angle;
Point = new PxPoint(0, 0);
HasCentre = false;
Matrix = PxMatrix.Rotate(angle.ToRadians());
}
public PxMatrix CalcMatrix(PxSize viewPort, PxRectangle imageSize)
{
if (Option == PreserveAspectRatioOption.None)
{
return(PxMatrix.Translation(
viewPort.Width / imageSize.Width,
viewPort.Height / imageSize.Height,
0,
0
));
}
var scale = Option == PreserveAspectRatioOption.Meet
? Math.Min(
viewPort.Height / imageSize.Height,
viewPort.Width / imageSize.Width
)
: Math.Max(
viewPort.Height / imageSize.Height,
viewPort.Width / imageSize.Width
);
var scaledW = imageSize.Width * scale;
var scaledH = imageSize.Height * scale;
var scaleX = scaledW / imageSize.Width;
var scaleY = scaledH / imageSize.Height;
return(PxMatrix.Translation(
scaleX,
scaleY,
imageSize.X + CalcOffset(AlignX, viewPort.Width, scaledW), // / scaleX,
imageSize.Y + CalcOffset(AlignY, viewPort.Height, scaledH) // / scaleY
));
}
public static PxMatrix GetPositionMatrix(this IElement element, IFrameContext context)
{
return(PxMatrix.Translate(
AA.X.GetMeasure(element, context),
AA.Y.GetMeasure(element, context)
));
}
public MultiTransform3(ITransform t0, ITransform t1, ITransform t2)
{
_t0 = t0;
_t1 = t1;
_t2 = t2;
Matrix = _t2.Matrix * (_t1.Matrix * _t0.Matrix);
}
public MultiTransform4(ITransform t0, ITransform t1, ITransform t2, ITransform t3)
{
_t0 = t0;
_t1 = t1;
_t2 = t2;
_t3 = t3;
Matrix = _t3.Matrix * (_t2.Matrix * (_t1.Matrix * _t0.Matrix));
}
public RotateTransform(Angle angle, float x, float y)
{
Angle = angle;
Point = new PxPoint(x, y);
HasCentre = true;
Matrix =
PxMatrix.Translate(-x, -y) *
PxMatrix.Rotate(angle.ToRadians()) *
PxMatrix.Translate(x, y);
}
public MatrixTransform(float m11, float m12, float m21, float m22, float m31, float m32)
{
M11 = m11;
M12 = m12;
M21 = m21;
M22 = m22;
M31 = m31;
M32 = m32;
Matrix = new PxMatrix(m11, m12, m21, m22, m31, m32);
}
public TransformHelperImpl(D2D1.RenderTarget target, PxMatrix matrix, float x, float y)
{
_target = target;
_matrix = target.Transform;
var matrix2 =
PxMatrix.Translate(-x, -y) *
matrix *
PxMatrix.Translate(x, y);
target.Transform = matrix2.ToMatrix3x2() * _matrix;
}
public PxMatrix Resolve(IElement element, IFrameContext context)
{
if (!HasCentre)
{
return(PxMatrix.Rotate(_radians));
}
var x = X.Resolve(element, context);
var y = Y.Resolve(element, context);
return
(PxMatrix.Translate(-x, -y) *
PxMatrix.Rotate(_radians) *
PxMatrix.Translate(x, y));
}
public static Task Render(IElement element, IFrameContext context, RendererDirect2D render)
{
if (TransformHelper.IsHidden(element))
{
return(Task.CompletedTask);
}
using (TransformHelper.Create(render, element, context))
using (LayerHelper.Create(render, element, context))
{
var font = element.GetFont(context);
var fill = element.GetFill(context);
var fillBrush = render.CreateBrush(element, context, fill.Brush, fill.Opacity);
if (fillBrush == null)
{
return(Task.CompletedTask);
}
foreach (var text in element.Children.OfType <ITextContent>())
{
using (var textLayout = render.CreateTextLayout(font, text.Content, 999999))
{
var frameSize = context.Size;
var textSize = new PxSize(textLayout.Metrics.WidthIncludingTrailingWhitespace, textLayout.Metrics.Height);
var scale = CalcScale(frameSize, textSize);
var matrix = PxMatrix.Translation(
scale,
scale,
(frameSize.Width - (scale * textSize.Width)) / 2f,
(frameSize.Height - (scale * textSize.Height)) / 2f
);
using (TransformHelper.Create(render, matrix))
{
render.Target.DrawTextLayout(
new DXM.RawVector2(0, 0),
textLayout,
fillBrush,
D2D1.DrawTextOptions.EnableColorFont
);
}
}
}
return(Task.CompletedTask);
}
}
public MultiTransform(ITransform[] transforms)
{
_t = transforms;
Matrix = transforms.Aggregate(PxMatrix.Identity, (current, m) => m.Matrix * current);
}
public SkewTransform(float x, float y)
{
X = x;
Y = x;
Matrix = PxMatrix.Skew(x, y);
}
public TranslateTransform(float x, float y)
{
X = x;
Y = y;
Matrix = PxMatrix.Translate(x, y);
}
public static DX.Matrix3x2 ToMatrix3x2(this PxMatrix m)
{
return(new DX.Matrix3x2(m.M11, m.M12, m.M21, m.M22, m.M31, m.M32));
}
public PxMatrix Resolve(IElement element, IFrameContext context)
{
return(PxMatrix.Translate(X.Resolve(element, context), Y.Resolve(element, context)));
}
public ShearTransform(float x, float y)
{
X = x;
Y = y;
Matrix = PxMatrix.Skew(x, y);
}
public MultiTransform2(ITransform t0, ITransform t1)
{
_t0 = t0;
_t1 = t1;
Matrix = _t1.Matrix * _t0.Matrix;
}
public static IDisposable Create(RendererDirect2D render, PxMatrix matrix)
{
return(new TransformHelperImpl(render.Target, matrix));
}
public ScaleTransform(float x, float y)
{
X = x;
Y = y;
Matrix = PxMatrix.Scale(x, y);
}
public TransformHelperImpl(D2D1.RenderTarget target, PxMatrix matrix)
{
_target = target;
_matrix = target.Transform;
target.Transform = matrix.ToMatrix3x2() * _matrix;
}
