// Token: 0x0600714D RID: 29005 RVA: 0x00206A90 File Offset: 0x00204C90
private object PagesChangedDelegate(object parameter)
{
PagesChangedEventArgs pagesChangedEventArgs = parameter as PagesChangedEventArgs;
if (pagesChangedEventArgs == null)
{
throw new ArgumentOutOfRangeException("parameter");
}
this.ValidatePaginationArgs(pagesChangedEventArgs.Start, pagesChangedEventArgs.Count);
int num = pagesChangedEventArgs.Count;
if (pagesChangedEventArgs.Start + pagesChangedEventArgs.Count >= this._cache.Count || pagesChangedEventArgs.Start + pagesChangedEventArgs.Count < 0)
{
num = this._cache.Count - pagesChangedEventArgs.Start;
}
List <PageCacheChange> list = new List <PageCacheChange>(1);
if (num > 0)
{
PageCacheChange pageCacheChange = this.DirtyRange(pagesChangedEventArgs.Start, num);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
this.FirePageCacheChangedEvent(list);
}
if (this.PagesChanged != null)
{
this.PagesChanged(this, pagesChangedEventArgs);
}
return(null);
}
/// <summary>
/// Updates entries in the cache to have the current default page size.
/// </summary>
private void SetDefaultPageSize(bool dirtyOnly)
{
//Create our list of changes. We can potentially have as many
//changes as there are pages in the document.
List <PageCacheChange> changes = new List <PageCacheChange>(PageCount);
Invariant.Assert(_defaultPageSize != Size.Empty, "Default Page Size is Empty.");
for (int i = 0; i < _cache.Count; i++)
{
if (_cache[i].Dirty || !dirtyOnly)
{
PageCacheEntry newEntry;
newEntry.PageSize = _defaultPageSize;
newEntry.Dirty = true;
PageCacheChange change = UpdateEntry(i, newEntry);
if (change != null)
{
changes.Add(change);
}
}
}
//Fire off our PageCacheChanged event.
FirePageCacheChangedEvent(changes);
}
/// <summary>
/// Asynchronously handles the PagesChanged event.
/// This means that one or more pages have been invalidated so we
/// dirty their cache entries and fire off our PagesChanged event.
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
private object PagesChangedDelegate(object parameter)
{
PagesChangedEventArgs args = parameter as PagesChangedEventArgs;
if (args == null)
{
throw new ArgumentOutOfRangeException("parameter");
}
//Validate incoming parameters
ValidatePaginationArgs(args.Start, args.Count);
//Start values outside the range of current pages are invalid.
//if (args.Start >= _cache.Count)
//{
// throw new ArgumentOutOfRangeException("args");
//}
//If the last page specified in the change is out of the range of currently-known
//pages we make the assumption that the IDP means to invalidate all pages and so
//we clip the count into range.
//We also take into account integer overflow... if the sum of Start+Count is less than
//zero then we've overflowed.
int adjustedCount = args.Count;
if (args.Start + args.Count >= _cache.Count ||
args.Start + args.Count < 0)
{
adjustedCount = _cache.Count - args.Start;
}
//Create our list of changes. We can have at most one.
List <PageCacheChange> changes = new List <PageCacheChange>(1);
//Now make the change if there is one to make.
if (adjustedCount > 0)
{
PageCacheChange change = DirtyRange(args.Start, adjustedCount);
if (change != null)
{
changes.Add(change);
}
//Fire off our PageCacheChanged event.
FirePageCacheChangedEvent(changes);
}
//Fire the PagesChanged event.
if (PagesChanged != null)
{
PagesChanged(this, args);
}
return(null);
}
// Token: 0x06007156 RID: 29014 RVA: 0x00206FE4 File Offset: 0x002051E4
private void ClearCache()
{
if (this._cache.Count > 0)
{
List <PageCacheChange> list = new List <PageCacheChange>(1);
PageCacheChange item = new PageCacheChange(0, this._cache.Count, PageCacheChangeType.Remove);
list.Add(item);
this._cache.Clear();
this.FirePageCacheChangedEvent(list);
}
}
/// <summary>
/// Clears out the current cache and lets listeners know of the change.
/// </summary>
private void ClearCache()
{
if (_cache.Count > 0)
{
//Build our list of changes
List <PageCacheChange> changes = new List <PageCacheChange>(1);
//This change indicates that all of the pages were removed from the cache.
PageCacheChange change = new PageCacheChange(0, _cache.Count, PageCacheChangeType.Remove);
changes.Add(change);
//Clear the cache
_cache.Clear();
//Fire the event.
FirePageCacheChangedEvent(changes);
}
}
// Token: 0x06007151 RID: 29009 RVA: 0x00206D48 File Offset: 0x00204F48
private void SetDefaultPageSize(bool dirtyOnly)
{
List <PageCacheChange> list = new List <PageCacheChange>(this.PageCount);
Invariant.Assert(this._defaultPageSize != Size.Empty, "Default Page Size is Empty.");
for (int i = 0; i < this._cache.Count; i++)
{
if (this._cache[i].Dirty || !dirtyOnly)
{
PageCacheEntry newEntry;
newEntry.PageSize = this._defaultPageSize;
newEntry.Dirty = true;
PageCacheChange pageCacheChange = this.UpdateEntry(i, newEntry);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
}
}
this.FirePageCacheChangedEvent(list);
}
/// <summary>
/// Asynchronously handles the PaginationProgress event.
/// This means that one or more pages have been added to the document, so we
/// add any new pages to the cache, mark them as dirty, and fire off our PaginationProgress
/// event.
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
private object PaginationProgressDelegate(object parameter)
{
PaginationProgressEventArgs args = parameter as PaginationProgressEventArgs;
if (args == null)
{
throw new InvalidOperationException("parameter");
}
//Validate incoming parameters.
ValidatePaginationArgs(args.Start, args.Count);
if (_isPaginationCompleted)
{
if (args.Start == 0)
{
//Since we've started repaginating from the beginning of the document
//after pagination was completed, we can't assume we know
//the default page size anymore.
_isDefaultSizeKnown = false;
_dynamicPageSizes = false;
}
//Reset our IsPaginationCompleted flag since we just got a pagination event.
_isPaginationCompleted = false;
}
//Check for integer overflow.
if (args.Start + args.Count < 0)
{
throw new ArgumentOutOfRangeException("args");
}
//Create our list of changes. We allocate space for 2 changes here
//as we can have as many as two changes resulting from a Pagination event.
List <PageCacheChange> changes = new List <PageCacheChange>(2);
PageCacheChange change;
//If we have pages to add or modify, do so now.
if (args.Count > 0)
{
//If pagination has added new pages onto the end of the document, we
//add new entries to our cache.
if (args.Start >= _cache.Count)
{
//Completely new pages, so we add new cache entries
change = AddRange(args.Start, args.Count);
if (change != null)
{
changes.Add(change);
}
}
else
{
//Pagination has updated some currently existing pages, so we'll
//update our entries.
if (args.Start + args.Count < _cache.Count)
{
//All pre-existing pages, so we just dirty the current cache entries.
change = DirtyRange(args.Start, args.Count);
if (change != null)
{
changes.Add(change);
}
}
else
{
//Some pre-existing pages, some new.
change = DirtyRange(args.Start, _cache.Count - args.Start);
if (change != null)
{
changes.Add(change);
}
change = AddRange(_cache.Count, args.Count - (_cache.Count - args.Start) + 1);
if (change != null)
{
changes.Add(change);
}
}
}
}
//If the document's PageCount is now less than the size of our cache due to repagination
//we remove the extra entries.
int pageCount = _documentPaginator != null ? _documentPaginator.PageCount : 0;
if (pageCount < _cache.Count)
{
change = new PageCacheChange(pageCount, _cache.Count - pageCount, PageCacheChangeType.Remove);
changes.Add(change);
//Remove the pages from the cache.
_cache.RemoveRange(pageCount, _cache.Count - pageCount);
}
//Fire off our PageCacheChanged event.
FirePageCacheChangedEvent(changes);
//Fire the PaginationProgress event.
if (PaginationProgress != null)
{
PaginationProgress(this, args);
}
return(null);
}
/// <summary>
/// Clears out the current cache and lets listeners know of the change.
/// </summary>
private void ClearCache()
{
if (_cache.Count > 0)
{
//Build our list of changes
List<PageCacheChange> changes = new List<PageCacheChange>(1);
//This change indicates that all of the pages were removed from the cache.
PageCacheChange change = new PageCacheChange(0, _cache.Count, PageCacheChangeType.Remove);
changes.Add(change);
//Clear the cache
_cache.Clear();
//Fire the event.
FirePageCacheChangedEvent(changes);
}
}
/// <summary>
/// Asynchronously handles the PaginationProgress event.
/// This means that one or more pages have been added to the document, so we
/// add any new pages to the cache, mark them as dirty, and fire off our PaginationProgress
/// event.
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
private object PaginationProgressDelegate(object parameter)
{
PaginationProgressEventArgs args = parameter as PaginationProgressEventArgs;
if (args == null)
{
throw new InvalidOperationException("parameter");
}
//Validate incoming parameters.
ValidatePaginationArgs(args.Start, args.Count);
if (_isPaginationCompleted)
{
if (args.Start == 0)
{
//Since we've started repaginating from the beginning of the document
//after pagination was completed, we can't assume we know
//the default page size anymore.
_isDefaultSizeKnown = false;
_dynamicPageSizes = false;
}
//Reset our IsPaginationCompleted flag since we just got a pagination event.
_isPaginationCompleted = false;
}
//Check for integer overflow.
if (args.Start + args.Count < 0)
{
throw new ArgumentOutOfRangeException("args");
}
//Create our list of changes. We allocate space for 2 changes here
//as we can have as many as two changes resulting from a Pagination event.
List<PageCacheChange> changes = new List<PageCacheChange>(2);
PageCacheChange change;
//If we have pages to add or modify, do so now.
if (args.Count > 0)
{
//If pagination has added new pages onto the end of the document, we
//add new entries to our cache.
if (args.Start >= _cache.Count)
{
//Completely new pages, so we add new cache entries
change = AddRange(args.Start, args.Count);
if (change != null)
{
changes.Add(change);
}
}
else
{
//Pagination has updated some currently existing pages, so we'll
//update our entries.
if (args.Start + args.Count < _cache.Count)
{
//All pre-existing pages, so we just dirty the current cache entries.
change = DirtyRange(args.Start, args.Count);
if (change != null)
{
changes.Add(change);
}
}
else
{
//Some pre-existing pages, some new.
change = DirtyRange(args.Start, _cache.Count - args.Start);
if (change != null)
{
changes.Add(change);
}
change = AddRange(_cache.Count, args.Count - (_cache.Count - args.Start) + 1);
if (change != null)
{
changes.Add(change);
}
}
}
}
//If the document's PageCount is now less than the size of our cache due to repagination
//we remove the extra entries.
int pageCount = _documentPaginator != null ? _documentPaginator.PageCount : 0;
if (pageCount < _cache.Count)
{
change = new PageCacheChange(pageCount, _cache.Count - pageCount, PageCacheChangeType.Remove);
changes.Add(change);
//Remove the pages from the cache.
_cache.RemoveRange(pageCount, _cache.Count - pageCount);
}
//Fire off our PageCacheChanged event.
FirePageCacheChangedEvent(changes);
//Fire the PaginationProgress event.
if (PaginationProgress != null)
{
PaginationProgress(this, args);
}
return null;
}
// Token: 0x0600714F RID: 29007 RVA: 0x00206BA0 File Offset: 0x00204DA0
private object GetPageCompletedDelegate(object parameter)
{
GetPageCompletedEventArgs getPageCompletedEventArgs = parameter as GetPageCompletedEventArgs;
if (getPageCompletedEventArgs == null)
{
throw new ArgumentOutOfRangeException("parameter");
}
bool flag = this._pageDestroyedWatcher.IsDestroyed(getPageCompletedEventArgs.DocumentPage);
this._pageDestroyedWatcher.RemovePage(getPageCompletedEventArgs.DocumentPage);
if (flag)
{
return(null);
}
if (!getPageCompletedEventArgs.Cancelled && getPageCompletedEventArgs.Error == null && getPageCompletedEventArgs.DocumentPage != DocumentPage.Missing)
{
if (getPageCompletedEventArgs.DocumentPage.Size == Size.Empty)
{
throw new ArgumentOutOfRangeException("args");
}
PageCacheEntry pageCacheEntry;
pageCacheEntry.PageSize = getPageCompletedEventArgs.DocumentPage.Size;
pageCacheEntry.Dirty = false;
List <PageCacheChange> list = new List <PageCacheChange>(2);
if (getPageCompletedEventArgs.PageNumber > this._cache.Count - 1)
{
PageCacheChange pageCacheChange = this.AddRange(getPageCompletedEventArgs.PageNumber, 1);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
pageCacheChange = this.UpdateEntry(getPageCompletedEventArgs.PageNumber, pageCacheEntry);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
}
else
{
PageCacheChange pageCacheChange = this.UpdateEntry(getPageCompletedEventArgs.PageNumber, pageCacheEntry);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
}
if (this._isDefaultSizeKnown && pageCacheEntry.PageSize != this._lastPageSize)
{
this._dynamicPageSizes = true;
}
this._lastPageSize = pageCacheEntry.PageSize;
if (!this._isDefaultSizeKnown)
{
this._defaultPageSize = pageCacheEntry.PageSize;
this._isDefaultSizeKnown = true;
this.SetDefaultPageSize(true);
}
this.FirePageCacheChangedEvent(list);
}
if (this.GetPageCompleted != null)
{
this.GetPageCompleted(this, getPageCompletedEventArgs);
}
return(null);
}
// Token: 0x06007149 RID: 29001 RVA: 0x00206848 File Offset: 0x00204A48
private object PaginationProgressDelegate(object parameter)
{
PaginationProgressEventArgs paginationProgressEventArgs = parameter as PaginationProgressEventArgs;
if (paginationProgressEventArgs == null)
{
throw new InvalidOperationException("parameter");
}
this.ValidatePaginationArgs(paginationProgressEventArgs.Start, paginationProgressEventArgs.Count);
if (this._isPaginationCompleted)
{
if (paginationProgressEventArgs.Start == 0)
{
this._isDefaultSizeKnown = false;
this._dynamicPageSizes = false;
}
this._isPaginationCompleted = false;
}
if (paginationProgressEventArgs.Start + paginationProgressEventArgs.Count < 0)
{
throw new ArgumentOutOfRangeException("args");
}
List <PageCacheChange> list = new List <PageCacheChange>(2);
if (paginationProgressEventArgs.Count > 0)
{
if (paginationProgressEventArgs.Start >= this._cache.Count)
{
PageCacheChange pageCacheChange = this.AddRange(paginationProgressEventArgs.Start, paginationProgressEventArgs.Count);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
}
else if (paginationProgressEventArgs.Start + paginationProgressEventArgs.Count < this._cache.Count)
{
PageCacheChange pageCacheChange = this.DirtyRange(paginationProgressEventArgs.Start, paginationProgressEventArgs.Count);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
}
else
{
PageCacheChange pageCacheChange = this.DirtyRange(paginationProgressEventArgs.Start, this._cache.Count - paginationProgressEventArgs.Start);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
pageCacheChange = this.AddRange(this._cache.Count, paginationProgressEventArgs.Count - (this._cache.Count - paginationProgressEventArgs.Start) + 1);
if (pageCacheChange != null)
{
list.Add(pageCacheChange);
}
}
}
int num = (this._documentPaginator != null) ? this._documentPaginator.PageCount : 0;
if (num < this._cache.Count)
{
PageCacheChange pageCacheChange = new PageCacheChange(num, this._cache.Count - num, PageCacheChangeType.Remove);
list.Add(pageCacheChange);
this._cache.RemoveRange(num, this._cache.Count - num);
}
this.FirePageCacheChangedEvent(list);
if (this.PaginationProgress != null)
{
this.PaginationProgress(this, paginationProgressEventArgs);
}
return(null);
}
// Token: 0x060071E1 RID: 29153 RVA: 0x00209034 File Offset: 0x00207234
private void OnPageCacheChanged(object sender, PageCacheChangedEventArgs args)
{
if (this._isLayoutCompleted)
{
List <RowCacheChange> list = new List <RowCacheChange>(args.Changes.Count);
for (int i = 0; i < args.Changes.Count; i++)
{
PageCacheChange pageCacheChange = args.Changes[i];
switch (pageCacheChange.Type)
{
case PageCacheChangeType.Add:
case PageCacheChangeType.Update:
if (pageCacheChange.Start > this.LastPageInCache)
{
RowCacheChange rowCacheChange = this.AddPageRange(pageCacheChange.Start, pageCacheChange.Count);
if (rowCacheChange != null)
{
list.Add(rowCacheChange);
}
}
else if (pageCacheChange.Start + pageCacheChange.Count - 1 <= this.LastPageInCache)
{
RowCacheChange rowCacheChange2 = this.UpdatePageRange(pageCacheChange.Start, pageCacheChange.Count);
if (rowCacheChange2 != null)
{
list.Add(rowCacheChange2);
}
}
else
{
RowCacheChange rowCacheChange3 = this.UpdatePageRange(pageCacheChange.Start, this.LastPageInCache - pageCacheChange.Start);
if (rowCacheChange3 != null)
{
list.Add(rowCacheChange3);
}
rowCacheChange3 = this.AddPageRange(this.LastPageInCache + 1, pageCacheChange.Count - (this.LastPageInCache - pageCacheChange.Start));
if (rowCacheChange3 != null)
{
list.Add(rowCacheChange3);
}
}
break;
case PageCacheChangeType.Remove:
if (this.PageCache.PageCount - 1 < this.LastPageInCache)
{
RowCacheChange rowCacheChange4 = this.TrimPageRange(this.PageCache.PageCount);
if (rowCacheChange4 != null)
{
list.Add(rowCacheChange4);
}
}
if (this._rowCache.Count <= 1 && (this._rowCache.Count == 0 || this._rowCache[0].PageCount < this._layoutColumns))
{
this.RecalcRows(0, this._layoutColumns);
}
break;
default:
throw new ArgumentOutOfRangeException("args");
}
}
RowCacheChangedEventArgs e = new RowCacheChangedEventArgs(list);
this.RowCacheChanged(this, e);
return;
}
if (this._isLayoutRequested)
{
this.RecalcRows(this._layoutPivotPage, this._layoutColumns);
}
}
