### Main Application Entry Point

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

This is the main entry point for the C# WinForms application, marked with the [STAThread] attribute. It enables visual styles, sets the compatible text rendering default, and starts the application's message loop by running the main form, PDFViewerForm.

```csharp
[STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new PDFViewerForm());
        }
```

--------------------------------

### Property: KeyAccelerators

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Get or set if Keyboard accelerators (like CTRL+A, CTRL+P, etc.) are enable or not.

```APIDOC
## Property: KeyAccelerators

### Description
Get or set if Keyboard accelerators (like CTRL+A, CTRL+P, etc.) are enable or not;

### Declaration
```csharp
[Browsable(false)]
public bool KeyAccelerators { get; set; }
```

### Property Value
- **Type**: System.Boolean
- **Description**: A boolean value indicating whether keyboard accelerators are enabled.
```

--------------------------------

### C# SumatraPDFControl Page Navigation Management

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

Demonstrates a C# class for managing page navigation within SumatraPDFControl. It includes methods for jumping to specific pages, navigating sequentially, using named destinations, and setting up basic toolbar controls for navigation. Requires the SumatraPDFControl library and basic Windows Forms components for toolbar setup.

```csharp
public class PDFNavigationManager
{
    private SumatraPDFControl pdfControl;

    public PDFNavigationManager(SumatraPDFControl control)
    {
        pdfControl = control;
    }

    // Navigate to specific page
    public void GoToPage(int pageNumber)
    {
        if (pageNumber >= 1 && pageNumber <= pdfControl.PageCount)
        {
            pdfControl.Page = pageNumber;
            Console.WriteLine($"Navigated to page {pageNumber}");
        }
        else
        {
            throw new ArgumentOutOfRangeException(nameof(pageNumber),
                $"Page must be between 1 and {pdfControl.PageCount}");
        }
    }

    // Get current page
    public int GetCurrentPage()
    {
        return pdfControl.Page;
    }

    // Sequential navigation
    public void NavigateNext()
    {
        pdfControl.GoToNextPage();
    }

    public void NavigatePrevious()
    {
        pdfControl.GoToPrevPage();
    }

    public void NavigateToFirst()
    {
        pdfControl.GoToFirstPage();
    }

    public void NavigateToLast()
    {
        pdfControl.GoToLastPage();
    }

    // Navigate using named destinations
    public void GoToNamedDestination(string destinationName)
    {
        pdfControl.NamedDest = destinationName;
        Console.WriteLine($"Navigated to named destination: {destinationName}");
    }

    public string GetCurrentNamedDestination()
    {
        return pdfControl.NamedDest;
    }

    // Get total page count
    public int GetTotalPages()
    {
        return pdfControl.PageCount;
    }

    // Example toolbar integration
    public void SetupNavigationToolbar(ToolStrip toolbar)
    {
        var btnFirst = new ToolStripButton("First");
        btnFirst.Click += (s, e) => NavigateToFirst();

        var btnPrev = new ToolStripButton("Previous");
        btnPrev.Click += (s, e) => NavigatePrevious();

        var txtPage = new ToolStripTextBox { Width = 50 };
        var btnGo = new ToolStripButton("Go");
        btnGo.Click += (s, e) =>
        {
            if (int.TryParse(txtPage.Text, out int page))
                GoToPage(page);
        };

        var btnNext = new ToolStripButton("Next");
        btnNext.Click += (s, e) => NavigateNext();

        var btnLast = new ToolStripButton("Last");
        btnLast.Click += (s, e) => NavigateToLast();

        toolbar.Items.AddRange(new ToolStripItem[] 
            { btnFirst, btnPrev, txtPage, btnGo, btnNext, btnLast });
    }
}
```

--------------------------------

### Property: DisplayMode

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Get or set mode to display PDF pages (SinglePage, Facing, BookView, Continuous, ContinuousFacing, ContinuousBookView, Automatic).

```APIDOC
## Property: DisplayMode

### Description
Get or set mode to display PDF pages (SinglePage, Facing, BookView, Continuous, ContinuousFacing, ContinuousBookView, Automatic)

### Declaration
```csharp
[Browsable(false)]
public SumatraPDFControl.DisplayModeEnum DisplayMode { get; set; }
```

### Property Value
- **Type**: SumatraPDFControl.DisplayModeEnum
- **Description**: Enum representing different display modes for PDF pages.
```

--------------------------------

### TextSearch

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Performs a text search within the document starting from the beginning.

```APIDOC
## TextSearch

### Description
Performs a text search within the document starting from the beginning.

### Method
Public

### Endpoint
N/A (Method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **searchText** (System.String) - Required - Text to search
- **matchCase** (System.Boolean) - Required - Match case

### Request Example
```csharp
SumatraPDFControl.TextSearch("example text", false);
```

### Response
#### Success Response
N/A (void method)

#### Response Example
None
```

--------------------------------

### Property: ContextMenuStrip

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Gets or sets the ContextMenuStrip associated with this control.

```APIDOC
## Property: ContextMenuStrip

### Description
Gets or sets the ContextMenuStrip associated with this control.

### Declaration
```csharp
public ContextMenuStrip ContextMenuStrip { get; set; }
```

### Property Value
- **Type**: System.Windows.Forms.ContextMenuStrip
- **Description**: The ContextMenuStrip for this control, or null if there is no ContextMenuStrip. The default is null.
```

--------------------------------

### SumatraPDFControl.ContextMenuOpeningEventArgs Handled Property (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.ContextMenuOpeningEventArgs.html

