pdf

type Array []Object

type Box struct {
	// Rectangle gives the size and location of the box.  Required.
	Rectangle Rectangle
	// Page gives the page number to draw on.  Default is 1.
	Page int
	// Fill gives the fill color for the box, as an array of three or four
	// bytes (R, G, B, and maybe A).  Default is no fill.
	Fill []byte
	// Stroke gives the stroke color for the box, as an array of three or
	// four bytes (R, G, B, and maybe A).  Default is no stroke.
	Stroke []byte
	// StrokeWidth gives the stroke width for the box (meaningful only if
	// Stroke is specified).  Default is 1pt.
	StrokeWidth float64
}

type Cell struct {
	// Row is the row number of the cell.  For cells that span rows,
	// it is the topmost row that the cell spans.  Rows are numbered from 0
	// starting at the top of the table.
	Row int
	// Col is the column number of the cell.  For cells that span columns,
	// it is the leftmost column that the cell spans.  Cells are numbered
	// from 0 starting at the left of the table.
	Col int
	// RowSpan is the number of rows the cell spans (default 1).
	RowSpan int
	// ColSpan is the number of columns the cell spans (default 1).
	ColSpan int
	// Fill is the background color of the cell, if any.
	Fill []byte
	// Text is the text to place in the cell.  Note that the Page,
	// Rectangle, MinFontSize, and Wrap will be overridden by Table.Draw.
	Text *Text
}

type Circle struct {
	// Center gives the center point of the circle.  Required.
	Center Point
	// Radius gives the radius of the circle.  Required.
	Radius float64
	// Page gives the page number to draw on.  Default is 1.
	Page int
	// Fill gives the fill color for the circle, as an array of three or
	// four bytes (R, G, B, and maybe A).  Default is no fill.
	Fill []byte
	// Stroke gives the stroke color for the circle, as an array of three or
	// four bytes (R, G, B, and maybe A).  Default is no stroke.
	Stroke []byte
}

type Cross struct {
	// Rectangle gives the size and location of the cross.  Required.
	Rectangle Rectangle
	// Page gives the page number to draw on.  Default is 1.
	Page int
	// LineWidth gives the line width.  Default is 1 point.
	LineWidth float64
	// Stroke gives the stroke color for the lines, as an array of three or
	// four bytes (R, G, B, and maybe A).  Default is black.
	Stroke []byte
}

type Dict map[Name]Object

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

type Line struct {
	// P1 and P2 give the endpoints of the line.  Required.
	P1, P2 Point
	// Page gives the page number to draw on.  Default is 1.
	Page int
	// Stroke gives the stroke color for the line, as an array of three or
	// four bytes (R, G, B, and maybe A).  Default is solid black.
	Stroke []byte
	// Width gives the line width.  Default is 1pt.
	Width float64
}

type Matrix struct{ A, B, C, D, E, F float64 }

type Name string

type Object any

type PDF struct {
	Info    Dict
	Catalog Dict
	Trailer Dict
	// contains filtered or unexported fields
}

type Path string

type Point struct{ X, Y float64 }

type Reader interface {
	io.Seeker
	io.ReaderAt
}

type Rectangle struct{ LLX, LLY, URX, URY float64 }

type Reference struct {
	Number     int
	Generation int
}

type Stream struct {
	Dict Dict
	Data []byte
}

