public PDFRendererPageControl(int page, PDFRendererControl pdf_renderer_control, PDFRendererControlStats pdf_renderer_control_stats, bool add_bells_and_whistles)
{
InitializeComponent();
this.page = page;
this.pdf_renderer_control = pdf_renderer_control;
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.add_bells_and_whistles = add_bells_and_whistles;
// Start with a reasonable size
this.Background = Brushes.White;
this.Height = remembered_image_height * pdf_renderer_control_stats.zoom_factor;
this.Width = remembered_image_width * pdf_renderer_control_stats.zoom_factor;
page_layers = new List <PageLayer>();
// Try to trap the DAMNED cursor keys escape route
KeyboardNavigation.SetDirectionalNavigation(this, KeyboardNavigationMode.None);
SetOperationMode(PDFRendererControl.OperationMode.Hand);
this.MouseDown += PDFRendererPageControl_MouseDown;
this.pdf_renderer_control_stats.pdf_document.PDFRenderer.OnPageTextAvailable += pdf_renderer_OnPageTextAvailable;
if (add_bells_and_whistles)
{
DropShadowEffect dse = new DropShadowEffect();
dse.Color = ThemeColours.Background_Color_Blue_Dark;
this.Effect = dse;
}
PopulateNeededLayers();
}
public PDFHandLayer(PDFRendererControl pdf_renderer_control, int page)
{
WPFDoEvents.AssertThisCodeIsRunningInTheUIThread();
this.page = page;
this.pdf_renderer_control = new WeakReference <PDFRendererControl>(pdf_renderer_control);
InitializeComponent();
Background = Brushes.Transparent;
Cursor = Cursors.Hand;
PDFRendererControlStats pdf_renderer_control_stats = pdf_renderer_control.GetPDFRendererControlStats();
int start_page_offset = pdf_renderer_control_stats.StartPageOffset;
if (0 != start_page_offset)
{
ObjPageNumberControl.SetPageNumber(String.Format("{2} ({0}/{1})", page, pdf_renderer_control_stats.pdf_document.PageCountAsString, (page + start_page_offset - 1)));
}
else
{
ObjPageNumberControl.SetPageNumber(String.Format("{0}/{1}", page, pdf_renderer_control_stats.pdf_document.PageCountAsString));
}
MouseDown += PDFHandLayer_MouseDown;
MouseUp += PDFHandLayer_MouseUp;
MouseMove += PDFHandLayer_MouseMove;
//Unloaded += PDFHandLayer_Unloaded;
Dispatcher.ShutdownStarted += Dispatcher_ShutdownStarted;
}
public PDFHighlightLayer(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
InitializeComponent();
this.Background = Brushes.Transparent;
this.Cursor = Cursors.Pen;
drag_area_tracker = new DragAreaTracker(this, false);
drag_area_tracker.OnDragStarted += drag_area_tracker_OnDragStarted;
drag_area_tracker.OnDragInProgress += drag_area_tracker_OnDragInProgress;
drag_area_tracker.OnDragComplete += drag_area_tracker_OnDragComplete;
text_selection_manager = new TextSelectionManager();
this.SizeChanged += PDFHighlightLayer_SizeChanged;
SetLeft(ObjHighlightRenderer, 0);
SetTop(ObjHighlightRenderer, 0);
this.text_layer_selection_mode = TextLayerSelectionMode.Sentence;
this.CurrentColourNumber = 0;
this.Loaded += PDFHighlightLayer_Loaded;
}
public PDFHandLayer(PDFRendererControlStats pdf_renderer_control_stats, int page, PDFRendererControl pdf_renderer_control)
{
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
this.pdf_renderer_control = pdf_renderer_control;
InitializeComponent();
Background = Brushes.Transparent;
Cursor = Cursors.Hand;
int start_page_offset = pdf_renderer_control_stats.StartPageOffset;
if (0 != start_page_offset)
{
ObjPageNumberControl.SetPageNumber(String.Format("{2} ({0}/{1})", page, pdf_renderer_control_stats.pdf_document.PDFRenderer.PageCount, (page + start_page_offset - 1)));
}
else
{
ObjPageNumberControl.SetPageNumber(String.Format("{0}/{1}", page, pdf_renderer_control_stats.pdf_document.PDFRenderer.PageCount));
}
MouseDown += PDFHandLayer_MouseDown;
MouseUp += PDFHandLayer_MouseUp;
MouseMove += PDFHandLayer_MouseMove;
}
public PDFTextSentenceLayer(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
InitializeComponent();
Focusable = true;
KeyboardNavigation.SetDirectionalNavigation(this, KeyboardNavigationMode.Once);
Background = Brushes.Transparent;
Cursor = Cursors.IBeam;
SizeChanged += PDFTextSentenceLayer_SizeChanged;
drag_area_tracker = new DragAreaTracker(this, false);
drag_area_tracker.OnDragStarted += drag_area_tracker_OnDragStarted;
drag_area_tracker.OnDragInProgress += drag_area_tracker_OnDragInProgress;
drag_area_tracker.OnDragComplete += drag_area_tracker_OnDragComplete;
text_selection_manager = new TextSelectionManager();
PreviewMouseDown += PDFTextSentenceLayer_PreviewMouseDown;
PreviewKeyDown += PDFTextLayer_PreviewKeyDown;
RequestBringIntoView += PDFTextSentenceLayer_RequestBringIntoView;
text_layer_selection_mode = TextLayerSelectionMode.Sentence;
}
public JumpToSectionPopup(PDFReadingControl pdf_reading_control, PDFRendererControl pdf_render_control, PDFRendererControlStats pdf_renderer_control_stats)
{
InitializeComponent();
this.pdf_reading_control = pdf_reading_control;
this.pdf_render_control = pdf_render_control;
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.popup = new AugmentedPopup(this);
// Add the bit explaining how to use bookmarks
{
TextBlock tb = new TextBlock();
tb.FontWeight = FontWeights.Bold;
tb.Text = "Bookmarks:";
this.Children.Add(tb);
}
{
{
MenuItem mi = new MenuItem();
mi.Header =
""
+ "You can create up to 9 bookmarks while reading a PDF by\n"
+ "holding down CTRL+SHIFT and pressing a number from 1 to 9.";
this.Children.Add(mi);
}
{
MenuItem mi = new MenuItem();
mi.Header =
""
+ "You can later jump to a remembered bookmark by\n"
+ "holding down CTRL and pressing a number from 1 to 9.";
this.Children.Add(mi);
}
}
this.Children.Add(new AugmentedSpacer());
// Then add the sections
{
TextBlock tb = new TextBlock();
tb.FontWeight = FontWeights.Bold;
tb.Text = "Sections:";
this.Children.Add(tb);
}
// First try from the PDF
{
BuildPopupFromPDF build_popup_from_pdf = new BuildPopupFromPDF(this);
build_popup_from_pdf.BuildMenu();
}
// If there are not enough bookmarks, go the OCR route
if (pdf_renderer_control_stats.pdf_document.PDFRenderer.PageCount < 100)
{
BuildPopupFromOCR build_popup_from_ocr = new BuildPopupFromOCR(this);
build_popup_from_ocr.BuildMenu();
}
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFHandLayer::Dispose({0}) @{1}", disposing, dispose_count);
try
{
if (0 == dispose_count)
{
WPFDoEvents.InvokeInUIThread(() =>
{
WPFDoEvents.AssertThisCodeIsRunningInTheUIThread();
try
{
foreach (var el in Children)
{
IDisposable node = el as IDisposable;
if (null != node)
{
node.Dispose();
}
}
}
catch (Exception ex)
{
Logging.Error(ex);
}
try
{
Children.Clear();
}
catch (Exception ex)
{
Logging.Error(ex);
}
MouseDown -= PDFHandLayer_MouseDown;
MouseUp -= PDFHandLayer_MouseUp;
MouseMove -= PDFHandLayer_MouseMove;
DataContext = null;
}, Dispatcher);
}
// Clear the references for sanity's sake
pdf_renderer_control_stats = null;
pdf_renderer_control = null;
}
catch (Exception ex)
{
Logging.Error(ex);
}
++dispose_count;
//base.Dispose(disposing); // parent only throws an exception (intentionally), so depart from best practices and don't call base.Dispose(bool)
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFTextSentenceLayer::Dispose({0}) @{1}", disposing, dispose_count);
try
{
if (null != drag_area_tracker)
{
WPFDoEvents.InvokeInUIThread(() =>
{
try
{
foreach (var el in Children)
{
IDisposable node = el as IDisposable;
if (null != node)
{
node.Dispose();
}
}
}
catch (Exception ex)
{
Logging.Error(ex);
}
try
{
ClearChildren();
Children.Clear();
}
catch (Exception ex)
{
Logging.Error(ex);
}
drag_area_tracker.OnDragStarted -= drag_area_tracker_OnDragStarted;
drag_area_tracker.OnDragInProgress -= drag_area_tracker_OnDragInProgress;
drag_area_tracker.OnDragComplete -= drag_area_tracker_OnDragComplete;
}, Dispatcher);
}
// Clear the references for sanity's sake
pdf_renderer_control_stats = null;
drag_area_tracker = null;
text_selection_manager = null;
DataContext = null;
}
catch (Exception ex)
{
Logging.Error(ex);
}
++dispose_count;
//base.Dispose(disposing); // parent only throws an exception (intentionally), so depart from best practices and don't call base.Dispose(bool)
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFInkLayer::Dispose({0}) @{1}", disposing, dispose_count);
try
{
if (0 == dispose_count)
{
WPFDoEvents.InvokeInUIThread(() =>
{
ObjInkCanvas.StrokeCollected -= ObjInkCanvas_StrokeCollected;
ObjInkCanvas.StrokeErased -= ObjInkCanvas_StrokeErased;
ObjInkCanvas.SelectionMoved -= ObjInkCanvas_SelectionMoved;
ObjInkCanvas.SelectionResized -= ObjInkCanvas_SelectionResized;
ObjInkCanvas.RequestBringIntoView -= ObjInkCanvas_RequestBringIntoView;
try
{
foreach (var el in Children)
{
IDisposable node = el as IDisposable;
if (null != node)
{
node.Dispose();
}
}
}
catch (Exception ex)
{
Logging.Error(ex);
}
try
{
Children.Clear();
}
catch (Exception ex)
{
Logging.Error(ex);
}
}, Dispatcher);
}
// Clear the references for sanity's sake
pdf_renderer_control_stats = null;
DataContext = null;
}
catch (Exception ex)
{
Logging.Error(ex);
}
++dispose_count;
//base.Dispose(disposing); // parent only throws an exception (intentionally), so depart from best practices and don't call base.Dispose(bool)
}
public PDFSearchLayer(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
InitializeComponent();
Background = Brushes.Transparent;
this.SizeChanged += PDFSearchLayer_SizeChanged;
}
public static bool IsLayerNeeded(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
foreach (PDFAnnotation pdf_annotation in pdf_renderer_control_stats.pdf_document.GetAnnotations())
{
if (pdf_annotation.Page == page)
{
return(true);
}
}
return(false);
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFInkLayer::Dispose({0}) @{1}", disposing, dispose_count);
WPFDoEvents.SafeExec(() =>
{
if (0 == dispose_count)
{
ObjInkCanvas.StrokeCollected -= ObjInkCanvas_StrokeCollected;
ObjInkCanvas.StrokeErased -= ObjInkCanvas_StrokeErased;
ObjInkCanvas.SelectionMoved -= ObjInkCanvas_SelectionMoved;
ObjInkCanvas.SelectionResized -= ObjInkCanvas_SelectionResized;
ObjInkCanvas.RequestBringIntoView -= ObjInkCanvas_RequestBringIntoView;
}
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
if (dispose_count == 0)
{
foreach (var el in Children)
{
IDisposable node = el as IDisposable;
if (null != node)
{
node.Dispose();
}
}
}
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
Children.Clear();
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
// Clear the references for sanity's sake
pdf_renderer_control_stats = null;
});
WPFDoEvents.SafeExec(() =>
{
DataContext = null;
});
++dispose_count;
//base.Dispose(disposing); // parent only throws an exception (intentionally), so depart from best practices and don't call base.Dispose(bool)
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFTextSentenceLayer::Dispose({0}) @{1}", disposing, dispose_count);
WPFDoEvents.SafeExec(() =>
{
if (dispose_count == 0)
{
foreach (var el in Children)
{
IDisposable node = el as IDisposable;
if (null != node)
{
node.Dispose();
}
}
}
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
ClearChildren();
Children.Clear();
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
if (drag_area_tracker != null)
{
drag_area_tracker.OnDragStarted -= drag_area_tracker_OnDragStarted;
drag_area_tracker.OnDragInProgress -= drag_area_tracker_OnDragInProgress;
drag_area_tracker.OnDragComplete -= drag_area_tracker_OnDragComplete;
}
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
// Clear the references for sanity's sake
pdf_renderer_control_stats = null;
drag_area_tracker = null;
text_selection_manager = null;
});
WPFDoEvents.SafeExec(() =>
{
DataContext = null;
});
++dispose_count;
//base.Dispose(disposing); // parent only throws an exception (intentionally), so depart from best practices and don't call base.Dispose(bool)
}
public PDFCameraLayer(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
InitializeComponent();
this.Background = Brushes.Transparent;
this.Cursor = Cursors.Cross;
drag_area_tracker = new DragAreaTracker(this);
drag_area_tracker.OnDragComplete += drag_area_tracker_OnDragComplete;
}
public PDFSearchLayer(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
WPFDoEvents.AssertThisCodeIsRunningInTheUIThread();
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
InitializeComponent();
Background = Brushes.Transparent;
SizeChanged += PDFSearchLayer_SizeChanged;
}
public JumpToSectionItem(JumpToSectionPopup jtsp, PDFReadingControl pdf_reading_control, PDFRendererControl pdf_render_control, PDFRendererControlStats pdf_renderer_control_stats, string section, int page)
{
InitializeComponent();
this.jtsp = jtsp;
this.pdf_reading_control = pdf_reading_control;
this.pdf_render_control = pdf_render_control;
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.section = section;
this.page = page;
ButtonSection.Header = section;
ButtonSection.Click += ButtonSection_Click;
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFHandLayer::Dispose({0}) @{1}", disposing, dispose_count);
WPFDoEvents.SafeExec(() =>
{
if (0 == dispose_count)
{
WPFDoEvents.AssertThisCodeIsRunningInTheUIThread();
foreach (var el in Children)
{
IDisposable node = el as IDisposable;
if (null != node)
{
node.Dispose();
}
}
}
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
Children.Clear();
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
MouseDown -= PDFHandLayer_MouseDown;
MouseUp -= PDFHandLayer_MouseUp;
MouseMove -= PDFHandLayer_MouseMove;
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
DataContext = null;
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
// Clear the references for sanity's sake
pdf_renderer_control_stats = null;
pdf_renderer_control = null;
});
++dispose_count;
//base.Dispose(disposing); // parent only throws an exception (intentionally), so depart from best practices and don't call base.Dispose(bool)
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFAnnotationItem::Dispose({0}) @{1}", disposing, dispose_count);
WPFDoEvents.SafeExec(() =>
{
if (dispose_count == 0)
{
// Get rid of managed resources / get rid of cyclic references:
if (null != pdf_annotation)
{
pdf_annotation.Bindable.PropertyChanged -= pdf_annotation_PropertyChanged;
}
ButtonAnnotationDetails.MouseEnter -= ButtonAnnotationDetails_MouseEnter;
ButtonAnnotationDetails.MouseLeave -= ButtonAnnotationDetails_MouseLeave;
ButtonAnnotationDetails.MouseDown -= ButtonAnnotationDetails_MouseDown;
TextAnnotationText.GotFocus -= TextAnnotationText_GotFocus;
TextAnnotationText.LostFocus -= TextAnnotationText_LostFocus;
TextAnnotationText.PreviewMouseDown -= TextAnnotationText_PreviewMouseDown;
TextAnnotationText.PreviewMouseMove -= TextAnnotationText_PreviewMouseMove;
TextAnnotationText.PreviewMouseUp -= TextAnnotationText_PreviewMouseUp;
ObjTagEditorControl.GotFocus -= ObjTagEditorControl_GotFocus;
ObjTagEditorControl.LostFocus -= ObjTagEditorControl_LostFocus;
ObjTagEditorControl.TagFeature_Add = null;
ObjTagEditorControl.TagFeature_Remove = null;
}
});
WPFDoEvents.SafeExec(() =>
{
// Clear the references for sanity's sake
DataContext = null;
});
WPFDoEvents.SafeExec(() =>
{
pdf_annotation_layer = null;
pdf_annotation = null;
pdf_renderer_control_stats = null;
pdf_annotation_editor_control_popup = null;
});
++dispose_count;
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFSearchLayer::Dispose({0}) @{1}", disposing, dispose_count);
WPFDoEvents.SafeExec(() =>
{
if (dispose_count == 0)
{
foreach (var el in Children)
{
IDisposable node = el as IDisposable;
if (null != node)
{
node.Dispose();
}
}
}
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
Children.Clear();
}, must_exec_in_UI_thread: true);
WPFDoEvents.SafeExec(() =>
{
DataContext = null;
}, Dispatcher);
WPFDoEvents.SafeExec(() =>
{
// Clear the references for sanity's sake
pdf_renderer_control_stats = null;
search_result_set = null;
});
++dispose_count;
//base.Dispose(disposing); // parent only throws an exception (intentionally), so depart from best practices and don't call base.Dispose(bool)
}
public PDFAnnotationLayer(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
InitializeComponent();
// Wizard
if (1 == page)
{
WizardDPs.SetPointOfInterest(this, "PDFReadingAnnotationLayer");
}
Background = Brushes.Transparent;
Cursor = Cursors.Cross;
SizeChanged += PDFAnnotationLayer_SizeChanged;
drag_area_tracker = new DragAreaTracker(this);
drag_area_tracker.OnDragComplete += drag_area_tracker_OnDragComplete;
// Add all the already existing annotations
foreach (PDFAnnotation pdf_annotation in pdf_renderer_control_stats.pdf_document.GetAnnotations())
{
if (pdf_annotation.Page == this.page)
{
if (!pdf_annotation.Deleted)
{
Logging.Info("Loading annotation on page {0}", page);
PDFAnnotationItem pdf_annotation_item = new PDFAnnotationItem(this, pdf_annotation, pdf_renderer_control_stats);
pdf_annotation_item.ResizeToPage(ActualWidth, ActualHeight);
Children.Add(pdf_annotation_item);
}
else
{
Logging.Info("Not loading deleted annotation on page {0}", page);
}
}
}
}
public PDFInkLayer(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.page = page;
InitializeComponent();
KeyboardNavigation.SetDirectionalNavigation(this, KeyboardNavigationMode.Contained);
this.SizeChanged += PDFInkLayer_SizeChanged;
ObjInkCanvas.StrokeCollected += ObjInkCanvas_StrokeCollected;
ObjInkCanvas.StrokeErased += ObjInkCanvas_StrokeErased;
ObjInkCanvas.SelectionMoved += ObjInkCanvas_SelectionMoved;
ObjInkCanvas.SelectionResized += ObjInkCanvas_SelectionResized;
ObjInkCanvas.RequestBringIntoView += ObjInkCanvas_RequestBringIntoView;
RebuildInks(page, pdf_renderer_control_stats.pdf_document.Inks);
RaiseInkChange(InkCanvasEditingMode.Ink);
}
public PDFAnnotationItem(PDFAnnotationLayer pdf_annotation_layer, PDFAnnotation pdf_annotation, PDFRendererControlStats pdf_renderer_control_stats)
{
this.pdf_annotation_layer = pdf_annotation_layer;
this.pdf_annotation = pdf_annotation;
this.pdf_renderer_control_stats = pdf_renderer_control_stats;
this.DataContext = pdf_annotation.Bindable;
InitializeComponent();
this.MouseEnter += TextAnnotationText_MouseEnter;
this.MouseLeave += TextAnnotationText_MouseLeave;
ButtonAnnotationDetails.MouseEnter += ButtonAnnotationDetails_MouseEnter;
ButtonAnnotationDetails.MouseLeave += ButtonAnnotationDetails_MouseLeave;
ButtonAnnotationDetails.Cursor = Cursors.Hand;
ButtonAnnotationDetails.MouseDown += ButtonAnnotationDetails_MouseDown;
ButtonAnnotationDetails.Source = Icons.GetAppIcon(Icons.Metadata);
ButtonAnnotationDetails.Width = 32;
ButtonAnnotationDetails.ToolTip = "Edit this annotation.";
RenderOptions.SetBitmapScalingMode(ButtonAnnotationDetails, BitmapScalingMode.HighQuality);
TextAnnotationText.Background = Brushes.Transparent;
TextAnnotationText.GotFocus += TextAnnotationText_GotFocus;
TextAnnotationText.LostFocus += TextAnnotationText_LostFocus;
TextAnnotationText.PreviewMouseDown += TextAnnotationText_PreviewMouseDown;
TextAnnotationText.PreviewMouseMove += TextAnnotationText_PreviewMouseMove;
TextAnnotationText.PreviewMouseUp += TextAnnotationText_PreviewMouseUp;
ObjTagEditorControl.GotFocus += ObjTagEditorControl_GotFocus;
ObjTagEditorControl.LostFocus += ObjTagEditorControl_LostFocus;
pdf_annotation.Bindable.PropertyChanged += pdf_annotation_PropertyChanged;
ObjTagEditorControl.TagFeature_Add = Features.Document_AddAnnotationTag;
ObjTagEditorControl.TagFeature_Remove = Features.Document_RemoveAnnotationTag;
ReColor();
}
public static bool IsLayerNeeded(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
return(pdf_renderer_control_stats.pdf_document.Highlights.GetHighlightsForPage(page).Count > 0);
}
public static bool IsLayerNeeded(PDFRendererControlStats pdf_renderer_control_stats, int page)
{
StrokeCollection stroke_collection = pdf_renderer_control_stats.pdf_document.Inks.GetInkStrokeCollection(page);
return(null != stroke_collection);
}
