/// <summary>
/// RealizeItems from the itemsToRealize enumerable upto the maxItemsToRealize limit.
/// </summary>
/// <param name="itemsToRealize">items to realize</param>
/// <param name="realizedItems">Set of Realized Items</param>
/// <param name="maxItemsToRealize">Max limit of items to realize</param>
/// <returns>count of items realized.</returns>
private int RealizeItems(IEnumerator <ISpatialItem> itemsToRealize, HashSet <ISpatialItem> realizedItems, int maxItemsToRealize)
{
int itemsRealized = 0;
// This has to happen again because of the lazy throttling that can happen after RealizeOverride has returned.
IVisualFactory f = VisualFactory ?? this.defaultFactory;
f.BeginRealize();
// Realize n items where n <= this.realizationQuantum.
while (itemsRealized < maxItemsToRealize && itemsToRealize.MoveNext())
{
ISpatialItem item = itemsToRealize.Current;
Visual realizedVisual = RealizeItem(item, false);
if (realizedVisual != null)
{
itemsRealized++;
realizedItems.Add(item);
}
}
f.EndRealize();
return(itemsRealized);
}
public void TickleZoomables(bool visibleOnly)
{
double scale = canvas.Scale;
IVisualFactory factory = canvas.VisualFactory;
factory.BeginRealize();
// todo: timeslice this work (throttle it)
IEnumerable <ISpatialItem> query = null;
if (visibleOnly)
{
query = canvas.Items.GetItemsIntersecting(canvas.ActualViewbox);
}
else
{
query = canvas.Items;
}
foreach (ISpatialItem item in query)
{
Visual visual = canvas.VisualFromItem(item);
if (visual == null && !canvas.IsPaused)
{
visual = canvas.RealizeItem(item, false);
}
if (visual != null)
{
TickleZoomable(scale, visual);
// see if there are any adorners on the visual that also need to be scaled
var layer = AdornerLayer.GetAdornerLayer(visual);
if (layer != null)
{
var adorners = layer.GetAdorners(visual as UIElement);
if (adorners != null)
{
foreach (var zoomableAdorner in adorners.OfType <ISemanticZoomable>())
{
TickleZoomable(scale, zoomableAdorner);
}
}
}
}
}
factory.EndRealize();
}
/// <summary>
/// Realizes and virtualizes items based on the current viewbox.
/// </summary>
/// <returns>An enumerator which allows this method to continue realization where it left off.</returns>
private IEnumerator RealizeOverride()
{
IVisualFactory f = VisualFactory ?? this.defaultFactory;
f.BeginRealize();
IEnumerator <ISpatialItem> itemEnumerator = null;
HashSet <ISpatialItem> realizedItems = new HashSet <ISpatialItem>();
// RealizeItems
if (this.Items != null)
{
IEnumerable <ISpatialItem> itemsToRealize = null;
if (this.IsVirtualizing)
{
// Only realize the items within our viewbox.
double scale = Scale;
Rect viewbox = ActualViewbox;
// Buffer the viewbox.
// This just seems to make things worse, especially when zoomed out a long way.
// A smarter algorithm would predict the direction we are moving and only prefetch those.
// viewbox.Inflate(viewbox.Width / 2, viewbox.Height / 2);
// Query the index for all items that intersect our viewbox.
// use ToList() because we can't leave the query to be lazy.
// by the time RealizeItems is called below the contents of the query
// may have mutated.
itemsToRealize = Items.GetItemsIntersecting(viewbox).ToList();
}
else
{
// Get all items.
itemsToRealize = Items;
}
itemEnumerator = itemsToRealize.GetEnumerator();
QuantizedWorkHandler realizeHandler = delegate(int realizationQuantum)
{
return(this.RealizeItems(itemEnumerator, realizedItems, realizationQuantum));
};
while (this.SelfThrottlingWorker(ref this.realizationQuantum, realizeHandler))
{
yield return(true);
}
// Raise VisualChildrenChanged only if new
if (realizedItems.Count > 0)
{
// Raise the VisualChildrenChanged event since all items are visible.
if (this.VisualChildrenChanged != null)
{
this.VisualChildrenChanged(this, EventArgs.Empty);
}
}
}
// VirtualizeItems
// Build a list of items to virtualize.
IList <ISpatialItem> itemsToVirtualize = new List <ISpatialItem>(this.visualMap.Count);
// Get any items that are no longer part of our result set.
foreach (ISpatialItem item in this.visualMap.Keys)
{
if (!realizedItems.Contains(item))
{
if (this.ShouldVirtualize(item))
{
itemsToVirtualize.Add(item);
}
}
}
itemEnumerator = itemsToVirtualize.GetEnumerator();
QuantizedWorkHandler virtualizingHandler = delegate(int virtualizationQuantum)
{
return(this.VirtualizeItems(itemEnumerator, virtualizationQuantum));
};
while (this.SelfThrottlingWorker(ref this.virtualizationQuantum, virtualizingHandler))
{
yield return(true);
}
f.EndRealize();
}