Gets or sets a value indicating whether the context menu opening event will be handled. If set to true, the default context menu will not be displayed. Defaults to false.

```csharp
public bool Handled { get; set; }
```

--------------------------------

### C# PDF Scroll Position Management with SumatraPDFControl

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

This C# code demonstrates how to manage the scroll position of a PDF document using the SumatraPDFControl. It allows getting, setting, saving, and restoring scroll states (page, X, Y coordinates) and includes functionality for a bookmark system. This requires the SumatraPDF library and a SumatraPDFControl instance.

```csharp
using SumatraPDF;
using static SumatraPDF.SumatraPDFControl;

public class PDFScrollManager
{
    private SumatraPDFControl pdfControl;
    private ScrollStateStruct lastScrollState;

    public PDFScrollManager(SumatraPDFControl control)
    {
        pdfControl = control;
        pdfControl.ScrollStateChanged += PdfControl_ScrollStateChanged;
    }

    // Get current scroll position
    public ScrollStateStruct GetScrollState()
    {
        return pdfControl.ScrollState;
    }

    // Set scroll position
    public void SetScrollState(int page, double x, double y)
    {
        var scrollState = new ScrollStateStruct(page, x, y);
        pdfControl.ScrollState = scrollState;
        Console.WriteLine($"Scroll state set: {scrollState}");
    }

    public void SetScrollState(ScrollStateStruct scrollState)
    {
        pdfControl.ScrollState = scrollState;
        Console.WriteLine($"Scroll state set: {scrollState}");
    }

    // Save current scroll position
    public ScrollStateStruct SaveScrollPosition()
    {
        lastScrollState = GetScrollState();
        Console.WriteLine($"Scroll position saved: {lastScrollState}");
        return lastScrollState;
    }

    // Restore saved scroll position
    public void RestoreScrollPosition()
    {
        if (lastScrollState.Page > 0)
        {
            SetScrollState(lastScrollState);
            Console.WriteLine($"Scroll position restored: {lastScrollState}");
        }
        else
        {
            Console.WriteLine("No saved scroll position available");
        }
    }

    // Scroll to top of page
    public void ScrollToTopOfPage(int page)
    {
        SetScrollState(page, 0, 0);
    }

    // Event handler for scroll changes
    private void PdfControl_ScrollStateChanged(object sender, ScrollStateEventArgs e)
    {
        Console.WriteLine($"Scroll changed: Page {e.ScrollState.Page}, " +
            $"X: {e.ScrollState.X:F2}, Y: {e.ScrollState.Y:F2}");
        lastScrollState = e.ScrollState;
    }

    // Example: Bookmark system using scroll states
    public class ScrollBookmark
    {
        public string Name { get; set; }
        public ScrollStateStruct ScrollState { get; set; }

        public ScrollBookmark(string name, ScrollStateStruct scrollState)
        {
            Name = name;
            ScrollState = scrollState;
        }
    }

    private List<ScrollBookmark> bookmarks = new List<ScrollBookmark>();

    public void AddBookmark(string name)
    {
        var currentState = GetScrollState();
        var bookmark = new ScrollBookmark(name, currentState);
        bookmarks.Add(bookmark);
        Console.WriteLine($"Bookmark added: {name} at {currentState}");
    }

    public void GoToBookmark(string name)
    {
        var bookmark = bookmarks.FirstOrDefault(b => b.Name == name);
        if (bookmark != null)
        {
            SetScrollState(bookmark.ScrollState);
            Console.WriteLine($"Navigated to bookmark: {name}");
        }
        else
        {
            Console.WriteLine($"Bookmark not found: {name}");
        }
    }

    public List<ScrollBookmark> GetBookmarks()
    {
        return new List<ScrollBookmark>(bookmarks);
    }
}

```

--------------------------------

### KeyAccelerators Property (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Gets or sets a boolean value indicating whether keyboard accelerators (shortcuts like CTRL+A, CTRL+P) are enabled in the SumatraPDFControl. This property is not browsable in the designer.

```csharp
[Browsable(false)]
public bool KeyAccelerators { get; set; }
```

--------------------------------

### Handle SumatraMessage Event in C#

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

This C# example illustrates how to subscribe to the SumatraMessage event. This event is a catch-all for messages from SumatraPDF that are not handled by other specific events. It passes a SumatraMessageEventArgs object containing the message details. Use this for general-purpose message handling.

```csharp
public void SubscribeToSumatraMessage(SumatraPDFControl pdfControl)
{
    pdfControl.SumatraMessage += PdfControl_SumatraMessage;
}

private void PdfControl_SumatraMessage(object sender, SumatraPDFControl.SumatraMessageEventArgs e)
{
    // Handle a generic SumatraPDF message
    Console.WriteLine($"Received Sumatra message: {e.Message}");
}
```

--------------------------------

### DisplayMode Property (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Gets or sets the display mode for PDF pages within the SumatraPDFControl. Supported modes include SinglePage, Facing, BookView, Continuous, ContinuousFacing, ContinuousBookView, and Automatic. This property is not browsable in the designer.

```csharp
[Browsable(false)]
public SumatraPDFControl.DisplayModeEnum DisplayMode { get; set; }
```

--------------------------------

### ContextMenuStrip Property (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Gets or sets the ContextMenuStrip associated with the SumatraPDFControl. This property allows developers to customize the right-click menu of the PDF viewer embedded within the control. The default value is null.