type Table struct {
	// Page is the page number onto which to draw the table.  Default 1.
	Page int
	// Rectangle is the page area into which to draw the table.  The table
	// is vertically aligned to the top of the rectangle and horizontally
	// centered in it.  After a call to Draw, Rectangle reflects the actual
	// rectangle used.
	Rectangle Rectangle
	// TableBorderWidth is the width of the border drawn around the table.
	TableBorderWidth float64
	// TableBorderStroke is the color of the border drawn around the table.
	TableBorderStroke []byte
	// CellPadX is the padding on the left and right side of each cell.
	CellPadX float64
	// CellPadY is the padding on the top and bottom of each cell.
	CellPadY float64
	// CellBorderWidth is the width of the border drawn around each cell of
	// the table.
	CellBorderWidth float64
	// CellBorderStroke is the color of the border drawn around each cell of
	// the table.
	CellBorderStroke []byte
	// Align specifies the alignment of the table within the Rectangle.  It
	// contains up to two letters:  "t", "m", or "b" to specify top, middle,
	// or bottom vertical alignment, and "l", "c", or "r" to specify left,
	// center, or right horizontal alignment.  The default is "tc".
	Align string
	// contains filtered or unexported fields
}

type Text struct {
	// String is the string to be drawn.  Required.  The string should be
	// encoded in UTF-8 as normal; however, only characters in the Windows
	// 1252 character set (a superset of ISO 8859-1) will actually be
	// rendered.
	String string
	// Rectangle is the page area into which to draw the string.  Required.
	Rectangle Rectangle
	// Page is the page number onto which to draw the string.  Default 1.
	Page int
	// Baseline, if nonzero, is the Y-coordinate of the baseline for the
	// first line of text.  This overrides any alignment specified in Align
	// or VAlign.
	Baseline float64
	// Font is the name of font in which the string should be drawn.  It
	// must be either "Courier", "Helvetica", or "Times-Roman".  Default is
	// "Helvetica".
	Font string
	// FontSize is the starting and maximum size of the font with which the
	// string should be drawn.  Default 12.0.
	FontSize float64
	// MinFontSize is the minimum size of the font with which the string
	// should be drawn.  Defaults to FontSize.  If less than FontSize, text
	// will be shrunk to fit within the Rectangle, but no smaller than
	// MinFontSize.
	MinFontSize float64
	// LineHeight is the distance between lines in a multi-line text block
	// (either String contains newlines or Wrap is enabled and String gets
	// wrapped).  Specified as a multiple of the font size, default 1.0.
	LineHeight float64
	// Color is the color in which the text should be drawn, as a slice of
	// three byte values, one each for red, green, and blue.  Default is
	// black (i.e., 0, 0, 0).
	Color []byte
	// Align specifies the alignment of the text within the rectangle.  It
	// contains up to two letters, one specifying the vertical alignment and
	// the other specifying the horizontal alignment.  The order of the two
	// does not matter.
	//
	// The vertical alignment characters are T, M, F, B, t, m, f, and b.
	// These stand for top, middle, first-middle, and bottom respectively.
	// The lowercase versions align based on the actual text (i.e., what
	// ascenders and descenders are actually used); the uppercase versions
	// align based on the font bounding box (i.e., assuming full ascenders
	// and descenders even if the text being rendered doesn't use them).
	// M/m differs from F/f only for multi-line text:  M/m centers the whole
	// block and F/f centers the first line.  If no vertical alignment
	// character is specified, the default is F.  Note that an nonzero value
	// of Baseline overrides any vertical alignment character.
	//
	// The horizontal alignment characters are l, c, and r, for left,
	// center, and right.  If no horizontal alignment character is
	// specified, the default is l.
	Align string
	// HAlign indicates how the text should be aligned horizontally.
	// Allowed values are "left" (the default), "center", and "right".
	// Deprecated:  use Align instead.
	HAlign string
	// VAlign indicates how the text hsould be aligned vertically.  Allowed
	// values are "top", "center", "bottom", and "baseline" (the default).
	// "baseline" means to arrange for the baseline of the first line of
	// text to be at Baseline, shifting that up as needed to make the text
	// fit in Rectangle.  Deprecated: use Align instead.
	VAlign string
	// Wrap indicates that text should be wrapped to fit in the Rectangle.
	Wrap bool
	// Clip indicates that text should be clipped to the Rectangle.  If
	// false, text that doesn't fit in the Rectangle is allowed to extend
	// past its boundaries.
	Clip bool
	// contains filtered or unexported fields
}