public MouseScrolledEventArgs (long timestamp, double x, double y, ScrollDirection direction) { X = x; Y = y; Timestamp = timestamp; Direction = direction; }
public LScrollView() { direction = ScrollDirection.BOTH; lastMovePoint = Vector2.zero; bounceable = true; scrollDistance = Vector2.zero; dragable = true; maxOffset = Vector2.zero; minOffset = Vector2.zero; }
public override bool HandleKeyPress(KeyInput e) { switch (e.KeyName) { case "up": Keyboard = Keyboard.Set(ScrollDirection.Up, (e.Event == KeyInputEvent.Down)); return true; case "down": Keyboard = Keyboard.Set(ScrollDirection.Down, (e.Event == KeyInputEvent.Down)); return true; case "left": Keyboard = Keyboard.Set(ScrollDirection.Left, (e.Event == KeyInputEvent.Down)); return true; case "right": Keyboard = Keyboard.Set(ScrollDirection.Right, (e.Event == KeyInputEvent.Down)); return true; } return false; }
public static string GetScrollCursor(Widget w, ScrollDirection edge, int2 pos) { if (!Game.Settings.Game.ViewportEdgeScroll || Ui.MouseOverWidget != w) return null; var blockedDirections = Game.viewport.GetBlockedDirections(); foreach (var dir in directions) if (edge.Includes(dir.Key)) return dir.Value + (blockedDirections.Includes(dir.Key) ? "-blocked" : ""); return null; }
public static Gdk.ScrollDirection ConvertScrollDirection(ScrollDirection d) { switch (d) { case ScrollDirection.Up: return Gdk.ScrollDirection.Up; case ScrollDirection.Down: return Gdk.ScrollDirection.Down; case ScrollDirection.Left: return Gdk.ScrollDirection.Left; case ScrollDirection.Right: return Gdk.ScrollDirection.Right; } throw new InvalidOperationException("Invalid mouse scroll direction value: " + d); }
private void OnPointChanged() { if (_scrolledDirection != ScrollDirection.None && PointChanged != null) { if (_scrolledDirection.HasFlag(ScrollDirection.Horizontal)) { EnsureXPositions(); } if (_scrolledDirection.HasFlag(ScrollDirection.Vertical)) { EnsureYPositions(); } PointChanged(this, new PointChangedEventArgs(_scrolledDirection)); } _scrolledDirection = ScrollDirection.None; }
protected override void OnScrolled (ScrollDirection direction, ModifierType mod) { if ((mod & ModifierType.ShiftMask) != ModifierType.ShiftMask) return; int shift = HueShift; if (direction == Gdk.ScrollDirection.Up) shift += 5; else if (direction == Gdk.ScrollDirection.Down) shift -= 5; if (shift < 0) shift += 360; shift %= 360; HueShift = shift; }
void TSC_VerifyViewSize(ScrollDirection direction, CodeBinaryOperatorType codeType, double CompareValue, CheckType ct) { double viewSize = 0; switch (direction) { case ScrollDirection.Horizontal: { viewSize = pattern_getHorizontalViewSize; Comment("Current HorizontalViewSize = " + viewSize + "(" + viewSize.GetType().ToString() + ")"); switch (codeType) { case CodeBinaryOperatorType.GreaterThan: { if (viewSize <= CompareValue) ThrowMe(ct); break; } case CodeBinaryOperatorType.LessThan: { if (viewSize >= CompareValue) ThrowMe(ct); break; } case CodeBinaryOperatorType.IdentityEquality: { if (Math.Abs(viewSize - CompareValue) > _ACCURACY) ThrowMe(ct); break; } default: { throw new NotImplementedException(); } } } break; case ScrollDirection.Vertical: { viewSize = pattern_getVerticalViewSize; Comment("Current VerticalViewSize = " + viewSize + "(" + viewSize.GetType().ToString() + ")"); switch (codeType) { case CodeBinaryOperatorType.GreaterThan: { if (viewSize <= CompareValue) ThrowMe(ct); break; } case CodeBinaryOperatorType.LessThan: { if (viewSize >= CompareValue) ThrowMe(ct); break; } case CodeBinaryOperatorType.IdentityEquality: { if (Math.Abs(viewSize - CompareValue) > _ACCURACY) ThrowMe(ct); break; } default: { throw new NotImplementedException(); } } } break; } m_TestStep++; }
public void ScrollMouse(ScrollDirection direction) { switch (direction) { case ScrollDirection.Down: SendMouseEvent(MouseState.ScrollDown); break; case ScrollDirection.Up: SendMouseEvent(MouseState.ScrollUp); break; } }
protected abstract bool OnNestedDirectionFling(CoordinatorLayout coordinatorLayout, V child, View target, float velocityX, float velocityY, ScrollDirection scrollDirection);
public ScrollChangedArgs(ScrollDirection scrollDirection, int value) { Direction = scrollDirection; Value = value; }
public static bool Includes(this ScrollDirection d, ScrollDirection s) { return (d & s) == s; }
public override bool LoseFocus(MouseInput mi) { Keyboard = ScrollDirection.None; return base.LoseFocus(mi); }
protected override void loadNewItem(ScrollDirection direction) { CoroutineRunner.Start(loadNewDailyItem(getNextDaily(direction, 2), direction, 2), this, "LoadDailyItem"); }
private static void ScrollPageHorizontal(ScrollViewer scrollViewer, ScrollDirection direction) { if (scrollViewer == null || direction == ScrollDirection.None) { return; } double actualWidth = scrollViewer.ActualWidth; double currentOffset = scrollViewer.HorizontalOffset; double newWidth = 0; if (direction == ScrollDirection.Left) { newWidth = currentOffset - actualWidth; } else if (direction == ScrollDirection.Right) { newWidth = currentOffset + actualWidth; } if (newWidth > scrollViewer.ExtentWidth) { newWidth = currentOffset; } if (newWidth < 0) { newWidth = 0; } scrollViewer.ChangeView(newWidth, null, null); }
public ScrollBody(ScrollDirection direction) { Direction = direction; Tnc.AddNode(new ScrollThumb(Direction)); }
public override bool HandleKeyPress(KeyInput e) { var key = Hotkey.FromKeyInput(e); Func <HotkeyReference, ScrollDirection, bool> handleMapScrollKey = (hotkey, scrollDirection) => { var isHotkey = false; var keyValue = hotkey.GetValue(); if (key.Key == keyValue.Key) { isHotkey = key == keyValue; keyboardDirections = keyboardDirections.Set(scrollDirection, e.Event == KeyInputEvent.Down && (isHotkey || keyValue.Modifiers == Modifiers.None)); } return(isHotkey); }; if (handleMapScrollKey(ScrollUpKey, ScrollDirection.Up) || handleMapScrollKey(ScrollDownKey, ScrollDirection.Down) || handleMapScrollKey(ScrollLeftKey, ScrollDirection.Left) || handleMapScrollKey(ScrollRightKey, ScrollDirection.Right)) { return(true); } if (e.Event != KeyInputEvent.Down) { return(false); } if (ZoomInKey.IsActivatedBy(e)) { worldRenderer.Viewport.AdjustZoom(0.25f); return(true); } if (ZoomOutKey.IsActivatedBy(e)) { worldRenderer.Viewport.AdjustZoom(-0.25f); return(true); } if (JumpToTopEdgeKey.IsActivatedBy(e)) { worldRenderer.Viewport.Center(new WPos(worldRenderer.Viewport.CenterPosition.X, 0, 0)); return(true); } if (JumpToBottomEdgeKey.IsActivatedBy(e)) { worldRenderer.Viewport.Center(new WPos(worldRenderer.Viewport.CenterPosition.X, worldRenderer.World.Map.ProjectedBottomRight.Y, 0)); return(true); } if (JumpToLeftEdgeKey.IsActivatedBy(e)) { worldRenderer.Viewport.Center(new WPos(0, worldRenderer.Viewport.CenterPosition.Y, 0)); return(true); } if (JumpToRightEdgeKey.IsActivatedBy(e)) { worldRenderer.Viewport.Center(new WPos(worldRenderer.World.Map.ProjectedBottomRight.X, worldRenderer.Viewport.CenterPosition.Y, 0)); return(true); } for (var i = 0; i < saveBookmarkHotkeys.Length; i++) { if (saveBookmarkHotkeys[i].IsActivatedBy(e)) { bookmarkPositions[i] = worldRenderer.Viewport.CenterPosition; return(true); } } for (var i = 0; i < restoreBookmarkHotkeys.Length; i++) { if (restoreBookmarkHotkeys[i].IsActivatedBy(e)) { var bookmark = bookmarkPositions[i]; if (bookmark.HasValue) { worldRenderer.Viewport.Center(bookmark.Value); return(true); } } } return(world.OrderGenerator.HandleKeyPress(e)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Override public void onNestedVerticalScrollConsumed(Android.Support.Design.Widget.CoordinatorLayout coordinatorLayout, V child, @ScrollDirection int scrollDirection, int currentOverScroll, int totalConsumedScroll) public override void onNestedVerticalScrollConsumed(CoordinatorLayout coordinatorLayout, V child, ScrollDirection scrollDirection, int currentOverScroll, int totalConsumedScroll) { handleDirection(coordinatorLayout, child, scrollDirection); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Override protected boolean onNestedDirectionFling(Android.Support.Design.Widget.CoordinatorLayout coordinatorLayout, V child, Android.View.View target, float velocityX, float velocityY, boolean consumed, @ScrollDirection int scrollDirection) protected override bool onNestedDirectionFling(CoordinatorLayout coordinatorLayout, V child, View target, float velocityX, float velocityY, bool consumed, ScrollDirection scrollDirection) { // if (consumed) { // handleDirection(child, scrollDirection); // } return(consumed); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Override public void onNestedVerticalPreScroll(Android.Support.Design.Widget.CoordinatorLayout coordinatorLayout, V child, Android.View.View target, int dx, int dy, int[] consumed, @ScrollDirection int scrollDirection) public override void onNestedVerticalPreScroll(CoordinatorLayout coordinatorLayout, V child, View target, int dx, int dy, int[] consumed, ScrollDirection scrollDirection) { // handleDirection(child, scrollDirection); }
public override void Tick(World world) { Edge = ScrollDirection.None; if (Game.Settings.Game.ViewportEdgeScroll && Game.HasInputFocus) { // Check for edge-scroll if (Viewport.LastMousePos.X < EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Left, true); if (Viewport.LastMousePos.Y < EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Up, true); if (Viewport.LastMousePos.X >= Game.viewport.Width - EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Right, true); if (Viewport.LastMousePos.Y >= Game.viewport.Height - EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Down, true); } if(Keyboard != ScrollDirection.None || Edge != ScrollDirection.None) { var scroll = new float2(0, 0); // Modified to use the ViewportEdgeScrollStep setting - Gecko if (Keyboard.Includes(ScrollDirection.Up) || Edge.Includes(ScrollDirection.Up)) scroll += new float2(0, -(Game.Settings.Game.ViewportEdgeScrollStep * 100)); if (Keyboard.Includes(ScrollDirection.Right) || Edge.Includes(ScrollDirection.Right)) scroll += new float2((Game.Settings.Game.ViewportEdgeScrollStep * 100), 0); if (Keyboard.Includes(ScrollDirection.Down) || Edge.Includes(ScrollDirection.Down)) scroll += new float2(0, (Game.Settings.Game.ViewportEdgeScrollStep * 100)); if (Keyboard.Includes(ScrollDirection.Left) || Edge.Includes(ScrollDirection.Left)) scroll += new float2(-(Game.Settings.Game.ViewportEdgeScrollStep * 100), 0); Game.viewport.Scroll(scroll); } }
private ClubPenguin.Task.Task getNextDaily(ScrollDirection direction, int aheadCount) { int nextItemIndex = getNextItemIndex(direction, aheadCount); return(dailyChallenges[nextItemIndex]); }
private void OnOffsetChanged(ScrollDirection direction, int firstRow) { ScrollReceiver?.ScrollChanged(new ScrollChangedArgs(direction, firstRow)); }
public void SendScrolled(double percent, ScrollDirection direction) { Scrolled?.Invoke(this, new ScrolledEventArgs { NewValue = percent, Direction = direction }); }
/////////////////////////////////////////////////////////////////////////// // Auto Hide Handling /////////////////////////////////////////////////////////////////////////// //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Override public void onNestedVerticalScrollUnconsumed(Android.Support.Design.Widget.CoordinatorLayout coordinatorLayout, V child, @ScrollDirection int scrollDirection, int currentOverScroll, int totalScroll) public override void onNestedVerticalScrollUnconsumed(CoordinatorLayout coordinatorLayout, V child, ScrollDirection scrollDirection, int currentOverScroll, int totalScroll) { // Empty body }
public ScrollEventArgs(ScrollDirection direction, Point mousePosition, int value) { Direction = direction; MousePosition = mousePosition; Value = value; }
public override void Tick() { Edge = ScrollDirection.None; if (Game.Settings.Game.ViewportEdgeScroll && Game.HasInputFocus && Widget.MouseOverWidget == this) { // Check for edge-scroll if (Viewport.LastMousePos.X < EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Left, true); if (Viewport.LastMousePos.Y < EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Up, true); if (Viewport.LastMousePos.X >= Game.viewport.Width - EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Right, true); if (Viewport.LastMousePos.Y >= Game.viewport.Height - EdgeScrollThreshold) Edge = Edge.Set(ScrollDirection.Down, true); } if(Keyboard != ScrollDirection.None || Edge != ScrollDirection.None) { var scroll = new float2(0, 0); // Modified to use the ViewportEdgeScrollStep setting - Gecko if (Keyboard.Includes(ScrollDirection.Up) || Edge.Includes(ScrollDirection.Up)) scroll += new float2(0, -1); if (Keyboard.Includes(ScrollDirection.Right) || Edge.Includes(ScrollDirection.Right)) scroll += new float2(1, 0); if (Keyboard.Includes(ScrollDirection.Down) || Edge.Includes(ScrollDirection.Down)) scroll += new float2(0, 1); if (Keyboard.Includes(ScrollDirection.Left) || Edge.Includes(ScrollDirection.Left)) scroll += new float2(-1, 0); float length = Math.Max(1, scroll.Length); scroll.X = (scroll.X / length) * Game.Settings.Game.ViewportEdgeScrollStep; scroll.Y = (scroll.Y / length) * Game.Settings.Game.ViewportEdgeScrollStep; Game.viewport.Scroll(scroll); } base.Tick(); }
/// <summary> /// Start the display scrollling in the specified direction. /// </summary> /// <param name="direction">Direction that the display should scroll.</param> public void StartScrolling(ScrollDirection direction) { StartScrolling(direction, 0x00, 0xff); }
public override void Update(GameTime gameTime) { _itemsContainer.Position = new Point(Left, Top); //MultiTextBox mtb = Parent as MultiTextBox; Point lastPosition = SliderButton.Position; Point lastMousePosition = MouseGUI.Position; _itemsContainer.Update(gameTime); if (MouseGUI.Focus == SliderButton) { Point delta = MouseGUI.Position - SliderButton.Center; direction = delta.Y > 0 ? ScrollDirection.DOWN : delta.Y < 0 ? ScrollDirection.UP : ScrollDirection.NONE; if (direction == ScrollDirection.DOWN) { if (GetBounds(delta.Y) == 0) { var slider = _itemsContainer[SliderButton].Position; _itemsContainer.UpdateSlot(SliderButton, new Point(slider.X, slider.Y + delta.Y)); _scrollEvent.OnScroll(Parent, ScrollDirection.DOWN, delta.Y); } else { var down = _itemsContainer[DownButton].Position; _itemsContainer.UpdateSlot(SliderButton, new Point(down.X, down.Y - SliderButton.Height)); } } else { if (direction == ScrollDirection.UP) { if (GetBounds(delta.Y) == 0) { var slider = _itemsContainer[SliderButton].Position; _itemsContainer.UpdateSlot(SliderButton, new Point(slider.X, slider.Y + delta.Y)); _scrollEvent.OnScroll(Parent, ScrollDirection.UP, delta.Y); } else { var up = _itemsContainer[UpButton].Position; _itemsContainer.UpdateSlot(SliderButton, new Point(up.X, up.Y + UpButton.Height)); } } } } else { IScrollable parent = (Parent as IScrollable); if (parent.NumberOfLines > parent.MaxLinesLength) { var slot = _itemsContainer[SliderButton]; int delta = (slot.Position.Y + CurrentScrollValue) - slot.Position.Y; if (delta > 0) { _itemsContainer.UpdateSlot(SliderButton, new Point(slot.Position.X, DownButton.Height + CurrentScrollValue)); } } } base.Update(gameTime); }
private void StartScrolling(ScrollDirection direction) { Scrolling = true; ScrollTween = 1f; scrollDirection = direction; }
/// <summary> /// Adds the bullet, then it will display the bullet screen effect.. /// </summary> /// <param name="textContent">Text content.</param> /// <param name="showBox">If set to <c>true</c> show box.</param> /// <param name="direction">Direction.</param> public void AddBullet(string name, string content, bool showBox = false, ScrollDirection direction = ScrollDirection.RightToLeft, Sprite head = null, Sprite photo = null) { CombScreenTextElement.Create(this, name, content, showBox, direction, head, photo); }
public override string ToString() { return(ScrollDirection.ToString()); }
/// <summary> /// Ons the direction nested pre scroll. /// </summary> /// <param name="scrollDirection">Direction of the overscroll: SCROLL_DIRECTION_UP, SCROLL_DIRECTION_DOWN</param> public abstract void onDirectionNestedPreScroll(CoordinatorLayout coordinatorLayout, V child, View target, int dx, int dy, int[] consumed, ScrollDirection scrollDirection);
public void didUpdateScrollDirection(ScrollDirection direction) { new UserScrollNotification(metrics: ScrollMetricsUtils.copyWith(this), context: this.context.notificationContext, direction: direction ).dispatch(this.context.notificationContext); }
/// ------------------------------------------------------------------- /// <summary>Changes the position to a new random position if the two are the same</summary> /// ------------------------------------------------------------------- private void VerifyNotSame(ref double positionToChange, string positionToChangeStr, double otherPosition, string otherPositionStr, ArrayList validPositions, ScrollDirection scrollDirection, double min, double max, RandomBoundaries boundaries, CheckType checkType) { if (positionToChange.Equals(otherPosition)) { if (validPositions.Count < 4) ThrowMe(CheckType.IncorrectElementConfiguration, validPositions.Count.ToString() + " valid scroll positions, not enough for test (4 minimum). Is your display resolution set too low?"); for (int i = 0; i < 10 && (positionToChange.Equals(otherPosition)); i++) { Comment("\"{0}\"({1}) and \"{2}\"({3}) were found to be the same. Find a new \"{0}\"", positionToChange, positionToChangeStr, otherPosition, otherPositionStr); // false says don't incremenet m_TestStep TSC_RandomPosition positionToChange = TSC_RandomPosition(scrollDirection, min, max, boundaries, false, checkType); } if (positionToChange.Equals(otherPosition)) ThrowMe(CheckType.Verification, "Cannot find a random \"{0}\" position", positionToChangeStr); Comment("Found new \"{0}\" position : {1}", positionToChangeStr, positionToChange); } }
public void ScrollViewportVerticallyByLines(ScrollDirection direction, int count) { Console.WriteLine("ScrollViewportVerticallyByLines"); }
/// <summary> /// Ons the direction nested pre scroll. /// </summary> /// <param name="coordinatorLayout"> /// <param name="child"></param> /// <param name="direction">Direction of the overscroll: SCROLL_DIRECTION_UP, SCROLL_DIRECTION_DOWN</param> /// <param name="currentOverScroll">Unconsumed value, negative or positive based on the direction</param> /// <param name="totalOverScroll">Cumulative value for current direction</param> public abstract void onNestedVerticalOverScroll(CoordinatorLayout coordinatorLayout, V child, ScrollDirection direction, int currentOverScroll, int totalOverScroll);
private void SetScrollBar(ScrollDirection direction) { if (direction.HasFlag(ScrollDirection.Horizontal)) { HorizontalScrollBar.ViewportSize = Points.ViewportWidth; HorizontalScrollBar.Maximum = Points.HorizontalExtent - Points.ViewportWidth; HorizontalScrollBar.Value = Points.HorizontalOffset; } if (direction.HasFlag(ScrollDirection.Vertical)) { VerticalScrollBar.ViewportSize = Points.ViewportHeight; VerticalScrollBar.Maximum = Points.VerticalExtent - Points.ViewportHeight; VerticalScrollBar.Value = Points.VerticalOffset; } }
static double GetWheelDelta (Adjustment adjustment, ScrollDirection direction) { double delta = adjustment.StepIncrement * 4; if (direction == ScrollDirection.Up || direction == ScrollDirection.Left) delta = -delta; return delta; }
/// <summary> /// Does the programmatic scrolling for this element. /// </summary> /// <param name="scrollDirection">The direction to scroll.</param> /// <param name="scrollAmount">The amount to scroll.</param> /// <seealso cref="InitializeProgrammaticScroll"/> public override void ScrollProgrammatically(ScrollDirection scrollDirection, ScrollAmount scrollAmount) { // Should never get called because InitializeProgrammaticScroll() returns false. throw new NotSupportedException(); }
private static void ScrollPageVertical(ScrollViewer scrollViewer, ScrollDirection direction) { if (scrollViewer == null || direction == ScrollDirection.None) { return; } double actualHeight = scrollViewer.ActualHeight; double currentOffset = scrollViewer.VerticalOffset; double newHeight = 0; if (direction == ScrollDirection.Up) { newHeight = currentOffset - actualHeight; } else if (direction == ScrollDirection.Down) { newHeight = currentOffset + actualHeight; } if (newHeight > scrollViewer.ExtentHeight) { newHeight = currentOffset; } if (newHeight < 0) { newHeight = 0; } scrollViewer.ChangeView(null, newHeight, null); }
public override void Tick() { edgeDirections = ScrollDirection.None; if (Game.Settings.Game.ViewportEdgeScroll && Game.HasInputFocus) edgeDirections = CheckForDirections(); if (keyboardDirections != ScrollDirection.None || edgeDirections != ScrollDirection.None) { var scroll = float2.Zero; foreach (var kv in ScrollOffsets) if (keyboardDirections.Includes(kv.Key) || edgeDirections.Includes(kv.Key)) scroll += kv.Value; var length = Math.Max(1, scroll.Length); scroll *= (1f / length) * Game.Settings.Game.ViewportEdgeScrollStep; worldRenderer.Viewport.Scroll(scroll, false); } }
/// <summary> /// Calculates the position of the Hit Object with a position offset. /// </summary> /// <returns></returns> public float GetSpritePosition(long offset) => HitPosition + ((InitialTrackPosition - offset) * (ScrollDirection.Equals(ScrollDirection.Down) ? -HitObjectManagerKeys.ScrollSpeed : HitObjectManagerKeys.ScrollSpeed) / HitObjectManagerKeys.TrackRounding);
public Layout(ScrollDirection direction, Widget content, Widget slider) : base(direction, content) { this.slider = slider; }
public bool ScrollViewportVerticallyByPage(ScrollDirection direction) { throw new NotImplementedException(); }
/// <summary> /// Updates the HitObject sprite positions /// </summary> public void UpdateSpritePositions(long offset) { // Update Sprite position with regards to LN's state // // If the LN end is not drawn, don't move the LN start up with time since it ends up sliding above the LN in // the end. if (CurrentlyBeingHeld && SkinManager.Skin.Keys[Ruleset.Mode].DrawLongNoteEnd) { if (offset > InitialTrackPosition) { UpdateLongNoteSize(offset); SpritePosition = HitPosition; } else { CurrentLongNoteSize = InitialLongNoteSize; SpritePosition = GetSpritePosition(offset); } } else { SpritePosition = GetSpritePosition(offset); } // Update HitBody HitObjectSprite.Y = SpritePosition; // Disregard the rest if it isn't a long note. if (!Info.IsLongNote) { return; } // Don't draw the body if the length is <= 0. Note that this does not mean that the LN should be hidden // altogether: very short LNs, including zero-size on some SV maps after SV adjustment, have this below zero // because CurrentLongNoteSize does not include half of the HitObjectSprite and half of the // LongNoteEndSprite. if (CurrentLongNoteSize <= 0) { LongNoteBodySprite.Visible = false; } // However, if the LN end is drawn and the actual LN size is <= 0, we can stop drawing the LN end as it has // probably been completely overlapped by the LN start at this point (and is sliding below the receptors). if (CurrentLongNoteSize + LongNoteSizeDifference <= 0) { LongNoteEndSprite.Visible = false; } //Update HoldBody Position and Size LongNoteBodySprite.Height = CurrentLongNoteSize; if (ScrollDirection.Equals(ScrollDirection.Down)) { LongNoteBodySprite.Y = SpritePosition + LongNoteBodyOffset - CurrentLongNoteSize; LongNoteEndSprite.Y = SpritePosition + LongNoteBodyOffset - CurrentLongNoteSize - LongNoteEndOffset; } else { LongNoteBodySprite.Y = SpritePosition + LongNoteBodyOffset; LongNoteEndSprite.Y = SpritePosition + LongNoteBodyOffset + CurrentLongNoteSize - LongNoteEndOffset; } }
/// <summary> /// Gets the amount scrolled in percentage. /// </summary> /// <param name="srollDirection">The direction for which data is required.</param> /// <param name="scrollElement">The element which is either the vertical or horizontal scroll bar.</param> /// <returns>The amount in percentage.</returns> /// <seealso cref="InitializeProgrammaticScroll"/> public override int GetScrolledPercentage(ScrollDirection scrollDirection, IUITechnologyElement scrollElement) { // Should never get called because InitializeProgrammaticScroll() returns false. throw new NotSupportedException(); }
void OnScroll(ScrollDirection value, double xCoordinate) { ITextViewLine line; SnapshotPoint lineStart; switch (value) { case ScrollDirection.Left: line = wpfTextView.Caret.ContainingTextViewLine; if (line.TextLeft >= wpfTextView.ViewportLeft) { StopScrolling(); } else if (wpfTextView.Caret.InVirtualSpace || wpfTextView.Caret.Position.BufferPosition != line.Start) { editorOperations.MoveToPreviousCharacter(true); } else { wpfTextView.ViewportLeft = line.TextLeft; StopScrolling(); } break; case ScrollDirection.Right: line = wpfTextView.Caret.ContainingTextViewLine; if (line.TextRight <= wpfTextView.ViewportRight) { StopScrolling(); } else if (wpfTextView.Caret.InVirtualSpace || wpfTextView.Caret.Position.BufferPosition < line.End) { editorOperations.MoveToNextCharacter(true); } else { wpfTextView.ViewportLeft = Math.Max(0, line.TextRight - wpfTextView.ViewportWidth); StopScrolling(); } break; case ScrollDirection.Up: line = wpfTextView.TextViewLines.FirstVisibleLine; if (line.VisibilityState == VisibilityState.FullyVisible && !line.IsFirstDocumentLine()) { line = wpfTextView.GetTextViewLineContainingBufferPosition(line.Start - 1); } lineStart = line.Start; if (line.VisibilityState != VisibilityState.FullyVisible) { wpfTextView.DisplayTextLineContainingBufferPosition(line.Start, 0, ViewRelativePosition.Top); } if (!line.IsValid) { line = wpfTextView.GetTextViewLineContainingBufferPosition(lineStart); } if (line.IsFirstDocumentLine()) { StopScrolling(); } editorOperations.MoveCaret(line, xCoordinate, true); break; case ScrollDirection.Down: line = wpfTextView.TextViewLines.LastVisibleLine; if (line.VisibilityState == VisibilityState.FullyVisible && !line.IsLastDocumentLine()) { line = wpfTextView.GetTextViewLineContainingBufferPosition(line.GetPointAfterLineBreak()); } lineStart = line.Start; if (line.VisibilityState != VisibilityState.FullyVisible) { wpfTextView.DisplayTextLineContainingBufferPosition(line.Start, 0, ViewRelativePosition.Bottom); } if (!line.IsValid) { line = wpfTextView.GetTextViewLineContainingBufferPosition(lineStart); } if (line.IsLastDocumentLine()) { StopScrolling(); } editorOperations.MoveCaret(line, xCoordinate, true); break; default: throw new ArgumentOutOfRangeException(nameof(value)); } wpfTextView.Caret.EnsureVisible(); }
public override bool HandleKeyPress(KeyInput e) { var key = Hotkey.FromKeyInput(e); var ks = Game.Settings.Keys; if (key == ks.MapScrollUp) { keyboardDirections = keyboardDirections.Set(ScrollDirection.Up, e.Event == KeyInputEvent.Down); return true; } if (key == ks.MapScrollDown) { keyboardDirections = keyboardDirections.Set(ScrollDirection.Down, e.Event == KeyInputEvent.Down); return true; } if (key == ks.MapScrollLeft) { keyboardDirections = keyboardDirections.Set(ScrollDirection.Left, e.Event == KeyInputEvent.Down); return true; } if (key == ks.MapScrollRight) { keyboardDirections = keyboardDirections.Set(ScrollDirection.Right, e.Event == KeyInputEvent.Down); return true; } return false; }
public static bool Includes(this ScrollDirection d, ScrollDirection s) { // PERF: Enum.HasFlag is slower and requires allocations. return((d & s) == s); }
public override bool YieldKeyboardFocus() { keyboardDirections = ScrollDirection.None; return base.YieldKeyboardFocus(); }
public static ScrollDirection Set(this ScrollDirection d, ScrollDirection s, bool val) { return((d.Includes(s) != val) ? d ^ s : d); }
public static ScrollDirection Set(this ScrollDirection d, ScrollDirection s, bool val) { return (d.Includes(s) != val) ? d ^ s : d; }
public override bool YieldKeyboardFocus() { keyboardDirections = ScrollDirection.None; return(base.YieldKeyboardFocus()); }
public ScrollEvent(ScrollDirection direction) { Direction = direction; }
public bool ScrollViewportVerticallyByPage(ScrollDirection direction) { bool hasFullyVisibleLines = textView.TextViewLines.Any(a => a.VisibilityState == VisibilityState.FullyVisible); if (direction == ScrollDirection.Up) { var firstVisibleLine = textView.TextViewLines.FirstVisibleLine; if (firstVisibleLine.Height > textView.ViewportHeight) { ScrollViewportVerticallyByPixels(textView.ViewportHeight); return(hasFullyVisibleLines); } double top; if (firstVisibleLine.VisibilityState == VisibilityState.FullyVisible) { if (firstVisibleLine.IsFirstDocumentLine()) { return(hasFullyVisibleLines); } top = firstVisibleLine.Top; } else { top = firstVisibleLine.Bottom; // Top of next line, which is possibly not in TextViewLines so we can't use its Top prop } var line = firstVisibleLine; // Top is only valid if the line is in TextViewLines, so use this variable to track the correct line top value double lineTop = line.Top; var prevLine = line; // Cache this since prevLine could've been disposed when we need to access this property var prevLineStart = prevLine.Start; while (lineTop + textView.ViewportHeight > top) { prevLine = line; prevLineStart = prevLine.Start; if (line.IsFirstDocumentLine()) { break; } line = textView.GetTextViewLineContainingBufferPosition(line.Start - 1); if (line.VisibilityState == VisibilityState.Unattached) { // Height is only fully initialized once it's been shown on the screen // (its LineTransform property is used to calculate Height) var lineStart = line.Start; textView.DisplayTextLineContainingBufferPosition(lineStart, 0, ViewRelativePosition.Bottom); line = textView.GetTextViewLineContainingBufferPosition(lineStart); Debug.Assert(line.VisibilityState != VisibilityState.Unattached); } lineTop -= line.Height; } textView.DisplayTextLineContainingBufferPosition(prevLineStart, 0, ViewRelativePosition.Top); } else { Debug.Assert(direction == ScrollDirection.Down); double pixels = textView.ViewportHeight; var lastVisibleLine = textView.TextViewLines.LastVisibleLine; if (lastVisibleLine.Height > textView.ViewportHeight) { // This line intentionally left blank } else if (lastVisibleLine.VisibilityState == VisibilityState.FullyVisible) { if (lastVisibleLine.IsLastDocumentLine()) { textView.DisplayTextLineContainingBufferPosition(lastVisibleLine.Start, 0, ViewRelativePosition.Top); return(hasFullyVisibleLines); } } else { pixels -= textView.ViewportBottom - lastVisibleLine.Top; } ScrollViewportVerticallyByPixels(-pixels); } return(hasFullyVisibleLines); }
public override void Tick() { Edge = ScrollDirection.None; if (Game.Settings.Game.ViewportEdgeScroll && Game.HasInputFocus) { Edge = CheckForDirections(); Scroll(); } }
public void ScrollViewportVerticallyByLine(ScrollDirection direction) => ScrollViewportVerticallyByLines(direction, 1);
static double GetWheelDelta (Scrollbar scrollbar, ScrollDirection direction) { double delta = System.Math.Pow (scrollbar.Adjustment.PageSize, 2.0 / 3.0); if (direction == ScrollDirection.Up || direction == ScrollDirection.Left) delta = -delta; if (scrollbar.Inverted) delta = -delta; return delta; }
public override bool OnNestedFling(CoordinatorLayout coordinatorLayout, Java.Lang.Object child, View target, float velocityX, float velocityY, bool consumed) { base.OnNestedFling(coordinatorLayout, child, target, velocityX, velocityY, consumed); _scrollDirection = velocityY > 0 ? ScrollDirection.SCROLL_DIRECTION_UP : ScrollDirection.SCROLL_DIRECTION_DOWN; return(OnNestedDirectionFling(coordinatorLayout, (V)child, target, velocityX, velocityY, _scrollDirection)); }