PdfSpace

using PdfSpace.Core;
using PdfSpace.Layout;

var pages = Enumerable.Range(0, 50).Select(_ => new PdfPageState()).ToArray();
var index = new PageLayoutIndex(pages, PageLayoutMode.TwoPage);
double width = 1280, zoom = 1.25, scroll = 0, pan = 0;

foreach (PagePlacement placement in index.Visible(width, height: 900, zoom, scroll, pan))
    Console.WriteLine($"page {placement.Index + 1} at {placement.Bounds}");

var screen = new PointD(400, 300);
int hit = index.HitTest(screen, width, zoom, scroll, pan);
if (hit >= 0)
{
    PointD pagePoint = index.Place(hit, width, zoom, scroll, pan).ToPage(pages[hit], screen, zoom);
    Console.WriteLine($"page {hit + 1}, PDF point {pagePoint}");
}
RectD rotatedBox = PageGeometry.DisplayBounds(pages[0] with { Rotation = 90 }, new RectD(72, 72, 200, 50));

using PdfSpace.Core;
using PdfSpace.Editing;

var session = new EditorSession(new PdfWorkspace(), new EditorHistoryOptions { MaximumEntries = 50 });
session.Changed += (_, _) => Console.WriteLine($"{session.UndoLabel} (dirty: {session.IsDirty})");

session.AddAnnotation(new Annotation
{
    Kind = AnnotationKind.Rectangle,
    Bounds = new RectD(72, 120, 180, 64),
    Color = 0xFF1473E6,
    StrokeWidth = 2
});
session.RotatePage();
session.DuplicatePage();
session.Execute("Bookmark pages", doc => doc with
{
    Pages = doc.Pages.Select((p, i) => p with { Bookmark = $"Page {i + 1}" }).ToArray()
});
session.Undo();
File.WriteAllText("review.pdfspace", WorkspaceJson.Save(session.Document));

using PdfSpace.Storage;

public sealed class FolderStorage(string root) : IWorkspaceStorage
{
    private string Recovery => Path.Combine(root, "recovery.pdfspace");
    public Task<WorkspaceFile?> OpenAsync() => Task.FromResult<WorkspaceFile?>(null); // show a file picker here
    public Task SaveAsync(string name, byte[] bytes, string contentType) => File.WriteAllBytesAsync(Path.Combine(root, name), bytes);
    public async Task<string?> ReadRecoveryAsync() => File.Exists(Recovery) ? await File.ReadAllTextAsync(Recovery) : null;
    public Task WriteRecoveryAsync(string workspace) => File.WriteAllTextAsync(Recovery, workspace);
    public Task ClearRecoveryAsync() { File.Delete(Recovery); return Task.CompletedTask; }
    public Task CopyTextAsync(string text) => Task.CompletedTask;          // host clipboard
    public Task PrintAsync(string name, byte[] pdf) => Task.CompletedTask; // host print dialog
}

using PdfSpace.Core;
using PdfSpace.Documents;

var workspace = PdfReader.Open(File.ReadAllBytes("report.pdf"), "report.pdf");
Console.WriteLine(PdfReader.ExtractText(workspace));

var search = new PdfSearchIndex();
foreach (SearchResult hit in search.Find(workspace, "revenue", wholeWord: true).Take(10))
    Console.WriteLine($"p.{hit.PageIndex + 1}: {hit.Text} at {hit.Bounds}");

int[] pages = PageRange.Parse("1-3, 5", workspace.Pages.Length); // zero-based indices
File.WriteAllBytes("form.xfdf", PdfFormDataCodec.WriteXfdf(PdfFormData.FromWorkspace(workspace)));
PdfFormData answers = PdfFormDataCodec.Read(File.ReadAllBytes("answers.json"), "answers.json");

using PdfSpace.Rendering.Skia;
using SkiaSharp;
using UglyToad.PdfPig;

using var document = PdfDocument.Open(File.ReadAllBytes("input.pdf"), SkiaRenderingParsingOptions.Instance);
document.AddSkiaPageFactory();

for (var page = 1; page <= document.NumberOfPages; page++)
{
    PdfPageSize size = document.GetPageSize(page);
    using var png = document.GetPageAsPng(page, scale: 2);
    File.WriteAllBytes($"page-{page}.png", png.ToArray());
    Console.WriteLine($"page {page}: {size.Width} x {size.Height} pt");
}
using SKPicture picture = document.GetPageAsSKPicture(1); // replay onto any SKCanvas

using PdfSpace.Documents;
using PdfSpace.Skia;
using SkiaSharp;

var workspace = PdfReader.Open(File.ReadAllBytes("input.pdf"), "input.pdf");
using var typeface = SKTypeface.FromFile("fonts/Inter.ttf");                 // annotation fallback text
using var renderer = new PdfRenderer { CacheCapacity = 8, Typeface = typeface }; // disposed before the typeface

