PdfViewer

A document is described by a BitPdfSource: either FromUrl (fetched through the registered HttpClient) or FromBytes for a buffer you already have - an upload, a database blob, an embedded resource - with FromBase64 and FromStreamAsync for the other two shapes a document arrives in. Everything else is on by default: the toolbar, lazy per-page rendering as you scroll, selectable text, and links that jump to the exact spot in the document they point at. AllowDropFile additionally lets a reader drop a pdf straight onto the viewer.

You can also drop a pdf onto the viewer below, or select one from your computer:

Without a Height the viewer is responsive: it is capped at 780px and shrinks to fit the viewport on small screens. Set the parameter to any CSS length to pin it instead. Width does the same for the horizontal axis; left unset the viewer fills whatever width its host gives it. Both are plain CSS lengths, so a percentage, a vh or a calc() all work, and a fit mode re-fits itself whenever the resulting box changes size.

ShowToolbar hides the toolbar entirely - useful when the hosting page drives the viewer through its public API. To keep the toolbar but trim it, ToolbarItems is a flags enum: combine only the groups you want and the rest are not rendered at all. OpenFile is one of those groups - it puts a file picker in the toolbar so a reader can open a pdf from their own machine without the page providing an upload of its own. The viewer opens the picked file itself unless OnFileOpened is handled, in which case the source is handed to you to drive Source with; MaxOpenFileSize caps what it will read. The page box in the navigation group takes the document's own page label ("iv", "A-1") as readily as a page number, and shows the plain number beside it whenever the two differ.

Four side panels ship with the viewer: page thumbnails, the document's own bookmarks (its outline), its embedded files, and its optional-content layers. Thumbnails render lazily on their own scroll, so opening the panel on a 500-page document only builds the handful on screen; the bookmarks tree folds and unfolds and is navigable by keyboard; the attachments panel saves an embedded file when its row is activated; the layers panel switches a group of content on or off and repaints the pages, the way a CAD or map document expects. DefaultSidebar picks the one that is open when a document loads, and the toolbar toggles decide from there. A toggle whose panel has nothing to show - no outline, no attachments - stays disabled.

InitialZoomMode sets the fit the viewer opens with, and the zoom dropdown offers the same five modes afterwards: Automatic (fit the width, but stop magnifying at 125% so a narrow page stays readable rather than filling a wide screen), FitWidth, FitPage, FitHeight and ActualSize - plus the percentage presets, which ZoomPresets replaces with a list of your own. A fit mode re-fits itself when the container resizes and when the reader reaches a page of a different size. MinZoom, MaxZoom and ZoomStep bound and pace every zoom, whether it comes from the buttons, Ctrl+wheel, a pinch or the public API - and a wheel or pinch zoom keeps the point under the cursor where it is instead of jumping back to the top of the page.

