private void dragX_Changed(DragListener drag)
{
Point currentPoint = Mouse.GetPosition(this.parent);
Vector deltaVector = Point.Subtract(currentPoint, this.startPoint);
var destAngle = (-0.5 * deltaVector.X) + skewX;
if (destAngle == 0 && skewY == 0)
{
this.ExtendedItem.Properties.GetProperty(FrameworkElement.RenderTransformProperty).Reset();
rtTransform = null;
skewTransform = null;
}
else
{
if ((rtTransform == null) || !(rtTransform.Component is SkewTransform))
{
if (!this.ExtendedItem.Properties.GetProperty(FrameworkElement.RenderTransformOriginProperty).IsSet)
{
this.ExtendedItem.Properties.GetProperty(FrameworkElement.RenderTransformOriginProperty).SetValue(new Point(0.5, 0.5));
}
if (this.skewTransform == null)
{
this.skewTransform = new SkewTransform(0, 0);
}
this.ExtendedItem.Properties.GetProperty(FrameworkElement.RenderTransformProperty).SetValue(skewTransform);
rtTransform = this.ExtendedItem.Properties[FrameworkElement.RenderTransformProperty].Value;
}
rtTransform.Properties["AngleX"].SetValue(destAngle);
}
_adornerLayer.UpdateAdornersForElement(this.ExtendedItem.View, true);
}
private void ArrangeChild()
{
int count = 0;
if (double.IsNaN(this.Width))
{
this.Width = 200;
}
if (double.IsNaN(this.Height))
{
this.Height = 200;
}
int l = Children.Count * CentralAngle;
int startAngle = -10;
foreach (FrameworkElement element in this.Children)
{
element.RenderTransformOrigin = new Point(1, 1);
TransformGroup tg = new TransformGroup();
RotateTransform r = new RotateTransform();
r.Angle = startAngle + CentralAngle * count++;
SkewTransform s = new SkewTransform();
s.AngleX = 90 - CentralAngle;
tg.Children.Add(s);
tg.Children.Add(r);
element.RenderTransform = tg;
if (!(double.IsNaN(this.Width)) && !(double.IsNaN(this.Height)) && !(double.IsNaN(element.DesiredSize.Width)) && !(double.IsNaN(element.DesiredSize.Height)))
{
element.Arrange(new Rect(Width / 2 - element.DesiredSize.Width, Height / 2 - element.DesiredSize.Height, element.DesiredSize.Width, element.DesiredSize.Height));
}
}
}
private void InitializeTransformGroup()
{
Transform[] transformArray = new Transform[4];
ScaleTransform scaleTransform = new ScaleTransform(this.decomposition.ScaleX, this.decomposition.ScaleY);
transformArray[0] = (Transform)scaleTransform;
SkewTransform skewTransform = new SkewTransform(this.decomposition.SkewX, this.decomposition.SkewY);
transformArray[1] = (Transform)skewTransform;
RotateTransform rotateTransform = new RotateTransform(this.decomposition.RotationAngle);
transformArray[2] = (Transform)rotateTransform;
if (this.decomposition.Center.X != 0.0 || this.decomposition.Center.Y != 0.0)
{
Point center = this.decomposition.Center;
scaleTransform.CenterX = center.X;
scaleTransform.CenterY = center.Y;
skewTransform.CenterX = center.X;
skewTransform.CenterY = center.Y;
rotateTransform.CenterX = center.X;
rotateTransform.CenterY = center.Y;
}
transformArray[3] = (Transform) new TranslateTransform(this.decomposition.TranslationX, this.decomposition.TranslationY);
this.transformGroup = new TransformGroup();
this.transformGroup.Children = new TransformCollection((IEnumerable <Transform>)transformArray);
}
public void CreateLines()
{
double opacityVal = 0.0;
for (double i = 0; i < 360; i += 0.5)
{
Line sweepLine = new Line();
sweepLine.X1 = 197.0;
sweepLine.Y1 = 186.0;
sweepLine.X2 = 120.0;
sweepLine.Y2 = 120.0;
sweepLine.Stroke = new SolidColorBrush(Colors.Black);
sweepLine.StrokeThickness = 1.0;
sweepLine.RenderTransformOrigin = new Point(0.5, 0.5);
sweepLine.Opacity = opacityVal;
opacityVal += 0.00138;
TransformGroup xformGroup = new TransformGroup();
RotateTransform rotateXform = new RotateTransform(i);
ScaleTransform scaleXform = new ScaleTransform();
SkewTransform skewXform = new SkewTransform();
TranslateTransform translateXform = new TranslateTransform();
xformGroup.Children.Add(scaleXform);
xformGroup.Children.Add(skewXform);
xformGroup.Children.Add(rotateXform);
xformGroup.Children.Add(translateXform);
sweepLine.RenderTransform = xformGroup;
appGrid.Children.Add(sweepLine);
}
}
public CompositeTransform()
{
var scaleTransform = new ScaleTransform();
var rotateTransform = new RotateTransform();
var translateTransform = new TranslateTransform();
var skewTransform = new SkewTransform();
scaleTransform.BindProperties(ScaleTransform.CenterXProperty, this, CenterXProperty);
scaleTransform.BindProperties(ScaleTransform.CenterYProperty, this, CenterYProperty);
scaleTransform.BindProperties(ScaleTransform.ScaleXProperty, this, ScaleXProperty);
scaleTransform.BindProperties(ScaleTransform.ScaleYProperty, this, ScaleYProperty);
rotateTransform.BindProperties(RotateTransform.CenterXProperty, this, CenterXProperty);
rotateTransform.BindProperties(RotateTransform.CenterYProperty, this, CenterYProperty);
rotateTransform.BindProperties(RotateTransform.AngleProperty, this, RotationProperty);
translateTransform.BindProperties(TranslateTransform.XProperty, this, TranslateXProperty);
translateTransform.BindProperties(TranslateTransform.YProperty, this, TranslateYProperty);
skewTransform.BindProperties(SkewTransform.CenterXProperty, this, CenterXProperty);
skewTransform.BindProperties(SkewTransform.CenterYProperty, this, CenterYProperty);
skewTransform.BindProperties(SkewTransform.AngleXProperty, this, SkewXProperty);
skewTransform.BindProperties(SkewTransform.AngleYProperty, this, SkewYProperty);
_transform = new TransformGroup
{
Children =
{
scaleTransform,
skewTransform,
rotateTransform,
translateTransform
}
};
}
/// <summary>
/// Gets the matrix that represents this transform.
/// Implements WPF's SkewTransform.Value.
/// </summary>
/// <param name="transform">Extended SkewTranform.</param>
/// <returns>Matrix representing transform.</returns>
public static Matrix GetMatrix(this SkewTransform transform)
{
Matrix matrix = Matrix.Identity;
var angleX = transform.AngleX;
var angleY = transform.AngleY;
var centerX = transform.CenterX;
var centerY = transform.CenterY;
bool hasCenter = centerX != 0 || centerY != 0;
if (hasCenter)
{
// If we have a center, translate matrix before/after skewing.
matrix = matrix.Translate(-centerX, -centerY);
matrix = matrix.Skew(angleX, angleY);
matrix = matrix.Translate(centerX, centerY);
}
else
{
matrix = matrix.Skew(angleX, angleY);
}
return(matrix);
}
/// <summary>
/// 根据数值,返回TransformGroup对象
/// </summary>
public static TransformGroup GetTransformGroupForXYOffset(double X, double Y, double scaleX, double scaleY)
{
ScaleTransform scaleTrans = new ScaleTransform()
{
ScaleX = scaleX, ScaleY = scaleY
};
RotateTransform rotateTrans = new RotateTransform()
{
Angle = 0.00D
};
TranslateTransform translateTrans = new TranslateTransform()
{
X = X, Y = Y
};
SkewTransform skewTrans = new SkewTransform();
TransformGroup transGroup = new TransformGroup();
transGroup.Children.Add(scaleTrans);
transGroup.Children.Add(skewTrans);
transGroup.Children.Add(rotateTrans);
transGroup.Children.Add(translateTrans);
return(transGroup);
}
/// <summary>
/// Walks the Transform(Group) and returns the corresponding Matrix.
/// </summary>
/// <param name="transform">Transform(Group) to walk.</param>
/// <returns>Computed Matrix.</returns>
private Matrix GetTransformMatrix(Transform transform)
{
if (null != transform)
{
// Process the TransformGroup
TransformGroup transformGroup = transform as TransformGroup;
if (null != transformGroup)
{
Matrix groupMatrix = Matrix.Identity;
foreach (Transform child in transformGroup.Children)
{
groupMatrix = MatrixMultiply(groupMatrix, GetTransformMatrix(child));
}
return(groupMatrix);
}
// Process the RotateTransform
RotateTransform rotateTransform = transform as RotateTransform;
if (null != rotateTransform)
{
double angle = rotateTransform.Angle;
double angleRadians = (2 * Math.PI * angle) / 360;
double sine = Math.Sin(angleRadians);
double cosine = Math.Cos(angleRadians);
return(new Matrix(cosine, sine, -sine, cosine, 0, 0));
}
// Process the ScaleTransform
ScaleTransform scaleTransform = transform as ScaleTransform;
if (null != scaleTransform)
{
double scaleX = scaleTransform.ScaleX;
double scaleY = scaleTransform.ScaleY;
return(new Matrix(scaleX, 0, 0, scaleY, 0, 0));
}
// Process the SkewTransform
SkewTransform skewTransform = transform as SkewTransform;
if (null != skewTransform)
{
double angleX = skewTransform.AngleX;
double angleY = skewTransform.AngleY;
double angleXRadians = (2 * Math.PI * angleX) / 360;
double angleYRadians = (2 * Math.PI * angleY) / 360;
return(new Matrix(1, angleYRadians, angleXRadians, 1, 0, 0));
}
// Process the MatrixTransform
MatrixTransform matrixTransform = transform as MatrixTransform;
if (null != matrixTransform)
{
return(matrixTransform.Matrix);
}
// TranslateTransform has no effect in LayoutTransform
}
// Fall back to no-op transformation
return(Matrix.Identity);
}
public Manager(TabControl tabs, StackPanel Background, StackPanel Edit)
{
// TODO: Complete member initialization
this.tabs = tabs;
this.Background = Background;
this.Edit = Edit;
trSkw = new SkewTransform(0, 0);
trRot = new RotateTransform(0);
trTns = new TranslateTransform(0, 0);
trScl = new ScaleTransform(1, 1);
trSkw2 = new SkewTransform(0, 0);
trRot2 = new RotateTransform(0);
trTns2 = new TranslateTransform(0, 0);
trScl2 = new ScaleTransform(1, 1);
trGrp2 = new TransformGroup();
trGrp2.Children.Add(trSkw2);
trGrp2.Children.Add(trRot2);
trGrp2.Children.Add(trTns2);
trGrp2.Children.Add(trScl2);
trGrp = new TransformGroup();
trGrp.Children.Add(trSkw);
trGrp.Children.Add(trRot);
trGrp.Children.Add(trTns);
trGrp.Children.Add(trScl);
}
public WindowBase()
{
this.WindowStyle = WindowStyle.None;
this.AllowsTransparency = true;
this.WindowStartupLocation = WindowStartupLocation.CenterScreen;
// Todo ：初始化动画变量
TransformGroup group = new TransformGroup();
ScaleTransform scale = new ScaleTransform();
SkewTransform skew = new SkewTransform();
RotateTransform rotate = new RotateTransform();
TranslateTransform translate = new TranslateTransform();
group.Children.Add(scale);
group.Children.Add(skew);
group.Children.Add(rotate);
group.Children.Add(translate);
this.RenderTransform = group;
// Todo ：初始化淡出初始效果
this.OpacityMask = this.FindResource("WindowOpMack") as Brush;
//this.Style = this.FindResource("DefaultWindowStyle") as Style;
//this.Icon = Images.CreateImageSourceFromImage(Properties.Resources.logo);
//12=6+6//Margin=6,Border.Effect.BlueRadius=6
this.MaxHeight = SystemParameters.WorkArea.Height + 12 + 2;
//bind command
this.CloseWindowCommand = new RoutedUICommand();
this.MaximizeWindowCommand = new RoutedUICommand();
this.MinimizeWindowCommand = new RoutedUICommand();
this.BindCommand(CloseWindowCommand, this.CloseCommand_Execute);
this.BindCommand(MaximizeWindowCommand, this.MaxCommand_Execute);
this.BindCommand(MinimizeWindowCommand, this.MinCommand_Execute);
}
//Skew Animation
private void skew(Node Snow)
{
DoubleAnimation skewA = new DoubleAnimation(0, 180, new TimeSpan(0, 0, 0, 0, 3000));
DoubleAnimation skewB = new DoubleAnimation(0, 180, new TimeSpan(0, 0, 0, 0, 3000));
skewA.AutoReverse = true;
skewA.RepeatBehavior = RepeatBehavior.Forever;
TransformGroup tg = new TransformGroup();
SkewTransform xst = new SkewTransform();
xst.CenterX = 25;
xst.CenterY = 25;
SkewTransform yst = new SkewTransform();
yst.CenterX = 25;
yst.CenterY = 25;
tg.Children.Add(xst);
tg.Children.Add(yst);
Snow.AllowResize = false;
Snow.RenderTransform = tg;
xst.BeginAnimation(SkewTransform.AngleXProperty, skewA);
yst.BeginAnimation(SkewTransform.AngleYProperty, skewB);
}
public void Inverses_sl2()
{
GeneralTransform inverse;
RotateTransform rotate = new RotateTransform {
Angle = 10.0
};
inverse = rotate.Inverse;
Assert.IsNull(inverse, "#0");
ScaleTransform scale = new ScaleTransform {
ScaleX = 2.0, ScaleY = 2.0
};
inverse = scale.Inverse;
Assert.IsNull(inverse, "#1");
SkewTransform skew = new SkewTransform {
AngleX = 1.0, AngleY = 1.0
};
inverse = skew.Inverse;
Assert.IsNull(inverse, "#2");
TranslateTransform translate = new TranslateTransform {
X = 5.0, Y = 5.0
};
inverse = translate.Inverse;
Assert.IsNull(inverse, "#3");
}
public void OnPositionUpdated_SkewTransform_TransformIsCloned()
{
SkewTransform skewTransform = CreateSkewTransform(1, 0);
Transform draggedTransform = VerifyTransformIsClonedOnDrag(skewTransform);
Assert.AreNotSame(draggedTransform, skewTransform, "Skew transform should not be identical after a drag.");
}
private void ApplyCSSChanges(SkewTransform skewTransform, double angleX, double angleY)
{
CSSEquivalent angleXcssEquivalent = AngleXProperty.GetTypeMetaData(typeof(SkewTransform)).GetCSSEquivalent(skewTransform);
if (angleXcssEquivalent != null)
{
object domElementX = angleXcssEquivalent.DomElement;
if (angleX != _appliedCssAngleX || (_domElementToWhichTheCssAngleXWasApplied != null && domElementX != _domElementToWhichTheCssAngleXWasApplied)) // Optimization to avoid setting the transform if the value is (0,0) or if it is the same as the last time.
{
INTERNAL_HtmlDomManager.SetDomElementStylePropertyUsingVelocity(angleXcssEquivalent.DomElement, angleXcssEquivalent.Name, angleXcssEquivalent.Value(skewTransform, angleX));
_appliedCssAngleX = angleX;
_domElementToWhichTheCssAngleXWasApplied = domElementX;
}
}
CSSEquivalent angleYcssEquivalent = AngleYProperty.GetTypeMetaData(typeof(SkewTransform)).GetCSSEquivalent(skewTransform);
if (angleYcssEquivalent != null)
{
object domElementY = angleYcssEquivalent.DomElement;
if (angleY != _appliedCssAngleY || (_domElementToWhichTheCssAngleYWasApplied != null && domElementY != _domElementToWhichTheCssAngleYWasApplied)) // Optimization to avoid setting the transform if the value is (0,0) or if it is the same as the last time.
{
INTERNAL_HtmlDomManager.SetDomElementStylePropertyUsingVelocity(angleYcssEquivalent.DomElement, angleYcssEquivalent.Name, angleYcssEquivalent.Value(skewTransform, angleY));
_appliedCssAngleY = angleY;
_domElementToWhichTheCssAngleYWasApplied = domElementY;
}
}
}
private void Prepare(FrameworkElement element)
{
// https://docs.microsoft.com/en-us/dotnet/framework/wpf/graphics-multimedia/how-to-set-a-property-after-animating-it-with-a-storyboard
element.BeginAnimation(UIElement.OpacityProperty, null);
element.BeginAnimation(UIElement.RenderTransformProperty, null);
element.Opacity = 1.0;
scaleTransform = new ScaleTransform();
skewTransform = new SkewTransform();
rotateTransform = new RotateTransform();
translateTransform = new TranslateTransform();
var transformGroup = new TransformGroup
{
Children =
{
scaleTransform,
skewTransform,
rotateTransform,
translateTransform
}
};
element.RenderTransform = transformGroup;
if (RenderTransformOrigin.HasValue)
{
element.RenderTransformOrigin = RenderTransformOrigin.Value;
}
}
public override void OnApplyTemplate()
{
_matrixTransform = GetTemplateChild(MatrixTransformPartName) as MatrixTransform;
_rotateTransform = GetTemplateChild(RotateTransformPartName) as RotateTransform;
_scaleTransform = GetTemplateChild(ScaleTransformPartName) as ScaleTransform;
_skewTransform = GetTemplateChild(SkewTransformPartName) as SkewTransform;
_translateTransform = GetTemplateChild(TranslateTransformPartName) as TranslateTransform;
UnregisterNames(MatrixTransformPartName, RotateTransformPartName, ScaleTransformPartName, SkewTransformPartName, TranslateTransformPartName);
if (_matrixTransform != null)
{
RegisterName(MatrixTransformPartName, _matrixTransform);
}
if (_rotateTransform != null)
{
RegisterName(RotateTransformPartName, _rotateTransform);
}
if (_scaleTransform != null)
{
RegisterName(ScaleTransformPartName, _scaleTransform);
}
if (_skewTransform != null)
{
RegisterName(SkewTransformPartName, _skewTransform);
}
if (_translateTransform != null)
{
RegisterName(TranslateTransformPartName, _translateTransform);
}
base.OnApplyTemplate();
RunOpeningEffects();
}
private bool ReadCanonicalForm(Transform transform, bool useIfChangeable)
{
bool flag = false;
if (CanonicalTransform.IsCanonical(transform))
{
TransformGroup transformGroup = (TransformGroup)transform;
ScaleTransform scaleTransform = transformGroup.Children[0] as ScaleTransform;
SkewTransform skewTransform = transformGroup.Children[1] as SkewTransform;
RotateTransform rotateTransform = transformGroup.Children[2] as RotateTransform;
TranslateTransform translateTransform = transformGroup.Children[3] as TranslateTransform;
this.decomposition.Center = new Point(scaleTransform.CenterX, scaleTransform.CenterY);
this.decomposition.Scale = new Vector(scaleTransform.ScaleX, scaleTransform.ScaleY);
this.decomposition.Skew = new Vector(skewTransform.AngleX, skewTransform.AngleY);
this.decomposition.RotationAngle = rotateTransform.Angle;
this.decomposition.Translation = new Vector(translateTransform.X, translateTransform.Y);
if (useIfChangeable && !transformGroup.IsFrozen)
{
this.transformGroup = transformGroup;
}
else
{
this.InitializeTransformGroup();
}
flag = true;
}
return(flag);
}
private static void RTSkewYAnimation(FrameworkElement Item, DoubleAnimation Ani, Action OnCompleted, SetExtentAnimationTimelineDelegate SetExtentValue)
{
SkewTransform Transform = CuxAnimation1.GetRTInstance <SkewTransform>(Item);
if (Transform != null)
{
if (SetExtentValue != null)
{
SetExtentValue(Ani);
}
Ani.Completed += new EventHandler(
delegate(object sender, EventArgs e)
{
if (!Ani.AutoReverse)
{
Transform.AngleY = Ani.To.Value;
if (OnCompleted != null && Transform.AngleY == Ani.To.Value)
{
OnCompleted();
}
}
else
{
if (OnCompleted != null)
{
OnCompleted();
}
}
});
Transform.BeginAnimation(SkewTransform.AngleYProperty, Ani);
}
}
/// <summary>
/// Draw the Kinect Objects onto a Body within a canvas
/// </summary>
/// <param name="canvas">The Canvas to paint images on</param>
/// <param name="sensor">The Kinect sensor</param>
/// <param name="body">The body to locate the images on</param>
/// <param name="kinectObjects">The Kinect Object</param>
public static void DrawKinectObjects(this Canvas canvas, KinectSensor sensor, Body body, List <KinectObject> kinectObjects)
{
if (kinectObjects == null)
{
return;
}
foreach (KinectObject kinectObject in kinectObjects)
{
Joint firstJoint = body.Joints[(JointType)kinectObject.FirstJoint],
secondJoint = body.Joints[(JointType)kinectObject.SecondJoint];
if (firstJoint.TrackingState == TrackingState.Tracked && secondJoint.TrackingState == TrackingState.Tracked)
{
CameraSpacePoint firstJointPos = firstJoint.Position,
secondJointPos = secondJoint.Position;
Point firstPoint = new Point(),
secondPoint = new Point();
ColorSpacePoint firstColorPoint = sensor.CoordinateMapper.MapCameraPointToColorSpace(firstJointPos),
secondColorPoint = sensor.CoordinateMapper.MapCameraPointToColorSpace(secondJointPos);
firstPoint.X = float.IsInfinity(firstColorPoint.X) ? 0 : firstColorPoint.X;
firstPoint.Y = float.IsInfinity(firstColorPoint.Y) ? 0 : firstColorPoint.Y;
secondPoint.X = float.IsInfinity(secondColorPoint.X) ? 0 : secondColorPoint.X;
secondPoint.Y = float.IsInfinity(secondColorPoint.Y) ? 0 : secondColorPoint.Y;
firstJoint = firstJoint.ScaleTo(canvas.ActualWidth, canvas.ActualHeight);
secondJoint = secondJoint.ScaleTo(canvas.ActualWidth, canvas.ActualHeight);
Image bmp = new Image()
{
Width = KinectUtils.DistanceBetween(firstJoint, secondJoint) * 1.5,
Height = KinectUtils.DistanceBetween(firstJoint, secondJoint) * 1.5
};
Canvas.SetTop(bmp, (firstPoint.Y + (secondPoint.Y - firstPoint.Y) / 2 - kinectObject.OffsetY) - bmp.Height / 2);
Canvas.SetLeft(bmp, (firstPoint.X + (secondPoint.X - firstPoint.X) / 2 + kinectObject.OffsetX) - bmp.Width / 2);
bmp.RenderTransformOrigin = new Point(0.5f, 0.5f);
var rotateT = new RotateTransform(KinectUtils.AngleBetween(firstJoint, secondJoint) + 90);
var skewT = new SkewTransform(KinectUtils.YAngleBetween(firstJoint, secondJoint), KinectUtils.YAngleBetween(firstJoint, secondJoint));
var transformGroup = new TransformGroup();
transformGroup.Children.Add(rotateT);
transformGroup.Children.Add(skewT);
bmp.RenderTransform = transformGroup;
//Load the image
bmp.Source = kinectObject.Image;
canvas.Children.Add(bmp);
}
}
}
private void ApplyCSSChanges(SkewTransform skewTransform, double angleX, double angleY)
{
CSSEquivalent angleXcssEquivalent = AngleXProperty.GetTypeMetaData(typeof(SkewTransform)).GetCSSEquivalent(skewTransform);
INTERNAL_HtmlDomManager.SetDomElementStylePropertyUsingVelocity(angleXcssEquivalent.DomElement, angleXcssEquivalent.Name, angleXcssEquivalent.Value(skewTransform, angleX));
CSSEquivalent angleYcssEquivalent = AngleYProperty.GetTypeMetaData(typeof(SkewTransform)).GetCSSEquivalent(skewTransform);
INTERNAL_HtmlDomManager.SetDomElementStylePropertyUsingVelocity(angleYcssEquivalent.DomElement, angleYcssEquivalent.Name, angleYcssEquivalent.Value(skewTransform, angleY));
}
//倾斜
public void SetDigitSkewTransform(double anglex)
{
SkewTransform stf = new SkewTransform(anglex, 0);
for (int i = 0; i < 10; i++)
{
Path0_9[i].RenderTransform = stf;
}
}
private void InitializeTransformGroup()
{
Transform[] transformArray = new Transform[CanonicalTransformOrder.TransformCount];
ScaleTransform scaleTransform = new ScaleTransform();
if (this.decomposition.ScaleX != 1.0)
{
scaleTransform.ScaleX = this.decomposition.ScaleX;
}
if (this.decomposition.ScaleY != 1.0)
{
scaleTransform.ScaleY = this.decomposition.ScaleY;
}
transformArray[CanonicalTransformOrder.ScaleIndex] = (Transform)scaleTransform;
SkewTransform skewTransform = new SkewTransform();
if (this.decomposition.SkewX != 0.0)
{
skewTransform.AngleX = this.decomposition.SkewX;
}
if (this.decomposition.SkewY != 0.0)
{
skewTransform.AngleY = this.decomposition.SkewY;
}
transformArray[CanonicalTransformOrder.SkewIndex] = (Transform)skewTransform;
RotateTransform rotateTransform = new RotateTransform();
if (this.decomposition.RotationAngle != 0.0)
{
rotateTransform.Angle = this.decomposition.RotationAngle;
}
transformArray[CanonicalTransformOrder.RotateIndex] = (Transform)rotateTransform;
if (this.decomposition.Center.X != 0.0 || this.decomposition.Center.Y != 0.0)
{
Point center = this.decomposition.Center;
scaleTransform.CenterX = center.X;
scaleTransform.CenterY = center.Y;
skewTransform.CenterX = center.X;
skewTransform.CenterY = center.Y;
rotateTransform.CenterX = center.X;
rotateTransform.CenterY = center.Y;
}
TranslateTransform translateTransform = new TranslateTransform();
if (this.decomposition.TranslationX != 0.0)
{
translateTransform.X = this.decomposition.TranslationX;
}
if (this.decomposition.TranslationY != 0.0)
{
translateTransform.Y = this.decomposition.TranslationY;
}
transformArray[CanonicalTransformOrder.TranslateIndex] = (Transform)translateTransform;
this.transformGroup = new TransformGroup();
this.transformGroup.Children = new TransformCollection((IEnumerable <Transform>)transformArray);
}
public SpawnerPortal()
{
InitializeComponent();
Scale = new ScaleTransform();
Scale.ScaleX = scaleStart;
Scale.ScaleY = scaleStart;
Skew = new SkewTransform();
StartRoutine(ShowSpawner, () => TimeSpan.FromSeconds(rnd.Next(30, 50)));
StartRoutine(SpawnerUpdate, () => TimeSpan.FromMilliseconds(16.666));
currentAnimation = IncreaseScaleAnimation;
}
public void Inverse_When_Not_Invertible()
{
// Angle of 45° so that we end up with the a singular matrix
// ( because tan(45°) = tan(Math.PI / 4) = 1 )
var transform = new SkewTransform {
AngleX = 45, AngleY = 45
};
var invertedTransform = transform.Inverse;
invertedTransform.Should().BeNull();
}
protected Transform GetTopTransformation()
{
double angle = Math.Atan((CellWidth / CellHeight) * SIZE_FACTOR_3_D) * 180 / Math.PI;
var skt = new SkewTransform(-angle, 0);
var sct = new ScaleTransform(1, SIZE_FACTOR_3_D, 0, 0);
var tg = new TransformGroup();
tg.Children.Add(skt);
tg.Children.Add(sct);
return(tg);
}
public void TryTransform()
{
var point = new Point(2, 3);
var transform = new SkewTransform {
AngleX = 20, AngleY = -20
};
var result = transform.TryTransform(point, out var outPoint);
result.Should().BeTrue();
outPoint.X.Should().BeInRange(3.091910, 3.091911);
outPoint.Y.Should().BeInRange(2.272059, 2.272060);
}
public void UpdateImage(string url)
{
var stackPanel = new StackPanel()
{
Orientation = Orientation.Horizontal
};
var transformGroup = new TransformGroup();
var skewTransform = new SkewTransform(0, 0, 0, 0);
var rotateTransform = new RotateTransform(0);
var scale = new ScaleTransform(-1, 1);
var origin = new Point(0.4, 0.3);
transformGroup.Children.Add(rotateTransform);
transformGroup.Children.Add(skewTransform);
transformGroup.Children.Add(scale);
var packIconMaterial = new PackIconMaterial()
{
Kind = PackIconMaterialKind.ThumbDownOutline,
Width = 36,
Height = 36,
RenderTransformOrigin = origin,
RenderTransform = transformGroup,
};
stackPanel.Children.Add(packIconMaterial);
var textBlock = new TextBlock()
{
Text = "Dislike",
VerticalAlignment = VerticalAlignment.Top,
FontSize = 24,
};
stackPanel.Children.Add(textBlock);
this.DislikeButton.Content = stackPanel;
var packIcon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.HeartOutline,
Height = 23,
Width = 23
};
HeartIcon.IconResource = packIcon;
BitmapImage bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.UriSource = new Uri(url, UriKind.Absolute);
bitmap.EndInit();
image.Source = bitmap;
}
public void TransformBounds()
{
var rect = new Rect(-5, 5, 100, 100);
var transform = new SkewTransform {
AngleX = 400, AngleY = 20
};
var result = transform.TransformBounds(rect);
result.X.Should().BeInRange(-0.804502, -0.804501);
result.Y.Should().BeInRange(3.180148, 3.180149);
result.Width.Should().BeInRange(183.909963, 183.909964);
result.Height.Should().BeInRange(136.397023, 136.397024);
}
private void DislikeButton_Click(object sender, RoutedEventArgs e)
{
reacted = !reacted;
string _path = Directory.GetCurrentDirectory() + "\\usersettings.json";
string jsonFromFile = File.ReadAllText(_path);
dynamic jsonObj = JsonConvert.DeserializeObject(jsonFromFile);
jsonObj["jokeCategory"][currentCategory] -= 1;
string output = JsonConvert.SerializeObject(jsonObj, Formatting.Indented);
File.WriteAllText(_path, output);
var stackPanel = new StackPanel()
{
Orientation = Orientation.Horizontal
};
var transformGroup = new TransformGroup();
var skewTransform = new SkewTransform(0, 0, 0, 0);
var rotateTransform = new RotateTransform(0);
var scale = new ScaleTransform(-1, 1);
var origin = new Point(0.4, 0.3);
transformGroup.Children.Add(rotateTransform);
transformGroup.Children.Add(skewTransform);
transformGroup.Children.Add(scale);
var packIconMaterial = new PackIconMaterial()
{
Kind = PackIconMaterialKind.ThumbDown,
Width = 36,
Height = 36,
RenderTransformOrigin = origin,
RenderTransform = transformGroup,
};
stackPanel.Children.Add(packIconMaterial);
var textBlock = new TextBlock()
{
Text = "Dislike",
VerticalAlignment = VerticalAlignment.Top,
FontSize = 24,
};
stackPanel.Children.Add(textBlock);
this.DislikeButton.Content = stackPanel;
//HeartIcon.Background = new SolidColorBrush(Colors.Transparent);
//DislikeIcon.Background = new SolidColorBrush(Colors.Blue);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
/*
* var skewGrass = new DoubleAnimation
* {
* From = -15.0f,
* To = 0.0f,
* Duration = new Duration(TimeSpan.FromMilliseconds(2000)),
* //RepeatBehavior = RepeatBehavior.,
* //EasingFunction = new BackEase(),
* //AutoReverse = true
* };
*/
DoubleAnimation skewGrassX;
DoubleAnimation skewGrassY;
DoubleAnimation rotate;
if ((explorerGrid.Tag == null) || (explorerGrid.Tag == "0"))
{
skewGrassX = new DoubleAnimation(-15.0f, 0.0f, new Duration(TimeSpan.FromMilliseconds(2000)));
skewGrassY = new DoubleAnimation(-10.0f, 0.0f, new Duration(TimeSpan.FromMilliseconds(2000)));
rotate = new DoubleAnimation(17.0f, 0.0f, new Duration(TimeSpan.FromMilliseconds(2000)));
explorerGrid.Tag = "1";
}
else
{
skewGrassX = new DoubleAnimation(-15.0f, new Duration(TimeSpan.FromMilliseconds(2000)));
skewGrassY = new DoubleAnimation(-10.0f, new Duration(TimeSpan.FromMilliseconds(2000)));
rotate = new DoubleAnimation(17.0f, new Duration(TimeSpan.FromMilliseconds(2000)));
explorerGrid.Tag = "0";
}
SkewTransform skewTransformX = new SkewTransform();
SkewTransform skewTransformY = new SkewTransform();
RotateTransform rotateTransform = new RotateTransform();
TransformGroup transformGroup = new TransformGroup();
transformGroup.Children.Add(skewTransformX);
transformGroup.Children.Add(skewTransformY);
transformGroup.Children.Add(rotateTransform);
explorerGrid.LayoutTransform = transformGroup;
skewTransformX.BeginAnimation(SkewTransform.AngleXProperty, skewGrassX);
skewTransformY.BeginAnimation(SkewTransform.AngleYProperty, skewGrassY);
rotateTransform.BeginAnimation(RotateTransform.AngleProperty, rotate);
}