```csharp
public ContextMenuStrip ContextMenuStrip { get; set; }
```

--------------------------------

### SumatraPDFControl Class Definition (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Defines the SumatraPDFControl class, inheriting from System.Windows.Forms.Control. It is decorated with attributes for toolbox display and GUID assignment, enabling it to function as a Windows Forms control for embedding PDF viewing capabilities. Requires a specific compiled Sumatra code version.

```csharp
[ToolboxBitmap(typeof(SumatraPDFControl), "Resources.SumatraPDFControlMini.png")]
[Guid("E5FDA170-ACF6-4C4D-AAF9-C8F9C70EE09C")]
public class SumatraPDFControl : Control, IDropTarget, ISynchronizeInvoke, IWin32Window, IArrangedElement, IBindableComponent, IComponent, IDisposable
```

--------------------------------

### C# PDF Rotation Control with SumatraPDFControl

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

This C# code manages document rotation using the SumatraPDFControl. It provides methods to rotate by specific angles (90, 180, 270 degrees), reset rotation, get the current rotation state, and set an absolute rotation. It also includes functionality to set up a toolbar with buttons for rotation actions and a label to display the current rotation state.

```csharp
using SumatraPDF;
using static SumatraPDF.SumatraPDFControl;

public class PDFRotationManager
{
    private SumatraPDFControl pdfControl;

    public PDFRotationManager(SumatraPDFControl control)
    {
        pdfControl = control;
    }

    // Rotate by specific angle
    public void RotateDocument(RotationEnum rotation)
    {
        pdfControl.RotateBy(rotation);
        Console.WriteLine($"Rotated by {rotation}");
    }

    // Rotate clockwise (90 degrees)
    public void RotateClockwise()
    {
        pdfControl.RotateBy(RotationEnum.Rot90);
    }

    // Rotate counter-clockwise (270 degrees)
    public void RotateCounterClockwise()
    {
        pdfControl.RotateBy(RotationEnum.Rot270);
    }

    // Rotate 180 degrees
    public void Rotate180()
    {
        pdfControl.RotateBy(RotationEnum.Rot180);
    }

    // Reset rotation
    public void ResetRotation()
    {
        pdfControl.RotateBy(RotationEnum.RotNone);
    }

    // Get current rotation
    public RotationEnum GetCurrentRotation()
    {
        return pdfControl.Rotation;
    }

    // Rotate to specific absolute angle
    public void SetRotation(RotationEnum targetRotation)
    {
        RotationEnum currentRotation = GetCurrentRotation();

        // Calculate rotation needed to reach target
        int current = (int)currentRotation;
        int target = (int)targetRotation;
        int difference = (target - current + 360) % 360;

        if (difference != 0)
        {
            pdfControl.RotateBy((RotationEnum)difference);
        }
    }

    // Setup rotation toolbar
    public void SetupRotationControls(ToolStrip toolbar)
    {
        var btnRotateLeft = new ToolStripButton("Rotate Left");
        btnRotateLeft.Click += (s, e) => RotateCounterClockwise();

        var btnRotateRight = new ToolStripButton("Rotate Right");
        btnRotateRight.Click += (s, e) => RotateClockwise();

        var btnRotate180 = new ToolStripButton("Rotate 180°");
        btnRotate180.Click += (s, e) => Rotate180();

        var btnResetRotation = new ToolStripButton("Reset Rotation");
        btnResetRotation.Click += (s, e) => ResetRotation();

        var lblRotation = new ToolStripLabel();
        Timer updateTimer = new Timer { Interval = 500 };
        updateTimer.Tick += (s, e) =>
            lblRotation.Text = $"Rotation: {GetCurrentRotation()}";
        updateTimer.Start();

        toolbar.Items.AddRange(new ToolStripItem[] 
            { btnRotateLeft, btnRotateRight, btnRotate180, 
              btnResetRotation, lblRotation });
    }
}
```

--------------------------------

### Initialize SumatraPDFControl and Load PDF Document

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

Demonstrates the basic initialization of the SumatraPDFControl in a Windows Forms application. It shows how to set up the control, subscribe to essential events like FileOpened, PageChanged, and StartupFinished, and load an initial PDF document. Error handling for file loading is also included.

```csharp
using System;
using System.Windows.Forms;
using SumatraPDF;

namespace MyPDFViewer
{
    public partial class MainForm : Form
    {
        private SumatraPDFControl pdfControl;

        public MainForm()
        {
            InitializeComponent();

            // Initialize the control
            pdfControl = new SumatraPDFControl
            {
                Dock = DockStyle.Fill,
                SumatraPDFPath = null, // Uses default path (x86 or x64 subdirectory)
                SumatraPDFExe = "SumatraPDF.exe" // Default executable name
            };

            // Subscribe to events
            pdfControl.FileOpened += PdfControl_FileOpened;
            pdfControl.PageChanged += PdfControl_PageChanged;
            pdfControl.StartupFinished += PdfControl_StartupFinished;

            this.Controls.Add(pdfControl);
        }

        private void LoadDocument(string pdfPath)
        {
            try
            {
                // Load PDF file starting at page 1, reusing existing SumatraPDF instance
                pdfControl.LoadFile(pdfPath, InitialPage: 1, NewSumatraInstance: false);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error loading PDF: {ex.Message}", "Error",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void PdfControl_FileOpened(object sender, EventArgs e)
        {
            // Document is loaded and ready for interaction
            int totalPages = pdfControl.PageCount;
            int currentPage = pdfControl.Page;
            string namedDest = pdfControl.NamedDest;

            Console.WriteLine($"PDF opened: Page {currentPage}/{totalPages}");

            // Initialize UI elements with document properties
            UpdatePageDisplay();
        }

        private void PdfControl_PageChanged(object sender, 
            SumatraPDFControl.PageChangedEventArgs e)
        {
            Console.WriteLine($"Page changed to: {e.Page}, NamedDest: {e.NamedDest}");
            UpdatePageDisplay();
        }

        private void PdfControl_StartupFinished(object sender, EventArgs e)
        {
            Console.WriteLine("SumatraPDF startup completed");
        }

        private void UpdatePageDisplay()
        {
            // Update UI with current page information
            this.Text = $"PDF Viewer - Page {pdfControl.Page} of {pdfControl.PageCount}";
        }
    }
}
```

