159 lines
4.3 KiB
Go
159 lines
4.3 KiB
Go
package pdf
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"runtime"
|
|
|
|
"github.com/go-pdf/fpdf"
|
|
"github.com/go-pdf/fpdf/contrib/gofpdi"
|
|
)
|
|
|
|
// PDF page boxes are reported in PostScript points while fpdf works in
|
|
// millimetres.
|
|
const mmPerPoint = 25.4 / 72.0
|
|
|
|
type documentPage struct {
|
|
width float64
|
|
height float64
|
|
}
|
|
|
|
func pointsToMillimetres(value float64) float64 {
|
|
return value * mmPerPoint
|
|
}
|
|
|
|
// documentPages returns the page geometry of a PDF in millimetres.
|
|
func documentPages(raw []byte) ([]documentPage, error) {
|
|
out := fpdf.New("P", "mm", "A4", "")
|
|
out.SetMargins(0, 0, 0)
|
|
out.SetAutoPageBreak(false, 0)
|
|
|
|
importer := gofpdi.NewImporter()
|
|
reader := new(io.ReadSeeker)
|
|
*reader = bytes.NewReader(raw)
|
|
importer.ImportPageFromStream(out, reader, 1, "/MediaBox")
|
|
|
|
sizes := importer.GetPageSizes()
|
|
if len(sizes) == 0 {
|
|
return nil, fmt.Errorf("PDF ohne Seiten")
|
|
}
|
|
pages := make([]documentPage, len(sizes))
|
|
for page := 1; page <= len(sizes); page++ {
|
|
size, ok := sizes[page]["/MediaBox"]
|
|
if !ok {
|
|
return nil, fmt.Errorf("PDF-Seite %d ohne MediaBox", page)
|
|
}
|
|
pages[page-1] = documentPage{
|
|
width: pointsToMillimetres(size["w"]),
|
|
height: pointsToMillimetres(size["h"]),
|
|
}
|
|
}
|
|
return pages, nil
|
|
}
|
|
|
|
// PageCount returns the number of pages in a PDF document.
|
|
func PageCount(raw []byte) (int, error) {
|
|
pages, err := documentPages(raw)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return len(pages), nil
|
|
}
|
|
|
|
// PadToEvenPages appends one blank page to documents with an odd page count so
|
|
// that every cover sheet and every service list starts on the front side of a
|
|
// sheet when printed duplex. Documents with an even page count are returned
|
|
// unchanged.
|
|
func PadToEvenPages(raw []byte) ([]byte, error) {
|
|
pages, err := documentPages(raw)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(pages)%2 == 0 {
|
|
return raw, nil
|
|
}
|
|
last := pages[len(pages)-1]
|
|
blank, err := blankPage(last.width, last.height)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return Merge([][]byte{raw, blank})
|
|
}
|
|
|
|
func blankPage(width, height float64) ([]byte, error) {
|
|
out := fpdf.New("P", "mm", "A4", "")
|
|
out.SetMargins(0, 0, 0)
|
|
out.SetAutoPageBreak(false, 0)
|
|
out.AddPageFormat("P", fpdf.SizeType{Wd: width, Ht: height})
|
|
|
|
var buffer bytes.Buffer
|
|
if err := out.Output(&buffer); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := out.Error(); err != nil {
|
|
return nil, err
|
|
}
|
|
return buffer.Bytes(), nil
|
|
}
|
|
|
|
// Merge concatenates PDF documents page by page, preserving page sizes and
|
|
// orientation. It is used for printable dispatch packets that combine a cover
|
|
// sheet with the selected plan variant for every recipient.
|
|
//
|
|
// All documents share one importer. A new importer per document would restart
|
|
// the internal template numbering, so later documents would silently overwrite
|
|
// earlier templates and their pages would show the wrong content.
|
|
func Merge(documents [][]byte) ([]byte, error) {
|
|
out := fpdf.New("P", "mm", "A4", "")
|
|
out.SetMargins(0, 0, 0)
|
|
out.SetAutoPageBreak(false, 0)
|
|
|
|
importer := gofpdi.NewImporter()
|
|
// Keep each source stream pointer alive so gofpdi sees a distinct source
|
|
// identifier for every document.
|
|
var readers []*io.ReadSeeker
|
|
|
|
for _, raw := range documents {
|
|
if len(raw) == 0 {
|
|
continue
|
|
}
|
|
reader := new(io.ReadSeeker)
|
|
*reader = bytes.NewReader(raw)
|
|
readers = append(readers, reader)
|
|
|
|
template := importer.ImportPageFromStream(out, reader, 1, "/MediaBox")
|
|
sizes := importer.GetPageSizes()
|
|
pages := len(sizes)
|
|
if pages == 0 {
|
|
return nil, fmt.Errorf("PDF ohne Seiten")
|
|
}
|
|
for page := 1; page <= pages; page++ {
|
|
size, ok := sizes[page]["/MediaBox"]
|
|
if !ok {
|
|
return nil, fmt.Errorf("PDF-Seite %d ohne MediaBox", page)
|
|
}
|
|
width := pointsToMillimetres(size["w"])
|
|
height := pointsToMillimetres(size["h"])
|
|
// A4 portrait is passed explicitly: fpdf swaps width and height for
|
|
// "L", which would turn an already landscape-sized box back into
|
|
// portrait. "P" keeps the requested dimensions as they are.
|
|
out.AddPageFormat("P", fpdf.SizeType{Wd: width, Ht: height})
|
|
if page > 1 {
|
|
template = importer.ImportPageFromStream(out, reader, page, "/MediaBox")
|
|
}
|
|
importer.UseImportedTemplate(out, template, 0, 0, width, height)
|
|
}
|
|
}
|
|
runtime.KeepAlive(readers)
|
|
|
|
var buffer bytes.Buffer
|
|
if err := out.Output(&buffer); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := out.Error(); err != nil {
|
|
return nil, err
|
|
}
|
|
return buffer.Bytes(), nil
|
|
}
|