public void TestCacheVirtualItemsEventArgs ()
{
int start = 7;
int end = 26;
CacheVirtualItemsEventArgs e = new CacheVirtualItemsEventArgs (start, end);
Assert.AreEqual (start, e.StartIndex, "A1");
Assert.AreEqual (end, e.EndIndex, "A2");
}
private void listViewSearchResults_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
//Console.WriteLine("cache");
//// we've gotten a request to refresh the cache
//// first check if it's really neccesary.
//if (listViewItemCache != null && e.StartIndex >= firstCachedIndex && e.EndIndex <= firstCachedIndex + listViewItemCache.Length)
//{
// // if the newly requested cache is a subset of the old cache we are done
// return;
//}
//// now we need to rebuild the cache.
//firstCachedIndex = e.StartIndex;
//int length = e.EndIndex - e.StartIndex + 1; //indexes are inclusive
//listViewItemCache = new ListViewItem[length];
//// fill the cache with the appropriate ListViewItems
//for (int i = 0; i < length; i++)
//{
// listViewItemCache[i] = new ListViewItem(searchResults[i + firstCachedIndex].Name);
//}
}
private void handler_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
if (m_cache != null && e.StartIndex >= m_firstItem && e.EndIndex <= m_firstItem + m_cache.Length)
return;
m_firstItem = e.StartIndex;
int length = e.EndIndex - e.StartIndex + 1;
m_cache = new ListViewItem[length];
for (int i = 0; i < m_cache.Length; i++)
{
m_cache[i] = GetItem(m_firstItem + i);
}
}
void listView_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
ListViewItem[] cache = new ListViewItem[e.EndIndex - e.StartIndex + 1];
for (int i = e.StartIndex; i <= e.EndIndex; ++i)
{
cache[i - e.StartIndex] = GetItem(i);
}
}
/// <summary>
/// Handle the CacheVirtualItems event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected virtual void HandleCacheVirtualItems(object sender, CacheVirtualItemsEventArgs e) {
if (this.VirtualListDataSource != null)
this.VirtualListDataSource.PrepareCache(e.StartIndex, e.EndIndex);
}
private void MyList_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
if (_itemCache != null &&
e.StartIndex >= _itemCacheIndex &&
e.EndIndex < _itemCacheIndex + _itemCache.Length &&
_curList.Equals(sender))
{
//If the newly requested cache is a subset of the old cache,
//no need to rebuild everything, so do nothing.
return;
}
//Now we need to rebuild the cache.
if (_curList.Equals(sender)) CreateCache(e.StartIndex, e.EndIndex);
}
private void listView_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
int length = e.EndIndex - e.StartIndex;
if (e.StartIndex >= firstCachedItemIndex
&& e.EndIndex < firstCachedItemIndex + cachedItems.Count)
return;
cachedItems.Clear();
firstCachedItemIndex = e.StartIndex;
for (int i = 0; i < length; i++)
cachedItems.Add(GetItem(firstCachedItemIndex + i));
}
/// <include file='doc\ListView.uex' path='docs/doc[@for="ListBox.OnCacheVirtualItems"]/*' />
/// <devdoc>
/// </devdoc>
protected virtual void OnCacheVirtualItems(CacheVirtualItemsEventArgs e)
{
CacheVirtualItemsEventHandler handler = (CacheVirtualItemsEventHandler)Events[EVENT_CACHEVIRTUALITEMS];
if (handler != null)
handler(this, e);
}
private void MyList_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
this.itemCacheLock.EnterUpgradeableReadLock();
try
{
if (_curList.Equals(sender))
{
if (_itemCache != null &&
e.StartIndex >= _itemCacheIndex &&
e.EndIndex < _itemCacheIndex + _itemCache.Length)
{
//If the newly requested cache is a subset of the old cache,
//no need to rebuild everything, so do nothing.
return;
}
//Now we need to rebuild the cache.
CreateCache(e.StartIndex, e.EndIndex);
}
}
finally { this.itemCacheLock.ExitUpgradeableReadLock(); }
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// cachevirtualitemseventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this CacheVirtualItemsEventHandler cachevirtualitemseventhandler, Object sender, CacheVirtualItemsEventArgs e, AsyncCallback callback)
{
if(cachevirtualitemseventhandler == null) throw new ArgumentNullException("cachevirtualitemseventhandler");
return cachevirtualitemseventhandler.BeginInvoke(sender, e, callback, null);
}
private void MyList_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
if (sender != this._curList)
return;
var listCache = this._listItemCache;
if (listCache?.TargetList == sender && listCache.IsSupersetOf(e.StartIndex, e.EndIndex))
{
// If the newly requested cache is a subset of the old cache,
// no need to rebuild everything, so do nothing.
return;
}
// Now we need to rebuild the cache.
this.CreateCache(e.StartIndex, e.EndIndex);
}
private void listViewHistory_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
CacheVirtualItems(e.StartIndex, e.EndIndex);
}
private void CacheRecords(object sender, CacheVirtualItemsEventArgs e)
{
// Item in cache, ignore
if (RecordCache != null && e.StartIndex >= FirstCacheIndex && e.EndIndex <= FirstCacheIndex + RecordCache.Length)
return;
FirstCacheIndex = e.StartIndex;
int length = e.EndIndex - e.StartIndex + 1;
RecordCache = new ListViewItem[length];
for (int i = 0; i < length; ++i)
RecordCache[i] = Storage.Rows[i + FirstCacheIndex];
}
private void lst_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
for (int i = e.StartIndex; i < e.EndIndex; i++)
{
int idx;
try
{
idx = imagens.Images.IndexOfKey(fotos[i].Código.ToString());
}
catch (ArgumentOutOfRangeException)
{
idx = -1;
}
if (idx < 0)
RecuperarImagem(fotos[i]);
}
}
private void testResultsList_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
testResultsController.CacheVirtualItems(e.StartIndex, e.EndIndex);
}
/// <summary>Handles the CacheVirtualItems event of the listView control.</summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Forms.CacheVirtualItemsEventArgs"/> instance containing the event data.</param>
private void listView_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
for (int i = e.StartIndex; i < e.EndIndex; i++)
if (itemCache[i] == null)
itemCache[i] = MakeItem(rootNode.Nodes[i]);
}
protected override void OnCacheVirtualItems(CacheVirtualItemsEventArgs e)
{
_itemsCache.Clear();
base.OnCacheVirtualItems(e);
for (int i = e.StartIndex;i <= e.EndIndex;++i)
{
_itemsCache[i] = GetVirtualItem(i);
}
}
private void _list_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
// We've gotten a request to refresh the cache.
// First check if it's really necessary.
if (_listCache.ContainsKey(e.StartIndex) && _listCache.ContainsKey(e.EndIndex))
{
// If the newly requested cache is a subset of the old cache,
// no need to rebuild everything, so do nothing.
return;
}
// Now we need to rebuild the cache.
int length = e.EndIndex - e.StartIndex + 1; // indexes are inclusive
// Fill the cache with the appropriate ListViewItems.
for (int i = 0; i < length; ++i)
{
// Skip already existing ListViewItemsItems
if (_listCache.ContainsKey(e.StartIndex + i))
continue;
// Add new ListViewItemsItem to the cache
_listCache.Add(e.StartIndex + i, CreateListViewItemByIndex(e.StartIndex + i));
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
/// <created>UPh,25.10.2015</created>
/// <changed>UPh,25.10.2015</changed>
// ********************************************************************************
protected override void OnCacheVirtualItems(CacheVirtualItemsEventArgs e)
{
//We've gotten a request to refresh the cache.
//First check if it's really necessary.
if (_LVICache != null && e.StartIndex >= _LVIFirstItem && e.EndIndex <= _LVIFirstItem + _LVICache.Length)
{
//If the newly requested cache is a subset of the old cache,
//no need to rebuild everything, so do nothing.
return;
}
//Now we need to rebuild the cache.
_LVIFirstItem = e.StartIndex;
int length = e.EndIndex - e.StartIndex + 1; //indexes are inclusive
_LVICache = new ListViewItem[length];
//Fill the cache with the appropriate ListViewItems.
for (int i = 0; i < length; i++)
{
_LVICache[i] = CreateLVItemAt(_LVIFirstItem + i);
}
}
private void _tailListView_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
_logFileCache.PrepareCache(e.StartIndex, e.EndIndex, false);
}
/// <summary>
/// CacheVirtualItems イベントを処理する
/// </summary>
private void listViewFileName_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
for (int i = e.StartIndex; i <= e.EndIndex; i++)
{
CacheListViewItem(this.findFileList[i]);
}
}
protected internal virtual void OnCacheVirtualItems (CacheVirtualItemsEventArgs e)
{
CacheVirtualItemsEventHandler eh = (CacheVirtualItemsEventHandler)Events [CacheVirtualItemsEvent];
if (eh != null)
eh (this, e);
}
private void ListCacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
int startIndex = e.StartIndex;
if (_cache.ContainsKey(startIndex) && _cache.ContainsKey(e.EndIndex))
return;
for (int i = 0; i < (e.EndIndex - startIndex + 1); ++i)
{
if (!_cache.ContainsKey(startIndex + i))
_cache.Add((startIndex + i), Item(startIndex + i));
}
}
private void EventList_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
CreateCache(e.StartIndex, e.EndIndex);
}
/// <summary>
/// Cache current view
/// </summary>
private void CacheVirtualItemsList(object sender, CacheVirtualItemsEventArgs e)
{
// Only recreate the cache if we need to.
if (cache != null && e.StartIndex >= firstItem && e.EndIndex <= firstItem + cache.Length)
return;
firstItem = e.StartIndex;
int length = e.EndIndex - e.StartIndex + 1;
cache = new ListViewItem[length];
for (int i = 0; i < cache.Length; i++)
cache[i] = GetListItem(firstItem + i);
}
/// <summary>
/// Manages the cache. ListView calls this when it might need a cache refresh.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void listView1_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
//We've gotten a request to refresh the cache.
//First check if it's really neccesary.
if (DisplayObjectsCache != null && e.StartIndex >= IndexOfFirstItemInCache && e.EndIndex <= IndexOfFirstItemInCache + DisplayObjectsCache.Length)
{
//If the newly requested cache is a subset of the old cache,
//no need to rebuild everything, so do nothing.
return;
}
//Now we need to rebuild the cache.
IndexOfFirstItemInCache = e.StartIndex;
int length = e.EndIndex - e.StartIndex + 1; //indexes are inclusive
DisplayObjectsCache = new ListViewItem[length];
//Fill the cache with the appropriate ListViewItems.
int x = 0;
for (int i = 0; i < length; i++)
{
x = (i + IndexOfFirstItemInCache) * (i + IndexOfFirstItemInCache);
DisplayObjectsCache[i] = CreateItemFromIndex(i + IndexOfFirstItemInCache);
}
}
private void _listView_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
if (myCache != null && e.StartIndex >= firstItem && e.EndIndex <= firstItem + myCache.Length)
{
//If the newly requested cache is a subset of the old cache,
//no need to rebuild everything, so do nothing.
return;
}
//Now we need to rebuild the cache.
firstItem = e.StartIndex;
int length = e.EndIndex - e.StartIndex + 1; //indexes are inclusive
myCache = new ListViewItem[length];
//Fill the cache with the appropriate ListViewItems.
for (int i = 0; i < length; i++)
{
myCache[i] = new ListViewItem(this._data[i].Id.ToString());
myCache[i].SubItems.Add(this._data[i].Name);
myCache[i].SubItems.Add(this._data[i].WorkersCount.ToString());
}
}
private void listViewSessions_CacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
{
for (int i = e.StartIndex; i < e.EndIndex + 1; i++)
{
lock (m_SessionViewCache)
{
if (!m_SessionViewCache.ContainsKey(i))
m_SessionViewCache.Add(i, GenerateListViewItem(i));
}
}
}
protected virtual void OnCacheVirtualItems(CacheVirtualItemsEventArgs e)
{
throw null;
}
