> 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/mainwindow-xaml.md).
# Simple PDF Viewer Component - PDFViewWPFSimple
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 System.Windows.Controls.Primitives;
using System.Runtime.InteropServices;
using System.Printing;
using pdftron;
using pdftron.PDF;
using pdftron.SDF;
using pdftron.Filters;
using pdftron.Common;
using System.ComponentModel;
namespace PDFViewWPFTestCS
{
///
/// Interaction logic for MainWindow.xaml
///
public partial class MainWindow : Window
{
private static pdftron.PDFNetLoader pdfNetLoader = pdftron.PDFNetLoader.Instance();
private bool _sliderShouldForwardValue = true;
private PDFViewViewer _currentViewer;
private TabItem _currentTab;
FindTextDialog _findTextDialog;
public FindTextDialog FindTextDialog
{
get { return _findTextDialog; }
set { _findTextDialog = value; }
}
public struct PrinterArguments
{
public PDFDoc DocToPrint;
public string PrinterName;
public string FileName;
public PageSet PageSet;
public PrinterMode PrinterMode;
public pdftron.PDF.OCG.Context OCG;
public PrinterArguments(PDFDoc docToPrint, string printerName, string fileName, PageSet pageSet, PrinterMode printerMode, pdftron.PDF.OCG.Context ocg)
{
this.DocToPrint = docToPrint;
this.PrinterName = printerName;
this.FileName = fileName;
this.PageSet = pageSet;
this.PrinterMode = printerMode;
this.OCG = ocg;
}
}
public MainWindow()
{
// Initialize PDFNet.
try
{
PDFNet.Initialize();
PDFNet.EnableJavaScript(true);
PDFNet.SetViewerCache(100 * 1024 * 1024, false);
}
catch (pdftron.Common.PDFNetException ex)
{
MessageBox.Show(ex.GetMessage(), "Licensing Error");
}
PDFViewWPFSecurityHandler.MainWindow = this;
pdftron.SDF.CreateDelegate del = new pdftron.SDF.CreateDelegate(PDFViewWPFSecurityHandler.Create);
pdftron.SDF.SecurityManagerSingleton.Instance().RegisterSecurityHandler("Standard",
new pdftron.SDF.SecurityDescriptor("Standard Security", del));
InitializeComponent();
slider_zoom.ValueChanged += slider_zoom_ValueChanged;
txtbox_zoom.KeyDown += txtbox_zoom_KeyDown;
txtbox_pagenum.KeyDown += txtbox_pagenum_KeyDown;
}
//void toolbar_footer_Loaded(object sender, RoutedEventArgs e)
//{
// var overflowGrid = toolbar_footer.Template.FindName("OverflowGrid", toolbar_footer) as FrameworkElement;
// if (overflowGrid != null)
// {
// overflowGrid.Visibility = Visibility.Collapsed;
// }
//}
#region Methods
public PDFViewViewer GetCurrentViewer()
{
PDFViewViewer view = null;
for (int i = 0; i < PDFTab.Items.Count; ++i)
{
TabItem current = (TabItem)PDFTab.Items.GetItemAt(i);
if (current.IsSelected)
{
StackPanel sp = current.Header as StackPanel;
sp.Children[1].Visibility = Visibility.Visible;
Grid g = (Grid)current.Content;
view = (PDFViewViewer)g.Children[0];
_currentTab = current;
break;
}
}
return view;
}
private TabItem GetCurrentTab()
{
TabItem item = null;
for (int i = 0; i < PDFTab.Items.Count; ++i)
{
item = (TabItem)PDFTab.Items.GetItemAt(i);
if (item.IsSelected)
{
break;
}
}
return item;
}
public void FindText(string str, bool match_case, bool match_whole_word, bool search_up, bool reg_exp)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.FindText(str, match_case, match_whole_word, search_up, reg_exp); // Use the build in Find text dialog.
}
return;
}
public void UpdateSidewindowButtons()
{
PDFViewViewer view = GetCurrentViewer();
if (view == null)
{
return;
}
double length = view.NaviWidth;
if (length > 10)
{
btn_collapse.IsEnabled = true;
}
else
{
btn_collapse.IsEnabled = false;
}
if (length < 200)
{
btn_expand.IsEnabled = true;
}
else
{
btn_expand.IsEnabled = false;
}
}
public void UpdateZoomState()
{
PDFViewViewer view = GetCurrentViewer();
if (view == null)
{
return;
}
SetZoomValue(view.ZoomLevel);
}
// Let's a viewer tell the mainwindow that it can be closed (e.g. open URL failed).
public void CloseViewer(PDFViewViewer viewer)
{
// Find the tab with the viewer
TabItem itemToDelete = null;
foreach (TabItem item in PDFTab.Items)
{
Grid g = item.Content as Grid;
if (g != null && g.Children.Contains(viewer))
{
itemToDelete = item;
break;
}
}
if (itemToDelete != null)
{
itemToDelete.Content = null;
PDFTab.Items.Remove(itemToDelete);
}
}
public void SetZoomValue(double zoom)
{
_sliderShouldForwardValue = false;
slider_zoom.Value = zoom;
_sliderShouldForwardValue = true;
string.Format("{0,0:1}", zoom);
txtbox_zoom.Text = string.Format("{0:0.#}", zoom * 100);
}
#endregion
#region Events
public void FindTextFinishedHandler(PDFViewWPF viewer, bool found, PDFViewWPF.Selection selection)
{
if (_findTextDialog != null)
{
_findTextDialog.TextSearchFinished(viewer, found, selection);
}
}
private void PDFTab_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
PDFViewViewer newViewer = GetCurrentViewer();
if (_currentViewer == newViewer)
{
return;
}
if (_currentViewer != null)
{
_currentViewer.ClearSearchSelection(true);
_currentViewer.Deactivate();
}
if (_currentTab != null)
{
StackPanel sp = _currentTab.Header as StackPanel;
sp.Children[1].Visibility = Visibility.Collapsed;
}
_currentViewer = GetCurrentViewer();
if (_currentViewer != null && _currentViewer.GetPDFDoc() != null)
{
toolbar_footer.IsEnabled = true;
toolbar_header2.IsEnabled = true;
toolbar_header3.IsEnabled = true;
btn_save.IsEnabled = true;
btn_print.IsEnabled = true;
txt_pagecount.Content = " / " + _currentViewer.GetPageCount().ToString();
txtbox_pagenum.Text = _currentViewer.GetCurrentPageNumber().ToString();
_currentViewer.UpdateToolButtonStates();
_currentViewer.UpdatePresentationModeButtonStates();
UpdateSidewindowButtons();
UpdateZoomState();
// set main window title
this.Title = _currentViewer.GetPDFDoc().GetFileName();
_currentViewer.Activate();
}
else
{
slider_zoom.Value = slider_zoom.Minimum;
txtbox_zoom.Text = "";
txtbox_pagenum.Text = "";
txt_pagecount.Content = "";
toolbar_footer.IsEnabled = false;
toolbar_header2.IsEnabled = false;
toolbar_header3.IsEnabled = false;
btn_save.IsEnabled = false;
btn_print.IsEnabled = false;
this.Title = "PDFViewWPF";
// No page presentation mode selected
SinglePageButton.IsChecked = false;
SingleContinuousButton.IsChecked = false;
FacingButton.IsChecked = false;
FacingContinuousButton.IsChecked = false;
FacingCoverButton.IsChecked = false;
FacingCoverContinuousButton.IsChecked = false;
// No tool mode selected
t_pan.IsChecked = false;
PanToolMenuItem.IsChecked = false;
t_annot_edit.IsChecked = false;
AnnotationEditToolMenuItem.IsChecked = false;
t_text_rect.IsChecked = false;
t_text_struct.IsChecked = false;
LineToolMenuItem.IsChecked = false;
ArrowToolMenuItem.IsChecked = false;
RectangleToolMenuItem.IsChecked = false;
OvalToolMenuItem.IsChecked = false;
InkToolMenuItem.IsChecked = false;
TextBoxToolMenuItem.IsChecked = false;
CalloutToolMenuItem.IsChecked = false;
StickyNoteToolMenuItem.IsChecked = false;
HighlightToolMenuItem.IsChecked = false;
UnderlineToolMenuItem.IsChecked = false;
StrikeoutToolMenuItem.IsChecked = false;
SquigglyToolMenuItem.IsChecked = false;
}
}
private void slider_zoom_ValueChanged(object sender, RoutedPropertyChangedEventArgs e)
{
if (_sliderShouldForwardValue)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ZoomLevel = slider_zoom.Value;
}
}
}
void txtbox_pagenum_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter && !string.IsNullOrWhiteSpace(txtbox_pagenum.Text))
{
int pagenum;
if (Int32.TryParse(txtbox_pagenum.Text, out pagenum))
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.SetCurrentPage(pagenum);
}
}
}
}
private void txtbox_zoom_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter && !string.IsNullOrWhiteSpace(txtbox_zoom.Text))
{
double newzoom;
if (Double.TryParse(txtbox_zoom.Text, out newzoom))
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ZoomLevel = newzoom / 100.0;
}
}
}
}
private void btnOpen_Clicked(object sender, RoutedEventArgs e)
{
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
dlg.CheckFileExists = true;
dlg.CheckPathExists = true;
dlg.Filter = "PDF (*.pdf)|*.pdf|All files (*.*)|*.*";
dlg.DefaultExt = ".pdf";
if (dlg.ShowDialog() == true)
{
PDFViewViewer view = new PDFViewViewer(this);
if (view.OpenPDF(dlg.FileName))
{
LoadViewer(view, dlg.SafeFileName);
}
}
}
private void btnOpenUrl_Clicked(object sender, RoutedEventArgs e)
{
OpenUrlDlg dlg = new OpenUrlDlg();
dlg.Owner = this;
if(dlg.ShowDialog() == true)
{
PDFViewViewer view = new PDFViewViewer(this);
if (view.OpenURL(dlg.URL, dlg.Pass))
{
LoadViewer(view, dlg.URL);
}
}
}
private void LoadViewer(PDFViewViewer view, String title)
{
TabItem item = new TabItem();
// add a close button
StackPanel tabHeaderStack = new StackPanel();
tabHeaderStack.Orientation = Orientation.Horizontal;
TextBlock tabLabel = new TextBlock();
tabLabel.Text = title;
tabHeaderStack.Children.Add(tabLabel);
Button tabCloseButton = new Button();
tabCloseButton.Width = 11;
tabCloseButton.Height = 11;
tabCloseButton.Content = "X";
tabCloseButton.Padding = new System.Windows.Thickness(0, -3, 1, 0);
tabCloseButton.BorderThickness = new System.Windows.Thickness(0);
tabCloseButton.Background = Brushes.Transparent;
tabCloseButton.Foreground = Brushes.DarkGray;
tabCloseButton.Margin = new Thickness(5, 3, 0, 0);
tabHeaderStack.Children.Add(tabCloseButton);
tabCloseButton.Click += btnClose_Clicked;
item.Header = tabHeaderStack;
view._safeDocName = title;
Grid grid = new Grid();
grid.Children.Add(view);
item.Content = grid;
PDFTab.Items.Add(item);
item.IsSelected = true;
}
private void btn_Prev_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.PrevPage();
}
}
private void btn_Next_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.NextPage();
}
}
private void btn_ZoomIn_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ZoomIn();
}
}
private void btn_ZoomOut_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ZoomOut();
}
}
private void btnExit_Clicked(object sender, RoutedEventArgs e)
{
this.Close();
}
protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
{
List tabsToClose = new List();
if (PDFTab.HasItems)
{
for (int i = 0; i < PDFTab.Items.Count; ++i)
{
TabItem item = (TabItem)PDFTab.Items.GetItemAt(i);
Grid g = (Grid)item.Content;
PDFViewViewer view = (PDFViewViewer)g.Children[0];
if (view == null) continue;
if (!view.CloseFile())
{
e.Cancel = true;
break;
}
else
{
tabsToClose.Add(item);
}
}
}
if (e.Cancel)
{
foreach (TabItem tab in tabsToClose)
{
PDFTab.Items.Remove(tab);
}
}
base.OnClosing(e);
}
private void btn_LastPage_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.LastPage();
}
}
private void btn_FirstPage_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.FirstPage();
}
}
private void btn_RotateCCW_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.RotateCounterClockwise();
}
}
private void btn_RotateCW_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.RotateClockwise();
}
}
private void FitWidth_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.FitWidth();
}
}
private void FitPageClicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.FitPage();
}
}
private void SinglePage_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.PageSingle();
}
}
private void SingleContinuous_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.PageSingleContinuous();
}
}
private void Facing_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.PageFacing();
}
}
private void FacingContinuous_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.PageFacingContinuous();
}
}
private void FacingCoverContinuous_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.PageFacingCoverContinous();
}
}
private void FacingCover_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.PageFacingCover();
}
}
private void btnPrint_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
PrintDialog pDlg = new PrintDialog();
pDlg.UserPageRangeEnabled = true;
Nullable result = pDlg.ShowDialog();
if (result == true)
{
PrintQueue pq = pDlg.PrintQueue;
PrintTicket pt = pDlg.PrintTicket;
PageSet ps = new PageSet(pDlg.PageRange.PageFrom, pDlg.PageRange.PageTo);
if (pDlg.PageRangeSelection == PageRangeSelection.AllPages)
ps = new PageSet(1, view.GetPageCount());
PrinterMode pm = new PrinterMode();
pm.SetCopyCount(pt.CopyCount.HasValue ? pt.CopyCount.Value : 1);
if (view.GetRotation() == pdftron.PDF.Page.Rotate.e_90 || view.GetRotation() == pdftron.PDF.Page.Rotate.e_270)
pm.SetOrientation(PrinterMode.Orientation.e_Orientation_Landscape);
else
pm.SetOrientation(PrinterMode.Orientation.e_Orientation_Portrait);
BackgroundWorker bgPrintWorker = new BackgroundWorker();
bgPrintWorker.DoWork += BackgroundPrintTask;
bgPrintWorker.RunWorkerCompleted += bgPrintWorker_RunWorkerCompleted;
bgPrintWorker.RunWorkerAsync(new PrinterArguments(view.GetPDFDoc(), pq.Name, view.GetPDFDoc().GetFileName(), ps, pm, view.Current_View.GetOCGContext()));
}
}
}
void bgPrintWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Error != null)
{
MessageBox.Show(string.Format("Printing failed: {0}{0}{1}", Environment.NewLine, e.Error.Message));
}
}
void BackgroundPrintTask(object sender, DoWorkEventArgs e)
{
PrinterArguments printerArgs = (PrinterArguments)e.Argument;
try
{
printerArgs.DocToPrint.LockRead();
Print.StartPrintJob(printerArgs.DocToPrint, printerArgs.PrinterName, printerArgs.DocToPrint.GetFileName(),
"", printerArgs.PageSet, printerArgs.PrinterMode, printerArgs.OCG);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
printerArgs.DocToPrint.UnlockRead();
}
}
private void btnClose_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
if (view.CloseFile())
{
TabItem tab = GetCurrentTab();
if (tab != null)
{
PDFTab.Items.Remove(tab);
}
}
}
}
private void btnSave_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
PDFDoc doc = view.GetPDFDoc();
if (doc != null)
{
if (String.IsNullOrEmpty(doc.GetFileName()))
{
btnSaveAs_Clicked(sender, e);
}
else
{
view.Save(doc.GetFileName());
}
}
}
}
private void btnSaveAs_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
string newname = view.SaveAs();
if (newname != null)
{
TabItem item = GetCurrentTab();
StackPanel sp = item.Header as StackPanel;
TextBlock tb = sp.Children[0] as TextBlock;
tb.Text = newname;
view._safeDocName = newname;
this.Title = view.GetPDFDoc().GetFileName();
}
}
}
private void btnExpand_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.OpenNavibar();
}
}
private void btnCollapsed_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.CloseNavibar();
}
}
private void btnSelectAll_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.SelectAll();
}
}
private void btnDeselectAll_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.DeselectAll();
}
}
#endregion Events
#region ToolMode
//////////////////////////////////////////////////////////////////////////
// Note: Tools that create or add annotations can be created either as
// persistent or not. If not persistent any shape creation tool will revert
// back to the pan tool when done.
// If persistent, any number of shapes can be drawn, and the tool has to
// be closed explicitly (by creating another tool).
// This can be changed by setting the 3rd parameter of ToolManager.CreateTool
// to true (persistent) or false (not persistent).
//////////////////////////////////////////////////////////////////////////
private void PanTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_pan, null);
}
}
private void TextSelectStruct_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_text_select, null);
}
}
private void TextSelectRect_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_text_select_rectangular, null);
}
}
private void AnnotationEditTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_annot_edit, null);
}
}
private void LineTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_line_create, null, true);
}
}
private void ArrowTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_arrow_create, null, true);
}
}
private void OvalTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_oval_create, null, true);
}
}
private void RectangleTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_rect_create, null, true);
}
}
private void InkTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_ink_create, null, true);
// You can create a multi-path ink annotation as follows:
// This means that you can have an annotation with multiple strokes.
//pdftron.PDF.Tools.FreehandCreate fhc = view.ToolManager.CurrentTool as pdftron.PDF.Tools.FreehandCreate;
//fhc.CreateMultiPathAnnotation = true;
// You can then use the following 2 functions to save or discard the current shape
//fhc.SaveShape();
//fhc.DiscardShape();
// Currently, the FreeHandCreate tool is set up so that the key 'y' will save the drawing and the key
// 'n' will discard it. Also, on the right click context menu, there's a save and discard option
}
}
private void HighlightTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_text_highlight, null, true);
}
}
private void UnderlineTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_text_underline, null, true);
}
}
private void StrikeoutTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_text_strikeout, null, true);
}
}
private void SquigglyTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_text_squiggly, null, true);
}
}
private void FreeTextToolTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_text_annot_create, null, true);
}
}
private void CalloutTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_callout_create, null, true);
}
}
private void StickyNoteTool_Clicked(object sender, RoutedEventArgs e)
{
PDFViewViewer view = GetCurrentViewer();
if (view != null)
{
view.ToolManager.CreateTool(pdftron.PDF.Tools.ToolManager.ToolType.e_sticky_note_create, null, true);
}
}
#endregion ToolMode
}
}
```
{% 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/mainwindow-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.