--------------------------------

### Handle StartupFinished Event in C#

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

This C# code demonstrates subscribing to the StartupFinished event. This event signals that the SumatraPDF.exe process has completed its startup. It's important to note that this event only fires for new process launches, not when an existing instance reloads a document. Methods like PageCount or Page are only reliable after this event.

```csharp
public void SubscribeToStartupFinished(SumatraPDFControl pdfControl)
{
    pdfControl.StartupFinished += PdfControl_StartupFinished;
}

private void PdfControl_StartupFinished(object sender, EventArgs e)
{
    // SumatraPDF.exe has finished startup
    Console.WriteLine("SumatraPDF startup finished.");
    // Now it's safe to access properties like PageCount or Page
}
```

--------------------------------

### Control Toolbar Visibility

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Get or set the visibility of the SumatraPDF default toolbar. This is a boolean property.

```csharp
[Browsable(false)]
public bool ToolBarVisible { get; set; }
```

--------------------------------

### StartupFinished Event

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

This event signals the completion of the SumatraPDF.exe startup process. It is crucial for methods and properties that depend on the application being fully initialized.

```APIDOC
## StartupFinished Event

### Description
Occurs after SumatraPDF.exe terminates startup process.

### Declaration
```csharp
public event EventHandler<EventArgs> StartupFinished
```

### Event Type
System.EventHandler<System.EventArgs>

### Remarks
This event occurs only after a new SumatraPDF.exe execution. Reusing an existing SumatraPDF.exe instance to load a new document will not trigger this event; only the [FileOpened](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_FileOpened) event will fire.

Because SumatraPDF loads documents asynchronously, some methods and properties require the startup process to end before functioning correctly. Examples include [PageCount](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_PageCount) or [Page](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_Page). Therefore, use these methods or properties only after the [StartupFinished](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_StartupFinished) event or the [FileOpened](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_FileOpened) event.

It is recommended to perform initialization procedures when handling the [FileOpened](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_FileOpened) event, as the [StartupFinished](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_StartupFinished) event only fires when a new instance of SumatraPDF.exe is executed.

### See Also
[FileOpened](SumatraPDF.SumatraPDFControl.html#SumatraPDF_SumatraPDFControl_FileOpened)
```

--------------------------------

### SumatraPDFControl.ContextMenuOpeningEventArgs Y Property (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.ContextMenuOpeningEventArgs.html

Gets the vertical position relative to the SumatraPDF control where the context menu is about to open. This property provides the Y-coordinate of the event.

```csharp
public int Y { get; }
```

--------------------------------

### Go to First Page - SumatraPDFControl

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Navigates the document view to the first page. This method is part of the SumatraPDFControl and does not require any parameters.

```csharp
public void GoToFirstPage()
```

--------------------------------

### SelectAll

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Selects all text within the current document.

```APIDOC
## SelectAll

### Description
Selects all text within the current document.

### Method
Public

### Endpoint
N/A (Method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
SumatraPDFControl.SelectAll();
```

### Response
#### Success Response
N/A (void method)

#### Response Example
None
```

--------------------------------

### SumatraPDFControl.ContextMenuOpeningEventArgs X Property (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.ContextMenuOpeningEventArgs.html

Gets the horizontal position relative to the SumatraPDF control where the context menu is about to open. This property provides the X-coordinate of the event.

```csharp
public int X { get; }
```

--------------------------------

### SumatraPDFControl Page Property

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

The Page property allows you to get or set the current PDF page viewing position. This property is not browsable and returns an integer.

```csharp
[Browsable(false)]
public int Page { get; set; }
```

--------------------------------

### Initialize PDF Management Classes

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

This C# method initializes various manager classes for the SumatraPDF control, including navigation, display, text, and event managers. These managers encapsulate specific functionalities related to PDF interaction, providing a structured way to access and control the PDF viewer's features. Each manager is instantiated with the pdfControl object.

```csharp
private void InitializeManagers()
        {
            navManager = new PDFNavigationManager(pdfControl);
            displayManager = new PDFDisplayManager(pdfControl);
            textManager = new PDFTextManager(pdfControl);
            eventManager = new PDFEventManager(pdfControl);
        }
```

--------------------------------

### SumatraPDFControl NamedDest Property

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

The NamedDest property allows you to get or set the current PDF NamedDest viewing position. This property is not browsable and returns a string.

```csharp
[Browsable(false)]
public string NamedDest { get; set; }
```

--------------------------------

### ContextMenuOpening Event

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Occurs before the context menu is displayed, allowing for potential modifications.

```APIDOC
## ContextMenuOpening Event

### Description
Occurs before trying to open ContextMenu by right mouse clicking button.