ScrollMode lays the pages out the four ways a desktop viewer does: stacked vertically (the default), side by side on one horizontally scrolling row, wrapped into rows that fill the width, or one page at a time. SpreadMode pairs them into spreads the way a printed book falls open - Odd pairs 1-2, 3-4, while Even leaves page 1 alone as a cover. CursorTool switches dragging between selecting text and panning the document. All three are toolbar controls too, and a choice made there survives the host re-rendering. Presentation mode (the toolbar's screen button, Ctrl+Alt+P, or TogglePresentationMode) combines them: fullscreen, one page at a time, scaled to fit - and leaving it, however it happens, puts the previous layout back. Whenever one page is shown at a time the surface has nothing to scroll, so the arrow keys and Space turn the page instead, and while presenting a click anywhere on the slide advances (Shift+click goes back).

Matches are counted in C# over a per-page text index, so the total covers the whole document without rendering any of it - stepping to a match is what brings its page in, one page at a time. The hits themselves are painted with the CSS Custom Highlight API, which never touches the page markup. Four options narrow or widen the query: Aa matches case, ab matches whole words, á tells an accented letter apart from its bare one (off by default, so typing resume finds résumé), and the last one paints every match rather than only the one being walked to. A query that matches nothing says so rather than showing a zero counter. Typing searches as you pause; Enter and Shift+Enter step through the results, and Search, SetSearchOptions, FindNext and ClearSearch do the same from code.

While focus is inside the viewer it handles the shortcuts readers already know from desktop pdf viewers. They are matched in the browser, so Ctrl+F, Ctrl+P and Ctrl+S open the viewer's own find box, print pass and download instead of the browser's, and a bare letter typed into the find or page box is never mistaken for a command. Set EnableKeyboardShortcuts to false to hand every key back to the page.

Html (the default) lays every page out as positioned DOM: it is fully prerenderable, stays crisp at any zoom and needs no JavaScript to paint. Canvas instead replays a display list produced by the same C# engine onto a per-page <canvas> - far fewer DOM nodes on graphics-heavy documents, re-rasterized when the zoom settles - while selection, find and links keep working through the DOM text layer above it.

You can also select a pdf file from your computer to view it here:

Some producers emit one show-text operator per glyph. Exact (the default) keeps each run in its own positioned span, so every glyph lands where the pdf says it does. Compact merges same-line, same-style runs into one span per visual line - dramatically fewer DOM nodes on those documents, at the cost of a small intra-line drift where explicit kerning between runs is approximated. Rotated text is never coalesced.

The toolbar's info button opens a properties dialog with the file name and size, the /Info fields, the pdf version and the current page size. The same data - and more - is on the component reference: Metadata, Permissions, PageLabels, FormFields, StructureTree and the whole parsed Document, so an app can index, audit or reflow a file without parsing it a second time.

An encrypted document opens with a password the viewer asks for in a dialog of its own, retrying as long as answers keep arriving and giving up when the reader cancels. A known password can be carried on the source instead with WithPassword, and OnPasswordRequested replaces the built-in dialog with your own UI. Set ShowPasswordPrompt to false to skip the asking entirely and let the failure surface through OnError. Once open, Permissions reports what the document's owner allows, and RespectPermissions makes the viewer act on it: a document that forbids printing or copying gets those toolbar controls disabled, its text stops being selectable, and the matching methods refuse. It is off by default, as in every browser pdf viewer - the flags are advisory, not a security boundary.

Select an encrypted pdf file from your computer to try it:

The viewer reports every state change a host might want to mirror: the document loading, the focused page, the zoom factor, the rotation and the open side panel - plus OnPageRendered as each page is actually built (lazily, as the reader reaches it), OnProgress while a URL source downloads (when the server declares a length), OnWarnings for the non-fatal diagnostics of a damaged file (a rebuilt cross-reference table, say) - also readable afterwards from Warnings - and OnError when a load or a page render fails.

Events:

Every toolbar action is also a method, so the viewer can be driven from your own chrome with the toolbar hidden - and a few things only the API offers: OpenAsync swaps the document without going through the Source parameter, GoToDestination and GoToNamedDestination land on the exact spot a bookmark or a named anchor points at rather than the top of its page, and ExtractText / RenderPageHtml hand you the document's text or a page's markup for indexing and export, while GetSelectedText and ClearSelection read and drop what the reader has highlighted - what a "quote this" or "look this up" action is built on. BackgroundRendering additionally moves parsing and page building off the UI thread where the runtime has a spare one (Blazor Server, or a WebAssembly app built with WasmEnableThreads); on the default single-threaded WebAssembly runtime it is a safe no-op.

First

Prev

/

Next

Last

Zoom -

100%

Zoom +

Fit page

Rotate ccw

Rotate cw

Thumbnails

First bookmark

Selected text

Download

Print

Present

Fullscreen

CurrentPage, Zoom and Rotation are two-way bindable: read them to follow the reader, assign them to drive the viewer. Bound one way - a value without its Changed callback - the value becomes the host's to control and the viewer stops moving it on its own, reporting what the reader did through OnPageChanged and friends instead.

Every string the viewer renders - button labels, aria labels, the zoom dropdown, the find box, the status messages and the properties dialog - comes from a BitPdfViewerTexts instance. Assign Texts with only the properties you want to replace; the rest keep their English defaults.

Printing renders every page in range first - lazily-rendered pages that were never scrolled to included, with a progress bar while it catches up - then clones them into a hidden frame, one sheet per page, at their true physical size. The sheet declares the page's own dimensions, so a landscape document reaches the printer as landscape instead of being cropped onto portrait paper, and canvas-mode pages are re-rasterized at 300 dpi rather than upscaling the screen bitmap. Print takes the whole document, PrintCurrentPage just the page in front of the reader, and Print with a range prints from one page to another. A document whose owner forbids printing keeps the button enabled unless RespectPermissions is set.

Print all

Print current page

Print pages 1-2

The chrome is built to the ARIA patterns assistive technology expects - and only claims the ones it implements. The toolbar is a labelled group whose toggles report aria-pressed (not a toolbar, whose single tab stop would take the arrow keys away from the page box and the dropdowns inside it); the thumbnail panel is a listbox with a roving tab stop, so one Tab reaches it and the arrow keys move the selection; the bookmarks panel is a real tree - each bookmark is the focusable treeitem itself, with the left and right arrows folding and unfolding branches and Home/End jumping to its ends. Moving to another page is announced through a polite live region, because the page box is an <input> and changing its value says nothing on its own. The password and properties dialogs open with focus inside them, keep Tab within them and close on Esc whether or not the keyboard shortcuts are enabled, and page content itself carries a selectable, screen-reader-readable text layer in reading order - the same layer find and copy work over. A page the engine cannot render says so in place of its content rather than shimmering forever; FailedPages lists them.

Style and Class reach the root element, while Styles and Classes address the individual parts - the toolbar and its buttons, the sidebars, the surface, each page and the properties dialog.

Set Dir to BitDir.Rtl to mirror the chrome - the toolbar groups, the sidebars and the find box - for right-to-left layouts. Page content itself keeps the orientation the document defines.