// Token: 0x060071D3 RID: 29139 RVA: 0x00208460 File Offset: 0x00206660 public void RecalcLayoutForScaleOrSpacing() { if (this.PageCache == null) { throw new InvalidOperationException(SR.Get("RowCacheRecalcWithNoPageCache")); } this._extentWidth = 0.0; this._extentHeight = 0.0; double num = 0.0; for (int i = 0; i < this._rowCache.Count; i++) { RowInfo rowInfo = this._rowCache[i]; int pageCount = rowInfo.PageCount; rowInfo.ClearPages(); rowInfo.VerticalOffset = num; for (int j = rowInfo.FirstPage; j < rowInfo.FirstPage + pageCount; j++) { Size scaledPageSize = this.GetScaledPageSize(j); rowInfo.AddPage(scaledPageSize); } this._extentWidth = Math.Max(rowInfo.RowSize.Width, this._extentWidth); num += rowInfo.RowSize.Height; this._extentHeight += rowInfo.RowSize.Height; this._rowCache[i] = rowInfo; } RowCacheChangedEventArgs e = new RowCacheChangedEventArgs(new List <RowCacheChange>(1) { new RowCacheChange(0, this._rowCache.Count) }); this.RowCacheChanged(this, e); }
// Token: 0x060071D4 RID: 29140 RVA: 0x002085B4 File Offset: 0x002067B4 public void RecalcRows(int pivotPage, int columns) { if (this.PageCache == null) { throw new InvalidOperationException(SR.Get("RowCacheRecalcWithNoPageCache")); } if (pivotPage < 0 || pivotPage > this.PageCache.PageCount) { throw new ArgumentOutOfRangeException("pivotPage"); } if (columns < 1) { throw new ArgumentOutOfRangeException("columns"); } this._layoutColumns = columns; this._layoutPivotPage = pivotPage; this._hasValidLayout = false; if (this.PageCache.PageCount < this._layoutColumns) { if (!this.PageCache.IsPaginationCompleted || this.PageCache.PageCount == 0) { this._isLayoutRequested = true; this._isLayoutCompleted = false; return; } this._layoutColumns = Math.Min(this._layoutColumns, this.PageCache.PageCount); this._layoutColumns = Math.Max(1, this._layoutColumns); this._layoutPivotPage = 0; } this._extentHeight = 0.0; this._extentWidth = 0.0; if (this.PageCache.DynamicPageSizes) { this._pivotRowIndex = this.RecalcRowsForDynamicPageSizes(this._layoutPivotPage, this._layoutColumns); } else { this._pivotRowIndex = this.RecalcRowsForFixedPageSizes(this._layoutPivotPage, this._layoutColumns); } this._isLayoutCompleted = true; this._isLayoutRequested = false; this._hasValidLayout = true; RowLayoutCompletedEventArgs e = new RowLayoutCompletedEventArgs(this._pivotRowIndex); this.RowLayoutCompleted(this, e); RowCacheChangedEventArgs e2 = new RowCacheChangedEventArgs(new List <RowCacheChange>(1) { new RowCacheChange(0, this._rowCache.Count) }); this.RowCacheChanged(this, e2); }
/// <summary> /// Recalculates the row layout given a starting page, and the number of pages to lay out /// on each row. /// In the event that there aren't currently enough pages to accomplish the layout, RowCache /// will wait until the pages are available and then fire off a RowLayoutCompleted event. /// </summary> /// <param name="pivotPage">The page to build the rows around</param> /// <param name="columns">The number of columns in the "pivot row"</param> public void RecalcRows(int pivotPage, int columns) { //Throw execption if we have no PageCache if (PageCache == null) { throw new InvalidOperationException(SR.Get(SRID.RowCacheRecalcWithNoPageCache)); } //Throw exception for illegal values if (pivotPage < 0 || pivotPage > PageCache.PageCount) { throw new ArgumentOutOfRangeException("pivotPage"); } //Can't lay out fewer than 1 column of pages. if (columns < 1) { throw new ArgumentOutOfRangeException("columns"); } //Store off the requested layout parameters. _layoutColumns = columns; _layoutPivotPage = pivotPage; //We've started a new layout, reset the valid layout flag. _hasValidLayout = false; //We can't do anything here if we haven't gotten enough pages to create the first row yet. //But we'll save off the specified columns & pivot page (above) //And as soon as we get some pages (in OnPageCacheChanged) //we'll start laying them out in the requested manner. if (PageCache.PageCount < _layoutColumns) { //If pagination is still happening or if we have no pages in our content //we need to wait until later. if (!PageCache.IsPaginationCompleted || PageCache.PageCount == 0) { //Reset our LayoutComputed flag, as we've been tasked to create a new one //but can't do it yet. _isLayoutRequested = true; _isLayoutCompleted = false; return; } //If pagination has completed, we trim down the column count and continue. else { //We're done paginating, but we don't have enough //pages to do the requested layout. So we'll need to trim down the column count, with a //lower bound of 1 column. _layoutColumns = Math.Min(_layoutColumns, PageCache.PageCount); _layoutColumns = Math.Max(1, _layoutColumns); //The pivot page is always the first page in this instance _layoutPivotPage = 0; } } //Reset the document extents, which will be recalculated by the RecalcRows methods. _extentHeight = 0.0; _extentWidth = 0.0; //Now call the specific RecalcRows... method for our document type. if (PageCache.DynamicPageSizes) { _pivotRowIndex = RecalcRowsForDynamicPageSizes(_layoutPivotPage, _layoutColumns); } else { _pivotRowIndex = RecalcRowsForFixedPageSizes(_layoutPivotPage, _layoutColumns); } _isLayoutCompleted = true; _isLayoutRequested = false; //Set the valid layout flag now that we're done _hasValidLayout = true; //We've computed the layout, so we'll fire off our RowLayoutCompleted event. //We pass along the pivotRow's Index so the listener can keep the pivot row visible. RowLayoutCompletedEventArgs args = new RowLayoutCompletedEventArgs(_pivotRowIndex); RowLayoutCompleted(this, args); //Fire off our RowCacheChanged event indicating that all rows have changed. List<RowCacheChange> changes = new List<RowCacheChange>(1); changes.Add(new RowCacheChange(0, _rowCache.Count)); RowCacheChangedEventArgs args2 = new RowCacheChangedEventArgs(changes); RowCacheChanged(this, args2); }
/// <summary> /// Recalculates the current row layout by applying the current Scale /// and PageSpacing to the current row layout. It does not change the /// contents of the rows. /// </summary> public void RecalcLayoutForScaleOrSpacing() { //Throw execption if we have no PageCache if (PageCache == null) { throw new InvalidOperationException(SR.Get(SRID.RowCacheRecalcWithNoPageCache)); } //Reset the extents _extentWidth = 0.0; _extentHeight = 0.0; //Walk through each row and based on the pages on the row, //recalculate the width and height of the row. double currentOffset = 0.0; for (int i = 0; i < _rowCache.Count; i++) { //Get this row and save off the page count. RowInfo currentRow = _rowCache[i]; int pageCount = currentRow.PageCount; //Clear the pages so we can add the new, rescaled ones. currentRow.ClearPages(); currentRow.VerticalOffset = currentOffset; //Add each page to the row. for (int j = currentRow.FirstPage; j < currentRow.FirstPage + pageCount; j++) { Size pageSize = GetScaledPageSize(j); currentRow.AddPage(pageSize); } //Adjust the extent width if necessary _extentWidth = Math.Max(currentRow.RowSize.Width, _extentWidth); currentOffset += currentRow.RowSize.Height; _extentHeight += currentRow.RowSize.Height; _rowCache[i] = currentRow; } //Fire off our RowCacheChanged event indicating that all rows have changed. List<RowCacheChange> changes = new List<RowCacheChange>(1); changes.Add(new RowCacheChange(0, _rowCache.Count)); RowCacheChangedEventArgs args = new RowCacheChangedEventArgs(changes); RowCacheChanged(this, args); }
/// <summary> /// Event Handler for the PageCacheChanged event. Called whenever an entry in the /// PageCache is changed. When this happens, the RowCache needs to Add, Remove, or /// Update row entries corresponding to the pages changed. /// </summary> /// <param name="sender">The object that sent this event.</param> /// <param name="args">The associated arguments.</param> private void OnPageCacheChanged(object sender, PageCacheChangedEventArgs args) { //If we have a computed layout then we'll add/remove/frob rows to conform //to that layout. if (_isLayoutCompleted) { List<RowCacheChange> changes = new List<RowCacheChange>(args.Changes.Count); for (int i = 0; i < args.Changes.Count; i++) { PageCacheChange pageChange = args.Changes[i]; switch (pageChange.Type) { case PageCacheChangeType.Add: case PageCacheChangeType.Update: if (pageChange.Start > LastPageInCache) { //Completely new pages, so we add new cache entries RowCacheChange change = AddPageRange(pageChange.Start, pageChange.Count); if (change != null) { changes.Add(change); } } else { if (pageChange.Start + pageChange.Count - 1 <= LastPageInCache) { //All pre-existing pages, so we just update the current cache entries. RowCacheChange change = UpdatePageRange(pageChange.Start, pageChange.Count); if (change != null) { changes.Add(change); } } else { //Some pre-existing pages, some new. RowCacheChange change; change = UpdatePageRange(pageChange.Start, LastPageInCache - pageChange.Start); if (change != null) { changes.Add(change); } change = AddPageRange(LastPageInCache + 1, pageChange.Count - (LastPageInCache - pageChange.Start)); if (change != null) { changes.Add(change); } } } break; case PageCacheChangeType.Remove: //If PageCount is now less than the size of our cache due to repagination //we remove the corresponding entries from our row cache. if (PageCache.PageCount - 1 < LastPageInCache) { //Remove pages starting at the first no-longer-existent page. //(PageCache.PageCount now points to the first dead page) RowCacheChange change = TrimPageRange(PageCache.PageCount); if (change != null) { changes.Add(change); } } //If because of the above trimming we have fewer pages left //in the document than the columns that were initially requested //We'll need to recalc our layout from scratch. //First we check to see if we have one or fewer rows left. if (_rowCache.Count <= 1) { //If we have either no rows left or the remaining row has //less than _layoutColumns pages on it, we need to recalc from the first page. if (_rowCache.Count == 0 || _rowCache[0].PageCount < _layoutColumns ) { RecalcRows(0, _layoutColumns); } } break; default: throw new ArgumentOutOfRangeException("args"); } } RowCacheChangedEventArgs newArgs = new RowCacheChangedEventArgs(changes); RowCacheChanged(this, newArgs); } else if (_isLayoutRequested) { //We've had a request to create a layout previously, but didn't have enough pages to do so before. //Try it now. RecalcRows(_layoutPivotPage, _layoutColumns); } }
/// <summary> /// When the RowCache is changed for any reason (due to a new layout, or if pages change, etc...) /// then we need to invalidate our Measure (so we can pick up any changes to visible pages) /// and invalidate our IDocumentScrollInfo parents so they know that something's changed. /// </summary> /// <param name="source"></param> /// <param name="args"></param> private void OnRowCacheChanged(object source, RowCacheChangedEventArgs args) { //If: //1) We have a saved pivot row from a previous RowCacheCompleted event, //and //2) We've been told to do a "Page-Fit" operation (that is, a non-zoom viewing preference) //and //3) The pivot row is now "clean" (that is, we know the actual dimensions of all the pages // on the row and we aren't just guessing) //Then we can now officially calculate the scale needed in order to fit the given row in the manner //chosen. if (_savedPivotRow != null && RowIsClean(_savedPivotRow)) { if (_documentLayout.ViewMode != ViewMode.Zoom && _documentLayout.ViewMode != ViewMode.SetColumns ) { if (_savedPivotRow.FirstPage < _rowCache.RowCount) { RowInfo newRow = _rowCache.GetRowForPageNumber(_savedPivotRow.FirstPage); //If the new row's dimensions differ, then we need to rescale, otherwise we do nothing. if (newRow.RowSize.Width != _savedPivotRow.RowSize.Width || newRow.RowSize.Height != _savedPivotRow.RowSize.Height) { //Rescale. ApplyViewParameters(newRow); } //Null out the saved Pivot Row -- we've scaled this row properly now //so we don't need to be concerned with it any longer. _savedPivotRow = null; } } else { // The view is already correct; null out the saved Pivot Row. _savedPivotRow = null; } } //If we're viewing a document with varying page size, we've scrolled since the last layout change //and the Width of the document has increased //then this means that new, wider pages have just been scrolled into view. //If we do nothing here, then the content prior to these new pages will appear to "jump" //to the right (because we center the pages within the width of the document.) //This jump is jarring and not a good user experience. //To prevent this, we adjust the HorizontalOffset such that the content that was previously visible //appears at the same position when it is rendered. if (_pageCache.DynamicPageSizes && _lastRowChangeVerticalOffset != VerticalOffset && _lastRowChangeExtentWidth < ExtentWidth) { if (_lastRowChangeExtentWidth != 0.0) { //Tweak the HorizontalOffset so that the content does not appear to move. SetHorizontalOffsetInternal(HorizontalOffset + (ExtentWidth - _lastRowChangeExtentWidth) / 2.0); } _lastRowChangeExtentWidth = ExtentWidth; } _lastRowChangeVerticalOffset = VerticalOffset; //The row cache has been changed. //If we're displaying rows that were affected, //we need to invalidate our measure so they'll be //redrawn. for (int i = 0; i < args.Changes.Count; i++) { RowCacheChange change = args.Changes[i]; if( RowCacheChangeIsVisible( change )) { InvalidateMeasure(); InvalidateChildMeasure(); } } InvalidateDocumentScrollInfo(); }
// 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); } }