### Declaration
`public event EventHandler<SumatraPDFControl.ContextMenuOpeningEventArgs> ContextMenuOpening`

### Event Type
- **Type**: `System.EventHandler<SumatraPDFControl.ContextMenuOpeningEventArgs>`
- **Description**: Handles the event when the context menu is about to open.
```

--------------------------------

### Control Table of Contents Visibility

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Get or set the visibility of the SumatraPDF Table of Contents (Toc) sidebar. This is a boolean property. If the document does not have a Toc, this will always be false.

```csharp
[Browsable(false)]
public bool TocVisible { get; set; }
```

--------------------------------

### Handle Key Press Events in C#

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

This snippet demonstrates how to subscribe to and handle KeyDown, KeyPress, and KeyUp events in C#. These events are triggered when a user interacts with the keyboard while the SumatraPDFControl has focus. Proper event handling ensures responsive user interfaces.

```csharp
public partial class MainForm : Form
{
    public MainForm()
    {
        InitializeComponent();
        // Subscribe to the events
        sumatraPDFControl1.KeyDown += SumatraPDFControl_KeyDown;
        sumatraPDFControl1.KeyPress += SumatraPDFControl_KeyPress;
        sumatraPDFControl1.KeyUp += SumatraPDFControl_KeyUp;
    }

    private void SumatraPDFControl_KeyDown(object sender, KeyEventArgs e)
    {
        // Handle KeyDown event
        Console.WriteLine($"KeyDown: {e.KeyCode}");
    }

    private void SumatraPDFControl_KeyPress(object sender, KeyPressEventArgs e)
    {
        // Handle KeyPress event
        Console.WriteLine($"KeyPress: {e.KeyChar}");
    }

    private void SumatraPDFControl_KeyUp(object sender, KeyEventArgs e)
    {
        // Handle KeyUp event
        Console.WriteLine($"KeyUp: {e.KeyCode}");
    }

    // Dispose event handlers when the form is closed
    protected override void OnFormClosed(FormClosedEventArgs e)
    {
        sumatraPDFControl1.KeyDown -= SumatraPDFControl_KeyDown;
        sumatraPDFControl1.KeyPress -= SumatraPDFControl_KeyPress;
        sumatraPDFControl1.KeyUp -= SumatraPDFControl_KeyUp;
        base.OnFormClosed(e);
    }
}
```

--------------------------------

### OpenPrintDialog

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Displays a print dialog for the current document, allowing the user to initiate a background print job.

```APIDOC
## OpenPrintDialog

### Description
Displays a print dialog for the current document, allowing the user to initiate a background print job. The print process occurs in the background, with Sumatra PDF providing an interface to cancel the operation.

### Method
Public

