diff --git a/README.md b/README.md
index 4c1ed55..e6c5e81 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,7 @@ doc.Write(f)
Or from the shell:
-```
+```sh
go run ./cmd/html2pdf -in report.html -out report.pdf
```
@@ -56,16 +56,20 @@ package bundles — Inter (sans), Lora (serif), Go Mono (mono) — so the glyphs
drawn always match the metrics the layout pass measured against; there is no
web-font fetch to fail silently.
-Two gaps, both inherited from — not introduced by — the layout engine:
+Images — raster `` — go through
+the engine's own fetch/decode/size pipeline (`Engine.LoadImages`) and are
+embedded as bitmaps, so they're laid out and drawn exactly as the engine's
+raster canvas would draw them. A relative `src` resolves against
+`Options.BaseURL`; an image that fails to fetch or decode is simply left out,
+as on the raster canvas. This is the one place `Export` touches the network.
+
+One gap remains, inherited from — not introduced by — the layout engine:
- **Inline-level background/border/padding does not paint.** A styled
`` never gets its own box in go-webengine's layout (confirmed against
its reference raster painter too — a shared engine limitation). Style the
*containing* block/table-cell instead of an inner inline element when you
need a filled badge or pill.
-- **Inline `` and ``
+
+Both image gaps the README used to document are closed in one step. Rather
+than re-implement fetch/decode/budgeting, `Export` calls the engine's own
+pipeline — `Engine.LoadImages`, exported for exactly this in
+go-webengine/engine#114 — and hands its intrinsic-size map to
+`layout.LayoutDocument` and its bitmap map to the PDF painter. So an image is
+laid out at, and drawn at, precisely the size the engine's raster canvas would
+use; an inline `` arrives already rasterised by the same path.
+
+Embedded image XObjects per page, this run: Wikipedia (Go) 30, countries
+list 10, `go.dev/blog` 40, Hacker News 6, `pkg.go.dev/net/http` 88,
+`react.dev` 166, `example.com` 0 and RFC 9110 0 (neither carries an `` and
-// ` — are fetched,
+// decoded and sized by the engine's own pipeline (Engine.LoadImages) and
+// embedded as bitmaps, so they are laid out and drawn exactly as the engine's
+// raster canvas would. A relative src resolves against Options.BaseURL; an
+// image that fails to fetch or decode is simply left out. This is the one
+// place Export touches the network.
//
// # Quick start
//
@@ -31,9 +35,11 @@
package html2pdf
import (
+ "context"
"fmt"
"github.com/go-pdfkit/pdfkit"
+ "github.com/go-webengine/engine"
"github.com/go-webengine/engine/css"
"github.com/go-webengine/engine/dom"
"github.com/go-webengine/engine/layout"
@@ -68,6 +74,11 @@ type Options struct {
// a common small-desktop/tablet breakpoint. Set below the print column's
// own width (rare) to lay out 1:1 with no scaling.
ViewportPx float64
+
+ // BaseURL is the document's own URL, used to resolve a relative before
` +
+ `after
`
+ doc, err := Export(html, Options{})
+ if err != nil {
+ t.Fatalf("Export: %v", err)
+ }
+ var buf bytes.Buffer
+ if err := doc.Write(&buf); err != nil {
+ t.Fatalf("Write: %v", err)
+ }
+ // pdfkit writes every embedded bitmap as an image XObject.
+ if !bytes.Contains(buf.Bytes(), []byte("/Subtype /Image")) {
+ t.Error("no image XObject in output: the rides the same engine pipeline (serialised then
+ // rasterised), so it lands as a bitmap too — closing the gap the README
+ // used to document.
+ html := `` +
+ `` +
+ ` ` +
+ ``
+ doc, err := Export(html, Options{})
+ if err != nil {
+ t.Fatalf("Export: %v", err)
+ }
+ var buf bytes.Buffer
+ if err := doc.Write(&buf); err != nil {
+ t.Fatalf("Write: %v", err)
+ }
+ if !bytes.Contains(buf.Bytes(), []byte("/Subtype /Image")) {
+ t.Error("no image XObject in output: the inline was not embedded")
+ }
+}
+
+func TestExportSkipsAnUnfetchableImage(t *testing.T) {
+ // A src that can't be fetched is left out of the maps by the engine —
+ // the document still exports, with no image XObject and no panic. Uses an
+ // unroutable scheme so this never touches the network.
+ html := `text
`
+ doc, err := Export(html, Options{})
+ if err != nil {
+ t.Fatalf("Export: %v", err)
+ }
+ var buf bytes.Buffer
+ if err := doc.Write(&buf); err != nil {
+ t.Fatalf("Write: %v", err)
+ }
+ if bytes.Contains(buf.Bytes(), []byte("/Subtype /Image")) {
+ t.Error("an image XObject appeared for an unfetchable src")
+ }
+}
+
+func TestExportRelativeImageResolvesAgainstBaseURL(t *testing.T) {
+ // With no BaseURL a relative src has nothing to resolve against and is
+ // skipped rather than crashing; the export still succeeds. (A real
+ // resolution round-trip needs the network and lives in corpus/.)
+ html := `t
`
+ if _, err := Export(html, Options{}); err != nil {
+ t.Fatalf("Export without BaseURL: %v", err)
+ }
+ if _, err := Export(html, Options{BaseURL: "https://x.test/dir/"}); err != nil {
+ t.Fatalf("Export with BaseURL: %v", err)
+ }
+}
+
+func TestPaintImageIgnoresAnItemWithNoBitmap(t *testing.T) {
+ // Defensive: an image item whose element has no decoded bitmap must draw
+ // nothing and not dereference a nil map entry (a nil imgs map is the
+ // case where every fetch failed).
+ e := &exporter{imgs: nil, scale: 1, pageHPt: 800, marginPt: 10}
+ e.paintImage(&layout.InlineItem{Image: &dom.Node{}, ImgW: 10, ImgH: 10})
+}
diff --git a/render.go b/render.go
index 85d054d..1eb6411 100644
--- a/render.go
+++ b/render.go
@@ -5,14 +5,18 @@
package html2pdf
import (
+ "image"
+
"github.com/go-pdfkit/pdfkit"
"github.com/go-webengine/engine/css"
+ "github.com/go-webengine/engine/dom"
"github.com/go-webengine/engine/layout"
)
// exporter holds the state for painting one page's slice of the box tree.
type exporter struct {
fonts *fontSet
+ imgs map[*dom.Node]image.Image // decoded bitmaps, keyed by element
pageWPt float64
pageHPt float64
marginPt float64
@@ -102,13 +106,18 @@ func (e *exporter) paintBorders(b *layout.Box, top, bot, x0, y0, x1, y1 float64)
}
}
-// paintLine draws one line box's text items, skipping the line entirely if it
-// doesn't intersect the current page slice.
+// paintLine draws one line box's items — text runs, and image items as
+// embedded bitmaps — skipping the line entirely if it doesn't intersect the
+// current page slice.
func (e *exporter) paintLine(line *layout.LineBox) {
if line.Y+line.H <= e.pageTop || line.Y >= e.pageBot {
return
}
for _, it := range line.Items {
+ if it.Image != nil {
+ e.paintImage(it)
+ continue
+ }
if it.Text == "" || it.Style == nil {
continue
}
@@ -119,3 +128,21 @@ func (e *exporter) paintLine(line *layout.LineBox) {
_ = e.p.TextShaped(x, y, it.Text)
}
}
+
+// paintImage embeds an image item's decoded bitmap into the box layout gave
+// it. The engine's raster painter blits the bitmap at (X, Y) at its native
+// size, which its loader already made equal to (ImgW, ImgH) — so that box,
+// scaled to the print column, is the destination rectangle. An element whose
+// fetch or decode failed has no bitmap and draws nothing, same as on the
+// raster canvas. Unlike a background, an image that straddles a page break is
+// not clipped per page — it's an atom (its own line box), so pagination
+// already keeps it whole; the page-slice test on the line is enough.
+func (e *exporter) paintImage(it *layout.InlineItem) {
+ bmp, ok := e.imgs[it.Image]
+ if !ok || bmp == nil || it.ImgW <= 0 || it.ImgH <= 0 {
+ return
+ }
+ x0, y0 := e.toPdf(it.X, it.Y)
+ x1, y1 := e.toPdf(it.X+it.ImgW, it.Y+it.ImgH)
+ e.p.DrawImage(bmp, pdfkit.Rect{X: x0, Y: y1, Width: x1 - x0, Height: y0 - y1})
+}
` and inline `