public virtual bool EnsureRowVisible(GridViewRowInfo rowInfo)
{
if (rowInfo.ViewInfo != this.ViewInfo || rowInfo.ViewInfo == this.MasterViewInfo && rowInfo.PinPosition != PinnedRowPosition.None || (!this.TableElement.ElementTree.Control.Visible && !(this.TableElement.ElementTree.Control is MultiColumnComboGridView) || (this.TableElement.ElementTree.Control.Size == Size.Empty || (SizeF)this.TableElement.Size == SizeF.Empty)))
{
return(false);
}
if (this.TableElement.MasterTemplate != null && this.TableElement.MasterTemplate.EnablePaging)
{
int pageIndex = this.TableElement.MasterTemplate.PageIndex;
if (this.TableElement.MasterTemplate.EnableGrouping && this.TableElement.MasterTemplate.GroupDescriptors.Count > 0)
{
int num = -2;
IEnumerator enumerator = (IEnumerator) new PagedGroupedTraverser(((RadDataView <GridViewRowInfo>) this.TableElement.MasterTemplate.DataView).GroupBuilder.Groups.GroupList);
while (enumerator.MoveNext())
{
GridViewGroupRowInfo current = enumerator.Current as GridViewGroupRowInfo;
if (current != null && current.GroupLevel == 0)
{
++num;
}
if (enumerator.Current == rowInfo)
{
break;
}
}
if (num >= 0)
{
pageIndex = num / this.TableElement.MasterTemplate.PageSize;
}
}
else
{
pageIndex = this.TableElement.ViewTemplate.DataView.GetItemPage(rowInfo);
}
if (pageIndex != this.TableElement.MasterTemplate.PageIndex && !(rowInfo is GridViewNewRowInfo))
{
this.TableElement.MasterTemplate.MoveToPage(pageIndex);
this.TableElement.ViewElement.UpdateRows(true);
if (this.TableElement.GridViewElement != null)
{
this.GridViewElement.PagingPanelElement.UpdateView();
}
}
}
this.UpdateLayout();
GridViewDetailsRowInfo viewDetailsRowInfo = rowInfo as GridViewDetailsRowInfo;
if (viewDetailsRowInfo == null)
{
return(this.EnsureRowVisibleCore(rowInfo));
}
RadScrollBarElement vScrollBar = this.UseScrollbarsInHierarchy ? this.VScrollBar : this.MasterVScrollBar;
if (this.GetRowElement((GridViewRowInfo)viewDetailsRowInfo) is GridDetailViewRowElement || !this.EnsureRowVisibleByTraverser(vScrollBar, (GridViewRowInfo)viewDetailsRowInfo, (float)vScrollBar.SmallChange))
{
return(false);
}
this.UpdateLayout();
return(true);
}
protected virtual void EnsureRowVisibilityAtBottom(
GridViewRowInfo rowInfo,
bool isLastRow,
RectangleF rowRect,
RectangleF innerClientRect,
ref RadScrollBarElement vericalScrollBar,
ref int scrollValue)
{
RadScrollBarElement hscrollBar = this.TableElement.HScrollBar;
Rectangle boundingRectangle = hscrollBar.ControlBoundingRectangle;
Size size1 = this.TableElement.Size;
Size size2 = this.ViewElement.TopPinnedRows.Size;
int initialDeltaAtBottom = this.GetInitialDeltaAtBottom(size1);
int num = (int)((double)rowRect.Bottom - (double)innerClientRect.Bottom);
if (size1.Height == 0 || size1.Height + this.TableElement.RowSpacing <= size2.Height || (double)size1.Height - (double)rowRect.Height + (double)num == (double)size2.Height)
{
vericalScrollBar = this.UseScrollbarsInHierarchy ? this.ParentVScrollBar : this.MasterVScrollBar;
scrollValue = vericalScrollBar.Value;
if (this.IsScrollBarVisible(hscrollBar))
{
initialDeltaAtBottom += boundingRectangle.Size.Height;
}
}
else if (this.IsScrollBarVisible(hscrollBar))
{
initialDeltaAtBottom += (int)((double)innerClientRect.Bottom - (double)boundingRectangle.Top);
}
else if (this.IsScrollBarVisible(this.ParentHScrollBar))
{
initialDeltaAtBottom += (int)((double)innerClientRect.Bottom - (double)this.ParentHScrollBar.ControlBoundingRectangle.Top);
}
this.EnsureScrollingDelta(rowInfo, isLastRow, ref initialDeltaAtBottom);
scrollValue += num + initialDeltaAtBottom;
}
protected override void CreateChildElements()
{
this.containerVersionNumber = -1;
this.synchronizationPropertiesVersionNumber = -1;
base.CreateChildElements();
this.DrawText = false;
this.DrawImage = false;
this.ClipDrawing = true;
this.Padding = new Padding(10);
this.layoutContainer = this.CreateLayoutConatiner();
this.Children.Add((RadElement)this.layoutContainer);
this.horizontalScrollBar = this.CreateScrollBarElement();
this.horizontalScrollBar.ScrollType = ScrollType.Horizontal;
this.horizontalScrollBar.Minimum = 0;
this.horizontalScrollBar.ZIndex = 1000;
this.horizontalScrollBar.ThemeRole = "RadScrollBarElement";
this.horizontalScrollBar.MinSize = new Size(0, RadScrollBarElement.HorizontalScrollBarHeight);
this.horizontalScrollBar.ScrollTimerDelay = 1;
this.horizontalScrollBar.Visibility = ElementVisibility.Collapsed;
this.horizontalScrollBar.ValueChanged += new EventHandler(this.HorizontalScrollBar_ValueChanged);
this.Children.Add((RadElement)this.horizontalScrollBar);
this.verticalScrollBar = this.CreateScrollBarElement();
this.verticalScrollBar.ScrollType = ScrollType.Vertical;
this.verticalScrollBar.Minimum = 0;
this.verticalScrollBar.ZIndex = 1000;
this.verticalScrollBar.ThemeRole = "RadScrollBarElement";
this.verticalScrollBar.MinSize = new Size(RadScrollBarElement.VerticalScrollBarWidth, 0);
this.verticalScrollBar.ScrollTimerDelay = 1;
this.verticalScrollBar.Visibility = ElementVisibility.Collapsed;
this.verticalScrollBar.ValueChanged += new EventHandler(this.VerticalScrollBar_ValueChanged);
this.Children.Add((RadElement)this.verticalScrollBar);
}
protected virtual bool TryEnsureRowVisibilityByTraverser(
GridViewRowInfo rowInfo,
bool isLastRow,
RadScrollBarElement verticalScrollBar,
ScrollableRowsContainerElement scrollableRows,
out GridRowElement row,
out bool isTraverserd)
{
int num = verticalScrollBar.Maximum - verticalScrollBar.LargeChange + 1;
if (isLastRow && num != verticalScrollBar.Value)
{
this.ChangeScrollbarValue(verticalScrollBar, num);
this.UpdateLayout();
}
row = this.GetRowElement(rowInfo);
isTraverserd = false;
if (row != null)
{
return(false);
}
int height = (int)this.RowScroller.ElementProvider.GetElementSize(rowInfo).Height;
this.EnsureScrollingDelta(rowInfo, isLastRow, ref height);
if (this.UseScrollbarsInHierarchy && scrollableRows.Children.Count > 0)
{
GridDetailViewRowElement child = scrollableRows.Children[scrollableRows.Children.Count - 1] as GridDetailViewRowElement;
height += child != null ? child.RowInfo.Height - child.Size.Height : 0;
}
isTraverserd = this.EnsureRowVisibleByTraverser(verticalScrollBar, rowInfo, (float)height);
return(true);
}
private bool EnsureRowVisibleByTraverserDown(
RadScrollBarElement vScrollBar,
GridViewRowInfo rowInfo,
ScrollableRowsContainerElement rows,
float delta)
{
GridRowElement child = (GridRowElement)rows.Children[rows.Children.Count - 1];
GridTraverser enumerator = (GridTraverser)((IEnumerable)this.RowScroller).GetEnumerator();
while (enumerator.Current is GridViewDetailsRowInfo)
{
enumerator.MoveNext();
}
enumerator.MovePrevious();
if (enumerator.Current == rowInfo)
{
return(this.ChangeScrollbarValue(vScrollBar, vScrollBar.Value - (int)delta));
}
do
{
;
}while (enumerator.MoveNext() && enumerator.Current != child.RowInfo);
enumerator.MoveNext();
if (enumerator.Current == rowInfo)
{
return(this.ChangeScrollbarValue(vScrollBar, vScrollBar.Value + (int)delta));
}
return(false);
}
protected override void CreateChildElements()
{
this.horizontalScrollBar = new RadScrollBarElement();
this.horizontalScrollBar.ScrollType = ScrollType.Horizontal;
this.horizontalScrollBar.Visibility = ElementVisibility.Collapsed;
this.horizontalScrollBar.Minimum = 0;
this.horizontalScrollBar.ZIndex = 1000;
this.horizontalScrollBar.Class = "ScrollPanelHorizontalScrollBar";
this.horizontalScrollBar.ThemeRole = "RadScrollBarElement";
this.Children.Add(this.horizontalScrollBar);
this.verticalScrollBar = new RadScrollBarElement();
this.verticalScrollBar.ScrollType = ScrollType.Vertical;
this.verticalScrollBar.Visibility = ElementVisibility.Collapsed;
this.verticalScrollBar.Minimum = 0;
this.verticalScrollBar.ZIndex = 1000;
this.verticalScrollBar.Class = "ScrollPanelVerticalScrollBar";
this.verticalScrollBar.ThemeRole = "RadScrollBarElement";
this.Children.Add(this.verticalScrollBar);
this.blankSpot = new FillPrimitive();
this.blankSpot.Class = "ScrollPanelBlankSpotFill";
this.blankSpot.Visibility = ElementVisibility.Collapsed;
this.blankSpot.ZIndex = 1000;
this.blankSpot.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
this.Children.Add(this.blankSpot);
this.horizontalScrollBar.Scroll += OnHScroll;
this.verticalScrollBar.Scroll += OnVScroll;
this.horizontalScrollBar.ScrollParameterChanged += new EventHandler(OnScrollBarParameterChanged);
this.verticalScrollBar.ScrollParameterChanged += new EventHandler(OnScrollBarParameterChanged);
}
protected virtual bool EnsureRowVisibleCore(GridViewRowInfo rowInfo)
{
bool isTraverserd = false;
bool isLastRow = false;
bool isFirstRow = false;
GridRowElement row = this.GetRowElement(rowInfo);
this.DetermineScrollableRowPosition(rowInfo, out isFirstRow, out isLastRow);
ScrollableRowsContainerElement scrollableRows = this.ViewElement.ScrollableRows;
RadScrollBarElement vericalScrollBar = this.UseScrollbarsInHierarchy ? this.VScrollBar : this.MasterVScrollBar;
if (row == null && this.TryEnsureRowVisibilityByTraverser(rowInfo, isLastRow, vericalScrollBar, scrollableRows, out row, out isTraverserd))
{
return(isTraverserd);
}
RectangleF boundingRectangle1 = (RectangleF)this.MasterTableElement.ViewElement.ScrollableRows.ControlBoundingRectangle;
RectangleF innerClientRectangle = this.GetInnerClientRectangle(rowInfo);
Rectangle boundingRectangle2 = row.ControlBoundingRectangle;
int scrollValue = vericalScrollBar.Value;
if (this.GridViewElement.SplitMode != RadGridViewSplitMode.None && this.MasterTableElement != row.TableElement)
{
return(false);
}
if ((double)boundingRectangle2.Bottom > (double)boundingRectangle1.Bottom || (double)boundingRectangle2.Bottom > (double)innerClientRectangle.Bottom)
{
this.EnsureRowVisibilityAtBottom(rowInfo, isLastRow, (RectangleF)boundingRectangle2, innerClientRectangle, ref vericalScrollBar, ref scrollValue);
}
else if ((double)boundingRectangle2.Y < (double)boundingRectangle1.Y || this.ParentHScrollBar.Visibility == ElementVisibility.Visible && this.ParentHScrollBar.ControlBoundingRectangle.IntersectsWith(boundingRectangle2) || this.UseScrollbarsInHierarchy && (double)boundingRectangle2.Y < (double)innerClientRectangle.Y)
{
this.EnsureRowVisibilityAtTop((RectangleF)boundingRectangle2, boundingRectangle1, innerClientRectangle, ref vericalScrollBar, ref scrollValue);
}
return(this.ChangeScrollbarValue(vericalScrollBar, scrollValue));
}
private void ScrollColumns(GridTableElement tableElement, Point location)
{
GridTableHeaderRowElement rowElement = tableElement.GetRowElement((GridViewRowInfo)tableElement.ViewInfo.TableHeaderRow) as GridTableHeaderRowElement;
if (rowElement == null)
{
return;
}
Rectangle boundingRectangle1 = rowElement.ControlBoundingRectangle;
Rectangle boundingRectangle2 = rowElement.ScrollableColumns.ControlBoundingRectangle;
int num = 0;
if (location.X > boundingRectangle2.Right)
{
num = location.X - boundingRectangle2.Right;
}
else if (location.X < boundingRectangle2.X)
{
num = location.X - boundingRectangle2.X;
}
RadScrollBarElement hscrollBar = tableElement.HScrollBar;
if (tableElement.RightToLeft)
{
num *= -1;
}
if (num == 0 || hscrollBar.Visibility != ElementVisibility.Visible)
{
return;
}
hscrollBar.Value = this.ClampValue(hscrollBar.Value + num, hscrollBar.Minimum, hscrollBar.Maximum - hscrollBar.LargeChange + 1);
}
protected virtual bool UpdateOnMeasure(SizeF availableSize)
{
RectangleF clientRectangle = this.GetClientRectangle(availableSize);
RadScrollBarElement scrollBarElement1 = this.HScrollBar;
RadScrollBarElement scrollBarElement2 = this.VScrollBar;
if (this.Orientation == Orientation.Horizontal)
{
scrollBarElement1 = this.VScrollBar;
scrollBarElement2 = this.HScrollBar;
}
ElementVisibility visibility = scrollBarElement1.Visibility;
if (this.FitItemsToSize)
{
this.HScrollBar.Visibility = ElementVisibility.Collapsed;
}
else
{
scrollBarElement1.LargeChange = (int)((double)clientRectangle.Width - (double)scrollBarElement2.DesiredSize.Width - (double)this.ViewElement.Margin.Horizontal);
scrollBarElement1.SmallChange = scrollBarElement1.LargeChange / 10;
scrollBarElement1.Visibility = scrollBarElement1.LargeChange < scrollBarElement1.Maximum ? ElementVisibility.Visible : ElementVisibility.Collapsed;
}
SizeF size = clientRectangle.Size;
if (this.HScrollBar.Visibility == ElementVisibility.Visible)
{
size.Height -= this.HScrollBar.DesiredSize.Height;
}
this.scroller.ClientSize = size;
return(visibility != scrollBarElement1.Visibility);
}
private void ScrollRows(GridTableElement tableElement, Point location)
{
ScrollableRowsContainerElement scrollableRows = tableElement.ViewElement.ScrollableRows;
RadScrollBarElement veritcalScrollbar = this.GetVeritcalScrollbar(tableElement);
Rectangle boundingRectangle = scrollableRows.ControlBoundingRectangle;
if (boundingRectangle.Contains(location) || location.X < boundingRectangle.X || location.X > boundingRectangle.Right)
{
return;
}
int num = 0;
if (location.Y > boundingRectangle.Bottom)
{
num = location.Y - boundingRectangle.Bottom;
}
else if (location.Y < boundingRectangle.Y)
{
num = location.Y - boundingRectangle.Y;
}
if (num == 0 || veritcalScrollbar.Visibility != ElementVisibility.Visible)
{
return;
}
veritcalScrollbar.Value = this.ClampValue(veritcalScrollbar.Value + num, veritcalScrollbar.Minimum, veritcalScrollbar.Maximum - veritcalScrollbar.LargeChange + 1);
}
private void scrollTimer_Tick(object sender, EventArgs e)
{
if (this.scrollDelta == 0 || this.tableElement == null)
{
return;
}
RadScrollBarElement scrollBarElement = Control.ModifierKeys != Keys.Shift ? this.tableElement.VScrollBar : this.tableElement.HScrollBar;
int num = scrollBarElement.Value + this.scrollDelta;
if (num < scrollBarElement.Minimum)
{
num = scrollBarElement.Minimum;
}
else if (num > scrollBarElement.Maximum - scrollBarElement.LargeChange + 1)
{
num = scrollBarElement.Maximum - scrollBarElement.LargeChange + 1;
}
if (scrollBarElement.LargeChange > 0)
{
scrollBarElement.Value = num;
}
if (this.scrollReason == BaseGridBehavior.ScrollReason.PageUp)
{
this.NavigateToPage(this.GetFirstScrollableRow(this.tableElement, true), Keys.None);
}
else if (this.scrollReason == BaseGridBehavior.ScrollReason.PageDown)
{
this.NavigateToPage(this.GetLastScrollableRow(this.tableElement), Keys.None);
this.GridViewElement.TableElement.RowScroller.UpdateScrollRange();
}
this.scrollReason = BaseGridBehavior.ScrollReason.MouseWheel;
this.scrollDelta = 0;
this.scrollTimer.Stop();
}
protected override void OnMouseWheel(MouseEventArgs e)
{
RadScrollLayoutPanel scrollLayoutPanel = this.ColumnChooserElement.ScrollViewer.ScrollLayoutPanel;
RadScrollBarElement verticalScrollBar = scrollLayoutPanel.VerticalScrollBar;
if (verticalScrollBar.Visibility == ElementVisibility.Visible)
{
int num1 = Math.Max(1, e.Delta / SystemInformation.MouseWheelScrollDelta);
int num2 = Math.Sign(e.Delta) * num1 * SystemInformation.MouseWheelScrollLines;
int ypos = verticalScrollBar.Value - num2 * verticalScrollBar.SmallChange;
if (ypos > verticalScrollBar.Maximum - verticalScrollBar.LargeChange + 1)
{
ypos = verticalScrollBar.Maximum - verticalScrollBar.LargeChange + 1;
}
if (ypos < verticalScrollBar.Minimum)
{
ypos = 0;
}
else if (ypos > verticalScrollBar.Maximum)
{
ypos = verticalScrollBar.Maximum;
}
if (ypos != verticalScrollBar.Value)
{
scrollLayoutPanel.ScrollTo(0, ypos);
HandledMouseEventArgs handledMouseEventArgs = e as HandledMouseEventArgs;
if (handledMouseEventArgs != null)
{
handledMouseEventArgs.Handled = true;
}
}
}
base.OnMouseWheel(e);
}
protected virtual bool UpdateOnMeasure(SizeF availableSize)
{
RectangleF clientRect = GetClientRectangle(availableSize);
RadScrollBarElement hscrollbar = this.HScrollBar;
RadScrollBarElement vscrollbar = this.VScrollBar;
if (this.Orientation == Orientation.Horizontal)
{
hscrollbar = this.VScrollBar;
vscrollbar = this.HScrollBar;
}
ElementVisibility visibility = hscrollbar.Visibility;
if (FitItemsToSize)
{
HScrollBar.Visibility = ElementVisibility.Collapsed;
}
else
{
hscrollbar.LargeChange = (int)(clientRect.Width - vscrollbar.DesiredSize.Width - this.ViewElement.Margin.Horizontal);
hscrollbar.SmallChange = hscrollbar.LargeChange / 10;
hscrollbar.Visibility = hscrollbar.LargeChange < hscrollbar.Maximum ? ElementVisibility.Visible : ElementVisibility.Collapsed;
}
SizeF clientSize = clientRect.Size;
if (HScrollBar.Visibility == ElementVisibility.Visible)
{
clientSize.Height -= HScrollBar.DesiredSize.Height;
}
this.scroller.ClientSize = clientSize;
return(visibility != hscrollbar.Visibility);
}
private void radMenuItem5_Click(object sender, EventArgs e)
{
RadScrollBarElement scrollbar = new RadScrollBarElement();
surface1.Element.Children.Add(new SurfaceObject(10, 10, scrollbar));
radButtonRemove.Enabled = true;
surface1.Element.CurrentObject = (SurfaceObject)surface1.Element.Children[surface1.Element.Children.Count - 1];
}
public ScrollService(RadElement owner, RadScrollBarElement scrollBar)
{
this.owner = owner;
this.scrollBar = scrollBar;
this.timer = new Timer();
this.timer.Interval = 5;
this.timer.Tick += new EventHandler(timer_Tick);
}
private bool IsScrollBarVisible(RadScrollBarElement scrollBar)
{
if (scrollBar.Visibility != ElementVisibility.Visible)
{
return(false);
}
return(this.MasterTableElement.ViewElement.ScrollableRows.ControlBoundingRectangle.IntersectsWith(scrollBar.ControlBoundingRectangle));
}
private int GetScrollBarValue(RadScrollBarElement scrollBar)
{
if (scrollBar.Visibility == ElementVisibility.Visible)
{
return(scrollBar.Value);
}
return(scrollBar.Minimum);
}
protected virtual void OnScrollParametersChanged(RadScrollBarElement scrollBar)
{
if (scrollBar == null || this.ScrollParametersChanged == null)
{
return;
}
this.ScrollParametersChanged((object)this, new RadPanelScrollParametersEventArgs(scrollBar.ScrollType == ScrollType.Horizontal, scrollBar.GetParameters()));
}
protected virtual void OnScrollParametersChanged(RadScrollBarElement scrollBar)
{
if (scrollBar != null && ScrollParametersChanged != null)
{
ScrollParametersChanged(this, new RadPanelScrollParametersEventArgs(
scrollBar.ScrollType == ScrollType.Horizontal, scrollBar.GetParameters()));
}
}
private void SetPosition(MouseEventArgs e, bool dragging)
{
RadScrollBarElement scrollBar = this.Parent as RadScrollBarElement;
if (scrollBar != null)
{
scrollBar.SetThumbPosition(GetNewLocation(e), dragging);
}
}
protected override void CreateChildItems(RadElement parent)
{
base.CreateChildItems((RadElement)this.scrollBar);
this.scrollBar = this.CreateScrollBarElement();
this.scrollBar.ScrollType = this.ScrollType;
this.scrollBar.Scroll += new ScrollEventHandler(this.scrollBar_Scroll);
this.scrollBar.ValueChanged += new EventHandler(this.scrollBar_ValueChanged);
this.scrollBar.ScrollParameterChanged += new EventHandler(this.scrollBar_ScrollParameterChanged);
this.RootElement.Children.Add((RadElement)this.scrollBar);
}
public virtual bool ScrollToCaret()
{
TextBoxControlCaret caret = this.TextBoxElement.Caret;
RadScrollBarElement hscrollBar = this.textBoxElement.HScrollBar;
RadScrollBarElement vscrollBar = this.textBoxElement.VScrollBar;
if (caret == null || this.CaretPosition == (TextPosition)null)
{
vscrollBar.Value = vscrollBar.Minimum;
hscrollBar.Value = hscrollBar.Minimum;
return(false);
}
RectangleF boundingRectangle = (RectangleF)caret.ControlBoundingRectangle;
RectangleF viewportBounds = (RectangleF)this.TextBoxElement.ViewElement.ViewportBounds;
float num1 = 0.0f;
float num2 = 0.0f;
LineInfo line = this.CaretPosition.Line;
ITextBlock textBlock = this.CaretPosition.TextBlock;
int charPosition = this.CaretPosition.CharPosition;
if (textBlock == line.StartBlock && charPosition == 0)
{
num1 = (float)(hscrollBar.Minimum - hscrollBar.Value);
}
else if ((double)boundingRectangle.X > (double)viewportBounds.Right || (double)boundingRectangle.X < (double)viewportBounds.Left)
{
num1 = boundingRectangle.X - viewportBounds.X - viewportBounds.Width / 2f;
}
this.SetScrollBarValue(hscrollBar, hscrollBar.Value + (int)num1);
if (this.textBoxElement.Multiline)
{
if (line == this.textBoxElement.ViewElement.Lines.FirstLine)
{
num2 = (float)(vscrollBar.Minimum - vscrollBar.Value);
}
else if (line == this.textBoxElement.ViewElement.Lines.LastLine)
{
int num3 = this.textBoxElement.ViewElement.VScroller.MaxValue - 1;
if (num3 != 0)
{
num2 = (float)(num3 - vscrollBar.Value + 1);
}
}
else if ((double)boundingRectangle.Top < (double)viewportBounds.Top)
{
num2 = boundingRectangle.Top - viewportBounds.Top;
}
else if ((double)boundingRectangle.Bottom > (double)viewportBounds.Bottom)
{
num2 = boundingRectangle.Bottom - viewportBounds.Bottom;
}
this.SetScrollBarValue(vscrollBar, vscrollBar.Value + (int)num2);
}
return(true);
}
protected void SetScrollValue(RadScrollBarElement scrollbar, int newValue)
{
if (newValue > scrollbar.Maximum - scrollbar.LargeChange + 1)
{
newValue = scrollbar.Maximum - scrollbar.LargeChange + 1;
}
if (newValue < scrollbar.Minimum)
{
newValue = scrollbar.Minimum;
}
scrollbar.Value = newValue;
}
protected override void CreateChildElements()
{
base.CreateChildElements();
this.itemsLayout = new StackLayoutPanel();
this.Children.Add((RadElement)this.itemsLayout);
this.scrollBar = new RadScrollBarElement();
this.scrollBar.ScrollType = ScrollType.Horizontal;
this.scrollBar.ValueChanged += new EventHandler(this.scrollBar_ValueChanged);
this.Children.Add((RadElement)this.scrollBar);
this.scrollService = new ScrollService((RadElement)this, this.scrollBar);
this.scrollService.EnableInertia = true;
}
public TextBoxScroller(RadScrollBarElement scrollBar)
{
this.scrollBar = scrollBar;
this.scrollBar.ClampValue = true;
this.scrollBar.ValueChanged += new EventHandler(this.OnScrollBarValueChanged);
this.scrollBar.Scroll += new ScrollEventHandler(this.OnScrollBarScroll);
this.scrollBar.Visibility = ElementVisibility.Collapsed;
this.thumbTimer = new Timer();
this.thumbTimer.Interval = 10;
this.thumbTimer.Enabled = false;
this.thumbTimer.Tick += new EventHandler(this.OnThumbTimerTick);
this.scrollState = ScrollState.AutoHide;
}
protected override void CreateChildElements()
{
base.CreateChildElements();
this.Header.RadPropertyChanged += this.OnNCElement_PropertyChanged;
this.Footer.RadPropertyChanged += this.OnNCElement_PropertyChanged;
this.scrollbar = new RadScrollBarElement();
this.scrollbar.Visibility = ElementVisibility.Collapsed;
this.scrollbar.ScrollType = ScrollType.Vertical;
this.scrollbar.Scroll += this.OnScrollbar_Scroll;
this.scrollbar.SmallChange = 5;
this.scrollbar.ZIndex = 3;
this.Children.Add(this.scrollbar);
}
protected bool ChangeScrollbarValue(RadScrollBarElement scrollbar, int value)
{
if (value > scrollbar.Maximum - scrollbar.LargeChange + 1)
{
value = scrollbar.Maximum - scrollbar.LargeChange + 1;
}
if (value < scrollbar.Minimum || value > scrollbar.Maximum)
{
return(false);
}
scrollbar.Value = value;
return(true);
}
protected virtual bool EnsureRowVisibleByTraverser(
RadScrollBarElement vScrollBar,
GridViewRowInfo rowInfo,
float delta)
{
ScrollableRowsContainerElement scrollableRows = this.ViewElement.ScrollableRows;
RadElementCollection children = scrollableRows.Children;
int num1 = vScrollBar.Maximum - vScrollBar.LargeChange + 1;
while (vScrollBar.Maximum != 0 && children.Count == 0)
{
this.ChangeScrollbarValue(vScrollBar, vScrollBar.Value + 1);
this.UpdateLayout();
if (scrollableRows.Children.Count > 0 || vScrollBar.Value == num1 || vScrollBar.Value == vScrollBar.Maximum)
{
break;
}
}
if (children.Count == 0)
{
return(false);
}
if (this.EnsureRowVisibleByTraverserDown(vScrollBar, rowInfo, scrollableRows, delta))
{
return(true);
}
GridRowElement child = (GridRowElement)scrollableRows.Children[0];
if (((GridTraverser)((IEnumerable)this.RowScroller).GetEnumerator()).Current == rowInfo)
{
int num2 = vScrollBar.Value - (int)delta;
if (num2 < vScrollBar.Minimum)
{
num2 = vScrollBar.Minimum;
}
else if (num2 > vScrollBar.Maximum)
{
num2 = vScrollBar.Maximum;
}
return(this.ChangeScrollbarValue(vScrollBar, num2));
}
GridViewGroupRowInfo parent = rowInfo.Parent as GridViewGroupRowInfo;
if (parent != null && !parent.IsExpanded)
{
return(false);
}
return(this.RowScroller.ScrollToItem(rowInfo, false));
}
private void SetScrollBarValue(RadScrollBarElement scrollBar, int value)
{
int minimum = scrollBar.Minimum;
int num = scrollBar.Maximum - scrollBar.LargeChange + 1;
if (value > num)
{
value = num;
}
if (value < minimum)
{
value = minimum;
}
scrollBar.Value = value;
}
/// <summary>
/// Scroll to Top of RadChat Conversation
/// </summary>
/// <param name="radchat">RadChat Control</param>
public void ScrollToTop(RadChat radchat)
{
RadScrollBarElement scrollbar = radchat.ChatElement.MessagesViewElement.Scroller.Scrollbar;
scrollbar.Value = 0;
while (scrollbar.Value < scrollbar.Maximum - scrollbar.LargeChange + 1)
{
scrollbar.PerformSmallIncrement(-1);
radchat.ChatElement.MessagesViewElement.Scroller.UpdateScrollRange();
Application.DoEvents();
}
scrollbar.PerformLast();
}
