/// <summary>
/// Retrieves DocumentViewerBase that hosts this view.
/// </summary>
/// <returns>DocumentViewerBase that hosts this view.</returns>
private DocumentViewerBase GetHostViewer()
{
DocumentViewerBase hostViewer = null;
Visual visualParent;
// First do quick check for TemplatedParent. It will cover good
// amount of cases, because static viewers will have their
// DocumentPageViews defined in the style.
// If quick check does not work, do a visual tree walk.
if (this.TemplatedParent is DocumentViewerBase)
{
hostViewer = (DocumentViewerBase)this.TemplatedParent;
}
else
{
// Check if hosted by DocumentViewerBase.
visualParent = VisualTreeHelper.GetParent(this) as Visual;
while (visualParent != null)
{
if (visualParent is DocumentViewerBase)
{
hostViewer = (DocumentViewerBase)visualParent;
break;
}
visualParent = VisualTreeHelper.GetParent(visualParent) as Visual;
}
}
return(hostViewer);
}
//-------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
/// <summary>
/// Constructor.
/// </summary>
/// <param name="viewer">Viewer associated with TextView.</param>
/// <param name="renderScope">Render scope - root of layout structure visualizing content.</param>
/// <param name="textContainer">TextContainer representing content.</param>
internal MultiPageTextView(DocumentViewerBase viewer, UIElement renderScope, ITextContainer textContainer)
{
_viewer = viewer;
_renderScope = renderScope;
_textContainer = textContainer;
_pageTextViews = new List<DocumentPageTextView>();
OnPagesUpdatedCore();
}
// Token: 0x06005D93 RID: 23955 RVA: 0x001A5704 File Offset: 0x001A3904
private bool ShouldReflowContent()
{
bool result = false;
if (DocumentViewerBase.GetIsMasterPage(this))
{
DocumentViewerBase hostViewer = this.GetHostViewer();
if (hostViewer != null)
{
result = hostViewer.IsMasterPageView(this);
}
}
return(result);
}
/// <summary>
/// Check whether content needs to be reflowed.
/// </summary>
/// <returns>True, if content needs to be reflowed.</returns>
private bool ShouldReflowContent()
{
bool shouldReflow = false;
DocumentViewerBase hostViewer;
if (DocumentViewerBase.GetIsMasterPage(this))
{
hostViewer = GetHostViewer();
if (hostViewer != null)
{
shouldReflow = hostViewer.IsMasterPageView(this);
}
}
return(shouldReflow);
}
// Token: 0x06005D94 RID: 23956 RVA: 0x001A5730 File Offset: 0x001A3930
private DocumentViewerBase GetHostViewer()
{
DocumentViewerBase result = null;
if (base.TemplatedParent is DocumentViewerBase)
{
result = (DocumentViewerBase)base.TemplatedParent;
}
else
{
for (Visual visual = VisualTreeHelper.GetParent(this) as Visual; visual != null; visual = (VisualTreeHelper.GetParent(visual) as Visual))
{
if (visual is DocumentViewerBase)
{
result = (DocumentViewerBase)visual;
break;
}
}
}
return(result);
}
internal BringIntoViewState(DocumentViewerBase source, ContentPosition contentPosition, DependencyObject targetObject, Rect targetRect)
{
this.Source = source;
this.ContentPosition = contentPosition;
this.TargetObject = targetObject;
this.TargetRect = targetRect;
}
/// <summary>
/// Checks if all of the pages in a given range are currently visible,
/// and if yes - returns true
/// </summary>
/// <param name="viewer">the viewer</param>
/// <param name="startPage">first page in range to check for visibility</param>
/// <param name="endPage">last page in range to check for visibility</param>
/// <returns>true all pages in the range are visible, false otherwise</returns>
private static bool AreAllPagesVisible(DocumentViewerBase viewer, int startPage, int endPage)
{
Invariant.Assert(viewer != null, "viewer is null.");
Invariant.Assert(endPage >= startPage, "EndPage is less than StartPage");
bool pageVisibility = true;
//if visible pages are less than selected then we have invisible pages
// for sure
if (viewer.PageViews.Count <= endPage - startPage)
return false;
for (int page = startPage; page <= endPage; page++)
{
if (FindView(viewer, page) == null)
{
//there is at least one invisible page
pageVisibility = false;
break;
}
}
return pageVisibility;
}
/// <summary>
/// Gets the DocumentPageView for a particular page if any
/// </summary>
/// <param name="viewer">DocumentViewer</param>
/// <param name="pageNb">pageNb</param>
/// <returns>DocumentPageView; null if page is not loaded</returns>
internal static DocumentPageView FindView(DocumentViewerBase viewer, int pageNb)
{
Invariant.Assert(viewer != null, "viewer is null");
Invariant.Assert(pageNb >= 0, "negative pageNb");
foreach (DocumentPageView view in viewer.PageViews)
{
if (view.PageNumber == pageNb)
return view;
}
return null;
}
/// <summary>
/// Returns the AnnotationService enabled for the viewer. If no service is
/// enabled for the viewer, returns null.
/// </summary>
/// <param name="viewer">viewer to check for an enabled AnnotationService</param>
/// <returns>the AnnotationService instance for this viewer, null if a service
/// is not enabled for this viewer</returns>
/// <exception cref="ArgumentNullException">viewer is null</exception>
public static AnnotationService GetService(DocumentViewerBase viewer)
{
if (viewer == null)
throw new ArgumentNullException("viewer");
return viewer.GetValue(AnnotationService.ServiceProperty) as AnnotationService;
}
/// <summary>
/// Unregister for notifications from the viewer and its DPVs for
/// any changes that may occur.
/// </summary>
private void UnregisterOnDocumentViewer(DocumentViewerBase viewer)
{
Invariant.Assert(viewer != null, "Parameter 'viewer' is null.");
foreach (DocumentPageView view in _views)
{
view.PageConnected -= new EventHandler(OnContentChanged);
}
_views.Clear();
viewer.PageViewsChanged -= new EventHandler(OnPageViewsChanged);
}
/// <summary>
/// Register for notifications from the viewer and its DPVs for
/// any changes that may occur. As DPV content goes away we
/// need to unload annotations.
/// </summary>
private void RegisterOnDocumentViewer(DocumentViewerBase viewer)
{
Invariant.Assert(viewer != null, "Parameter 'viewer' is null.");
Invariant.Assert(_views.Count == 0, "Failed to unregister on a viewer before registering on new viewer.");
foreach (DocumentPageView view in viewer.PageViews)
{
view.PageConnected += new EventHandler(OnContentChanged);
_views.Add(view);
}
viewer.PageViewsChanged += new EventHandler(OnPageViewsChanged);
}
/// <summary>
/// Creates an instance of the AnnotationService focused on a particular
/// DocumentViewerBase.
/// </summary>
/// <param name="viewer">the viewer this service will operate on</param>
/// <exception cref="ArgumentNullException">viewer is null</exception>
public AnnotationService(DocumentViewerBase viewer)
{
if (viewer == null)
throw new ArgumentNullException("viewer");
Initialize(viewer);
}
/// <summary>
/// Finds the DocumentViewerBase object if root is DocumentViewerBase or FlowDocumentReader
/// in paginated mode. If the root is FDSV or FDR in scroll mode - sets only the document;
/// </summary>
/// <param name="root">root the service is enabled on</param>
/// <param name="documentViewerBase">DocumentViewerBase used by the viewer</param>
/// <param name="document">document for the viewer</param>
static private void GetViewerAndDocument(DependencyObject root, out DocumentViewerBase documentViewerBase, out IDocumentPaginatorSource document)
{
documentViewerBase = root as DocumentViewerBase;
// Initialize out parameters
document = null;
if (documentViewerBase != null)
{
document = documentViewerBase.Document;
}
else
{
FlowDocumentReader reader = root as FlowDocumentReader;
if (reader != null)
{
documentViewerBase = AnnotationHelper.GetFdrHost(reader) as DocumentViewerBase;
document = reader.Document;
}
else
{
FlowDocumentScrollViewer docScrollViewer = root as FlowDocumentScrollViewer;
// For backwards compatibility with internal APIs - you can enable
// a service on any element with internal APIs - so the root might
// not be neither an FDR or a FDSV
if (docScrollViewer != null)
{
document = docScrollViewer.Document;
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="owner">Owner of the AutomationPeer.</param>
public DocumentViewerBaseAutomationPeer(DocumentViewerBase owner)
: base(owner)
{ }
/// <summary>
/// New instance
/// </summary>
public DocumentViewerBaseRunReader(DocumentViewerBase docViewer)
{
this.docViewer = docViewer;
}