### Endpoint
N/A (Method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
SumatraPDFControl.OpenPrintDialog();
```

### Response
#### Success Response
N/A (void method)

#### Response Example
None
```

--------------------------------

### Implement Custom Context Menu for SumatraPDFControl in C#

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

This C# code demonstrates how to create and manage a custom context menu for the SumatraPDFControl. It allows for adding various PDF manipulation options such as page navigation, text selection, zooming, rotation, printing, and reloading. Event handlers are attached to menu items and the context menu opening event to enable dynamic updates and control menu visibility.

```csharp
using SumatraPDF;
using static SumatraPDF.SumatraPDFControl;

public class PDFContextMenuManager
{
    private SumatraPDFControl pdfControl;
    private ContextMenuStrip customContextMenu;

    public PDFContextMenuManager(SumatraPDFControl control)
    {
        pdfControl = control;
        SetupCustomContextMenu();

        // Attach context menu event
        pdfControl.ContextMenuOpening += OnContextMenuOpening;
    }

    private void SetupCustomContextMenu()
    {
        customContextMenu = new ContextMenuStrip();

        // Navigation items
        var mnuFirstPage = new ToolStripMenuItem("First Page");
        mnuFirstPage.Click += (s, e) => pdfControl.GoToFirstPage();

        var mnuPrevPage = new ToolStripMenuItem("Previous Page");
        mnuPrevPage.Click += (s, e) => pdfControl.GoToPrevPage();

        var mnuNextPage = new ToolStripMenuItem("Next Page");
        mnuNextPage.Click += (s, e) => pdfControl.GoToNextPage();

        var mnuLastPage = new ToolStripMenuItem("Last Page");
        mnuLastPage.Click += (s, e) => pdfControl.GoToLastPage();

        customContextMenu.Items.Add(mnuFirstPage);
        customContextMenu.Items.Add(mnuPrevPage);
        customContextMenu.Items.Add(mnuNextPage);
        customContextMenu.Items.Add(mnuLastPage);
        customContextMenu.Items.Add(new ToolStripSeparator());

        // Text operations
        var mnuSelectAll = new ToolStripMenuItem("Select All");
        mnuSelectAll.Click += (s, e) => pdfControl.SelectAll();

        var mnuCopy = new ToolStripMenuItem("Copy");
        mnuCopy.Click += (s, e) => pdfControl.CopySelection();

        customContextMenu.Items.Add(mnuSelectAll);
        customContextMenu.Items.Add(mnuCopy);
        customContextMenu.Items.Add(new ToolStripSeparator());

        // Zoom items
        var mnuZoomIn = new ToolStripMenuItem("Zoom In");
        mnuZoomIn.Click += (s, e) => pdfControl.Zoom = pdfControl.Zoom * 1.25f;

        var mnuZoomOut = new ToolStripMenuItem("Zoom Out");
        mnuZoomOut.Click += (s, e) => pdfControl.Zoom = pdfControl.Zoom / 1.25f;

        var mnuFitPage = new ToolStripMenuItem("Fit Page");
        mnuFitPage.Click += (s, e) =>
            pdfControl.ZoomVirtual = ZoomVirtualEnum.FitPage;

        var mnuFitWidth = new ToolStripMenuItem("Fit Width");
        mnuFitWidth.Click += (s, e) =>
            pdfControl.ZoomVirtual = ZoomVirtualEnum.FitWidth;

        customContextMenu.Items.Add(mnuZoomIn);
        customContextMenu.Items.Add(mnuZoomOut);
        customContextMenu.Items.Add(mnuFitPage);
        customContextMenu.Items.Add(mnuFitWidth);
        customContextMenu.Items.Add(new ToolStripSeparator());

        // Rotation items
        var mnuRotateLeft = new ToolStripMenuItem("Rotate Left");
        mnuRotateLeft.Click += (s, e) =>
            pdfControl.RotateBy(RotationEnum.Rot270);

        var mnuRotateRight = new ToolStripMenuItem("Rotate Right");
        mnuRotateRight.Click += (s, e) =>
            pdfControl.RotateBy(RotationEnum.Rot90);

        customContextMenu.Items.Add(mnuRotateLeft);
        customContextMenu.Items.Add(mnuRotateRight);
        customContextMenu.Items.Add(new ToolStripSeparator());

        // Document operations
        var mnuPrint = new ToolStripMenuItem("Print...");
        mnuPrint.Click += (s, e) => pdfControl.OpenPrintDialog();

        var mnuReload = new ToolStripMenuItem("Reload");
        mnuReload.Click += (s, e) => pdfControl.ReloadCurrentFile();

        customContextMenu.Items.Add(mnuPrint);
        customContextMenu.Items.Add(mnuReload);

        // Assign context menu to control
        pdfControl.ContextMenuStrip = customContextMenu;
    }

    private void OnContextMenuOpening(object sender, ContextMenuOpeningEventArgs e)
    {
        Console.WriteLine($"Context menu opening at ({e.X}, {e.Y})");

        // Example: Conditionally show/hide context menu
        // e.Handled = true; // Prevents menu from opening

        // Example: Update menu items based on current state
        UpdateMenuItems();
    }

    private void UpdateMenuItems()
    {
        // Update menu item states based on current document state
        int currentPage = pdfControl.Page;
        int pageCount = pdfControl.PageCount;

        // Enable/disable navigation items
        foreach (ToolStripItem item in customContextMenu.Items)
        {
            if (item is ToolStripMenuItem menuItem)
            {
                switch (menuItem.Text)
                {
                    case "First Page":
                    case "Previous Page":
                        menuItem.Enabled = currentPage > 1;
                        break;
                    case "Next Page":
                    case "Last Page":
                        menuItem.Enabled = currentPage < pageCount;
                        break;
                }
            }
        }
    }
}
```

--------------------------------

### SumatraPDFControl Rotation Property

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

The Rotation property gets the current PDF rotation state. The RotationEnum type is used to represent rotation values. Use the RotateBy method to change the rotation.

```csharp
[Browsable(false)]
public SumatraPDFControl.RotationEnum Rotation { get; }
```

--------------------------------

### C# Zoom and Display Management for SumatraPDFControl

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

Manages zoom and display modes for SumatraPDFControl. Supports setting numeric zoom, virtual zoom modes (FitPage, FitWidth, FitContent), and display modes. Includes event handlers for ZoomChanged and DisplayModeChanged, and a method to set up zoom controls in a ToolStrip. Requires the SumatraPDF library.

```csharp
using SumatraPDF;
using static SumatraPDF.SumatraPDFControl;

public class PDFDisplayManager
{
    private SumatraPDFControl pdfControl;

    public PDFDisplayManager(SumatraPDFControl control)
    {
        pdfControl = control;

        // Subscribe to zoom changes
        pdfControl.ZoomChanged += PdfControl_ZoomChanged;
        pdfControl.DisplayModeChanged += PdfControl_DisplayModeChanged;
    }

    // Set numeric zoom (percentage)
    public void SetZoom(float zoomPercent)
    {
        if (zoomPercent >= 8.33f && zoomPercent <= 6400f)
        {
            pdfControl.Zoom = zoomPercent;
            Console.WriteLine($"Zoom set to {zoomPercent}%");
        }
        else
        {
            throw new ArgumentOutOfRangeException(nameof(zoomPercent),
                "Zoom must be between 8.33% and 6400%");
        }
    }

    // Get current numeric zoom
    public float GetZoom()
    {
        return pdfControl.Zoom;
    }

    // Set virtual zoom modes
    public void SetZoomFitPage()
    {
        pdfControl.ZoomVirtual = ZoomVirtualEnum.FitPage;
    }

    public void SetZoomFitWidth()
    {
        pdfControl.ZoomVirtual = ZoomVirtualEnum.FitWidth;
    }

    public void SetZoomFitContent()
    {
        pdfControl.ZoomVirtual = ZoomVirtualEnum.FitContent;
    }

    public ZoomVirtualEnum GetZoomVirtual()
    {
        return pdfControl.ZoomVirtual;
    }

    // Display modes
    public void SetDisplayMode(DisplayModeEnum mode)
    {
        pdfControl.DisplayMode = mode;
        Console.WriteLine($"Display mode set to {mode}");
    }

    public DisplayModeEnum GetDisplayMode()
    {
        return pdfControl.DisplayMode;
    }

    // Event handlers
    private void PdfControl_ZoomChanged(object sender, ZoomChangedEventArgs e)
    {
        Console.WriteLine($"Zoom changed to {e.Zoom}%, " +
            $"Virtual: {e.ZoomVirtual}, MouseWheel: {e.MouseWheel}");

        // Example: Limit maximum zoom to 300%
        if (e.Zoom > 300f)
        {
            pdfControl.Zoom = 300f;
        }
    }

    private void PdfControl_DisplayModeChanged(object sender,
        DisplayModeChangedEventArgs e)
    {
        Console.WriteLine($"Display mode changed to {e.DisplayMode}");
    }

    // Complete zoom toolbar setup
    public void SetupZoomControls(ToolStrip toolbar)
    {
        var btnZoomIn = new ToolStripButton("Zoom In");
        btnZoomIn.Click += (s, e) => SetZoom(GetZoom() * 1.25f);

        var btnZoomOut = new ToolStripButton("Zoom Out");
        btnZoomOut.Click += (s, e) => SetZoom(GetZoom() / 1.25f);

        var cmbZoom = new ToolStripComboBox();
        cmbZoom.Items.AddRange(new object[] 
            { "Fit Page", "Fit Width", "Fit Content", "50%", "75%",
              "100%", "125%", "150%", "200%", "300%" });
        cmbZoom.SelectedIndexChanged += (s, e) =>
        {
            switch (cmbZoom.SelectedIndex)
            {
                case 0: SetZoomFitPage(); break;
                case 1: SetZoomFitWidth(); break;
                case 2: SetZoomFitContent(); break;
                default:
                    if (float.TryParse(cmbZoom.Text.TrimEnd('%'), out float zoom))
                        SetZoom(zoom);
                    break;
            }
        };

        var cmbDisplayMode = new ToolStripComboBox();
        cmbDisplayMode.Items.AddRange(Enum.GetNames(typeof(DisplayModeEnum)));
        cmbDisplayMode.SelectedIndexChanged += (s, e) =>
        {
            SetDisplayMode((DisplayModeEnum)cmbDisplayMode.SelectedIndex);
        };

        toolbar.Items.AddRange(new ToolStripItem[] 
            { btnZoomOut, btnZoomIn, cmbZoom, 
              new ToolStripSeparator(), cmbDisplayMode });
    }
}
```

--------------------------------

### SumatraPDFControl ScrollState Property

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

The ScrollState property allows you to get or set the current PDF scroll state, represented by X and Y units from the visible PDF page. This property is not browsable and uses a ScrollStateStruct.

```csharp
[Browsable(false)]
public SumatraPDFControl.ScrollStateStruct ScrollState { get; set; }
```

--------------------------------

### FileOpened Event

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Occurs after a new document has been loaded into the SumatraPDFControl.

```APIDOC
## FileOpened Event

### Description
Occurs after a new document load by SumatraPDFControl.

### Declaration
`public event EventHandler<EventArgs> FileOpened`

### Event Type
- **Type**: `System.EventHandler<System.EventArgs>`
- **Description**: Handles the event when a file is successfully opened.
```

--------------------------------

### Configure SumatraPDF Path

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Specify the directory where the SumatraPDF executable is located. If not provided, it defaults to the same directory as the SumatraPDFControl.dll. This property is a string.

```csharp
public string SumatraPDFPath { get; set; }
```

--------------------------------

### Open Print Dialog in SumatraPDFControl

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Opens the print dialog for the current document being displayed in SumatraPDFControl. This allows users to configure print settings and initiate printing. The printing process occurs in the background, with an interface to cancel.

```csharp
public void OpenPrintDialog()
```

--------------------------------

### ScrollState Property (C#)

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.ScrollStateEventArgs.html

Gets the scroll state associated with the ScrollStateEventArgs. This property returns a SumatraPDFControl.ScrollStateStruct object, providing details about the document's scroll position. It is accessible within the event handler for ScrollStateChanged.

```csharp
public SumatraPDFControl.ScrollStateStruct ScrollState { get; }
```

--------------------------------

### Set Virtual Zoom Mode

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Get or set the current virtual zoom mode for the PDF. This can include options like 'Fit width', 'Fit Page', 'Fit Content', or 'None'. The type is SumatraPDFControl.ZoomVirtualEnum.

```csharp
[Browsable(false)]
public SumatraPDFControl.ZoomVirtualEnum ZoomVirtual { get; set; }
```

--------------------------------

### SumatraPDFControl.ZoomChangedEventArgs Constructor

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.ZoomChangedEventArgs.html

Initializes a new instance of the SumatraPDFControl.ZoomChangedEventArgs class. This constructor takes the zoom factor, virtual zoom display mode, and a boolean indicating if the mouse wheel was used as parameters.

```csharp
public ZoomChangedEventArgs(float Zoom, SumatraPDFControl.ZoomVirtualEnum ZoomVirtual, bool MouseWheel)
```

--------------------------------

### Go to Next Page - SumatraPDFControl

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Navigates the document view to the next page. This method is part of the SumatraPDFControl and does not require any parameters.

```csharp
public void GoToNextPage()
```

--------------------------------

### LoadFile

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Loads a specified PDF file into the SumatraPDF control. It allows setting the initial page and choosing whether to open a new Sumatra PDF instance.

```APIDOC
## LoadFile

### Description
Loads a specified PDF file into the SumatraPDF control. It allows setting the initial page and choosing whether to open a new Sumatra PDF instance.

### Method
Public

### Endpoint
N/A (Method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
SumatraPDFControl.LoadFile("C:\path\to\document.pdf", 5, true);
```

### Response
#### Success Response
N/A (void method)

#### Response Example
None
```

--------------------------------

### DisplayMode Property for DisplayModeChangedEventArgs in C#

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.DisplayModeChangedEventArgs.html

Gets the current display mode of the Sumatra PDF control. This property is part of the DisplayModeChangedEventArgs class and provides information about the display mode when the DisplayModeChanged event is raised. It returns a SumatraPDFControl.DisplayModeEnum value.

```csharp
public SumatraPDFControl.DisplayModeEnum DisplayMode { get; }
```

--------------------------------

### Set Numeric Zoom Scale

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Get or set the current numeric zoom scale of the PDF document. This property is a float. For virtual zoom modes like fit width or fit page, use the ZoomVirtual property.

```csharp
[Browsable(false)]
public float Zoom { get; set; }
```

--------------------------------

### C# SumatraPDF Document Operations: Print, Reload, and Auto-Reload

Source: https://context7.com/marcoscmonteiro/sumatrapdfcontrol/llms.txt

This C# class demonstrates how to interact with the SumatraPDF control for printing documents, reloading the current file, and loading new files with an integrated auto-reload feature. It utilizes a FileSystemWatcher to monitor for external file changes, ensuring the displayed document is always up-to-date. The class requires an instance of SumatraPDFControl and manages file watching through SetupFileWatcher and StopWatchingFile methods.

```csharp
using SumatraPDF;
using System.IO;
using System.Windows.Forms;

public class PDFDocumentOperations
{
    private SumatraPDFControl pdfControl;
    private FileSystemWatcher fileWatcher;
    private string currentFilePath;

    public PDFDocumentOperations(SumatraPDFControl control)
    {
        pdfControl = control;
    }

    // Open print dialog
    public void PrintDocument()
    {
        pdfControl.OpenPrintDialog();
        Console.WriteLine("Print dialog opened");
    }

    // Reload current document
    public void ReloadDocument()
    {
        pdfControl.ReloadCurrentFile();
        Console.WriteLine("Document reloaded");
    }

    // Load file with automatic reload on changes
    public void LoadFileWithAutoReload(string filePath, int initialPage = 1)
    {
        currentFilePath = filePath;

        // Stop existing file watcher
        StopWatchingFile();

        // Load the file
        pdfControl.LoadFile(filePath, initialPage, NewSumatraInstance: false);

        // Setup file watcher for auto-reload
        SetupFileWatcher(filePath);
    }

    private void SetupFileWatcher(string filePath)
    {
        if (!File.Exists(filePath))
            return;

        string directory = Path.GetDirectoryName(filePath);
        string fileName = Path.GetFileName(filePath);

        fileWatcher = new FileSystemWatcher(directory)
        {
            Filter = fileName,
            NotifyFilter = NotifyFilters.LastWrite,
            EnableRaisingEvents = true
        };

        fileWatcher.Changed += (s, e) =>
        {
            // Delay to ensure file write is complete
            System.Threading.Thread.Sleep(500);
            ReloadDocument();
            Console.WriteLine($"File changed, document reloaded: {e.Name}");
        };
    }

    private void StopWatchingFile()
    {
        if (fileWatcher != null)
        {
            fileWatcher.EnableRaisingEvents = false;
            fileWatcher.Dispose();
            fileWatcher = null;
        }
    }

    // Load with new SumatraPDF instance
    public void LoadFileNewInstance(string filePath, int initialPage = 1)
    {
        pdfControl.LoadFile(filePath, initialPage, NewSumatraInstance: true);
        Console.WriteLine($"File loaded in new instance: {filePath}");
    }

    // Setup print button
    public void SetupPrintButton(ToolStripButton btnPrint)
    {
        btnPrint.Text = "Print";
        btnPrint.Click += (s, e) => PrintDocument();
    }

    // Setup reload button
    public void SetupReloadButton(ToolStripButton btnReload)
    {
        btnReload.Text = "Reload";
        btnReload.Click += (s, e) => ReloadDocument();
    }

    // Cleanup
    public void Dispose()
    {
        StopWatchingFile();
    }
}

```

--------------------------------

### Constructor: SumatraPDFControl()

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

The default constructor for the SumatraPDFControl class.

```APIDOC
## Constructor: SumatraPDFControl()

### Description
Default constructor

### Declaration
```csharp
public SumatraPDFControl()
```
```

--------------------------------

### Load File - SumatraPDFControl

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Loads a Sumatra PDF supported file into the control. The current file will be closed before loading the new one. It accepts the file path as a string, an integer for the initial page number, and a boolean to specify if the file should be opened in a new instance.

```csharp
public void LoadFile(String filePath, Int32 pageNumber, Boolean newInstance)
```

--------------------------------

### Load PDF File in SumatraPDFControl

Source: https://github.com/marcoscmonteiro/sumatrapdfcontrol/blob/master/docs/api/SumatraPDF.SumatraPDFControl.html

Loads a specified PDF file into the SumatraPDFControl. It allows setting the initial page to display and controlling whether to open a new SumatraPDF instance. This method is crucial for programmatically opening and managing PDF documents.

```csharp
public void LoadFile(string PDFFile, int InitialPage = 1, bool NewSumatraInstance = false)
```