docspec

type BooleanQuad ¶

type BooleanQuad struct {
	// contains filtered or unexported fields
}

BooleanQuad represents on/off state for each side of a rectangle

func NewBooleanQuad(top, right, bottom, left bool) BooleanQuad

func NewSingletonBooleanQuad(value bool) BooleanQuad

type Color ¶

type Color struct {
	// contains filtered or unexported fields
}

Color represents an RGB color

func NewColor(red, green, blue int) Color

type Document ¶

type Document struct {
	Children []*Page
}

Document is the fundamental unit of layout. It encapsulates global settings and a list of pages. The list of pages is manipulated by the layout engine to create page breaks, and is thus not exposed to userspace.

type DocumentBuilder ¶

type DocumentBuilder struct {
	// contains filtered or unexported fields
}

DocumentBuilder specifies the public interface for building documents

func NewDocumentBuilder(renderer DocumentRenderer, size documentSize, margin Size) *DocumentBuilder

func (d *DocumentBuilder) CreateDocumentTree(nodeList []*LayoutNode) error

func (d *DocumentBuilder) PrettyPrintDocumentTree()

func (d *DocumentBuilder) RenderToWriter(writer io.Writer) error

type DocumentRenderer ¶

type DocumentRenderer interface {
	// Render takes a document and renders it into some result value suitable
	// for the type of renderer.  For example, for an FPDF renderer, the result
	// would be an FPDF struct that can be saved to a file.  For a JPEG
	// renderer, the result would be JPEG byte data.  And so on.
	Render(root *Document) (result interface{}, err error)

	// SaveToFile takes in the render result and saves it via a io.Writer
	Save(renderResult interface{}, writer io.Writer) error

	// SplitText calculates from font attributes present in TextNode the
	// optimal number and size of lines required to render the text node into
	// the given rect.  This method is present in the renderer so that the main
	// layout engine can communicate with the renderer to prepare text node's
	// with different text overflow behaviors.
	SplitText(targetRect Rect, textNode TextNode) []string

	// GetTextWidth gets the width that a piece of text would have if it was
	// not split.  This is so that a text node can have an inherent width and
	// height can be used in a Height/WidthAsChildren definition.
	GetInherentTextRect(textNode TextNode) Rect
}

DocumentRenderer defines the interface which must be implemented by a type in order to render a document tree into a document. It's defined here in the docspec package so that users can write their own renderer beyond the ones already defined by docspec.

type FontConfig ¶

type FontConfig struct {
	Name  string
	Style string
	File  string
}

FontConfig represents the font data required to initialize the font with the underlying FPDF library.

type Future ¶

type Future struct {
	// contains filtered or unexported fields
}

Future is a datatype modeling a value defined by a recursive function that cannot be evaluated until the entire layout tree is constructed. For example, the height of a node is often defined by the height of its children, which do not yet exist at the time of the node's construction. While in this way it is conceptually similar to a "Future" as used in many programming language's asyncIO implementation, it has nothing to do with concurrency.

func HeightAsChildren() Future

func HeightFill() Future

func HeightPercentage(percentage Size) Future

func StaticSize(size Size) Future

func WidthAsChildren() Future

func WidthFill() Future

func WidthPercentage(percentage Size) Future

type ImageNode ¶

type ImageNode struct {
	// full path to a local file from which to read the image.  Currently only
	// gif, jpeg, and png file types are supported.
	Src           string
	RatioBehavior imageFit
	Alignment     imageAlignment
	// contains filtered or unexported fields
}

ImageNode represents an image drawn from a local file

type LayoutChildAlignment ¶

type LayoutChildAlignment struct {
	Vertical   childAlignment
	Horizontal childAlignment
}

LayoutChildAlignment configures where on the x and y axis inside a given node to position that node's children

type LayoutNode ¶

type LayoutNode struct {
	ID                 string
	Children           []*LayoutNode
	VisualNode         interface{}
	Parent             *LayoutNode
	Page               *Page
	X                  Size
	Y                  Size
	Width              Future
	Height             Future
	Border             BooleanQuad
	BorderColor        Color
	ShowFill           bool
	FillColor          Color
	Padding            SizesQuad
	Margin             SizesQuad
	ChildAlignment     LayoutChildAlignment
	ChildFlowDirection childFlowDirection
	// contains filtered or unexported fields
}

