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; }