> For the complete documentation index, see [llms.txt](https://docs.apryse.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.apryse.com/core/get-started/samples/pdfviewcontrol-xaml.md).
# PDF Viewer - PDFViewWPF
Sample C# code for using Apryse SDK's PDFViewWPF class.
Sample C# code for using Apryse SDK's PDFViewWPF class. Learn more about our [Server SDK for .NET](/core/get-started/frameworks/dotnet.md) and [PDF Viewer SDK](/core/viewer/viewer.md).
{% tabs %}
{% tab title="C#" %}
{% code lineNumbers="true" %}
```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using pdftron;
using pdftron.PDF;
using pdftron.SDF;
using pdftron.Common;
namespace PDFViewWPFTestCS
{
///
/// Interaction logic for PDFViewViewer.xaml
///
public partial class PDFViewViewer : UserControl
{
private PDFDoc _pdfdoc = null; // currently open PDF document
private SideWindowControl _sidecontrol;
private GridLength _oldwidth = new GridLength(200);
private PDFViewWPF.Selection _currentSearchSelection;
private List _onScreenSelection = new List();
private MainWindow Current_Main { get; set; }
public PDFViewWPF Current_View { get; set; }
public bool IsNaviOpen { get; set; }
public double NaviWidth
{
get { return DocViewerGrid.ColumnDefinitions[0].Width.Value; }
set { DocViewerGrid.ColumnDefinitions[0].Width = new GridLength(value); }
}
public double ZoomLevel
{
get { return Current_View.GetZoom(); }
set { Current_View.SetZoom(value); }
}
public string _safeDocName { get; set; }
private pdftron.PDF.Tools.ToolManager _ToolManager;
public pdftron.PDF.Tools.ToolManager ToolManager
{
get { return _ToolManager; }
}
public PDFViewViewer(MainWindow main_window)
{
InitializeComponent();
PresentationSource source = PresentationSource.FromVisual(Application.Current.MainWindow);
double scaleFactor = 1;
if (source != null)
{
scaleFactor = 1 / source.CompositionTarget.TransformFromDevice.M11;
}
Current_Main = main_window;
Current_View = new PDFViewWPF();
Current_View.PixelsPerUnitWidth = scaleFactor;
Current_View.SetRenderedContentCacheSize(16);
Current_View.UseLayoutRounding = true;
_sidecontrol = new SideWindowControl();
Current_View.SetAntiAliasing(true);
Current_View.SetPathHinting(true);
Current_View.SetThinLineAdjustment(true, true);
Current_View.SetupThumbnails(false, true, true, 500, 200 * 1024 * 1024, 0.2);
Current_View.SetProgressiveRendering(true);
Current_View.SetProgressiveRenderingInterval(750);
Current_View.SetPageBorderVisibility(true);
NaviBarGrid.Children.Add(_sidecontrol);
PDFGrid.Children.Add(Current_View);
_ToolManager = new pdftron.PDF.Tools.ToolManager(Current_View);
_ToolManager.ToolModeChanged += ToolManager_ToolModeChanged;
Current_View.Loaded += _pdfviewWpf_Loaded;
Current_View.OnSetDoc += Current_View_OnSetDoc;
Current_View.FindTextFinished += Current_View_FindTextFinished;
Current_View.LayoutChanged += Current_View_LayoutChanged;
Current_View.CurrentScrollChanged += _pdfviewWpf_ScollChanged; // set zoom textbox value
Current_View.CurrentZoomChanged += _pdfviewWpf_CurrentZoomChanged; // set zoom textbox value
Current_View.CurrentPageNumberChanged += Current_View_CurrentPageNumberChanged;
Current_View.SetDownloadReportHandler(OnDownload, null);
this.KeyDown += new KeyEventHandler(OnViewKeyDown);
this.KeyUp += new KeyEventHandler(OnViewKeyUp);
//hide sidebar
main_window.btn_collapse.IsEnabled = false;
main_window.btn_expand.IsEnabled = true;
PDFGrid.Margin = new Thickness(0);
SideWindowSplitter.DragCompleted += SideWindowSplitter_DragCompleted;
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_continuous);
Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_width);
Current_View.SetBackgroundColor(Colors.DarkGray);
Current_View.SetUrlExtraction(false);
// This allows touch interaction
Current_View.IsManipulationEnabled = true;
this.ToolManager.SelectedAnnotationsChanged += ToolManager_SelectedAnnotationsChanged;
}
private void ToolManager_SelectedAnnotationsChanged()
{
List annots = ToolManager.SelectedAnnotations;
}
///
/// This will be called each time we switch to this tab, and when we first open it.
///
///
///
private void _pdfviewWpf_Loaded(object sender, RoutedEventArgs e)
{
Current_Main.txtbox_pagenum.Text = Current_View.GetCurrentPage().ToString();
Current_Main.SetZoomValue(Current_View.GetZoom());
}
///
/// This will happen whenever we open a new document.
/// It is guaranteed to happen after the document is loaded and ready to be used, so we
/// replicate it here in case there are some timing issues between the loaded handler and he document being loaded.
///
///
void Current_View_OnSetDoc(PDFViewWPF viewer)
{
Current_Main.txtbox_pagenum.Text = Current_View.GetCurrentPage().ToString();
Current_Main.slider_zoom.Value = Current_View.GetZoom();
Current_Main.SetZoomValue(Current_View.GetZoom());
pdftron.PDF.Action open_action = viewer.GetDoc().GetOpenAction();
if (open_action.IsValid() && open_action.GetType() == pdftron.PDF.Action.Type.e_JavaScript)
{
ActionParameter action_param = new ActionParameter(open_action);
viewer.ExecuteAction(action_param);
}
}
#region Events
void ToolManager_ToolModeChanged(pdftron.PDF.Tools.ToolManager.ToolType toolType)
{
UpdateToolButtonStates();
}
public void UpdateToolButtonStates()
{
if (_ToolManager == null)
{
return;
}
Current_Main.t_pan.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_pan);
Current_Main.PanToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_pan);
Current_Main.t_annot_edit.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_annot_edit);
Current_Main.AnnotationEditToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_annot_edit);
Current_Main.t_text_rect.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_select_rectangular);
Current_Main.t_text_struct.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_select);
Current_Main.LineToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_line_create);
Current_Main.ArrowToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_arrow_create);
Current_Main.RectangleToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_rect_create);
Current_Main.OvalToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_oval_create);
Current_Main.InkToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_ink_create);
Current_Main.TextBoxToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_annot_create);
Current_Main.CalloutToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_callout_create);
Current_Main.StickyNoteToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_sticky_note_create);
Current_Main.HighlightToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_highlight);
Current_Main.UnderlineToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_underline);
Current_Main.StrikeoutToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_strikeout);
Current_Main.SquigglyToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_squiggly);
}
void Current_View_LayoutChanged(PDFViewWPF viewer)
{
UpdatePresentationModeButtonStates();
HighlightSelection();
}
public void UpdatePresentationModeButtonStates()
{
Current_Main.SinglePageButton.IsChecked = false;
Current_Main.SingleContinuousButton.IsChecked = false;
Current_Main.FacingButton.IsChecked = false;
Current_Main.FacingContinuousButton.IsChecked = false;
Current_Main.FacingCoverButton.IsChecked = false;
Current_Main.FacingCoverContinuousButton.IsChecked = false;
switch (Current_View.GetPagePresentationMode())
{
case PDFViewWPF.PagePresentationMode.e_single_page:
Current_Main.SinglePageButton.IsChecked = true;
break;
case PDFViewWPF.PagePresentationMode.e_single_continuous:
Current_Main.SingleContinuousButton.IsChecked = true;
break;
case PDFViewWPF.PagePresentationMode.e_facing:
Current_Main.FacingButton.IsChecked = true;
break;
case PDFViewWPF.PagePresentationMode.e_facing_continuous:
Current_Main.FacingContinuousButton.IsChecked = true;
break;
case PDFViewWPF.PagePresentationMode.e_facing_cover:
Current_Main.FacingCoverButton.IsChecked = true;
break;
case PDFViewWPF.PagePresentationMode.e_facing_continuous_cover:
Current_Main.FacingCoverContinuousButton.IsChecked = true;
break;
}
}
void SideWindowSplitter_DragCompleted(object sender, System.Windows.Controls.Primitives.DragCompletedEventArgs e)
{
Current_Main.UpdateSidewindowButtons();
}
public void SetCurrentPage(int page)
{
Current_View.CurrentPageNumber = page;
//Current_View.SetCurrentPage(page);
}
void _pdfviewWpf_CurrentZoomChanged(PDFViewWPF viewer)
{
double zoom = Current_View.GetZoom();
Current_Main.SetZoomValue(zoom);
HighlightSelection();
}
void _pdfviewWpf_ScollChanged(PDFViewWPF viewer, ScrollChangedEventArgs e)
{
//add you code here
}
void Current_View_CurrentPageNumberChanged(PDFViewWPF viewer, int currentPage, int totalPages)
{
Current_Main.txtbox_pagenum.Text = currentPage.ToString();
HighlightSelection();
}
void txtbox_pagenum_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter && !string.IsNullOrWhiteSpace(Current_Main.txtbox_pagenum.Text))
{
int pagenum;
if (Int32.TryParse(Current_Main.txtbox_pagenum.Text, out pagenum))
Current_View.SetCurrentPage(pagenum);
}
}
private void txtbox_zoom_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter && !string.IsNullOrWhiteSpace(Current_Main.txtbox_zoom.Text))
{
int newzoom;
if (Int32.TryParse(Current_Main.txtbox_zoom.Text, out newzoom))
Current_View.SetZoom(newzoom / 100.0);
}
}
private void OnViewKeyDown(object sender, KeyEventArgs e)
{
if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
{
if (e.Key == Key.F)
{
if (Current_Main.FindTextDialog == null)
{
Current_Main.FindTextDialog = new FindTextDialog();
Current_Main.FindTextDialog.Owner = Current_Main;
Current_Main.FindTextDialog.Show();
}
else
{
Current_Main.FindTextDialog.ActivateFindText();
}
}
if (e.Key == Key.S)
{
if (_pdfdoc != null && Current_View != null && (_pdfdoc.IsModified()))
this.Save(_pdfdoc.GetFileName());
}
}
}
void OnViewKeyUp(object sender, KeyEventArgs e)
{
}
public void OpenNavibar()
{
DocViewerGrid.ColumnDefinitions[0].Width = new GridLength(200);
Current_Main.btn_expand.IsEnabled = false;
Current_Main.btn_collapse.IsEnabled = true;
IsNaviOpen = true;
}
public void CloseNavibar()
{
_oldwidth = DocViewerGrid.ColumnDefinitions[0].Width;
DocViewerGrid.ColumnDefinitions[0].Width = new GridLength(0);
Current_Main.btn_collapse.IsEnabled = false;
Current_Main.btn_expand.IsEnabled = true;
IsNaviOpen = false;
}
#endregion
#region Methods
public bool OpenPDF(String filename)
{
try
{
try
{
_pdfdoc = new PDFDoc(filename);
}
catch (Exception ex)
{
_pdfdoc = OpenImage(filename);
if (_pdfdoc == null)
throw ex;
}
if (!_pdfdoc.InitSecurityHandler())
{
MessageBox.Show("Document authentication error", "PDFViewWPF Error");
return false;
}
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_continuous);
Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_width);
Current_View.SetUrlExtraction(false);
if (_pdfdoc.GetPageCount() > 2000)
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_page);
}
Current_View.SetDoc(_pdfdoc);
_sidecontrol.CreateSideWindow(Current_View, _ToolManager);
}
catch (PDFNetException ex)
{
MessageBox.Show(ex.Message);
return false;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
return false;
}
return true;
}
// A utility function used to display other images types besides PDF (TIF, JPEG, BMG,PNG, etc)
public PDFDoc OpenImage(string filename)
{
try
{
PDFDoc pdfDoc = new PDFDoc();
ElementBuilder f = new ElementBuilder();
ElementWriter writer = new ElementWriter();
pdftron.PDF.Page page = pdfDoc.PageCreate();
writer.Begin(page);
// Add image to the document
pdftron.PDF.Image img = pdftron.PDF.Image.Create(pdfDoc, filename);
pdftron.PDF.Rect imgBox = new pdftron.PDF.Rect(0, 0, img.GetImageWidth(), img.GetImageHeight());
pdftron.PDF.Rect scaledBox = new pdftron.PDF.Rect();
double scaleFactor;
if (imgBox.Height() / imgBox.Width() > 792 / 612)
scaleFactor = imgBox.Height() / 792;
else
scaleFactor = imgBox.Width() / 612;
scaledBox.x2 = imgBox.x2 / scaleFactor;
scaledBox.y2 = imgBox.y2 / scaleFactor;
// set crop and media box of this page to fit with the scaled image
page.SetCropBox(scaledBox);
page.SetMediaBox(scaledBox);
// create the image element and add it to the page
int width = (int)scaledBox.Width();
int height = (int)scaledBox.Height();
int offsetX = 0;
int offsetY = 0;
Element element = f.CreateImage(img, new Matrix2D(width, 0, 0, height, offsetX, offsetY));
writer.WritePlacedElement(element);
writer.End(); // Finish writing to the page
pdfDoc.PagePushBack(page);
return pdfDoc;
}
catch (Exception)
{
return null;
}
}
public bool OpenURL(String url, String password)
{
try
{
// Open a PDF file at the given url. This works best with PDF's that
// are linearized, as pages can be downloaded and viewed in random access order,
// without the need to download the entire document. A viewing session can also be
// persisted across multiple viewing/application sessions to remove redundant downloads
// and improve overall performance by using the optional cache_file parameter.
_ToolManager.IsEnabled = false;
Current_View.OpenURLAsync(url, "", password);
}
catch (PDFNetException ex)
{
_ToolManager.IsEnabled = true;
MessageBox.Show(ex.Message);
return false;
}
catch (Exception ex)
{
_ToolManager.IsEnabled = true;
MessageBox.Show(ex.ToString());
return false;
}
return true;
}
public PDFDoc GetPDFDoc()
{
if (_pdfdoc == null) return null;
else return Current_View.GetDoc();
}
public void SetPageViewMode(PDFViewWPF.PageViewMode mode)
{
Current_View.SetPageViewMode(mode);
}
public PDFViewWPF.PageViewMode GetPageViewMode()
{
return Current_View.GetPageViewMode();
}
public void FitPage()
{
Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_page);
}
public void FitWidth()
{
Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_width);
}
public double GetZoom()
{
return Current_View.GetZoom();
}
public void SetZoom(double zoom)
{
Current_View.SetZoom(zoom);
}
public void ZoomIn()
{
Current_View.SetZoom(Current_View.GetZoom() * 1.25);
}
public void ZoomOut()
{
Current_View.SetZoom(Current_View.GetZoom() / 1.25);
}
public int GetCurrentPageNumber()
{
return Current_View.GetCurrentPage();
}
public void FirstPage()
{
Current_View.GotoFirstPage();
}
public void PrevPage()
{
Current_View.GotoPreviousPage();
}
public void NextPage()
{
Current_View.GotoNextPage();
}
public void LastPage()
{
Current_View.GotoLastPage();
}
public void PageSingle()
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_page);
}
public void PageSingleContinuous()
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_continuous);
}
public void PageFacingContinuous()
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing_continuous);
}
public void PageFacing()
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing);
}
public void PageFacingCover()
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing_cover);
}
public void PageFacingCoverContinous()
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing_continuous_cover);
}
public void RotateClockwise()
{
Current_View.RotateClockwise();
Current_View.UpdatePageLayout();
Current_View.Update();
}
public void RotateCounterClockwise()
{
Current_View.RotateCounterClockwise();
//Current_View.UpdatePageLayout();
//Current_View.Update();
}
public pdftron.PDF.Page.Rotate GetRotation()
{
return Current_View.GetRotation();
}
public void SetAntiAliasing(bool anti_alias)
{
Current_View.SetAntiAliasing(anti_alias);
Current_View.Update();
}
public void SetRasterizer(bool built_in)
{
if (built_in)
Current_View.SetRasterizerType(PDFRasterizer.Type.e_BuiltIn);
else
Current_View.SetRasterizerType(PDFRasterizer.Type.e_GDIPlus);
Current_View.Update();
}
public void SetSmoothImages(bool smooth_images)
{
Current_View.SetImageSmoothing(smooth_images);
Current_View.Update();
}
///
///
///
/// The path to save the file to
/// true if we should save, whether or not it is modified
public void Save(string filename, bool force = false)
{
if (_pdfdoc == null) return;
System.IO.FileInfo fi = new System.IO.FileInfo(filename);
if (fi.Exists && fi.IsReadOnly)
{
MessageBox.Show("This is a read only file. Please choose Save As and enter a new file name to save.", "Error during the Save");
return;
}
bool locked = false;
try
{
bool shouldSave = force;
if (!shouldSave)
{
Current_View.DocLock(true);
locked = true;
if (_pdfdoc.IsModified())
{
Current_View.DocUnlock();
locked = false;
shouldSave = true;
}
}
if (shouldSave)
{
Current_View.CancelRendering();
_pdfdoc.Save(filename, pdftron.SDF.SDFDoc.SaveOptions.e_incremental);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error during the Save");
}
finally
{
if (locked)
{
Current_View.DocUnlock();
}
}
}
public string SaveAs()
{
if (_pdfdoc != null && Current_View != null)
{
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.Filter = "PDF Files (*.pdf)|*.pdf|All Files (*.*)|*.*";
dlg.DefaultExt = ".pdf";
dlg.FileName = _pdfdoc.GetFileName();
if (dlg.ShowDialog() == true)
{
this.Save(dlg.FileName);
return dlg.SafeFileName;
}
}
return null;
}
public bool CloseFile()
{
if (_pdfdoc != null && Current_View != null && _pdfdoc.IsModified())
{
string messageBoxText = "Would you like to save changes to " + _safeDocName + "?";
string caption = "PDFViewWPF";
MessageBoxButton button = MessageBoxButton.YesNoCancel;
MessageBoxImage icon = MessageBoxImage.Question;
MessageBoxResult defaultResult = MessageBoxResult.Yes;
MessageBoxOptions options = MessageBoxOptions.DefaultDesktopOnly;
MessageBoxResult result;
result = MessageBox.Show(messageBoxText, caption, button, icon, defaultResult, options);
if (result == MessageBoxResult.Yes)
{
this.Save(_pdfdoc.GetFileName());
Dispose();
return true;
}
else if (result == MessageBoxResult.No)
{
Dispose();
return true;
}
else
return false;
}
else
{
Dispose();
return true;
}
}
public void Dispose()
{
Current_View.CloseDoc();
Current_View.Dispose();
if(_pdfdoc != null) _pdfdoc.Dispose();
}
public void Activate()
{
Current_View.Activate();
_sidecontrol.Activate();
}
public void Deactivate()
{
Current_View.Deactivate();
_sidecontrol.Deactivate();
}
//public void SetToolMode(PDFViewWPF.ToolMode tool_mode)
//{
// Current_View.SetToolMode(tool_mode);
//}
public void CopySelectedText()
{
Current_View.CopySelectedTextToClipboardAsUnicode();
}
public void SelectAll()
{
_ToolManager.CurrentTool.SelectAll();
}
public void DeselectAll()
{
_ToolManager.CurrentTool.DeselectAll();
}
public void FindText(string str, bool match_case, bool match_whole_word, bool search_up, bool reg_exp)
{
Current_View.FindText(str, match_case, match_whole_word, search_up, reg_exp); // Use the build in Find text dialog.
}
void Current_View_FindTextFinished(PDFViewWPF viewer, bool found, PDFViewWPF.Selection selection)
{
Current_Main.FindTextFinishedHandler(viewer, found, selection);
_currentSearchSelection = selection;
HighlightSelection();
viewer.ClearSelection();
_ToolManager.ClearSelectedTextHighlighting();
}
///
/// Highlights the search result if any
///
/// A text selection acquired by mPDFView.FindText
/// true if and only if the selections contains at least one highlight
private bool HighlightSelection()
{
ClearSearchSelection();
if (_currentSearchSelection == null)
{
return false;
}
double[] quads = _currentSearchSelection.GetQuads();
int numQuads = quads.Length / 8;
int pageNumber = _currentSearchSelection.GetPageNum();
int quadNumber = 0;
int[] visiblePages = Current_View.GetVisiblePages();
if (!visiblePages.Contains(pageNumber))
{
return false;
}
List rects = new List();
// get highlights in control (screen) space
for (int i = 0; i < numQuads; i++)
{
quadNumber = i * 8;
double x1 = quads[quadNumber + 0];
double y1 = quads[quadNumber + 1];
double x2 = quads[quadNumber + 2];
double y2 = quads[quadNumber + 3];
double x3 = quads[quadNumber + 4];
double y3 = quads[quadNumber + 5];
double x4 = quads[quadNumber + 6];
double y4 = quads[quadNumber + 7];
Current_View.ConvPagePtToScreenPt(ref x1, ref y1, pageNumber);
Current_View.ConvPagePtToScreenPt(ref x2, ref y2, pageNumber);
Current_View.ConvPagePtToScreenPt(ref x3, ref y3, pageNumber);
Current_View.ConvPagePtToScreenPt(ref x4, ref y4, pageNumber);
double left, right, top, bottom;
left = Math.Min(x1, Math.Min(x2, Math.Min(x3, x4)));
right = Math.Max(x1, Math.Max(x2, Math.Max(x3, x4)));
top = Math.Min(y1, Math.Min(y2, Math.Min(y3, y4)));
bottom = Math.Max(y1, Math.Max(y2, Math.Max(y3, y4)));
rects.Add(new System.Windows.Rect(left, top, right - left, bottom - top));
}
Canvas annotCanvas = Current_View.GetCanvas();
// add highlight(s) to annotation canvas
foreach (System.Windows.Rect rect in rects)
{
Rectangle highlight = new Rectangle();
highlight.Fill = new SolidColorBrush() { Color = Colors.Blue };
highlight.Fill.Opacity = 0.3;
highlight.Width = rect.Width;
highlight.Height = rect.Height;
Canvas.SetLeft(highlight, rect.Left + Current_View.GetHScrollPos());
Canvas.SetTop(highlight, rect.Top + Current_View.GetVScrollPos());
annotCanvas.Children.Add(highlight);
_onScreenSelection.Add(highlight);
}
return numQuads > 0;
}
///
/// Removes the rectangles highlighting the selection, but keeps the selection for future reference
/// to be used with HighlightSelection
///
/// If true, will also delete the underlaying selection
public void ClearSearchSelection(bool deleteSelection = false)
{
foreach (Rectangle rect in _onScreenSelection)
{
Canvas parent = rect.Parent as Canvas;
if (parent != null)
{
parent.Children.Remove(rect);
}
}
if (deleteSelection)
{
_currentSearchSelection = null;
}
}
public int GetPageCount()
{
return Current_View.GetPageCount();
}
private void OnDownload(DownloadedType type, Int32 page_num, Int32 obj_num, String msg, Object obj)
{
switch (type)
{
case DownloadedType.e_opened:
// e_opened indicates that we have a valid, but incomplete PDFDoc.
_pdfdoc = Current_View.GetDoc();
if (_pdfdoc.GetPageCount() > 2000)
{
Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_page);
}
_sidecontrol.CreateSideWindow(Current_View, _ToolManager);
// the PDF should be treated as read only, and only simple functions
// should be called on the doc, until e_finished has been called.
break;
case DownloadedType.e_page:
// this indicates the entire page is downloaded and it is safe to modify.
// for example add a new annotation
break;
case DownloadedType.e_finished:
// we now have the full PDF file and it can be treated like any other
_ToolManager.IsEnabled = true;
if (MessageBox.Show("Download complete, would you like to save the PDF locally?",
"PDF Downloaded", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
SaveAs();
}
break;
case DownloadedType.e_failed:
// downloading has stopped if this occurs
_ToolManager.IsEnabled = true;
MessageBox.Show(msg);
Current_Main.CloseViewer(this);
break;
}
}
#endregion
}
}
```
{% endcode %}
{% endtab %}
{% endtabs %}
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.apryse.com/core/get-started/samples/pdfviewcontrol-xaml.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.