protected override SizeF ArrangeOverride(SizeF finalSize)
{
InitializeOffset();
foreach (RadElement element in this.Children)
{
if (this.orientation == Orientation.Vertical)
{
IVirtualizedElement <T> virtualizedElement = (IVirtualizedElement <T>)element;
float width = FitElementsToSize /*|| element.StretchHorizontally*/ ? finalSize.Width : element.DesiredSize.Width;
float height = ElementProvider.GetElementSize(virtualizedElement.Data).Height;
RectangleF arrangeRect = new RectangleF(ScrollOffset.Width, offset, width, height);
if (RightToLeft)
{
arrangeRect.X = finalSize.Width - width;
}
arrangeRect = ArrangeElementCore(element, finalSize, arrangeRect);
offset += arrangeRect.Height + ItemSpacing;
}
else
{
float height = FitElementsToSize || element.StretchVertically ? finalSize.Height : element.DesiredSize.Height;
RectangleF arrangeRect = ArrangeElementCore(element, finalSize, new RectangleF(offset, 0, element.DesiredSize.Width, height));
offset += arrangeRect.Width + ItemSpacing;
}
}
return(finalSize);
}
public override bool ShouldUpdate(
IVirtualizedElement <RadListDataItem> element,
RadListDataItem data,
object context)
{
return(base.ShouldUpdate(element, data, context));
}
protected override bool MeasureElement(IVirtualizedElement <T> element)
{
RadElement radElement = element as RadElement;
if (radElement == null)
{
return(false);
}
SizeF elementDesiredSize = MeasureElementCore(radElement, availableSize);
bool continueMeasure = true;
if (this.orientation == Orientation.Vertical)
{
continueMeasure = availableSize.Height > elementDesiredSize.Height;
float height = elementDesiredSize.Height + ItemSpacing;
availableSize.Height -= height;
desiredSize.Height += height;
desiredSize.Width = Math.Max(desiredSize.Width, elementDesiredSize.Width);
return(continueMeasure);
}
continueMeasure = availableSize.Width > elementDesiredSize.Width;
float width = elementDesiredSize.Width + ItemSpacing;
availableSize.Width -= width;
desiredSize.Width += width;
desiredSize.Height = Math.Max(desiredSize.Height, elementDesiredSize.Height);
return(continueMeasure);
}
protected virtual SizeF MeasureElementCore(RadElement element, SizeF availableSize)
{
IVirtualizedElement <T> virtualizedElement = (IVirtualizedElement <T>)element;
SizeF fixedSize = ElementProvider.GetElementSize(virtualizedElement.Data);
if (Orientation == System.Windows.Forms.Orientation.Vertical)
{
if (fixedSize.Height > 0)
{
availableSize.Height = fixedSize.Height;
}
if (!FitElementsToSize)
{
availableSize.Width = float.PositiveInfinity;
}
}
else
{
availableSize.Width = fixedSize.Width;
if (!FitElementsToSize)
{
availableSize.Height = float.PositiveInfinity;
}
}
element.Measure(availableSize);
return(element.DesiredSize);
}
public override bool IsCompatible(
IVirtualizedElement <RadTreeNode> element,
RadTreeNode data,
object context)
{
return(base.IsCompatible(element, data, context));
}
protected virtual void MeasureElements()
{
int position = 0;
foreach (T data in DataProvider)
{
if (!IsItemVisible(data))
{
continue;
}
IVirtualizedElement <T> element = UpdateElement(position, data);
if (element == null)
{
continue;
}
position++;
if (!MeasureElement(element))
{
break;
}
}
while (position < this.Children.Count)
{
RemoveElement(position);
}
}
protected override bool BeginMeasure(System.Drawing.SizeF availableSize)
{
this.SuspendThemeRefresh();
foreach (ListViewDataItem data in DataProvider)
{
if (data.IsMeasureValid)
{
continue;
}
IVirtualizedElement <ListViewDataItem> element = UpdateElement(data is ListViewDataItemGroup ? 1 : 0, data);
RadElement radElement = element as RadElement;
if (radElement != null)
{
radElement.InvalidateMeasure();
radElement.Measure(availableSize);
}
}
this.owner.Owner.IsItemsMeasureValid = true;
this.ResumeThemeRefresh();
owner.Scroller.UpdateScrollRange();
return(base.BeginMeasure(availableSize));
}
protected override SizeF ArrangeOverride(SizeF finalSize)
{
this.InitializeOffset();
foreach (RadElement child in this.Children)
{
if (this.orientation == Orientation.Vertical)
{
IVirtualizedElement <T> virtualizedElement = (IVirtualizedElement <T>)child;
float width = this.FitElementsToSize ? finalSize.Width : child.DesiredSize.Width;
float height = this.ElementProvider.GetElementSize(virtualizedElement.Data).Height;
RectangleF arrangeRect = new RectangleF(this.ScrollOffset.Width, this.offset, width, height);
if (this.RightToLeft)
{
arrangeRect.X = finalSize.Width - width;
}
arrangeRect = this.ArrangeElementCore(child, finalSize, arrangeRect);
this.offset += arrangeRect.Height + (float)this.ItemSpacing;
}
else
{
float height = this.FitElementsToSize || child.StretchVertically ? finalSize.Height : child.DesiredSize.Height;
this.offset += this.ArrangeElementCore(child, finalSize, new RectangleF(this.offset, 0.0f, child.DesiredSize.Width, height)).Width + (float)this.ItemSpacing;
}
}
return(finalSize);
}
protected override bool MeasureElement(IVirtualizedElement <T> element)
{
RadElement element1 = element as RadElement;
if (element1 == null)
{
return(false);
}
SizeF sizeF = this.MeasureElementCore(element1, this.availableSize);
if (this.orientation == Orientation.Vertical)
{
bool flag = (double)this.availableSize.Height > (double)sizeF.Height;
float num = sizeF.Height + (float)this.ItemSpacing;
this.availableSize.Height -= num;
this.desiredSize.Height += num;
this.desiredSize.Width = Math.Max(this.desiredSize.Width, sizeF.Width);
return(flag);
}
bool flag1 = (double)this.availableSize.Width > 0.0;
float num1 = sizeF.Width + (float)this.ItemSpacing;
this.availableSize.Width -= num1;
this.desiredSize.Width += num1;
this.desiredSize.Height = Math.Max(this.desiredSize.Height, sizeF.Height);
return(flag1);
}
public IVirtualizedElement <int> GetElement(int data, object context)
{
bool flag = this.owner.IsRowExpanded(data);
IVirtualizedElement <int> virtualizedElement = (IVirtualizedElement <int>)null;
for (int index = this.cachedRows.Count - 1; index >= 0; --index)
{
if ((!flag && !this.cachedRows[index].IsChildViewInitialized || flag && this.cachedRows[index].IsChildViewInitialized) && this.cachedRows[index].IsCompatible(data, context))
{
virtualizedElement = (IVirtualizedElement <int>) this.cachedRows[index];
this.cachedRows.RemoveAt(index);
break;
}
}
if (virtualizedElement == null && this.cachedRows.Count > 10)
{
for (int index = this.cachedRows.Count - 1; index >= 0; --index)
{
if (this.cachedRows[index].IsCompatible(data, context))
{
virtualizedElement = (IVirtualizedElement <int>) this.cachedRows[index];
this.cachedRows.RemoveAt(index);
break;
}
}
}
if (virtualizedElement == null)
{
VirtualGridRowElement element;
switch (data)
{
case -3:
element = this.CreateElement(data, typeof(VirtualGridFilterRowElement), context);
element.Initialize(this.owner);
element.Attach(-3, context);
break;
case -2:
element = this.CreateElement(data, typeof(VirtualGridNewRowElement), context);
element.Initialize(this.owner);
element.Attach(-2, context);
break;
case -1:
element = this.CreateElement(data, typeof(VirtualGridHeaderRowElement), context);
element.Initialize(this.owner);
element.Attach(-1, context);
break;
default:
element = this.CreateElement(data, typeof(VirtualGridRowElement), context);
element.Initialize(this.owner);
break;
}
return((IVirtualizedElement <int>)element);
}
virtualizedElement.Attach(data, context);
return(virtualizedElement);
}
public virtual bool ShouldUpdate(IVirtualizedElement <T> element, T data, object context)
{
if (element.Data.Equals((object)data))
{
return(!this.IsCompatible(element, data, context));
}
return(true);
}
protected override bool MeasureElement(IVirtualizedElement <ListViewDataItem> element)
{
bool result = base.MeasureElement(element);
maxDesiredWidth = Math.Max(maxDesiredWidth, element.Data.ActualSize.Width);
return(result);
}
protected override bool MeasureElement(IVirtualizedElement <GridViewRowInfo> element)
{
if (element == null)
{
return(false);
}
base.MeasureElement(element);
return(true);
}
protected override IVirtualizedElement <GridViewRowInfo> UpdateElement(
int position,
GridViewRowInfo data)
{
IVirtualizedElement <GridViewRowInfo> virtualizedElement = this.updateAction != ScrollableRowsUpdateAction.ScrollUp ? base.UpdateElement(position, data) : this.UpdateElementOnScrollUp(position, data);
this.updateAction = ScrollableRowsUpdateAction.None;
return(virtualizedElement);
}
protected override bool MeasureElement(IVirtualizedElement <ListViewDataItem> element)
{
bool flag = base.MeasureElement(element);
this.maxDesiredWidth = Math.Max(this.maxDesiredWidth, element.Data.ActualSize.Width);
this.cachedDesiredSize.Height += (float)element.Data.ActualSize.Height;
this.cachedDesiredSize.Width = Math.Max(this.cachedDesiredSize.Width, (float)element.Data.ActualSize.Width);
return(flag);
}
protected override bool MeasureElement(IVirtualizedElement <ListViewDataItem> element)
{
RadElement element1 = element as RadElement;
BaseListViewGroupVisualItem viewGroupVisualItem = element as BaseListViewGroupVisualItem;
if (element1 == null)
{
return(false);
}
SizeF sizeF = this.MeasureElementCore(element1, this.clientRect.Size);
bool flag = true;
if (this.Orientation == Orientation.Vertical)
{
if ((double)this.currentX + (double)sizeF.Width > (double)this.clientRect.Right)
{
this.currentX = this.clientRect.X;
this.currentY += this.maxItemHeight;
this.maxItemHeight = 0.0f;
if ((double)this.currentY >= (double)this.clientRect.Bottom)
{
flag = false;
}
}
this.currentX += sizeF.Width;
this.maxItemHeight = Math.Max(this.maxItemHeight, sizeF.Height);
}
else if (viewGroupVisualItem != null)
{
this.currentY = this.clientRect.Y;
this.currentX += this.maxItemWidth + (float)this.owner.GroupIndent;
this.maxItemWidth = 0.0f;
if ((double)this.currentX >= (double)this.clientRect.Right)
{
flag = false;
}
}
else
{
if ((double)this.currentY + (double)sizeF.Height > (double)this.clientRect.Bottom)
{
this.currentY = this.clientRect.Y;
this.currentX += this.maxItemWidth;
this.maxItemWidth = 0.0f;
if ((double)this.currentX >= (double)this.clientRect.Right)
{
flag = false;
}
}
this.currentY += sizeF.Height;
this.maxItemWidth = Math.Max(this.maxItemWidth, sizeF.Width);
}
this.cachedDesiredSize.Width = Math.Max(this.cachedDesiredSize.Width, this.currentX + sizeF.Width);
this.cachedDesiredSize.Height = Math.Max(this.cachedDesiredSize.Height, this.currentY + sizeF.Height);
return(flag);
}
protected virtual void RemoveElement(int position)
{
IVirtualizedElement <T> virtualizedElement = (IVirtualizedElement <T>) this.Children[position];
ElementProvider.CacheElement(virtualizedElement);
this.BitState[InvalidateMeasureOnRemoveStateKey] = false;
this.Children.RemoveAt(position);
this.BitState[InvalidateMeasureOnRemoveStateKey] = true;
virtualizedElement.Detach();
}
public virtual IVirtualizedElement <T> GetElement(T data, object context)
{
IVirtualizedElement <T> element = GetElementFromCache(data, context);
if (element != null)
{
return(element);
}
return(this.CreateElement(data, context));
}
protected virtual void RemoveElement(int position)
{
IVirtualizedElement <T> child = (IVirtualizedElement <T>) this.Children[position];
this.ElementProvider.CacheElement(child);
this.InvalidateMeasureOnRemove = false;
this.Children.RemoveAt(position);
this.InvalidateMeasureOnRemove = true;
child.Detach();
}
protected override IVirtualizedElement <ListViewDataItem> UpdateElement(int position, ListViewDataItem data)
{
IVirtualizedElement <ListViewDataItem> element = null;
object elementContext = this.GetElementContext();
if (position < this.Children.Count)
{
element = (IVirtualizedElement <ListViewDataItem>) this.Children[position];
if (ElementProvider.ShouldUpdate(element, data, elementContext))
{
if (position < this.Children.Count - 1)
{
IVirtualizedElement <ListViewDataItem> nextElement = (IVirtualizedElement <ListViewDataItem>) this.Children[position + 1];
if (nextElement.Data.Equals(data))
{
this.Children.Move(position + 1, position);
nextElement.Synchronize();
return(nextElement);
}
}
if (ElementProvider.IsCompatible(element, data, elementContext))
{
element.Detach();
element.Attach(data, elementContext);
}
else
{
int index = FindCompatibleElement(position, data);
if (index > position)
{
this.Children.Move(index, position);
element = (IVirtualizedElement <ListViewDataItem>) this.Children[position];
element.Detach();
element.Attach(data, elementContext);
}
else
{
position = Math.Min(position, this.Children.Count);
element = ElementProvider.GetElement(data, elementContext);
InsertElement(position, element, data);
}
}
}
}
else
{
position = Math.Min(position, this.Children.Count);
element = ElementProvider.GetElement(data, elementContext);
InsertElement(position, element, data);
}
return(element);
}
public bool CacheElement(IVirtualizedElement <int> element)
{
VirtualGridRowElement virtualGridRowElement = element as VirtualGridRowElement;
if (virtualGridRowElement == null || virtualGridRowElement.IsDisposed || (virtualGridRowElement.IsDisposing || this.cachedRows.Contains(virtualGridRowElement)))
{
return(false);
}
this.cachedRows.Add(virtualGridRowElement);
return(true);
}
public override bool IsCompatible(
IVirtualizedElement <GridViewRowInfo> element,
GridViewRowInfo data,
object context)
{
if (element != null && element.Data != null && (element.Data.IsCurrent && this.rowView.GridViewElement.IsInEditMode))
{
return(element.Data == data);
}
return(base.IsCompatible(element, data, context));
}
public override bool ShouldUpdate(
IVirtualizedElement <GanttViewDataItem> element,
GanttViewDataItem data,
object context)
{
if (element is GanttViewSummaryItemElement && data.Items.Count == 0 || element is GanttViewMilestoneItemElement && data.Start != data.End || element is GanttViewTaskItemElement && (data.Items.Count > 0 || data.Start == data.End))
{
return(true);
}
return(base.ShouldUpdate(element, data, context));
}
protected virtual void InsertElement(int position, IVirtualizedElement <T> element, T data)
{
if (element != null)
{
((RadElement)element).Visibility = ElementVisibility.Visible;
this.Children.checkForAlreadyAddedItems = false;
this.Children.Insert(position, (RadElement)element);
this.Children.checkForAlreadyAddedItems = true;
element.Attach(data, GetElementContext());
}
}
protected override IVirtualizedElement <RadListDataItem> UpdateElement(
int position,
RadListDataItem data)
{
object elementContext = this.GetElementContext();
IVirtualizedElement <RadListDataItem> element;
if (position < this.Children.Count)
{
element = (IVirtualizedElement <RadListDataItem>) this.Children[position];
if (this.ElementProvider.ShouldUpdate(element, data, elementContext))
{
if (position < this.Children.Count - 1)
{
IVirtualizedElement <RadListDataItem> child = (IVirtualizedElement <RadListDataItem>) this.Children[position + 1];
if (child.Data.Equals((object)data))
{
this.Children.Move(position + 1, position);
child.Synchronize();
return(child);
}
}
if (this.ElementProvider.IsCompatible(element, data, elementContext))
{
element.Detach();
element.Attach(data, elementContext);
}
else
{
int compatibleElement = this.FindCompatibleElement(position, data);
if (compatibleElement > position)
{
this.Children.Move(compatibleElement, position);
element = (IVirtualizedElement <RadListDataItem>) this.Children[position];
element.Detach();
element.Attach(data, elementContext);
}
else
{
position = Math.Min(position, this.Children.Count);
element = this.ElementProvider.GetElement(data, elementContext);
this.InsertElement(position, element, data);
}
}
}
}
else
{
position = Math.Min(position, this.Children.Count);
element = this.ElementProvider.GetElement(data, elementContext);
this.InsertElement(position, element, data);
}
return(element);
}
public Element GetElement(Item item)
{
foreach (RadElement child in this.ViewElement.Children)
{
IVirtualizedElement <Item> virtualizedElement = child as IVirtualizedElement <Item>;
if (virtualizedElement != null && (object)virtualizedElement.Data == (object)item)
{
return((Element)virtualizedElement);
}
}
return(default(Element));
}
/// <summary>
/// Gets the <see cref="Element"/> with the specified item.
/// </summary>
/// <value></value>
public Element GetElement(Item item)
{
foreach (RadElement element in this.ViewElement.Children)
{
IVirtualizedElement <Item> virtualElement = element as IVirtualizedElement <Item>;
if (virtualElement != null && virtualElement.Data == item)
{
return((Element)virtualElement);
}
}
return(default(Element));
}
public override bool IsCompatible(
IVirtualizedElement <GridViewColumn> element,
GridViewColumn data,
object context)
{
Type cellType = ((GridRowElement)context).GetCellType(data);
Type type = element.GetType();
if ((object)cellType != null && cellType.IsAssignableFrom(type))
{
return(element.IsCompatible(data, context));
}
return(false);
}
public override bool CacheElement(IVirtualizedElement <GridViewColumn> element)
{
GridCellElement gridCellElement = element as GridCellElement;
if (gridCellElement.RowInfo != null)
{
this.cachedElements.Add(new CellElementProvider.CellElementInfo(element, gridCellElement.RowInfo.GetType()));
}
else
{
(element as IDisposable)?.Dispose();
}
return(true);
}
protected override bool MeasureElement(
IVirtualizedElement <GanttViewTimelineDataItem> element)
{
GanttViewTimelineItemElement timelineItemElement = element as GanttViewTimelineItemElement;
if (timelineItemElement == null)
{
return(false);
}
SizeF sizeF = this.MeasureElementCore((RadElement)timelineItemElement, this.availableSize);
this.desiredSize.Height = Math.Max(this.desiredSize.Height, sizeF.Height);
this.desiredSize.Width += sizeF.Width;
return((double)this.desiredSize.Width - (double)this.Owner.TimelineScroller.Scrollbar.Value < (double)this.availableSize.Width);
}