LayoutNode represents a rectangular container into which content can be rendered. Layout nodes control all layout such as width, height, padding, and so on. Value nodes such as a text nodes or image nodes are used to render content into the rect defined by the LayoutNode.

Splitting over pages is determined by testing if the node's height would take it over the draw rect of the current page. If it would, then the tree is traversed backwards until the parent node that is a direct child of the Page is found, and the origin of that node is placed at the origin of the page, and x,y coordination calculation continues down the page as before. If that parent node's height is greater than the height of the page (i.e. the node cannot fit on a single page), then an error is raised. An error is also raised is a node's measured height is greater than the height of any page, meaning that the above test would result in infinite recursion.

Layout calculation takes place in two phases: first the widths and heights of all the nodes are calculated, and then the x,y coordinates of each rect is calculated. Thus the entire document tree is iterated over at least 3 times: twice as described above, and then at least once again during rendering.

func CreateNodeList(nodes ...*LayoutNode) []*LayoutNode

func Div(parent *LayoutNode, options LayoutNodeProps, cb func(*LayoutNode)) *LayoutNode

func Image(parent *LayoutNode, options LayoutNodeProps, imageProps ImageNode) *LayoutNode

func Text(parent *LayoutNode, options LayoutNodeProps, textProps TextNode) *LayoutNode

func (n *LayoutNode) Clone() *LayoutNode

type LayoutNodeProps ¶

type LayoutNodeProps struct {
	ID                 string
	Border             BooleanQuad
	BorderColor        Color
	ShowFill           bool
	FillColor          Color
	Padding            SizesQuad
	Margin             SizesQuad
	Width              Future
	Height             Future
	ChildAlignment     LayoutChildAlignment
	ChildFlowDirection childFlowDirection
}

LayoutNodeProps is the subset of the properties of the LayoutNode struct which can be passed into node constructors.

type PDF ¶

type PDF = *gofpdf.Fpdf

PDF is an alias for a pointer to gopdf's FPDF type, created for easier typing

type PDFRenderer ¶

type PDFRenderer struct {
	// contains filtered or unexported fields
}

PDFRenderer implements the DocumentRenderer interface for Adobe pdf documents.

func NewPDFRenderer(ds documentSize, fontsDir string, fonts ...FontConfig) (*PDFRenderer, error)

func (r *PDFRenderer) GetInherentTextRect(textNode TextNode) Rect

func (r *PDFRenderer) Render(document *Document) (result interface{}, err error)

func (r *PDFRenderer) Save(renderResult interface{}, writer io.Writer) error

func (r *PDFRenderer) SplitText(targetRect Rect, textNode TextNode) []string

type Page ¶

type Page struct {
	Children []*LayoutNode
	Width    Size
	Height   Size
	Margin   SizesQuad
}

Page is a special layout node that is always statically sized at the size specified in the document settings.

type Rect ¶

type Rect struct {
	// contains filtered or unexported fields
}

Rect represents a rectangle in unknown space (no x and y values are specified, only size)

type Size ¶

type Size = float64

Size is the fundmental unit of measurement used for widths, heights, margins, and other measured areas.

type SizesQuad ¶

type SizesQuad struct {
	// contains filtered or unexported fields
}

SizesQuad represents values that occur for each of the four sides of a rectangle, such as padding and margin

func NewSingletonSizeQuad(value Size) SizesQuad

func NewSizeQuad(top, right, bottom, left Size) SizesQuad

type TextNode ¶

type TextNode struct {
	Text       string
	FontFamily string
	FontStyle  fontStyle
	// size of the font in points (1pt == 0.3528mm)
	FontSize Size
	Color    Color
	// multiplier used to determine line height based on font size
	LineHeight       Size
	Alignment        textAlignment
	Link             string
	OverflowBehavior overflowBehavior
}

TextNode represents a paragraph of text, possibly containing a link