public ButtonGroupContainer(TextWriter contextTextWriter, string dropDownButtonText, SlideDirection direction) { writer = contextTextWriter; var starterTemplate = "<div class=\"btn-group\"><a class=\"btn btn-primary btn-group-xs dropdown-toggle\" data-toggle=\"dropdown\">{0}<span class=\"caret\"></span></a><ul class=\"dropdown-menu\">"; starterTemplate = string.Format(starterTemplate, dropDownButtonText); writer.WriteLine(starterTemplate); }
private void NagivateToPage(SlideDirection direction, PlaylistsPage page) { this.SlideInFrom = direction == SlideDirection.RightToLeft ? Constants.SlideDistance : -Constants.SlideDistance; switch (page) { case PlaylistsPage.Playlists: this.regionManager.RequestNavigate(RegionNames.PlaylistsRegion, typeof(PlaylistsPlaylists).FullName); break; case PlaylistsPage.SmartPlaylists: this.regionManager.RequestNavigate(RegionNames.PlaylistsRegion, typeof(PlaylistsSmartPlaylists).FullName); break; default: break; } }
private void NagivateToPage(SlideDirection direction, InformationPage page) { this.SlideInFrom = direction == SlideDirection.RightToLeft ? Constants.SlideDistance : -Constants.SlideDistance; switch (page) { case InformationPage.Help: this.regionManager.RequestNavigate(RegionNames.InformationRegion, typeof(InformationHelp).FullName); break; case InformationPage.About: this.regionManager.RequestNavigate(RegionNames.InformationRegion, typeof(InformationAbout).FullName); break; default: break; } }
/// <summary> /// Slide the toolbar to the previous button. /// </summary> public void SlideToolbarButtonsToPrev() { // Do not slide before the first button if (toolbarButtonsIndex > 0) { UpdateToolbarButtonsLocation(toolbarButtonsPanel, 1, SlideDirection.Previous); toolbarButtonsIndex--; } // If autosliding and at first button, wrap around to the last button else if (toolbarButtonsIndex == 0 && this.autoSlide == true) { UpdateToolbarButtonsLocation(toolbarButtonsPanel, toolbarButtons.Count - 1, SlideDirection.Next); toolbarButtonsIndex = toolbarButtons.Count - 1; } lastSlideDirection = SlideDirection.Previous; }
/// <summary> /// Slide the toolbar to the next button. /// </summary> public void SlideToolbarButtonsToNext() { // Do not slide after the last button if (toolbarButtonsIndex < toolbarButtons.Count - 1) { UpdateToolbarButtonsLocation(toolbarButtonsPanel, 1, SlideDirection.Next); toolbarButtonsIndex++; } // If autosliding and at last button, wrap around to first button else if (toolbarButtonsIndex == toolbarButtons.Count - 1 && this.autoSlide == true) { UpdateToolbarButtonsLocation(toolbarButtonsPanel, toolbarButtons.Count - 1, SlideDirection.Previous); toolbarButtonsIndex = 0; } lastSlideDirection = SlideDirection.Next; }
public static SlideDirection GetReversedSlideDirection(SlideDirection dir) { switch (dir) { default: case C_SlideShow.SlideDirection.Left: return(C_SlideShow.SlideDirection.Right); case C_SlideShow.SlideDirection.Top: return(C_SlideShow.SlideDirection.Bottom); case C_SlideShow.SlideDirection.Right: return(C_SlideShow.SlideDirection.Left); case C_SlideShow.SlideDirection.Bottom: return(C_SlideShow.SlideDirection.Top); } }
public CoverArtControlViewModel(IPlaybackService playbackService, ICacheService cacheService, IMetadataService metadataService) { this.playbackService = playbackService; this.cacheService = cacheService; this.metadataService = metadataService; this.playbackService.PlaybackSuccess += (_, e) => { this.SlideDirection = e.IsPlayingPreviousTrack ? SlideDirection.UpToDown : SlideDirection.DownToUp; this.RefreshCoverArtAsync(this.playbackService.CurrentTrack); }; this.playbackService.PlayingTrackChanged += (_, __) => this.RefreshCoverArtAsync(this.playbackService.CurrentTrack); // Defaults this.SlideDirection = SlideDirection.DownToUp; this.RefreshCoverArtAsync(this.playbackService.CurrentTrack); }
private void RefreshDisplay(SlideDirection slideDirection = SlideDirection.Creation) { switch (slideDirection) { case SlideDirection.Creation: Index = 0; Batches[Index].Generate(); Batches[Index].Visibility = Visibility.Visible; if (Batches.Length == 1) break; Batches[Index + 1].Generate(); Batches[Index + 1].Visibility = Visibility.Collapsed; break; case SlideDirection.Right: if (Index == Batches.Length - 1) break; if (Index != 0) Batches[Index - 1].Liberate(); Batches[Index].Visibility = Visibility.Collapsed; Batches[Index + 1].Visibility = Visibility.Visible; Index += 1; if (Index == Batches.Length - 1) break; Batches[Index + 1].Generate(); break; case SlideDirection.Left: if (Index == 0) break; if (Index != Batches.Length - 1) Batches[Index + 1].Liberate(); Batches[Index].Visibility = Visibility.Collapsed; Batches[Index - 1].Visibility = Visibility.Visible; Index -= 1; if (Index == 0) break; Batches[Index - 1].Generate(); break; default: throw new ArgumentOutOfRangeException(nameof(slideDirection), slideDirection, null); } }
protected ScreenOffset CalcScreenOffset(SlideDirection inDir) { SlideDirection dir = inDir; if (inDir == SlideDirection.random) { int idx = UnityEngine.Random.Range(0, 4); switch (idx) { case 0: dir = SlideDirection.bottom; break; case 1: dir = SlideDirection.left; break; case 2: dir = SlideDirection.top; break; case 3: dir = SlideDirection.right; break; } } switch (dir) { case SlideDirection.bottom: return(new ScreenOffset(Utils.OffsetCalcMode.Centered, Utils.OffsetCalcMode.ScreenBottom)); case SlideDirection.left: return(new ScreenOffset(Utils.OffsetCalcMode.ScreenLeft, Utils.OffsetCalcMode.Centered)); case SlideDirection.top: return(new ScreenOffset(Utils.OffsetCalcMode.Centered, Utils.OffsetCalcMode.ScreenTop)); case SlideDirection.right: return(new ScreenOffset(Utils.OffsetCalcMode.ScreenRight, Utils.OffsetCalcMode.Centered)); } return(new ScreenOffset(Utils.OffsetCalcMode.Centered, Utils.OffsetCalcMode.ScreenBottom)); }
void Update() { if (Block.State == BlockState.Sliding) { Elapsed += Time.deltaTime; if (Elapsed >= Duration) { Block.State = TargetState; Block.Type = TargetType; Direction = SlideDirection.None; if (Block.State == BlockState.Idle) { matchDetector.RequestMatchDetection(Block); } } } }
static Matrix <int> ConvertForMovement(Matrix <int> matrix, SlideDirection direction, bool isPreparation) { Matrix <int> convertedMatrix; switch (direction) { case SlideDirection.Right: { convertedMatrix = new Matrix <int>(matrix); break; } case SlideDirection.Left: { convertedMatrix = matrix.GetHorizontalInversed(); break; } case SlideDirection.Down: { convertedMatrix = matrix.GetTransposed(); break; } case SlideDirection.Up: { if (isPreparation) { convertedMatrix = matrix.GetTransposed().GetHorizontalInversed(); } else { convertedMatrix = matrix.GetHorizontalInversed().GetTransposed(); } break; } default: throw new ArgumentException(nameof(direction)); } return(convertedMatrix); }
private ImageFadeType GetSlideFadeType(Slide slide, Slide previousSlide, SlideDirection direction) { var thisSlideFadeInType = direction == SlideDirection.Forward ? slide.FadeInForward ? ImageFadeType.FadeIn : ImageFadeType.None : slide.FadeInReverse ? ImageFadeType.FadeIn : ImageFadeType.None; if (previousSlide == null) { // previous image (if any) is a regular image _not_ a slide var regularImageFadeType = _optionsService.ImageFadeType; switch (regularImageFadeType) { case ImageFadeType.CrossFade: case ImageFadeType.FadeInOut: case ImageFadeType.FadeOut: if (thisSlideFadeInType == ImageFadeType.FadeIn) { return(ImageFadeType.CrossFade); } return(thisSlideFadeInType); default: return(thisSlideFadeInType); } } var previousSlideFadeOutType = direction == SlideDirection.Forward ? previousSlide.FadeOutForward ? ImageFadeType.FadeOut : ImageFadeType.None : previousSlide.FadeOutReverse ? ImageFadeType.FadeOut : ImageFadeType.None; if (thisSlideFadeInType == ImageFadeType.FadeIn && previousSlideFadeOutType == ImageFadeType.FadeOut) { return(ImageFadeType.CrossFade); } if (previousSlideFadeOutType == ImageFadeType.FadeOut) { return(ImageFadeType.FadeOut); } return(thisSlideFadeInType); }
private void GotoState(ApplicationStates state) { ApplicationStates cur = App.CurrentState; if (state == ApplicationStates.Back) { if (App.PreviousState == ApplicationStates.Back) { return; } state = App.PreviousState; } if (state == App.CurrentState) { return; } FrameworkElement view = (FrameworkElement)IoC.Repository[state.ToString() + "View"]; if (view == null) { return; } //BaseViewModel vm = (BaseViewModel)IoC.Repository[state.ToString() + "ViewModel"]; //if (vm != null) // view.DataContext = vm; SlideDirection direction = SlideDirection.Left; var dir = App.SlideDirections.Where(s => s.Item1 == cur && s.Item2 == state).FirstOrDefault(); if (dir != null) { direction = dir.Item3; } slide.Slide(view, direction); App.PreviousState = App.CurrentState; App.CurrentState = state; }
public static Vector2 GetDirection(SlideDirection direction) { switch (direction) { case SlideDirection.LEFT: return(new Vector2(-1.0f, 0f)); case SlideDirection.RIGHT: return(new Vector2(1.0f, 0f)); case SlideDirection.TOP: return(new Vector2(0f, -1.0f)); case SlideDirection.BOTTOM: return(new Vector2(0f, 1.0f)); default: throw new Exception(); } }
void Update() { if (block.State == BlockState.Sliding) { Elapsed += Time.deltaTime; if (Elapsed >= slideDuration.Value) { block.State = targetState; block.Type = targetType; Elapsed = 0; Direction = SlideDirection.None; if (matchDetector != null) { matchDetector.RequestMatchDetection(block); } } } }
/// <summary> /// Returns thickness used in animation. Animations from directions start with this thickness /// and animations to directions end with this thickness /// </summary> /// <param name="offset"></param> /// <param name="direction"></param> /// <returns></returns> private static Thickness GetSlideThickness(double offset, SlideDirection direction) { switch (direction) { case SlideDirection.Left: return(new Thickness(-offset, 0, offset, 0)); case SlideDirection.Top: return(new Thickness(0, -offset, 0, offset)); case SlideDirection.Right: return(new Thickness(offset, 0, -offset, 0)); case SlideDirection.Bottom: return(new Thickness(0, offset, 0, -offset)); default: throw new ArgumentException("Invalid Slide Direction"); } }
private void SetNowPlaying() { if (this.playbackService.Queue.Count > 0) { if (this.IsShowcaseButtonChecked) { this.SlideDirection = SlideDirection.LeftToRight; this.regionManager.RequestNavigate(RegionNames.NowPlayingContentRegion, typeof(NowPlayingScreenShowcase).FullName); } else { this.SlideDirection = SlideDirection.RightToLeft; this.regionManager.RequestNavigate(RegionNames.NowPlayingContentRegion, typeof(NowPlayingScreenList).FullName); } } else { this.SlideDirection = SlideDirection.RightToLeft; this.regionManager.RequestNavigate(RegionNames.NowPlayingContentRegion, typeof(NothingPlayingControl).FullName); } }
public PlaybackInfoControlViewModel(IPlaybackService playbackService) { this.playbackService = playbackService; this.refreshTimer.Interval = this.refreshTimerIntervalMilliseconds; this.refreshTimer.Elapsed += RefreshTimer_Elapsed; this.playbackService.PlaybackSuccess += (_, e) => { this.SlideDirection = e.IsPlayingPreviousTrack ? SlideDirection.UpToDown : SlideDirection.DownToUp; this.refreshTimer.Stop(); this.refreshTimer.Start(); }; this.playbackService.PlaybackProgressChanged += (_, __) => this.UpdateTime(); this.playbackService.PlayingTrackPlaybackInfoChanged += (_, __) => this.RefreshPlaybackInfoAsync(this.playbackService.CurrentTrack.Value, true); // Defaults this.SlideDirection = SlideDirection.DownToUp; this.RefreshPlaybackInfoAsync(this.playbackService.CurrentTrack.Value, false); }
public RTSlider() { _title = "Slider"; _titleFont = new Font(FontFamily.GenericSansSerif, 8); _titleColor = Color.DimGray; _showTitle = true; _minVal = -1; _maxVal = 1; _logScale = false; _val = 0; _format = "F2"; _unit = ""; _valueColor = Color.DimGray; _valueFont = new Font(FontFamily.GenericSansSerif, 8); _showValue = true; _showScale = true; _scaleColor = Color.DimGray; _slideWidth = 5; _slideKnob = 20; _slideColor = Color.Silver; _slideMarkColor = Color.Red; _slideMarkFill = Color.DarkRed; _slideDirection = SlideDirection.Vertical; _slideScaleDist = 20; _slideScaleWidth = 10; _showScaleValues = true; _scaleFont = new Font(FontFamily.GenericSansSerif, 8); _lableLength = 3; _scaleValueColor = Color.DimGray; brushSlideMark = new SolidBrush(_slideMarkFill); penSlideMark = new Pen(_slideMarkColor); penSlide = new Pen(_slideColor); valueBrush = new SolidBrush(_valueColor); titleBrush = new SolidBrush(_titleColor); scaleFontBrush = new SolidBrush(_scaleValueColor); scalePen = new Pen(_scaleColor); this.DoubleBuffered = true; }
private void OnPrevious(object sender, RoutedEventArgs e) { if (_selIndex == MaxShapeCount) { return; } var shape = _rootShape.Shapes.ElementAt(_selIndex); shape.ImplicitAnimations = _slideRightImplicitAnimationCollection; shape.Offset = HideOffset; _selIndex++; _nextIndex = _selIndex; UpdateButtonState(); slideDirection = SlideDirection.RightToLeft; _startVal = 1; _endVal = -0.5f; _sw.Start(); }
public CoverArtControlViewModel(IPlaybackService playbackService, ICacheService cacheService, IMetadataService metadataService) { this.playbackService = playbackService; this.cacheService = cacheService; this.metadataService = metadataService; this.refreshTimer.Interval = this.refreshTimerIntervalMilliseconds; this.refreshTimer.Elapsed += RefreshTimer_Elapsed; this.playbackService.PlaybackSuccess += (_, e) => { this.SlideDirection = e.IsPlayingPreviousTrack ? SlideDirection.UpToDown : SlideDirection.DownToUp; this.refreshTimer.Stop(); this.refreshTimer.Start(); }; this.playbackService.PlayingTrackArtworkChanged += (_, __) => this.RefreshCoverArtAsync(this.playbackService.CurrentTrack); // Defaults this.SlideDirection = SlideDirection.DownToUp; this.RefreshCoverArtAsync(this.playbackService.CurrentTrack); }
private void SlideCompleted(UserControl newView, SlideDirection slideDirection) { ViewFrame.Navigate(newView); Manager.MainWindowViewModel.ViewFrameSource = newView; if (slideDirection == SlideDirection.None) { return; } Storyboard sb = new Storyboard(); switch (slideDirection) { case SlideDirection.Left: sb = (this.FindResource("slideScreenInFromRightAndShow") as Storyboard).Clone(); break; case SlideDirection.Right: sb = (this.FindResource("slideScreenInFromLeftAndShow") as Storyboard).Clone(); break; case SlideDirection.Up: sb = (this.FindResource("slideScreenInFromBelowAndShow") as Storyboard).Clone(); break; case SlideDirection.Down: sb = (this.FindResource("slideScreenInFromAboveAndShow") as Storyboard).Clone(); break; default: break; } Storyboard.SetTarget(sb, Viewer); sb.Begin(); }
/// <summary> /// Navigates the current view frame source to a different view control. /// </summary> /// <param name="newView">View control to navigate to.</param> /// <param name="slideDirection">Frame navigation transition slide direction.</param> public void NavigateToView(UserControl newView, SlideDirection slideDirection) { Storyboard sb; string resource = string.Empty; switch (slideDirection) { case SlideDirection.Left: resource = "slideScreenOutToLeftAndFade"; break; case SlideDirection.Right: resource = "slideScreenOutToRightAndFade"; break; case SlideDirection.Up: resource = "slideScreenOutToAboveAndFade"; break; case SlideDirection.Down: resource = "slideScreenOutToBelowAndFade"; break; } if (!string.IsNullOrEmpty(resource)) { sb = (this.FindResource(resource) as Storyboard).Clone(); Storyboard.SetTarget(sb, Viewer); sb.Completed += (sender, e) => { SlideCompleted(newView, slideDirection); }; sb.Begin(); return; } SlideCompleted(newView, SlideDirection.None); }
// Update is called once per frame void Update() { //if(Clock.Instance.State != Clock.ClockState.Game) { // return; //} if (block.State == BlockState.Sliding) { Elapsed += Time.deltaTime; if (Elapsed >= Duration) { block.State = TargetState; block.Type = TargetType; Direction = SlideDirection.None; if (block.State == BlockState.Idle) { matchDetector.RequestMatchDetection(block); } } } }
private Vector2 GetSlidePosition(SlideDirection direction) { float canvasSize = (direction == SlideDirection.Left || direction == SlideDirection.Right) ? m_Dialog.rectTransform.root.GetComponent <Canvas>().pixelRect.width : m_Dialog.rectTransform.root.GetComponent <Canvas>().pixelRect.height; float dialogSize = (direction == SlideDirection.Left || direction == SlideDirection.Right) ? LayoutUtility.GetPreferredWidth(m_Dialog.rectTransform) : LayoutUtility.GetPreferredHeight(m_Dialog.rectTransform); dialogSize *= 1.1f; switch (direction) { case SlideDirection.Bottom: return(new Vector2(0f, -(canvasSize + dialogSize))); case SlideDirection.Left: return(new Vector2(-(canvasSize + dialogSize), 0f)); case SlideDirection.Right: return(new Vector2(canvasSize + dialogSize, 0f)); case SlideDirection.Top: return(new Vector2(0f, canvasSize + dialogSize)); } return(Vector2.zero); }
public static DialogAnimatorSlide AddOrSetupDialogAnimatorSlide(MaterialDialogCompat materialDialog, float animationDuration, SlideDirection slideInDirection, SlideDirection slideOutDirection, Tween.TweenType slideInTweenType, Tween.TweenType slideOutTweenType) { var animator = GetOrAddTypedDialogAnimator <DialogAnimatorSlide>(materialDialog); if (animator != null) { animator.m_AnimationDuration = animationDuration; animator.m_SlideInDirection = slideInDirection; animator.m_SlideOutDirection = slideOutDirection; if (slideInTweenType == Tween.TweenType.Custom || slideOutTweenType == Tween.TweenType.Custom) { Debug.LogWarning("Cannot set tween type to 'Custom'"); } else { animator.m_SlideInTweenType = slideInTweenType; animator.m_SlideOutTweenType = slideOutTweenType; } } return(animator); }
public static DialogAnimatorSlide AddOrSetupDialogAnimatorSlide(MaterialDialogCompat materialDialog, float animationDuration, SlideDirection slideInDirection, SlideDirection slideOutDirection) { var animator = GetOrAddTypedDialogAnimator <DialogAnimatorSlide>(materialDialog); if (animator != null) { animator.m_AnimationDuration = animationDuration; animator.m_SlideInDirection = slideInDirection; animator.m_SlideOutDirection = slideOutDirection; } return(animator); }
private Vector2 GetSlidePosition(SlideDirection direction) { float canvasSize = (direction == SlideDirection.Left || direction == SlideDirection.Right) ? m_Dialog.rectTransform.root.GetComponent<Canvas>().pixelRect.width : m_Dialog.rectTransform.root.GetComponent<Canvas>().pixelRect.height; float dialogSize = (direction == SlideDirection.Left || direction == SlideDirection.Right) ? LayoutUtility.GetPreferredWidth(m_Dialog.rectTransform) : LayoutUtility.GetPreferredHeight(m_Dialog.rectTransform); dialogSize *= 1.1f; switch (direction) { case SlideDirection.Bottom: return new Vector2(0f, -(canvasSize + dialogSize)); case SlideDirection.Left: return new Vector2(-(canvasSize + dialogSize), 0f); case SlideDirection.Right: return new Vector2(canvasSize + dialogSize, 0f); case SlideDirection.Top: return new Vector2(0f, canvasSize + dialogSize); } return Vector2.zero; }
public static IDisposable ButtonGroup(this HtmlHelper htmlHelper, string dropDownButtonText = "Actions", SlideDirection direction = SlideDirection.Down) { var writer = htmlHelper.ViewContext.Writer; return new ButtonGroupContainer(writer, dropDownButtonText, direction); }
/// <summary> /// Slides the transition following the transition arrow /// to avoid colliding with the colliding rectangle /// </summary> /// <param name="center">The current center of the text box</param> /// <param name="colliding">The colliding rectangle</param> /// <returns></returns> public Point Slide(Point center, Rectangle colliding, SlideDirection direction) { Point retVal; double angle = Angle; if (direction == SlideDirection.Up) { retVal = new Point((int)(center.X + Math.Cos(angle) * DELTA), (int)(center.Y + Math.Sin(angle) * DELTA)); } else { retVal = new Point((int)(center.X - Math.Cos(angle) * DELTA), (int)(center.Y - Math.Sin(angle) * DELTA)); } return retVal; }
/// <summary> /// Provides derived classes an opportunity to handle changes /// to the ForwardDirection property. /// </summary> /// <param name="oldForwardDirection">The old ForwardDirection value</param> /// <param name="newForwardDirection">The new ForwardDirection value</param> protected virtual void OnForwardDirectionChanged( SlideDirection oldForwardDirection, SlideDirection newForwardDirection) { ((SlideAnimation)this.ForwardInAnimation).Direction = newForwardDirection; ((SlideAnimation)this.ForwardOutAnimation).Direction = newForwardDirection; }
void SlidePage(SlideDirection dir) { RectTransform curpage = null; switch (dir) { case SlideDirection.Up: curpage = FPage; FPage = DPage; DPage = BPage; BPage = UPage; UPage = curpage; break; case SlideDirection.Down: curpage = FPage; FPage = UPage; UPage = BPage; BPage = DPage; DPage = curpage; break; case SlideDirection.Left: curpage = FPage; FPage = RPage; RPage = BPage; BPage = LPage; LPage = curpage; break; case SlideDirection.Right: curpage = FPage; FPage = LPage; LPage = BPage; BPage = RPage; RPage = curpage; break; } SetPagePosition (); }
private static DoubleAnimationUsingKeyFrames CreateFrontElementSlideAnimation(SlideDirection direction, FrameworkElement elementToMove, Duration duration) { var animation = new DoubleAnimationUsingKeyFrames(); double offset = elementToMove.ActualWidth; animation.BeginTime = new TimeSpan(0); animation.KeyFrames.Add(new EasingDoubleKeyFrame { KeyTime = new TimeSpan(0), Value = direction == SlideDirection.SlideLeftToRight ? -offset : 0 }); animation.KeyFrames.Add(new EasingDoubleKeyFrame { KeyTime = new TimeSpan(duration.TimeSpan.Ticks), Value = direction == SlideDirection.SlideLeftToRight ? 0 : -offset }); Storyboard.SetTargetProperty(animation, new PropertyPath("(UIElement.RenderTransform).(CompositeTransform.TranslateX)")); Storyboard.SetTarget(animation, elementToMove); return animation; }
public SlideEventArgs(SlideDirection direction) { Direction = direction; }
public DialogAnimatorSlide(float animationDuration, SlideDirection slideInDirection, SlideDirection slideOutDirection) { m_AnimationDuration = animationDuration; m_SlideInDirection = slideInDirection; m_SlideOutDirection = slideOutDirection; }
/// <summary> /// Initialize with direction /// </summary> /// <param name="dir">Direction</param> /// <param name="user_data">User data</param> public SlidingEventArgs(SlideDirection dir, object user_data) { _slide_direction = dir; _user_data = user_data; }
public DialogAnimatorSlide(float animationDuration, SlideDirection slideInDirection, SlideDirection slideOutDirection, Tween.TweenType slideInTweenType, Tween.TweenType slideOutTweenType) { m_AnimationDuration = animationDuration; m_SlideInDirection = slideInDirection; m_SlideOutDirection = slideOutDirection; if (slideInTweenType == Tween.TweenType.Custom || slideOutTweenType == Tween.TweenType.Custom) { Debug.LogWarning("Cannot set tween type to 'Custom'"); } else { m_SlideInTweenType = slideInTweenType; m_SlideOutTweenType = slideOutTweenType; } }
public SlideFinishedEventArgs(SlideDirection dir) { Direction = dir; }
public static Task Slide(this UIView view, SlideDirection slideDirection, double duration = DefaultAnimationDuration, UIViewAnimationOptions animationOptions = UIViewAnimationOptions.CurveLinear) { System.Diagnostics.Debug.WriteLine("Slide Direction: {0}", slideDirection); CGAffineTransform startingTransform, endingTransform; switch (slideDirection) { case SlideDirection.FromBottom: startingTransform = CGAffineTransform.MakeTranslation(0f, view.Bounds.Height); endingTransform = CGAffineTransform.MakeIdentity(); break; case SlideDirection.FromLeft: startingTransform = CGAffineTransform.MakeTranslation(-view.Bounds.Width, 0f); endingTransform = CGAffineTransform.MakeIdentity(); break; case SlideDirection.FromRight: startingTransform = CGAffineTransform.MakeTranslation(view.Bounds.Width, 0f); endingTransform = CGAffineTransform.MakeIdentity(); break; case SlideDirection.FromTop: startingTransform = CGAffineTransform.MakeTranslation(0f, -view.Bounds.Height); endingTransform = CGAffineTransform.MakeIdentity(); break; case SlideDirection.ToBottom: startingTransform = CGAffineTransform.MakeIdentity(); endingTransform = CGAffineTransform.MakeTranslation(0f, view.Bounds.Height); break; case SlideDirection.ToLeft: startingTransform = CGAffineTransform.MakeIdentity(); endingTransform = CGAffineTransform.MakeTranslation(-view.Bounds.Width, 0f); break; case SlideDirection.ToRight: startingTransform = CGAffineTransform.MakeIdentity(); endingTransform = CGAffineTransform.MakeTranslation(view.Bounds.Width, 0f); break; case SlideDirection.ToTop: startingTransform = CGAffineTransform.MakeIdentity(); endingTransform = CGAffineTransform.MakeTranslation(0f, -view.Bounds.Height); break; default: startingTransform = CGAffineTransform.MakeIdentity(); endingTransform = CGAffineTransform.MakeIdentity(); break; } view.Transform = startingTransform; var animationCompleted = new TaskCompletionSource <object> (); UIView.Animate(duration, 0, animationOptions, () => { if (animationCompleted.Task.IsCanceled) { return; } view.Transform = endingTransform; }, () => animationCompleted.TrySetResult(null) ); return(animationCompleted.Task); }
public OobeViewModel(IDialogService dialogService, IEventAggregator eventAggregator) { this.dialogService = dialogService; this.eventAggregator = eventAggregator; this.dialogService.DialogVisibleChanged += (isDialogVisible) => { this.IsOverlayVisible = isDialogVisible; }; this.eventAggregator.GetEvent <ChangeOobeSlideDirectionEvent>().Subscribe((slideDirection) => { this.SlideDirection = slideDirection; }); // Initial slide direction this.SlideDirection = SlideDirection.RightToLeft; }
public void SlideIn(SlideDirection pDirection) { Position = Offset; if( SourceObject != null ) { Position += SourceObject.Position; } Vector2 Destination; switch(pDirection){ case(SlideDirection.LEFT): Destination = new Vector2(Position.X - Width, Position.Y); break; case(SlideDirection.RIGHT): Position += new Vector2(-Width, 0.0f); Destination = new Vector2(Position.X + Width, Position.Y); break; case(SlideDirection.UP): Position += new Vector2(0.0f, -Height); Destination = new Vector2(Position.X, Position.Y + Height); break; case(SlideDirection.DOWN): default: Destination = new Vector2(Position.X, Position.Y - Height); break; } Sequence baseSequence = new Sequence(); baseSequence.Add( new CallFunc( () => { Visible = true; EventHandler handler = OnSlideInStart; if ( handler != null ) { handler( this, null ); } } ) ); baseSequence.Add( new MoveTo( Destination, MoveDuration) ); baseSequence.Add( new CallFunc( () => { EventHandler handler = OnSlideInComplete; if ( handler != null ) { handler( this, null ); } } ) ); this.RunAction( baseSequence ); if (DismissDelay > 0.0f) { Sequence sequence = new Sequence(); sequence.Add( new DelayTime(DismissDelay) ); sequence.Add( new CallFunc( () => {AllowDismiss (); } ) ); this.RunAction(sequence); } if (Lifetime > 0.0f) { Sequence sequence = new Sequence(); sequence.Add( new DelayTime(1.0f + Lifetime) ); sequence.Add( new CallFunc( () => {SlideOut(); } ) ); this.RunAction(sequence); } }
public void SlideOut(SlideDirection pDirection) { InputManager.Instance.TapDetected -= HandleInputManagerInstanceTapDetected; InputManager.Instance.DragDetected -= HandleInputManagerInstanceDragDetected; Vector2 Destination; Destination = Offset; if (SourceObject != null) { Destination += SourceObject.Position; } switch(pDirection){ case(SlideDirection.LEFT): Destination += new Vector2(-Width, 0.0f); break; case(SlideDirection.DOWN): Destination += new Vector2(0.0f, -Height); break; default: break; } Sequence sequence = new Sequence(); sequence.Add( new CallFunc( () => { EventHandler handler = OnSlideOutStart; if ( handler != null ) { handler( this, null ); } } ) ); sequence.Add( new MoveTo( Destination, MoveDuration) ); sequence.Add( new CallFunc( () => { // Visible=false; EventHandler handler = OnSlideOutComplete; if ( handler != null ) { handler( this, null ); } } ) ); this.RunAction(sequence); }
/// <summary> /// Initializes a new instance of the <see cref="SlideTransition"/> class. /// </summary> /// <param name="direction">The direction.</param> public SlideTransition(SlideDirection direction) { SlideDirection = direction; Duration = new Duration(TimeSpan.FromSeconds(0.3)); }
public EffectsBuilder SlideIn(SlideDirection direction) { return Add(EffectsList.SlideIn, direction.ToString().ToLower()); }
public void SelectNextFile(SlideDirection direction) { if (SelectedItems.Count == 0) { return; } var item = SelectedItems[0]; fileListView.SelectedIndices.Clear(); var index = item.Index; if (direction == SlideDirection.Front) { index++; if (index == fileListView.Items.Count - 1) { index = 0; } } else { index--; if (index == 0) { index = fileListView.Items.Count - 1; } } fileListView.SelectedIndices.Add(index); }
/// <summary> /// Provides derived classes an opportunity to handle changes /// to the BackwardDirection property. /// </summary> /// <param name="oldBackwardDirection">The old BackwardDirection value</param> /// <param name="newBackwardDirection">The new BackwardDirection value</param> protected virtual void OnBackwardDirectionChanged( SlideDirection oldBackwardDirection, SlideDirection newBackwardDirection) { ((SlideAnimation)this.BackwardInAnimation).Direction = newBackwardDirection; ((SlideAnimation)this.BackwardOutAnimation).Direction = newBackwardDirection; }