public void Close()
{
OnClose();
// Prevent any interaction from happening during the animation
IsHitTestVisible = false;
var scale = (ScaleTransform)RenderTransform;
scale.CenterX = ActualWidth / 2; scale.CenterY = ActualHeight / 2;
var fadeOut = new DoubleAnimation(0, FadeOutDuration);
var shrink = new DoubleAnimation(0.8, FadeOutDuration);
fadeOut.Completed += delegate
{
var manager = (ChildWindowManager)Parent;
if (manager == null)
{
return;
}
manager.Hide(this);
};
RenderTransform.BeginAnimation(ScaleTransform.ScaleXProperty, shrink);
RenderTransform.BeginAnimation(ScaleTransform.ScaleYProperty, shrink);
BeginAnimation(OpacityProperty, fadeOut, HandoffBehavior.SnapshotAndReplace);
}
private void Window_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
{
if (((bool)e.NewValue) != true)
{
return;
}
BeginAnimation(OpacityProperty, new DoubleAnimation(0, 1, TimeSpan.FromMilliseconds(200))
{
EasingFunction = new QuadraticEase()
});
RenderTransform.BeginAnimation(ScaleTransform.ScaleXProperty, new DoubleAnimation(.5, 1, TimeSpan.FromMilliseconds(500))
{
EasingFunction = new ElasticEase()
{
Oscillations = 1
}
});
RenderTransform.BeginAnimation(ScaleTransform.ScaleYProperty, new DoubleAnimation(.5, 1, TimeSpan.FromMilliseconds(500))
{
EasingFunction = new ElasticEase()
{
Oscillations = 1
}
});
}
private void PerformLayout(object sender, RoutedEventArgs e)
{
Point currentPosition = RenderTransform.Transform(new Point(0.0, 0.0));
double onScreenState = (currentPosition.Y - m_yPosInactive) / (m_yPosActive - m_yPosInactive);
MainWindow mainWindow = (MainWindow)Application.Current.MainWindow;
double screenHeight = mainWindow.ActualHeight;
double screenWidth = mainWindow.ActualWidth;
double viewHeight = ActualHeight;
double viewWidth = ActualWidth;
m_yPosActive = screenHeight * 0.5 - (viewHeight * 0.5 + ConversionHelpers.AndroidToWindowsDip(16));
m_yPosInactive = screenHeight * 0.5 + viewHeight * 0.5;
double layoutY = m_yPosInactive;
if (!m_isFirstLayout)
{
layoutY = onScreenState * (m_yPosActive - m_yPosInactive) + m_yPosInactive;
}
m_isFirstLayout = false;
var transform = new TranslateTransform(
-(viewWidth * 0.5 + ConversionHelpers.AndroidToWindowsDip(32)),
layoutY);
RenderTransform = transform;
}
private void PerformLayout(object sender, RoutedEventArgs e)
{
Point currentPosition = RenderTransform.Transform(new Point(0.0, 0.0));
MainWindow mainWindow = (MainWindow)Application.Current.MainWindow;
double screenHeight = mainWindow.MainGrid.ActualHeight;
double screenWidth = mainWindow.MainGrid.ActualWidth;
double viewHeight = ActualHeight;
double viewWidth = ActualWidth;
double pointWidth = m_compassPoint.Width;
double pointHeight = m_compassPoint.Height;
m_compassPointOffsetX = (viewWidth) * 0.5;
m_compassPointOffsetY = (viewHeight) * 0.5;
const double margin = 23.0;
m_yPosActive = screenHeight * 0.5 - (viewHeight * 0.5) - (margin);
m_yPosInactive = screenHeight * 0.5 + viewHeight * 0.5;
var transform = new TranslateTransform(currentPosition.X, m_isActive ? m_yPosActive : m_yPosInactive);
RenderTransform = transform;
}
/// <summary>
/// kbd4hire 20090318
/// Move transformation to view coordindates here.
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
private IEnumerable <Point2D> convertPoints(IEnumerable <IPoint> points)
{
foreach (IPoint2D point in points)
{
yield return(RenderTransform.TransformVector(point.X, point.Y));
}
}
void InputMaterialProperty()
{
if (_propBlock == null)
{
_propBlock = new MaterialPropertyBlock();
}
if (_renderer == null)
{
_renderer = GetComponent <SpriteRenderer>();
}
if (_renderTransform == null)
{
_renderTransform = GetComponent <RenderTransform>();
}
if (_renderer.sharedMaterial?.shader.name == DepthShaderName)
{
_renderer.sortingOrder = Mathf.FloorToInt((-_renderTransform.z_weight + 1f) * 100f);
_renderer.GetPropertyBlock(_propBlock);
Vector4 spriteRectData = new Vector4(_renderer.sprite.rect.x, _renderer.sprite.rect.y, _renderer.sprite.rect.width, _renderer.sprite.rect.height);
_propBlock.SetVector("_SpriteRect", spriteRectData);
_renderer.SetPropertyBlock(_propBlock);
}
else
{
_renderer.sortingOrder = 300;
}
}
/// <inheritdoc />
protected override Size ArrangeOverride(Size finalSize)
{
if (_visualCollection != null)
{
var padding = 2.0;
var adornedElementHeight = AdornedFeatures.ActualHeight;
var adornedElementWidth = AdornedFeatures.ActualWidth;
var x = 0.0;
var y = adornedElementHeight + padding; // by default, appear below target attributes to edit
var adornerOrigin = RenderTransform.Transform(new Point(0, 0));
if ((adornerOrigin.X != 0) || (adornerOrigin.Y != 0))
{
// Ensure we position so we're visible, if possible.
var adornerLeftEdge = adornerOrigin.X;
var adornerRightEdge = adornerLeftEdge + _layoutRoot.DesiredSize.Width;
var adornerTopEdge = adornerOrigin.Y + y;
var adornerBottomEdge = adornerTopEdge + _layoutRoot.DesiredSize.Height;
if (adornerRightEdge > _layer.ActualWidth)
{
// Nudge to the left enough to keep visible.
x = _layer.ActualWidth - adornerRightEdge - padding;
}
if (adornerBottomEdge > _layer.ActualHeight)
{
// Place above the adorned element.
y = -_layoutRoot.DesiredSize.Height - padding;
}
}
Rect elementRect = new Rect(x, y, _layoutRoot.DesiredSize.Width, _layoutRoot.DesiredSize.Height);
_layoutRoot.Arrange(elementRect);
}
return(finalSize);
}
void UpdateTransformYAnimation(double animationTranformTimeSpan)
{
var positionAnimation = AnimationFactory.CreateDoubleAnimation(this, TranslateTransform.YProperty, -_currentYoffSet, durationSpan: TimeSpan.FromMilliseconds(animationTranformTimeSpan), easingFuction: EasingFunction);
positionAnimation.Completed += PositionYAnimationCompleted;
RenderTransform.BeginAnimation(TranslateTransform.YProperty, positionAnimation);
}
private void OnRenderTransformOriginChanged(DependencyPropertyChangedEventArgs e)
{
if (RenderTransform.IsNullOrIdentity())
{
return;
}
InvalidateVisualTransform();
}
/// <summary>
/// kbd4hire 20090318
/// Move transformation to view coordindates here.
/// </summary>
/// <param name="coordinates"></param>
/// <returns></returns>
private IEnumerable <Point2D> convertCoordinates(IEnumerable coordinates)
{
foreach (ICoordinate coordinate in coordinates)
{
yield return(RenderTransform.TransformVector(
coordinate[Ordinates.X],
coordinate[Ordinates.Y]));
}
}
protected override void OnVisualBoundsChanged()
{
if (RenderTransform.IsNullOrIdentity())
{
return;
}
InvalidateVisualTransform();
}
public void Component_MouseMove(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
if (ParentCircuit.ParentWindow.SelectedTool == "SELECT")
{
if (DragStarted)
{
Point newPosition = new Point(e.GetPosition(this).X - moveOrigin.X, e.GetPosition(this).Y - moveOrigin.Y);
newPosition = RenderTransform.Transform(newPosition);
newPosition = new Point(newPosition.X + ComponentPosition.X, newPosition.Y + ComponentPosition.Y);
Point snappedPosition = Util.snap(newPosition, Constants.ScaleFactor);
ComponentPosition = snappedPosition;
Canvas.SetLeft(this, ComponentPosition.X);
Canvas.SetTop(this, ComponentPosition.Y);
}
}
}
//The below statements handle the case that the mouse is moved over a component
//while a wire or leaded component is beign placed
if (Breadboard.StartedWire)
{
Point actualCoord = e.GetPosition(ParentCircuit.ParentWindow.DrawArea);
Orientation o = Util.getBestOrientation(Breadboard.WirePointA, actualCoord);
int length = 0;
if (o == Orientation.Horizontal)
{
length = (int)((actualCoord.X - Breadboard.WirePointA.X) / Constants.ScaleFactor);
}
else
{
length = (int)((actualCoord.Y - Breadboard.WirePointA.Y) / Constants.ScaleFactor);
}
Breadboard.NewWire.Length = length;
Breadboard.NewWire.WireOrientation = o;
Breadboard.NewWire.Render();
}
else if (Breadboard.StartedLeadedComponent)
{
Point actualCoord = e.GetPosition(ParentCircuit.ParentWindow.DrawArea);
Orientation o = Util.getBestOrientation(Breadboard.ComponentPointA, actualCoord);
int length = 0;
if (o == Orientation.Horizontal)
{
length = (int)((actualCoord.X - Breadboard.ComponentPointA.X) / Constants.ScaleFactor);
}
else
{
length = (int)((actualCoord.Y - Breadboard.ComponentPointA.Y) / Constants.ScaleFactor);
}
Breadboard.NewLeadedComponent.Length = length;
Breadboard.NewLeadedComponent.orientation = o;
Breadboard.NewLeadedComponent.Render();
}
}
protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
{
var bounds = LayoutInformation.GetLayoutSlot(this);
if (bounds.Contains(RenderTransform.Transform(hitTestParameters.HitPoint)))
{
return(new PointHitTestResult(this, hitTestParameters.HitPoint));
}
return(null);
}
public void AnimateToIntermediateOnScreenState(float onScreenState)
{
Point currentPosition = RenderTransform.Transform(new Point(0.0, 0.0));
double viewY = currentPosition.Y;
double newY = m_yPosInactive + (m_yPosActive - m_yPosInactive) * onScreenState;
if (viewY != newY)
{
RenderTransform = new TranslateTransform(currentPosition.X, newY);
}
}
protected override Matrix GetVisualTransformOverride()
{
if (RenderTransform.IsNullOrIdentity())
{
return(Matrix.Identity);
}
double offsetX = RenderTransformOrigin.X * RenderSize.Width;
double offsetY = RenderTransformOrigin.Y * RenderSize.Height;
return(Matrix.TranslationMatrix(-offsetX, -offsetY) * RenderTransform.Value * Matrix.TranslationMatrix(offsetX, offsetY));
}
public void Hide()
{
var animation = new DoubleAnimation
{
To = -MenuWidth,
Duration = TimeSpan.FromMilliseconds(100)
};
RenderTransform.BeginAnimation(TranslateTransform.XProperty, animation);
_isShown = false;
(FindName("ShadowColumn") as ColumnDefinition).Width = new GridLength(0);
}
public void Show()
{
var animation = new DoubleAnimation
{
To = 0,
Duration = TimeSpan.FromMilliseconds(AnimationTime)
};
RenderTransform.BeginAnimation(TranslateTransform.XProperty, animation);
ShadowColumn.Width = new GridLength(10000);
_isShown = true;
}
public void Show()
{
var animation = new DoubleAnimation
{
From = -MenuWidth * .85, To = 0, Duration = TimeSpan.FromMilliseconds(100)
};
RenderTransform.BeginAnimation(TranslateTransform.XProperty, animation);
_isShown = true;
var p = Parent as Panel;
(FindName("ShadowColumn") as ColumnDefinition).Width = new GridLength(10000);
}
private void Animate(Transform newValue, TransitionSpeed transitionSpeed)
{
var duration = TransitionSpeedToDuration(transitionSpeed);
var matrixAnimation = new MatrixAnimation(newValue.Value, duration, FillBehavior.HoldEnd)
{
EasingFunction = GetEasingFunction(transitionSpeed)
};
Timeline.SetDesiredFrameRate(matrixAnimation, FrameRate);
RenderTransform.BeginAnimation(MatrixTransform.MatrixProperty, matrixAnimation, HandoffBehavior.SnapshotAndReplace);
}
public void UpdateViewPortRect()
{
// calc the view port window
viewPort = new Rect(0, 0, ActualWidth, ActualHeight);
viewPort = RenderTransform.TransformBounds(viewPort);
Point topLeft = RenderTransform.Inverse.Transform(new Point(0, 0));
Point bottomRight = RenderTransform.Inverse.Transform(new Point(ActualWidth, ActualHeight));
Rect r = new Rect(topLeft, bottomRight);
viewPort = r;
}
public void UpdateScreenLocation(float x, float y)
{
Point currentPosition = RenderTransform.Transform(new Point(0.0, 0.0));
MainWindow mainWindow = (MainWindow)Application.Current.MainWindow;
double screenHeight = mainWindow.MainGrid.ActualHeight;
double screenWidth = mainWindow.MainGrid.ActualWidth;
double marginX = 25;
TranslateTransform transform = new TranslateTransform(x - (screenWidth * 0.5f) + (ActualWidth * 0.5f) + marginX,
y - (screenHeight * 0.5f));
RenderTransform = transform;
}
protected override void OnVisualParentChanged(DependencyObject oldParent)
{
// The window is added to the visual tree -> perform a small animation
var scale = (ScaleTransform)RenderTransform;
scale.CenterX = Width / 2; scale.CenterY = Height / 2;
var fadeIn = new DoubleAnimation(0, 1, FadeOutDuration, FillBehavior.Stop);
var expand = new DoubleAnimation(0.8, 1, FadeOutDuration, FillBehavior.Stop);
RenderTransform.BeginAnimation(ScaleTransform.ScaleXProperty, expand);
RenderTransform.BeginAnimation(ScaleTransform.ScaleYProperty, expand);
BeginAnimation(OpacityProperty, fadeIn);
base.OnVisualParentChanged(oldParent);
}
void AnimateIn(object sender, EventArgs args)
{
var animation = new DoubleAnimation {
From = -Height,
To = 0,
Duration = AnimationDuration,
EasingFunction = AnimationEase,
};
animation.Completed += BeginTimer;
RenderTransform.ApplyAnimationClock(TranslateTransform.YProperty,
animation.CreateClock());
}
public void Hide()
{
var animation = new DoubleAnimation
{
To = GetHidePositionX(),
Duration = TimeSpan.FromMilliseconds(AnimationTime)
};
RenderTransform.BeginAnimation(TranslateTransform.XProperty, animation);
ShadowColumn.Width = new GridLength(0);
IsOverlayVisible = false;
_isShown = false;
}
void Sprite_ManipulationDelta(object sender, System.Windows.Input.ManipulationDeltaEventArgs e)
{
GeneralTransform gt = TransformToVisual(e.ManipulationContainer).Inverse;
if (e.PinchManipulation != null)
{
if (isnewmanipul)
{
tx = CT.TranslateX;
ty = CT.TranslateY;
r = CT.Rotation;
isnewmanipul = false;
}
Point originalCenter = RenderTransform.Transform(gt.Transform(e.PinchManipulation.Original.Center));
Point newCenter = RenderTransform.Transform(gt.Transform(e.PinchManipulation.Current.Center));
CT.TranslateX = tx + newCenter.X - originalCenter.X;
CT.TranslateY = ty + newCenter.Y - originalCenter.Y;
CT.Rotation = r + angleBetween2Lines(
gt.Transform(e.PinchManipulation.Current.PrimaryContact),
gt.Transform(e.PinchManipulation.Current.SecondaryContact),
gt.Transform(e.PinchManipulation.Original.PrimaryContact),
gt.Transform(e.PinchManipulation.Original.SecondaryContact)) * (CT.ScaleX * CT.ScaleY > 0 ? 1 : -1);
//CT.ScaleX=CT.ScaleY*= e.PinchManipulation.DeltaScale;
double k = e.PinchManipulation.DeltaScale;
if (firstManipuletion)
{
firstWidth = Width;
firstHeight = Height;
firstManipuletion = false;
}
Width = Math.Min(Width * k, firstWidth * maxZC);
Height = Math.Min(Height * k, firstHeight * maxZC);
}
else
{
Point start = RenderTransform.Transform(gt.Transform(new Point(0, 0)));
Point end = RenderTransform.Transform(gt.Transform(e.DeltaManipulation.Translation));
CT.TranslateX += end.X - start.X;
CT.TranslateY += end.Y - start.Y;
isnewmanipul = true;
}
e.Handled = true;
//SetTransform();
Dispatcher.BeginInvoke(SetTransform);
}
public void AnimateViewToY(double y)
{
var currentPosition = RenderTransform.Transform(new Point(0.0, 0.0));
var animation = new DoubleAnimation();
animation.From = currentPosition.Y;
animation.To = y;
animation.Duration = new Duration(TimeSpan.FromMilliseconds(m_stateChangeAnimationTimeMilliseconds));
animation.EasingFunction = new SineEase();
var transform = new TranslateTransform(currentPosition.X, currentPosition.Y);
RenderTransform = transform;
transform.BeginAnimation(TranslateTransform.YProperty, animation);
}
protected override void OnLayoutCore(bool changed, int left, int top, int right, int bottom)
{
var newSize = new Size(right - left, bottom - top).PhysicalToLogicalPixels();
base.OnLayoutCore(changed, left, top, right, bottom);
if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
{
this.Log().DebugFormat(
"[{0}/{1}] OnLayoutCore({2}, {3}, {4}, {5}) (parent: {5},{6})",
GetType(),
Name,
left, top, right, bottom,
MeasuredWidth,
MeasuredHeight
);
}
var previousSize = _actualSize;
_actualSize = newSize;
RenderSize = _actualSize;
if (
// If the layout has changed, but the final size has not, this is just a translation.
// So unless there was a layout requested, we can skip arranging the children.
(changed && _lastLayoutSize != newSize)
// Even if nothing changed, but a layout was requested, arrang the children.
|| IsLayoutRequested
)
{
_lastLayoutSize = newSize;
OnBeforeArrange();
_layouter.Arrange(new Rect(0, 0, newSize.Width, newSize.Height));
OnLayoutUpdated();
OnAfterArrange();
}
if (previousSize != newSize)
{
SizeChanged?.Invoke(this, new SizeChangedEventArgs(previousSize, newSize));
RenderTransform?.OnViewSizeChanged(previousSize, newSize);
}
}
// Update is called once per frame
void Update()
{
if (Player.CurrentPlayer == null)
{
return;
}
RenderTransform target = Player.CurrentPlayer.RenderTrasform;
float z = transform.position.z;
Vector3 targetPos = target.transform.position;
targetPos.z = z;
transform.position = Vector3.Lerp(transform.position, targetPos, 4f * Time.deltaTime);
}
private void GoPage(int pageIndex)
{
if (pageIndex > PageCount - 1 || pageIndex < 0)
{
return;
}
DoubleAnimation moveAnimation = new DoubleAnimation
{
To = -(pageIndex) * ActualWidth,
DecelerationRatio = 0.3,
AccelerationRatio = 0.3,
Duration = TimeSpan.FromMilliseconds(500)
};
RenderTransform.BeginAnimation(TranslateTransform.XProperty, moveAnimation);
}
private void dispatcherTimer_Tick(object sender, EventArgs e)
{
if (!onBlur)
{
return;
}
try
{
Point zero = new Point(0, 0);
Point relativePoint = TransformToAncestor(Window).Transform(new Point(0, 0));
//l.Content = Math.Round(-RenderTransform.Transform(zero).X * 2 + relativePoint.X).ToString();
blur.Margin = new Thickness((-RenderTransform.Transform(zero).X * 2 + relativePoint.X), -relativePoint.Y, 0, 0);
}
catch (InvalidOperationException)
{
}
}
