/// <summary> /// Event handler for failures in the network during the simulation. /// </summary> /// <remarks> /// The effect is a viewport animation to bring the failed object into view, if it is not visible already. /// </remarks> /// <param name="sender">The object that raised the event.</param> /// <param name="args">Event arguments.</param> private async void OnNetworkFailure(object sender, EventArgs args) { IRectangle rect = null; if (sender is ModelNode) { // For nodes just include the node itself in the viewport var graphNode = modelNodeToINode[sender as ModelNode]; rect = graphNode.Layout; } else if (sender is ModelEdge) { var modelEdge = sender as ModelEdge; var graphEdge = modelEdgeToIEdge[modelEdge]; // For edges we need to get the bounding box of the end points // We don't need to consider bends in this demo as there are none. rect = new RectD(graphEdge.SourcePort.GetLocation(), graphEdge.TargetPort.GetLocation()); } // Don't do anything if the failing element is visible already if (GraphControl.Viewport.Contains(rect)) { return; } // Enlarge the viewport so that we get an overview of the neighborhood as well var rectD = rect.ToRectD().GetEnlarged(new InsetsD(200)); // Animated the transition to the failed element await animator.Animate(new ViewportAnimation(GraphControl, rectD, TimeSpan.FromMilliseconds(1000)).CreateEasedAnimation()); }
void Update(object sender, EventArgs e) { camera.Render(); myScene.MoveScene(controls.GetControls()); myScene.RotateScene(controls.GetRotation()); animator1.Animate((animator) => { if (animator1.opts[0] == false) { animator.position.Add(new Vector3(-0.5f, 0f, 0f)); if (animator.position.x < -5f) { animator1.opts[0] = true; } } else { animator.position.Add(new Vector3(0.5f, 0f, 0f)); if (animator.position.x > 5f) { animator1.opts[0] = false; } } return(animator); }); animator2.Animate((animator) => { animator.rotation.Add(new Vector3(0.5f, 0f, 0f)); return(animator); }); }
public void Remove(Control child, bool animate = false) { var div = child.Node.ParentElement; var cell = div.ParentElement; var row = cell.ParentElement; if (animate) { int height = row.MeasureOffsetHeight(); div.Style.Overflow = "hidden"; Animator.Animate( progress => { var newHeight = (int)(height * (1 - progress)); div.Style.Height = newHeight + "px"; }, AnimationSpeed, () => { div.Style.Overflow = ""; div.Style.Height = ""; div.RemoveChild(child.Node); table.RemoveChild(row); base.RemoveChild(child); }); } else { div.RemoveChild(child.Node); table.RemoveChild(row); base.RemoveChild(child); } }
public override void Use(Player player) { if (CurrentItem != null) { if (PhotoAnimatonRunning) { return; } if (player.Inventory.Count >= player.Inventory.Capacity) { return; } player.Inventory.Pickup(CurrentItem); CurrentItem = null; return; } var texture = TakePhoto(player.Camera); var photo = Instantiate(PhotoPrefab).GetComponent <PhotoItem>(); photo.Image = texture; photo.transform.SetParent(transform, false); photo.transform.position = PhotoPrefab.transform.position; photo.transform.rotation = PhotoPrefab.transform.rotation; PhotoAnimatonRunning = true; StartCoroutine(Animator.Animate( () => Animator.MoveToLocal(photo.transform, Vector3.forward * -.3f, 1f, Easing.Linear), () => Animator.Action(() => PhotoAnimatonRunning = false))); CurrentItem = photo; }
public void Draw(RenderTarget target, RenderStates states) { if (_animatedObject != null) { _animator.Animate(_animatedObject); } target.Draw(_sprite); }
/// <summary> /// Called after the layout has been calculated. /// </summary> /// <remarks> /// Applies the layout in an animation and cleans up. Calls OnDone to raise the Done event after the animation has been completed. /// </remarks> /// <param name="graph">The graph to apply the layout to.</param> /// <param name="moduleContext">The module context.</param> /// <param name="compoundEdit">The undo edit which wraps the layout. It was created in <see cref="StartWithIGraph"/> and will be closed here.</param> protected virtual async Task LayoutDone(IGraph graph, ILookup moduleContext, ICompoundEdit compoundEdit) { if (abortDialog != null) { if (abortDialog.IsVisible) { abortDialog.Close(); } abortDialog = null; } GraphControl view = moduleContext.Lookup <GraphControl>(); if (LayoutMorphingEnabled && view != null) { var morphingAnimation = graph.CreateLayoutAnimation(layoutGraph, TimeSpan.FromSeconds(1)); Rectangle2D box = LayoutGraphUtilities.GetBoundingBox(layoutGraph, layoutGraph.GetNodeCursor(), layoutGraph.GetEdgeCursor()); RectD targetBounds = box.ToRectD(); ViewportAnimation vpAnim = new ViewportAnimation(view, targetBounds, TimeSpan.FromSeconds(1)) { MaximumTargetZoom = 1.0d, TargetViewMargins = view.ContentMargins }; var animations = new List <IAnimation>(); animations.Add(morphingAnimation); animations.Add(CreateTableAnimations()); if (ViewPortMorphingEnabled) { animations.Add(vpAnim); } TableLayoutConfigurator.CleanUp(graph); Animator animator = new Animator(view); await animator.Animate(animations.CreateParallelAnimation().CreateEasedAnimation()); try { compoundEdit.Commit(); view.UpdateContentRect(); } finally { OnDone(new LayoutEventArgs()); } } else { layoutGraph.CommitLayoutToOriginalGraph(); RestoreTableLayout(); compoundEdit.Commit(); if (view != null) { view.UpdateContentRect(); } OnDone(new LayoutEventArgs()); } }
public void FadeIn(TimeSpan duration) { Opacity = 0.01; Rectangle lWorkingArea = CalculateTotalScreenBounds(); Bounds = new Rectangle(lWorkingArea.X - 150, lWorkingArea.Y - 150, 100, 100); Show(); Bounds = new Rectangle(Owner.PointToScreen(Point.Empty), Owner.ClientSize); Animator.Animate(this, "Opacity", 0.01, fFinalOpacity, duration); }
protected override void OnElementChanged(VisualElementChangedEventArgs e) { base.OnElementChanged(e); if (this.NativeView == null) { return; } //Accessing page numbers from the ScrollView abstraction renderer AnimatedScrollView animatedScrollView = (AnimatedScrollView)Element; _pages = animatedScrollView.NumberOfPage; nativeScrollView = (UIScrollView)this.NativeView; nativeScrollView.ContentSize = new CGSize(_pages * (float)this.NativeView.Frame.Width, (float)this.NativeView.Frame.Height); //TODO: Put these 2 parameters into the Abstraction renderer nativeScrollView.PagingEnabled = true; nativeScrollView.ShowsHorizontalScrollIndicator = false; // _isAtEnd = false; Animator = new Animator(); ScrollView = new UIScrollView(nativeScrollView.Bounds); ScrollView.Scrolled += (sender, args) => { Animator.Animate(Convert.ToInt32(ScrollView.ContentOffset.X)); _isAtEnd = ScrollView.ContentOffset.X >= MaxContentOffsetXForScrollView(ScrollView); //animatedScrolledService = ScrollView.Delegate; if (_isAtEnd && this.RespondsToSelector(new Selector("AnimatedScrollViewControllerDidScrollToEnd:"))) { //animatedScrolledService.AnimatedScrollViewControllerDidScrollToEnd(this); } }; ScrollView.ScrollAnimationEnded += (sender, args) => { //WeakDelegate = scrollView.Delegate; //animatedScrolledService = ScrollView.Delegate; if (_isAtEnd && this.RespondsToSelector(new Selector("AnimatedScrollViewControllerDidEndDraggingAtEnd:"))) { //animatedScrolledService.AnimatedScrollViewControllerDidEndDraggingAtEnd(this); } }; nativeScrollView.Add(ScrollView); }
private void Form1_Load(object sender, EventArgs e) { Animator.Animate(150, (frame, frequency) => { if (!Visible || IsDisposed) { return(false); } Opacity = (double)frame / frequency; return(true); }); }
protected override void OnScrollChanged(int x, int y, int oldx, int oldy) { // if (!button1YOrigin.HasValue) // button1YOrigin = _views [1].GetY (); // // Trace.WriteLine("Scrolling", "X from ["+oldx+"] to ["+x+"]"); // _views[0].SetY(x); // _views[1].SetY(button1YOrigin.Value-x); Animator.Animate(Convert.ToInt32(x)); base.OnScrollChanged(x, y, oldx, oldy); }
public void SlideDown() { var height = headerDiv.OffsetHeight; headerDiv.Style.Top = -height + "px"; headerDiv.Style.Position = "absolute"; Animator.Animate( progress => { var newHeight = Math.Min(progress * height, height); headerDiv.Style.Top = (-height + newHeight) + "px"; headerContainerDiv.Style.Height = newHeight + "px"; }, 300, () => { // Reset the style so that it fits into the normal HTML flow. This ensure that, // after animating, the slid-down content will resize, refit its contents, etc. // if the window resizes. headerDiv.Style.Position = "relative"; headerContainerDiv.Style.Height = "inherit"; } ); /* * int? start = null; * Action<int> step = null; * step = timestamp => * { * start = start ?? timestamp; * var progress = Math.Min((timestamp - start.Value) / duration * height, height); * headerDiv.Style.Top = (-height + progress) + "px"; * headerContainerDiv.Style.Height = progress + "px"; * if (progress < height) * { * Browser.Window.RequestAnimationFrame(step); * } * else * { * // Reset the style so that it fits into the normal HTML flow. This ensure that, * // after animating, the slid-down content will resize, refit its contents, etc. * // if the window resizes. * headerDiv.Style.Position = "relative"; * headerContainerDiv.Style.Height = "inherit"; * } * }; * Browser.Window.RequestAnimationFrame(step); */ }
private void AnimateIn(Point locationToBe) { Focus(); var animacao = Animator.Animate(this, new XLocationEffect(), EasingFunctions.QuintEaseOut, locationToBe.X, 1000, 50); Task.Run(() => { while (animacao.ElapsedMilliseconds < 250) { Thread.Sleep(50); } }); }
private void Animate() { Animator.Animate(_handle, OnAnimate(), length: Duration, easing: Easing, repeat: IsRepeat, finished: (v, c) => { var repeat = IsRepeat(); IsRunning = !repeat; Debug.WriteLine($"Timeline Finished (plays: {_playCount + 1}, repeat: {repeat}, handle: {_handle})"); _playCount++; OnFinished(); }); }
public void UpdateTransform(Matrix3D matrix, bool animate) { if (Content != null && animate) { ContentAnimation animation = new ContentAnimation { OldMatrix = Transform.Value, NewMatrix = matrix, }; Animator.Animate(this, animation); } else { Transform = new MatrixTransform3D(matrix); } }
private void FadeOutIn(TimeSpan time) { var animator = Animator.Animate(this, new FormFadeEffect(), EasingFunctions.Linear, 0, Convert.ToInt32(time.TotalMilliseconds), 50); Task.Run(() => { while (animator.ElapsedMilliseconds < Convert.ToInt32(time.TotalMilliseconds)) { Thread.Sleep(50); } Invoke((MethodInvoker) delegate { Visible = false; Close(); }); }); }
/// <summary> /// Create a new layout instance and start it in a new thread /// </summary> /// <returns></returns> private InteractiveOrganicLayout StartLayout() { // create the layout InteractiveOrganicLayout organicLayout = new InteractiveOrganicLayout { MaximumDuration = 2000 }; // use an animator that animates an infinite animation var animator = new Animator(GraphControl) { AutoInvalidation = false, AnimationPriority = DispatcherPriority.Input }; animator.Animate(delegate { if (!organicLayout.Running) { animator.Stop(); return; } if (organicLayout.CommitPositionsSmoothly(50, 0.05) > 0) { GraphControl.UpdateVisual(); } }, TimeSpan.MaxValue); // run the layout in a separate thread Thread thread = new Thread(new ThreadStart(delegate { // we run the real interactive version of the organic layout // previously we only calculated the initial layout using OrganicLayout organicLayout.ApplyLayout(copiedLayoutGraph); // stop the animator when the layout returns (does not normally happen at all) graphControl.Dispatcher.Invoke(new Action <Animator>(animator1 => animator1.Stop()), animator); })); thread.IsBackground = true; thread.Start(); return(organicLayout); }
public void FadeOut(TimeSpan duration) { Animator.Animate(this, "Opacity", Opacity, 0, duration, EndFadeOut); }
private static void Goto(Location destination, int duration, EasingFunction easing = null) { hw.DisplayDestination(destination.GetName()); elevator.Play(new ElevatorEffect()); var destFloor = destination.GetFloor(); if(easing == null) easing = new ExponentialEase(); var length = new TimeSpan(0, 0, 0, duration); var animator = new Animator { InitialValue = CurrentFloor, FinalValue = destFloor, EasingFunction = easing, Length = length, Set = SetCurrentFloor }; animator.Animate(); }
public static AnimationStatus Animate(this Control control, IEffect iAnimation, EasingDelegate easing, int valueToReach, int duration, int delay, bool reverse = false, int loops = 1) { return(Animator.Animate(control, iAnimation, easing, valueToReach, duration, delay, reverse, loops)); }
public int SolutionPart2(int steps, params string[] input) { var animator = new Animator(true, input); return(animator.Animate(steps)); }
public int SolutionPart2(int steps, params string[] input) { var animator = new Animator(true, input); return animator.Animate(steps); }
private Element InternalAdd(Control child, HorizontalAlignment alignment, int spaceAbove, bool animate = false) { if (Count > 0) { spaceAbove += spacing; } base.AddChild(child); var row = Browser.Document.CreateElement("tr"); var cell = Browser.Document.CreateElement("td"); var div = Browser.Document.CreateElement("div"); cell.AppendChild(div); switch (alignment) { case HorizontalAlignment.Fill: child.Node.Style.Width = "100%"; div.Style.Width = "100%"; break; case HorizontalAlignment.Left: cell.SetAttribute("align", "left"); break; case HorizontalAlignment.Center: cell.SetAttribute("align", "center"); break; case HorizontalAlignment.Right: cell.SetAttribute("align", "right"); break; } if (spaceAbove != 0) { div.Style.MarginTop = spaceAbove + "px"; // TODO!? Shouldn't this be padding? } div.AppendChild(child.Node); row.AppendChild(cell); if (animate) { int height = row.MeasureOffsetHeight(); row.Style.Display = "none"; div.Style.Overflow = "hidden"; Animator.Animate( progress => { var newHeight = (int)(height * progress); div.Style.Height = newHeight + "px"; row.Style.Display = ""; }, AnimationSpeed, () => { div.Style.Overflow = ""; div.Style.Height = ""; }); } return(row); }
private async void StartAnimation() { // animates the nodes in random fashion Random r = new Random(DateTime.Now.TimeOfDay.Milliseconds); await animator.Animate(Animations.CreateGraphAnimation(graphControl.Graph, Mappers.FromDelegate <INode, IRectangle>(node => new RectD(r.NextDouble() * 800, r.NextDouble() * 800, node.Layout.Width, node.Layout.Height)), null, null, null, TimeSpan.FromSeconds(5))); }
IEnumerator Animation(bool enabled) => Animator.Animate( () => Animator.MoveToLocal(Lamp.transform, new Vector3(0, .007f, 0), .2f, Easing.Linear), () => Animator.Action(() => ToggleLights(enabled)), () => Animator.Wait(.05f), () => Animator.MoveToLocal(Lamp.transform, Vector3.zero, .2f, Easing.Linear));