private void _NotifyPageCompleted(FixedPage result, Exception error, bool cancelled, object userToken)
 {
     if (GetPageRootCompleted != null)
     {
         GetPageRootCompletedEventArgs e = new GetPageRootCompletedEventArgs(result, error, cancelled, userToken);
         GetPageRootCompleted(this, e);
     }
 }
        // Token: 0x06002CE2 RID: 11490 RVA: 0x000CA868 File Offset: 0x000C8A68
        private void OnGetPageRootCompleted(object sender, GetPageRootCompletedEventArgs args)
        {
            PageContent pageContent = (PageContent)sender;

            pageContent.GetPageRootCompleted -= this.OnGetPageRootCompleted;
            this._pendingPages.Remove(pageContent);
            ArrayList arrayList = new ArrayList();
            IEnumerator <KeyValuePair <object, FixedDocument.GetPageAsyncRequest> > enumerator = this._asyncOps.GetEnumerator();

            try
            {
                while (enumerator.MoveNext())
                {
                    KeyValuePair <object, FixedDocument.GetPageAsyncRequest> keyValuePair = enumerator.Current;
                    FixedDocument.GetPageAsyncRequest value = keyValuePair.Value;
                    if (value.PageContent == pageContent)
                    {
                        ArrayList arrayList2 = arrayList;
                        keyValuePair = enumerator.Current;
                        arrayList2.Add(keyValuePair.Key);
                        DocumentPage page = DocumentPage.Missing;
                        if (!value.Cancelled && !args.Cancelled && args.Error == null)
                        {
                            FixedPage result    = args.Result;
                            Size      fixedSize = this.ComputePageSize(result);
                            page = new FixedDocumentPage(this, result, fixedSize, this.Pages.IndexOf(pageContent));
                        }
                        this._NotifyGetPageAsyncCompleted(page, value.PageNumber, args.Error, value.Cancelled, value.UserState);
                    }
                }
            }
            finally
            {
                foreach (object key in arrayList)
                {
                    this._asyncOps.Remove(key);
                }
            }
        }
        private void OnGetPageRootCompleted(object sender, GetPageRootCompletedEventArgs args)
        {
            DocumentsTrace.FixedFormat.IDF.Trace(string.Format("IDP.OnGetPageRootCompleted {0}", Pages.IndexOf((PageContent)sender)));
            // Mark this page as no longer pending
            PageContent pc = (PageContent)sender;
            pc.GetPageRootCompleted -= new GetPageRootCompletedEventHandler(OnGetPageRootCompleted);
            _pendingPages.Remove(pc);

            // Notify all outstanding request for this particular page
            ArrayList completedRequests = new ArrayList();
            IEnumerator<KeyValuePair<Object, GetPageAsyncRequest>> ienum = _asyncOps.GetEnumerator();
            try
            {
                while (ienum.MoveNext())
                {
                    GetPageAsyncRequest asyncRequest = ienum.Current.Value;
                    // Process any outstanding request for this PageContent
                    if (asyncRequest.PageContent == pc)
                    {
                        completedRequests.Add(ienum.Current.Key);
                        DocumentPage result = DocumentPage.Missing;
                        if (!asyncRequest.Cancelled)
                        {
                            // Do synchronous measure since we have obtained the page
                            if (!args.Cancelled && (args.Error == null))
                            {
                                FixedPage c = (FixedPage)args.Result;
                                Size fixedSize = ComputePageSize(c);

//                              Measure / Arrange in GetVisual override of FixedDocumentPage, not here
                                result = new FixedDocumentPage(this, c, fixedSize, Pages.IndexOf(pc));
                            }
                        }
                        // this could throw
                        _NotifyGetPageAsyncCompleted(result, asyncRequest.PageNumber, args.Error, asyncRequest.Cancelled, asyncRequest.UserState);
                    }
                }
            }
            finally
            {
                // Remove completed requests from current async ops list
                foreach (Object userState in completedRequests)
                {
                    _asyncOps.Remove(userState);
                }
            }
        }
 private void _NotifyPageCompleted(FixedPage result, Exception error, bool cancelled, object userToken)
 {
     if (GetPageRootCompleted != null)
     {
         GetPageRootCompletedEventArgs e = new GetPageRootCompletedEventArgs(result, error, cancelled, userToken);
         GetPageRootCompleted(this, e);
     }
 }