/// <summary> /// Fire event after a page has been completed /// </summary> /// <param name="ea">GetPageCompletedEventArgs</param> public void FireEventGetPageCompleted(GetPageCompletedEventArgs ea) { if (GetPageCompleted != null) { GetPageCompleted(this, ea); } }
private void Client_GetPageCompleted(object sender, GetPageCompletedEventArgs e) { string xaml = e.Result.XAML; var page = XamlReader.Load(xaml); LayoutRoot.Children.Add(page as UIElement); this.client.GetDataAsync(1); }
// Token: 0x0600714E RID: 29006 RVA: 0x00206B48 File Offset: 0x00204D48 private void OnGetPageCompleted(object sender, GetPageCompletedEventArgs args) { if (!args.Cancelled && args.Error == null && args.DocumentPage != DocumentPage.Missing) { this._pageDestroyedWatcher.AddPage(args.DocumentPage); Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(this.GetPageCompletedDelegate), args); } }
// Token: 0x06006297 RID: 25239 RVA: 0x001BA800 File Offset: 0x001B8A00 private void HandleGetPageCompleted(object sender, GetPageCompletedEventArgs e) { if (!e.Cancelled && e.Error == null && e.DocumentPage != DocumentPage.Missing) { DocumentPage page = this.ComposePageWithAnnotationVisuals(e.PageNumber, e.DocumentPage); e = new GetPageCompletedEventArgs(page, e.PageNumber, e.Error, e.Cancelled, e.UserState); } this.OnGetPageCompleted(e); }
// Token: 0x06006F97 RID: 28567 RVA: 0x00201454 File Offset: 0x001FF654 private void OnGetPageCompleted(object sender, GetPageCompletedEventArgs e) { if (!this._disposed && e != null && !e.Cancelled && e.Error == null && e.PageNumber != 2147483647 && e.PageNumber == this.PageNumber && e.DocumentPage != null && e.DocumentPage != DocumentPage.Missing) { this._loaded = true; if (this.PageLoaded != null) { this.PageLoaded(this, EventArgs.Empty); } } }
/// <summary> /// Handler for the GetPageCompleted event fired by the DocumentPaginator. /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void OnGetPageCompleted(object sender, GetPageCompletedEventArgs args) { if (!args.Cancelled && args.Error == null && args.DocumentPage != DocumentPage.Missing) { //Add the page to the Watcher so we can determine if the page has been //destroyed in our Delegate. _pageDestroyedWatcher.AddPage(args.DocumentPage); //Since handling the GetPageCompleted event entails a bit of work, we'll //have our dispatcher call the GetPageCompletedDelegate at Normal priority. Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(GetPageCompletedDelegate), args); } }
/// <summary> /// We are being notified by the wrapped paginator. If getting the page /// was successful, we use the resulting page to produce a new page that /// includes annotatons. In either case, we fire an event from this instance. /// </summary> /// <param name="sender">source of the event</param> /// <param name="e">the args for this event</param> private void HandleGetPageCompleted(object sender, GetPageCompletedEventArgs e) { // If no errors, not cancelled, and page isn't missing, create a new page // with annotations and create a new event args for that page. if (!e.Cancelled && e.Error == null && e.DocumentPage != DocumentPage.Missing) { // Since we can't change the page the args is holding we create a new // args object with the page we produce. DocumentPage documentPage = ConstructPageWithHeaderAndFooter(e.PageNumber); e = new GetPageCompletedEventArgs(documentPage, e.PageNumber, e.Error, e.Cancelled, e.UserState); } // Fire the event OnGetPageCompleted(e); }
// Token: 0x06005D89 RID: 23945 RVA: 0x001A5458 File Offset: 0x001A3658 private void HandleGetPageCompleted(object sender, GetPageCompletedEventArgs e) { if (!this._disposed && e != null && !e.Cancelled && e.Error == null && e.PageNumber == this.PageNumber && e.UserState == this) { if (this._documentPageAsync != null && this._documentPageAsync != DocumentPage.Missing) { this._documentPageAsync.PageDestroyed -= this.HandleAsyncPageDestroyed; } this._documentPageAsync = e.DocumentPage; if (this._documentPageAsync == null) { this._documentPageAsync = DocumentPage.Missing; } if (this._documentPageAsync != DocumentPage.Missing) { this._documentPageAsync.PageDestroyed += this.HandleAsyncPageDestroyed; } base.InvalidateMeasure(); } }
/// <summary> /// Handles the GetPageCompleted event raised by the DocumentPaginator. /// At this point, we'll set the _loaded flag to indicate the page is loaded /// and fire the PageLoaded event. /// </summary> /// <param name="sender">Source of the event.</param> /// <param name="e">Details about this event.</param> private void OnGetPageCompleted(object sender, GetPageCompletedEventArgs e) { //If the GetPageCompleted action completed successfully //and is our page then we'll set the flag and fire the event. if (!_disposed && e != null && !e.Cancelled && e.Error == null && e.PageNumber != int.MaxValue && e.PageNumber == this.PageNumber && e.DocumentPage != null && e.DocumentPage != DocumentPage.Missing) { _loaded = true; if (PageLoaded != null) { PageLoaded(this, EventArgs.Empty); } } }
/// <summary> /// Handles GetPageCompleted event raised by the DocumentPaginator. /// </summary> /// <param name="sender">Source of the event.</param> /// <param name="e">Details about this event.</param> private void HandleGetPageCompleted(object sender, GetPageCompletedEventArgs e) { if (!_disposed && (e != null) && !e.Cancelled && e.Error == null) { if (e.PageNumber == this.PageNumber && e.UserState == this) { if (_documentPageAsync != null && _documentPageAsync != DocumentPage.Missing) { _documentPageAsync.PageDestroyed -= new EventHandler(HandleAsyncPageDestroyed); } _documentPageAsync = e.DocumentPage; if (_documentPageAsync == null) { _documentPageAsync = DocumentPage.Missing; } if (_documentPageAsync != DocumentPage.Missing) { _documentPageAsync.PageDestroyed += new EventHandler(HandleAsyncPageDestroyed); } InvalidateMeasure(); } // else; the page is not ours } }
/// <summary> /// Asynchronously handles the GetPageCompleted event. /// This means that a requested page is available, so we /// update the page's cache entry, mark it as clean and fire off our /// GetPageCompleted event. /// </summary> /// <param name="parameter"></param> /// <returns></returns> private object GetPageCompletedDelegate(object parameter) { GetPageCompletedEventArgs args = parameter as GetPageCompletedEventArgs; if (args == null) { throw new ArgumentOutOfRangeException("parameter"); } //Check to see if the page has been destroyed, and remove it from the Watcher. bool pageDestroyed = _pageDestroyedWatcher.IsDestroyed(args.DocumentPage); _pageDestroyedWatcher.RemovePage(args.DocumentPage); //The page was destroyed, return early. if (pageDestroyed) { return(null); } //We only update the entry if the GetPageAsync call was not canceled, //points to a valid page (i.e. is not DocumentPage.Missing) //and did not result in an Error condition. if (!args.Cancelled && args.Error == null && args.DocumentPage != DocumentPage.Missing) { if (args.DocumentPage.Size == Size.Empty) { throw new ArgumentOutOfRangeException("args"); } //Update the cache. PageCacheEntry newEntry; newEntry.PageSize = args.DocumentPage.Size; newEntry.Dirty = false; //Create our list of changes. We can have at most two. List <PageCacheChange> changes = new List <PageCacheChange>(2); PageCacheChange change; //If we add pages such that there's going to be a gap //in the cache (for example if we get PaginationProgress events //for pages 1-3 and then 7-10), we need to fill in the gap with entries. if (args.PageNumber > _cache.Count - 1) { //Add the new page (this will cause any pages we //skipped over to be filled in) change = AddRange(args.PageNumber, 1); if (change != null) { changes.Add(change); } //Update the just-retrieved-page to reflect the actual page size. change = UpdateEntry(args.PageNumber, newEntry); if (change != null) { changes.Add(change); } } else { //Just update the retrieved page's cache entry. change = UpdateEntry(args.PageNumber, newEntry); if (change != null) { changes.Add(change); } } //If this page is a different size than the last-retrieved page, then we have a //dynamic document. if (_isDefaultSizeKnown && newEntry.PageSize != _lastPageSize) { _dynamicPageSizes = true; } _lastPageSize = newEntry.PageSize; //If this is the first page in the document that we've actually retrieved from //the DocumentPaginator, we'll use this page's size as the default size and //update any dirty pages in the cache with this default size. //(Technically there should be no non-dirty pages in the document at this point, but //if we want to change our heuristic (for example, use the "most common page size") //to define the default then we don't want to clobber known pages.) if (!_isDefaultSizeKnown) { _defaultPageSize = newEntry.PageSize; _isDefaultSizeKnown = true; SetDefaultPageSize(true); } //Fire off our PageCacheChanged event. FirePageCacheChangedEvent(changes); } //Fire the GetPageCompleted event. if (GetPageCompleted != null) { GetPageCompleted(this, args); } return(null); }
protected override void OnGetPageCompleted(GetPageCompletedEventArgs e) { base.OnGetPageCompleted(e); }
// Token: 0x06006FE6 RID: 28646 RVA: 0x00202802 File Offset: 0x00200A02 internal void NotifyGetPageCompleted(GetPageCompletedEventArgs e) { this.OnGetPageCompleted(e); }
// 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); }