File.WriteAllBytes("first-page.png", renderer.ExportPng(workspace, pageIndex: 0, scale: 2));
File.WriteAllBytes("flattened.pdf", renderer.ExportPdf(workspace));              // visual copy, not native
File.WriteAllBytes("redacted.pdf", RasterRedactor.Export(workspace, renderer));  // image-only rebuild

using var surface = SKSurface.Create(new SKImageInfo(612, 792));
renderer.DrawPage(surface.Canvas, workspace, workspace.Pages[0]);

using PdfSpace.Pdf;
using SkiaSharp;

using var typeface = SKTypeface.FromFile("fonts/Inter.ttf"); // font for new annotation/form text
var workspace = PdfDocumentEngine.Open(File.ReadAllBytes("input.pdf"), "input.pdf");

PdfTextRun run = PdfTextEditor.Read(workspace, pageIndex: 0).First(r => r.Editable);
workspace = PdfTextEditor.Replace(workspace, run, "Updated heading");

var paths = PdfObjectEditor.Read(workspace, 0).Where(o => o.Kind == PdfPageObjectKind.Path && o.Editable).ToArray();
workspace = PdfObjectEditor.Transform(workspace, paths, PdfAffineMatrix.Translate(12, 6));

PdfWriteResult result = PdfDocumentEngine.Save(workspace, typeface); // native annotations + AcroForms
File.WriteAllBytes("native-copy.pdf", result.Bytes);
foreach (var warning in result.Warnings) Console.WriteLine(warning);

IPdfSecurityProvider security = new NativePdfSecurityProvider(); // desktop; not for AES on browserwasm
byte[] encrypted = await security.EncryptAsync(result.Bytes,
    new PdfProtectionOptions(openingPassword, ownerPassword, AllowCopy: false));

using PdfSpace.Ocr;
using PdfSpace.Skia;

var scan = PdfImageImporter.Open(File.ReadAllBytes("scan.png"), "scan.png"); // PNG/JPEG → one-page workspace
using var renderer = new PdfRenderer();
IOcrEngine engine = new TesseractProcessEngine(); // requires Tesseract 5 on PATH

var progress = new Progress<OcrProgress>(p => Console.WriteLine($"{p.Completed}/{p.Total} {p.Stage}"));
OcrBatch batch = await OcrBatch.RecognizeAsync(scan, renderer, engine, pages: [0], language: "eng", progress: progress);
var searchable = batch.Apply(scan); // adds the recognized OCR layer
Console.WriteLine($"{batch.WordCount} words on {batch.RecognizedPages} page(s)");

using Microsoft.UI.Xaml.Controls;
using PdfSpace.Controls;

var status = PdfTheme.Text("Ready");
var panel = new PdfToolPanel("Review");
panel.Heading("Annotate");
panel.Add("Highlight", PdfIconKind.Highlight, () => status.Text = "Highlight");
panel.Add("Add note", PdfIconKind.Comment, () => status.Text = "Note");
var palette = new PdfColorPalette();
palette.ColorChanged += argb => status.Text = $"#{argb:X8}";
panel.Items.Children.Add(palette);
panel.Items.Children.Add(status);

var dialogs = new PdfDialogHost();
var root = new Grid { Children = { panel, dialogs } };
window.Content = root;
string? title = await dialogs.PromptAsync("Rename", "New document title", initial: "Report.pdf");

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using PdfSpace.Core;
using PdfSpace.Documents;
using PdfSpace.Editing;
using PdfSpace.Viewer;

var session = new EditorSession(PdfReader.Open(pdfBytes, "input.pdf"));
var viewport = new PdfViewport(session);
var thumbnails = new PdfThumbnailView(viewport) { Width = 180 };

session.SetTool(PdfTool.Highlight);
viewport.NoteRequested += (pageIndex, point) => session.AddAnnotation(
    new Annotation { Kind = AnnotationKind.Note, Bounds = new RectD(point.X, point.Y, 24, 24), Text = "New note" }, pageIndex);
viewport.Loaded += (_, _) => viewport.FitPage(); // needs a nonzero arranged size

var root = new Grid { ColumnDefinitions = { new ColumnDefinition { Width = GridLength.Auto }, new ColumnDefinition() } };
Grid.SetColumn(viewport, 1);
root.Children.Add(thumbnails);
root.Children.Add(viewport);
window.Content = root;
window.Closed += (_, _) => viewport.Dispose();

using PdfSpace.Ocr;
using PdfSpace.Pdf;
using PdfSpace.Skia;
using PdfSpace.Storage;
using PdfSpace.Workbench;
using SkiaSharp;

using var fontData = SKData.CreateCopy(fontBytes);
var typeface = SKTypeface.FromData(fontData);          // host-owned UI/annotation font
IWorkspaceStorage storage = new FolderStorage(appData); // see PdfSpace.Storage above

var workbench = new PdfWorkbench(SampleDocument.Create(typeface), storage, typeface,
    security: new NativePdfSecurityProvider(), ocr: new TesseractProcessEngine()); // desktop providers
window.Content = workbench;
await workbench.OfferRecoveryAsync();
window.Closed += (_, _) => { workbench.Dispose(); typeface.Dispose(); };