public ScrollEventArgs(ScrollEventType type, int oldValue, int newValue, ScrollOrientation scroll) { _scrollType = type; _oldValue = oldValue; NewValue = newValue; _scrollOrientation = scroll; }
private void OnScroll(ScrollEventType type, int oldValue, int newValue, ScrollOrientation orientation) { if (Scroll == null) return; if (orientation == ScrollOrientation.HorizontalScroll) { if (type != ScrollEventType.EndScroll && isFirstScrollEventHorizontal) { type = ScrollEventType.First; } else if (!isFirstScrollEventHorizontal && type == ScrollEventType.EndScroll) { isFirstScrollEventHorizontal = true; } } else { if (type != ScrollEventType.EndScroll && isFirstScrollEventVertical) { type = ScrollEventType.First; } else if (!isFirstScrollEventHorizontal && type == ScrollEventType.EndScroll) { isFirstScrollEventVertical = true; } } Scroll(this, new ScrollEventArgs(type, oldValue, newValue, orientation)); }
public ScrollEventArgs(ScrollEventType type, int newValue, System.Windows.Forms.ScrollOrientation scroll) { this.oldValue = -1; this.type = type; this.newValue = newValue; this.scrollOrientation = scroll; }
public ScrollEventArgs (ScrollEventType type, int oldValue, int newValue, ScrollOrientation scroll) { this.new_value = newValue; this.old_value = oldValue; this.scroll_orientation = scroll; this.type = type; }
public ScrollEventArgs(ScrollEventType type, int oldValue, int newValue) { this.oldValue = -1; this.type = type; this.newValue = newValue; this.oldValue = oldValue; }
public ScrollEventArgs(ScrollEventType type, int oldValue, int newValue) { throw null; }
private void RaiseScrollEvent(ScrollEventType scrollEventType) { if (this.Scroll == null) return; this.Scroll((object)this, new ScrollEventArgs(scrollEventType, this.Value)); }
public virtual void OnScroll(ScrollEventType type = ScrollEventType.ThumbPosition) { if (Scroll != null) Scroll(this, new ScrollEventArgs(type, Value, Orientation)); }
private void ScrollRows(int rowCount, int deltaY, ScrollEventType scrollEventType) { bool invalidateTopOfRowHeaders = false; Debug.Assert(rowCount != 0); Debug.Assert(deltaY != 0); Debug.Assert(this.displayedBandsInfo.FirstDisplayedScrollingRow >= this.Rows.GetRowCount(DataGridViewElementStates.Visible | DataGridViewElementStates.Frozen)); this.verticalOffset -= deltaY; if (this.vertScrollBar.Enabled) { this.vertScrollBar.Value = this.verticalOffset; } ClearRegionCache(); int frozenRowsThickness = this.Rows.GetRowsHeight(DataGridViewElementStates.Visible | DataGridViewElementStates.Frozen); Rectangle rowsRect = this.layout.Data; if (this.layout.RowHeadersVisible) { rowsRect = Rectangle.Union(rowsRect, this.layout.RowHeaders); if (this.SingleHorizontalBorderAdded) { rowsRect.Y++; rowsRect.Height--; invalidateTopOfRowHeaders = true; } } else if (this.SingleVerticalBorderAdded) { Debug.Assert(rowsRect.X > 0); rowsRect.X--; rowsRect.Width++; } rowsRect.Y += frozenRowsThickness; rowsRect.Height -= frozenRowsThickness; Debug.Assert(rowsRect.Height >= 0); if (this.editingControl != null && (this.Rows.GetRowState(this.ptCurrentCell.Y) & DataGridViewElementStates.Frozen) == 0) { Debug.Assert(this.displayedBandsInfo.FirstDisplayedScrollingRow > -1); PositionEditingControl(true /*setLocation*/, false /*setSize*/, false /*setFocus*/); } if (MouseButtons != MouseButtons.None) { this.dataGridViewState1[DATAGRIDVIEWSTATE1_scrolledSinceMouseDown] = true; } // The mouse probably is not over the same cell after the scroll. UpdateMouseEnteredCell(null /*HitTestInfo*/, null /*MouseEventArgs*/); NativeMethods.RECT scrollArea = NativeMethods.RECT.FromXYWH(rowsRect.X, rowsRect.Y, rowsRect.Width, rowsRect.Height); SafeNativeMethods.ScrollWindow(new HandleRef(this, this.Handle), 0, deltaY, ref scrollArea, ref scrollArea); if (invalidateTopOfRowHeaders) { rowsRect.X = this.layout.Inside.X; rowsRect.Y = this.layout.Inside.Y; rowsRect.Width = this.layout.RowHeaders.Width; rowsRect.Height = 1; Invalidate(rowsRect); } if (!this.dataGridViewState2[DATAGRIDVIEWSTATE2_stopRaisingVerticalScroll]) { Debug.Assert(this.displayedBandsInfo.FirstDisplayedScrollingRow >= 0); int firstVisibleScrollingRow = this.Rows.GetFirstRow(DataGridViewElementStates.Visible, DataGridViewElementStates.Frozen); Debug.Assert(firstVisibleScrollingRow != -1); int newScrolledOffRowCount = this.Rows.GetRowCount(DataGridViewElementStates.Visible, firstVisibleScrollingRow, this.displayedBandsInfo.FirstDisplayedScrollingRow); Debug.Assert(newScrolledOffRowCount >= rowCount); OnScroll(scrollEventType, newScrolledOffRowCount - rowCount, newScrolledOffRowCount, ScrollOrientation.VerticalScroll); } }
internal void ProcessVerticalScroll(ScrollEventType scrollEventType) { if (this._verticalScrollChangesIgnored > 0) { return; } Debug.Assert(DoubleUtil.LessThanOrClose(this._vScrollBar.Value, this._vScrollBar.Maximum)); this._verticalScrollChangesIgnored++; try { Debug.Assert(this._vScrollBar != null); if (scrollEventType == ScrollEventType.SmallIncrement) { this.DisplayData.PendingVerticalScrollHeight = GetVerticalSmallScrollIncrease(); double newVerticalOffset = this._verticalOffset + this.DisplayData.PendingVerticalScrollHeight; if (newVerticalOffset > this._vScrollBar.Maximum) { this.DisplayData.PendingVerticalScrollHeight -= newVerticalOffset - this._vScrollBar.Maximum; } } else if (scrollEventType == ScrollEventType.SmallDecrement) { if (DoubleUtil.GreaterThan(this.NegVerticalOffset, 0)) { this.DisplayData.PendingVerticalScrollHeight -= this.NegVerticalOffset; } else { int previousScrollingSlot = this.GetPreviousVisibleSlot(this.DisplayData.FirstScrollingSlot); if (previousScrollingSlot >= 0) { ScrollSlotIntoView(previousScrollingSlot, false /*scrolledHorizontally*/); } return; } } else { this.DisplayData.PendingVerticalScrollHeight = this._vScrollBar.Value - this._verticalOffset; } if (!DoubleUtil.IsZero(this.DisplayData.PendingVerticalScrollHeight)) { // Invalidate so the scroll happens on idle InvalidateRowsMeasure(false /*invalidateIndividualElements*/); } // } finally { this._verticalScrollChangesIgnored--; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Scroll vertical /// </summary> /// <param name="type"></param> /// ------------------------------------------------------------------------------------ public void VerticalScroll(ScrollEventType type) { CheckDisposed(); Win32.PostMessage(Handle, Win32.WinMsgs.WM_VSCROLL, (int)type, 0); }
internal void DoScroll(int newValue, ScrollEventType eventType) { int oldValue = this.Value; this.Value = newValue; #if FRAMEWORK20 OnScroll(new ScrollEventArgs(eventType, oldValue, newValue, _ScrollBar.Orientation == eOrientation.Vertical ? ScrollOrientation.VerticalScroll : ScrollOrientation.HorizontalScroll)); #else OnScroll(new ScrollEventArgs(eventType, newValue)); #endif }
void OnClickOnSmallOrLargeDecreaseIncreaseButtons(double amountByWhichToIncreaseOrDecreaseTheValue, ScrollEventType scrollEventType) { double newValue = CoerceValue(this.Value + amountByWhichToIncreaseOrDecreaseTheValue); if (newValue != this.Value) { this.SetLocalValue(RangeBase.ValueProperty, newValue); // Note: we do not use "this.Value = newValue" because it deletes any bindings that the user may have set to the scrollbar with <ScrollBar Value="{Binding...}"/>. if (this.Scroll != null) { this.Scroll(this, new ScrollEventArgs(newValue, scrollEventType)); } } if (Orientation == Orientation.Horizontal) { _horizontalThumb.Focus(); } else { _verticalThumb.Focus(); } }
public ScrollEventArgs(ScrollEventType type, int newValue, ScrollOrientation scroll) { _scrollType = type; NewValue = newValue; _scrollOrientation = scroll; }
public ScrollEventArgs(ScrollEventType type, int oldValue, int newValue) { _scrollType = type; _oldValue = oldValue; NewValue = newValue; }
/// <summary> /// Initializes a new instance of the <see cref="ScrollEventArgs"/> class. /// </summary> public ScrollEventArgs(ScrollEventType type, int newValue) { Type = type; NewValue = newValue; OldValue = -1; }
public ScrollEventArgs(ScrollEventType type, int oldValue, int newValue, ScrollOrientation scroll) { throw null; }
/// <include file='doc\ScrollBar.uex' path='docs/doc[@for="ScrollBar.DoScroll"]/*' /> /// <devdoc> /// </devdoc> /// <internalonly/> private void DoScroll(ScrollEventType type) { // For Rtl systems we need to swap increment and decrement // if (RightToLeft == RightToLeft.Yes) { switch (type) { case ScrollEventType.First: type = ScrollEventType.Last; break; case ScrollEventType.Last: type = ScrollEventType.First; break; case ScrollEventType.SmallDecrement: type = ScrollEventType.SmallIncrement; break; case ScrollEventType.SmallIncrement: type = ScrollEventType.SmallDecrement; break; case ScrollEventType.LargeDecrement: type = ScrollEventType.LargeIncrement; break; case ScrollEventType.LargeIncrement: type = ScrollEventType.LargeDecrement; break; } } int newValue = value; int oldValue = value; // The ScrollEventArgs constants are defined in terms of the windows // messages.. this eliminates confusion between the VSCROLL and // HSCROLL constants, which are identical. // switch (type) { case ScrollEventType.First: newValue = minimum; break; case ScrollEventType.Last: newValue = maximum - LargeChange + 1; // si.nMax - si.nPage + 1; break; case ScrollEventType.SmallDecrement: newValue = Math.Max(value - SmallChange, minimum); break; case ScrollEventType.SmallIncrement: newValue = Math.Min(value + SmallChange, maximum - LargeChange + 1); // max - lChange + 1); break; case ScrollEventType.LargeDecrement: newValue = Math.Max(value - LargeChange, minimum); break; case ScrollEventType.LargeIncrement: newValue = Math.Min(value + LargeChange, maximum - LargeChange + 1); // si.nPos + si.nPage,si.nMax - si.nPage + 1); break; case ScrollEventType.ThumbPosition: case ScrollEventType.ThumbTrack: NativeMethods.SCROLLINFO si = new NativeMethods.SCROLLINFO(); si.fMask = NativeMethods.SIF_TRACKPOS; SafeNativeMethods.GetScrollInfo(new HandleRef(this, Handle), NativeMethods.SB_CTL, si); if (RightToLeft == RightToLeft.Yes) { newValue = ReflectPosition(si.nTrackPos); } else { newValue = si.nTrackPos; } break; } ScrollEventArgs se = new ScrollEventArgs(type, oldValue, newValue, this.scrollOrientation); OnScroll(se); Value = se.NewValue; }
/// <summary> /// Raises the <see cref="Scroll"/> event. /// </summary> /// <param name="type">The scroll event type.</param> protected internal void RaiseScrollEvent(ScrollEventType type) { var evtData = RoutedEventData.Retrieve(this); var evtDelegate = EventManager.GetInvocationDelegate<UpfScrollEventHandler>(ScrollEvent); evtDelegate(this, type, evtData); }
public ScrollEventArgs(ScrollEventType eventType, double newValue) { ScrollEventType = eventType; NewValue = newValue; }
private void OnScroll(ScrollEventType scrollType, int newValue) { var ev = Scroll; if (ev != null) ev(this, new ScrollEventArgs(scrollType, newValue)); }
protected void OnScroll(ScrollEventType scrollEventType) { Scroll?.Invoke(this, new ScrollEventArgs(scrollEventType, Value)); }
internal void ProcessHorizontalScroll(ScrollEventType scrollEventType) { if (this._horizontalScrollChangesIgnored > 0) { return; } // If the user scrolls with the buttons, we need to update the new value of the scroll bar since we delay // this calculation. If they scroll in another other way, the scroll bar's correct value has already been set double scrollBarValueDifference = 0; if (scrollEventType == ScrollEventType.SmallIncrement) { scrollBarValueDifference = GetHorizontalSmallScrollIncrease(); } else if (scrollEventType == ScrollEventType.SmallDecrement) { scrollBarValueDifference = -GetHorizontalSmallScrollDecrease(); } this._horizontalScrollChangesIgnored++; try { if (scrollBarValueDifference != 0) { Debug.Assert(this._horizontalOffset + scrollBarValueDifference >= 0); this._hScrollBar.Value = this._horizontalOffset + scrollBarValueDifference; } UpdateHorizontalOffset(this._hScrollBar.Value); } finally { this._horizontalScrollChangesIgnored--; } DataGridAutomationPeer peer = DataGridAutomationPeer.FromElement(this) as DataGridAutomationPeer; if (peer != null) { peer.RaiseAutomationScrollEvents(); } }
public ScrollEventArgs(ScrollEventType type, int newValue, ScrollOrientation scroll) { this.type = type; this.newValue = newValue; this.scrollOrientation = scroll; }
private void OnScroll(ScrollEventType scrollEventType, int oldValue, int newValue, ScrollOrientation orientation) { ScrollEventArgs se = new ScrollEventArgs(scrollEventType, oldValue, newValue, orientation); OnScroll(se); RefreshByCurrentPos(oldValue, newValue); if (ScrollOrientation.VerticalScroll == orientation) { if (se.NewValue != newValue) { try { this.dataGridViewState2[DATAGRIDVIEWSTATE2_stopRaisingVerticalScroll] = true; int rowIndex = this.Rows.GetFirstRow(DataGridViewElementStates.Visible, DataGridViewElementStates.Frozen); int rowIndexPrevious = rowIndex; newValue = se.NewValue; while (rowIndex != -1 && newValue > 0) { rowIndexPrevious = rowIndex; rowIndex = this.Rows.GetNextRow(rowIndex, DataGridViewElementStates.Visible); newValue--; } if (rowIndex != -1) { rowIndexPrevious = rowIndex; } if (rowIndexPrevious != -1) { this.FirstDisplayedScrollingRowIndex = rowIndexPrevious; } } finally { this.dataGridViewState2[DATAGRIDVIEWSTATE2_stopRaisingVerticalScroll] = false; } } } else { if (se.NewValue != newValue) { try { this.dataGridViewState2[DATAGRIDVIEWSTATE2_stopRaisingHorizontalScroll] = true; this.HorizontalOffset = se.NewValue; } finally { this.dataGridViewState2[DATAGRIDVIEWSTATE2_stopRaisingHorizontalScroll] = false; } } } }
public ScrollEventArgs(ScrollEventType type, int oldValue, int newValue) { this.type = type; this.newValue = newValue; this.oldValue = oldValue; }
private void ScrollRowsByCount(int rows, ScrollEventType scrollEventType) { Debug.Assert(rows != 0); Debug.Assert((rows > 0 && (scrollEventType == ScrollEventType.SmallIncrement || scrollEventType == ScrollEventType.LargeIncrement)) || (rows < 0 && (scrollEventType == ScrollEventType.SmallDecrement || scrollEventType == ScrollEventType.LargeDecrement))); int deltaY = 0; Debug.Assert(this.displayedBandsInfo.FirstDisplayedScrollingRow >= 0); int newFirstVisibleScrollingRow = this.displayedBandsInfo.FirstDisplayedScrollingRow; if (rows > 0) { for (int rowCount = rows; rowCount > 0; rowCount--) { deltaY -= this.Rows.SharedRow(newFirstVisibleScrollingRow).GetHeight(newFirstVisibleScrollingRow); newFirstVisibleScrollingRow = this.Rows.GetNextRow(newFirstVisibleScrollingRow, DataGridViewElementStates.Visible); Debug.Assert(newFirstVisibleScrollingRow != -1); } if (newFirstVisibleScrollingRow != -1) { int oldFirstVisibleScrollingRow = this.displayedBandsInfo.FirstDisplayedScrollingRow; // Tentative target value for this.displayedBandsInfo.FirstDisplayedScrollingRow. this.displayedBandsInfo.FirstDisplayedScrollingRow = newFirstVisibleScrollingRow; // This sets the actual value of this.displayedBandsInfo.FirstDisplayedScrollingRow ComputeVisibleRows(); // Compute the actual deltaY given the new this.displayedBandsInfo.FirstDisplayedScrollingRow if (this.displayedBandsInfo.FirstDisplayedScrollingRow > oldFirstVisibleScrollingRow) { deltaY = -this.Rows.GetRowsHeight(DataGridViewElementStates.Visible, oldFirstVisibleScrollingRow, this.displayedBandsInfo.FirstDisplayedScrollingRow); rows = this.Rows.GetRowCount(DataGridViewElementStates.Visible, oldFirstVisibleScrollingRow, this.displayedBandsInfo.FirstDisplayedScrollingRow); } else { Debug.Assert(this.displayedBandsInfo.FirstDisplayedScrollingRow == oldFirstVisibleScrollingRow); rows = 0; } } } else { for (int rowCount = rows; rowCount < 0; rowCount++) { newFirstVisibleScrollingRow = this.Rows.GetPreviousRow(newFirstVisibleScrollingRow, DataGridViewElementStates.Visible, DataGridViewElementStates.Frozen); if (newFirstVisibleScrollingRow != -1) { deltaY += this.Rows.SharedRow(newFirstVisibleScrollingRow).GetHeight(newFirstVisibleScrollingRow); } } if (newFirstVisibleScrollingRow != -1) { this.displayedBandsInfo.FirstDisplayedScrollingRow = newFirstVisibleScrollingRow; ComputeVisibleRows(); Debug.Assert(this.displayedBandsInfo.FirstDisplayedScrollingRow == newFirstVisibleScrollingRow); } } if (newFirstVisibleScrollingRow != -1 && rows != 0) { ScrollRows(rows, deltaY, scrollEventType); } FlushDisplayedChanged(); }
public ScrollEvent(int viewTag, ScrollEventType type, JObject data) : base(viewTag) { _type = type; _data = data; }
// Generate the events when the scrollbar is incremented or decremented private void GenerateManualScrollEvents(int newValue, ScrollEventType type) { ScrollEventArgs se = new ScrollEventArgs(type, newValue); OnScroll(se); // This should be checked. If the value is set back to the previous value, I assume // this prevents an OnValueChanged event. if (se.NewValue != value) { value = se.NewValue; LayoutScrollBar(); OnValueChanged(new EventArgs()); } }
public ScrollEventArgs (ScrollEventType type, int oldValue, int newValue) : this (type, oldValue, newValue, ScrollOrientation.HorizontalScroll) { }
private void ScroolToPosition(ScrollEventType scrollEventType, int newValue) { if (newValue == this.VertScrollBar.Value || newValue <= this.VertScrollBar.Minimum || this.VertScrollBar.Maximum <= newValue) return; this.VertScrollBar.Value = newValue; ScrollEventArgs scrollEventArgs = new ScrollEventArgs(scrollEventType, this.VertScrollBar.Value, newValue); this.HandleScroll(this, scrollEventArgs); }
public MonitorScrollEventArgs(Display monitor, ScrollEventType type, int oldValue, int newValue, ScrollOrientation scroll) : base(type, oldValue, newValue, scroll) { this.monitor = monitor; }
public ScrollEventArgs (ScrollEventType type, int newValue, ScrollOrientation scroll) : this (type, -1, newValue, scroll) { }
public void performScrollVertical(ScrollEventType type) { int param = getSBFromScrollEventType(type); if (param == -1) return; SendMessage(this.Handle, (uint)WM_VSCROLL, (System.UIntPtr)param, (System.IntPtr)0); }
/// <summary>TODO</summary> public void ScrollPanel(ScrollEventType type, ScrollOrientation orientation, int sign) { if (sign != 0) { ScrollProperties scroll; Func<Point, int, int, Point> func; if (orientation == ScrollOrientation.VerticalScroll) { scroll = VerticalScroll; func = (p, sgn, stp) => new Point(-p.X, -p.Y + stp * sgn); } else { scroll = HorizontalScroll; func = (p, sgn, stp) => new Point(-p.X + stp * sgn, -p.Y); } var step = type.HasFlag(ScrollEventType.LargeIncrement) || type.HasFlag(ScrollEventType.LargeDecrement) ? scroll.LargeChange : scroll.SmallChange; var oldValue = scroll.Value; AutoScrollPosition = func(AutoScrollPosition, sign, step); OnScroll(new ScrollEventArgs(type, oldValue, scroll.Value, orientation)); } }
private void SetValue(int value, ScrollEventType type) { value = NormalizeValue(value); #if FRAMEWORK20 OnScroll(new ScrollEventArgs(type, m_Value, value, this.ScrollOrientation)); #else OnScroll(new ScrollEventArgs(type, value)); #endif Value = value; _RaiseEndScroll = true; }
/// <summary> /// This raises the Scroll event, passing in the scrollEventType /// as a parameter to let the handler know what triggered this event. /// </summary> /// <param name="scrollEventType">ScrollEventType</param> internal void RaiseScrollEvent(ScrollEventType scrollEventType) { ScrollEventArgs newEvent = new ScrollEventArgs(scrollEventType, Value); if (Scroll != null) { Scroll(this, newEvent); } }
private void DoScroll(ScrollEventType type) { int newValue = value; int oldValue = value; switch (type) { case ScrollEventType.First: newValue = minimum; break; case ScrollEventType.Last: newValue = maximum - LargeChange + 1; break; case ScrollEventType.SmallDecrement: newValue = Math.Max(value - SmallChange, minimum); break; case ScrollEventType.SmallIncrement: newValue = Math.Min(value + SmallChange, maximum - LargeChange + 1); break; case ScrollEventType.LargeDecrement: newValue = Math.Max(value - LargeChange, minimum); break; case ScrollEventType.LargeIncrement: newValue = Math.Min(value + LargeChange, maximum - LargeChange + 1); break; case ScrollEventType.ThumbPosition: case ScrollEventType.ThumbTrack: Application.Log("not implemented yet"); break; } UpdateScrollRect(); ScrollEventArgs se = new ScrollEventArgs(type, oldValue, newValue, this.scrollOrientation); OnScroll(se); Value = se.NewValue; }
/// <summary> /// This is an instance constructor for the ScrollEventArgs class. It /// is constructed with a reference to the event being raised. /// </summary> /// <returns>Nothing.</returns> public ScrollEventArgs(ScrollEventType scrollEventType, double newValue) : base() { _scrollEventType = scrollEventType; _newValue = newValue; RoutedEvent =ScrollBar.ScrollEvent; }
public ScrollEventArgs(ScrollEventType scrollEventType, double newValue) { }
private void RaiseScrollEvent(ScrollEventType scrollEventType) { RaiseEvent(new ScrollEventArgs(ScrollEvent, this, scrollEventType, Value)); }
private void SetValue(int newValue, ScrollEventType type) { //FieldInfo fi = typeof(System.Windows.Forms.ScrollBar).GetField("value", BindingFlags.NonPublic | BindingFlags.Instance); //if (fi != null) //{ // fi.SetValue(this, newValue); // UpdateSystemScrollInfo(); //} //else if (m_ParentScrollBar.Value == newValue) return; if (m_UseLockWindowUpdate && m_ParentScrollBar.Parent != null) NativeFunctions.LockWindowUpdate(m_ParentScrollBar.Parent.Handle); else NativeFunctions.SendMessage(m_ParentScrollBar.Handle, NativeFunctions.WM_SETREDRAW, 0, 0); m_ParentScrollBarWndProc.SetValue(newValue, type); if (m_UseLockWindowUpdate && m_ParentScrollBar.Parent != null) NativeFunctions.LockWindowUpdate(IntPtr.Zero); else NativeFunctions.SendMessage(m_ParentScrollBar.Handle, NativeFunctions.WM_SETREDRAW, 1, 0); if (m_ParentScrollBar.Parent is DataGridView && type == ScrollEventType.ThumbTrack) { if (m_UseLockWindowUpdate) m_ParentScrollBar.Parent.Refresh(); else { Point p = m_ParentScrollBar.PointToClient(Control.MousePosition); if (!m_ParentScrollBar.ClientRectangle.Contains(p)) m_ParentScrollBar.Parent.Refresh(); } } PaintUsingDC(); }
private void OnScroll(ScrollEventType scrollType, int newValue) { if (Scroll != null) Scroll(this, new ScrollEventArgs(scrollType, newValue)); }
/// <summary> /// This is an instance constructor for the ScrollEventArgs class. It /// is constructed with a reference to the event being raised. /// </summary> /// <returns>Nothing.</returns> public ScrollEventArgs(ScrollEventType scrollEventType, double newValue) : base() { _scrollEventType = scrollEventType; _newValue = newValue; RoutedEvent = ScrollBar.ScrollEvent; }