From 8081d668c8238007c54e6fae261d5323b5753e46 Mon Sep 17 00:00:00 2001 From: John Fercher Date: Mon, 11 Sep 2023 20:22:48 -0300 Subject: [PATCH 01/24] keep --- cmd/main.go | 35 +++++++++++++++++++++++++++++++++++ pkg/v2/col/col.go | 43 +++++++++++++++++++++++++++++++++++++++++++ pkg/v2/component.go | 7 +++++++ pkg/v2/document.go | 40 ++++++++++++++++++++++++++++++++++++++++ pkg/v2/image/image.go | 34 ++++++++++++++++++++++++++++++++++ pkg/v2/row/row.go | 43 +++++++++++++++++++++++++++++++++++++++++++ pkg/v2/types.go | 8 ++++++++ 7 files changed, 210 insertions(+) create mode 100644 cmd/main.go create mode 100644 pkg/v2/col/col.go create mode 100644 pkg/v2/component.go create mode 100644 pkg/v2/document.go create mode 100644 pkg/v2/image/image.go create mode 100644 pkg/v2/row/row.go create mode 100644 pkg/v2/types.go diff --git a/cmd/main.go b/cmd/main.go new file mode 100644 index 00000000..bc9f3a5f --- /dev/null +++ b/cmd/main.go @@ -0,0 +1,35 @@ +package main + +import ( + "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/col" + "github.com/johnfercher/maroto/pkg/v2/image" + "github.com/johnfercher/maroto/pkg/v2/row" +) + +func main() { + pdf := v2.NewDocument("pdfzin") + + header := buildRow() + content := buildRow() + footer := buildRow() + + pdf.Add(header, content, footer) + + pdf.Render() +} + +func buildRow() v2.Component { + row := row.New(20) + + image := image.New("image1") + + col1 := col.New(4) + col1.Add(image) + + col2 := col.New(4) + col3 := col.New(4) + + row.Add(col1, col2, col3) + return row +} diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go new file mode 100644 index 00000000..e77c3e3f --- /dev/null +++ b/pkg/v2/col/col.go @@ -0,0 +1,43 @@ +package col + +import ( + "fmt" + "github.com/johnfercher/maroto/pkg/v2" +) + +type col struct { + size int + _type string + accept map[string]bool + components []v2.Component +} + +func New(size int) *col { + accept := make(map[string]bool) + accept[v2.Image] = true + + return &col{ + _type: v2.Col, + accept: accept, + size: size, + } +} + +func (d *col) Render() { + fmt.Println(d.size) + for _, component := range d.components { + component.Render() + } +} + +func (d *col) GetType() string { + return d._type +} + +func (d *col) Add(components ...v2.Component) { + for _, component := range components { + if _, ok := d.accept[component.GetType()]; ok { + d.components = append(d.components, component) + } + } +} diff --git a/pkg/v2/component.go b/pkg/v2/component.go new file mode 100644 index 00000000..153d8000 --- /dev/null +++ b/pkg/v2/component.go @@ -0,0 +1,7 @@ +package v2 + +type Component interface { + Render() + GetType() string + Add(component ...Component) +} diff --git a/pkg/v2/document.go b/pkg/v2/document.go new file mode 100644 index 00000000..7a758e6a --- /dev/null +++ b/pkg/v2/document.go @@ -0,0 +1,40 @@ +package v2 + +import "fmt" + +type document struct { + value string + _type string + accept map[string]bool + components []Component +} + +func NewDocument(value string) *document { + accept := make(map[string]bool) + accept[Row] = true + + return &document{ + _type: Document, + accept: accept, + value: value, + } +} + +func (d *document) Render() { + fmt.Println(d.value) + for _, component := range d.components { + component.Render() + } +} + +func (d *document) GetType() string { + return d._type +} + +func (d *document) Add(components ...Component) { + for _, component := range components { + if _, ok := d.accept[component.GetType()]; ok { + d.components = append(d.components, component) + } + } +} diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go new file mode 100644 index 00000000..8f376a60 --- /dev/null +++ b/pkg/v2/image/image.go @@ -0,0 +1,34 @@ +package image + +import ( + "fmt" + "github.com/johnfercher/maroto/pkg/v2" +) + +type image struct { + path string + _type string + components []v2.Component +} + +func New(path string) *image { + return &image{ + _type: v2.Image, + path: path, + } +} + +func (d *image) Render() { + fmt.Println(d.path) + for _, component := range d.components { + component.Render() + } +} + +func (d *image) GetType() string { + return d._type +} + +func (d *image) Add(_ ...v2.Component) { + return +} diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go new file mode 100644 index 00000000..48a91a72 --- /dev/null +++ b/pkg/v2/row/row.go @@ -0,0 +1,43 @@ +package row + +import ( + "fmt" + "github.com/johnfercher/maroto/pkg/v2" +) + +type row struct { + height int + _type string + accept map[string]bool + components []v2.Component +} + +func New(height int) *row { + accept := make(map[string]bool) + accept[v2.Col] = true + + return &row{ + _type: v2.Row, + accept: accept, + height: height, + } +} + +func (d *row) Render() { + fmt.Println(d.height) + for _, component := range d.components { + component.Render() + } +} + +func (d *row) GetType() string { + return d._type +} + +func (d *row) Add(components ...v2.Component) { + for _, component := range components { + if _, ok := d.accept[component.GetType()]; ok { + d.components = append(d.components, component) + } + } +} diff --git a/pkg/v2/types.go b/pkg/v2/types.go new file mode 100644 index 00000000..64aaad71 --- /dev/null +++ b/pkg/v2/types.go @@ -0,0 +1,8 @@ +package v2 + +const ( + Document = "document" + Row = "row" + Col = "col" + Image = "image" +) From 0dd544c5e70bef72f5d0ed61a8588c7adeeea900 Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Mon, 11 Sep 2023 22:34:07 -0300 Subject: [PATCH 02/24] add typing on document type, add text interface --- pkg/v2/col/col.go | 15 +++++---------- pkg/v2/document.go | 19 +++++++++---------- pkg/v2/image/image.go | 4 ++-- pkg/v2/row/row.go | 11 +++-------- pkg/v2/text/text.go | 34 ++++++++++++++++++++++++++++++++++ pkg/v2/types.go | 22 ++++++++++++++++++++++ 6 files changed, 75 insertions(+), 30 deletions(-) create mode 100644 pkg/v2/text/text.go diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index e77c3e3f..4f47723f 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -7,19 +7,14 @@ import ( type col struct { size int - _type string - accept map[string]bool + _type v2.DocumentType components []v2.Component } func New(size int) *col { - accept := make(map[string]bool) - accept[v2.Image] = true - return &col{ - _type: v2.Col, - accept: accept, - size: size, + _type: v2.Col, + size: size, } } @@ -31,12 +26,12 @@ func (d *col) Render() { } func (d *col) GetType() string { - return d._type + return d._type.String() } func (d *col) Add(components ...v2.Component) { for _, component := range components { - if _, ok := d.accept[component.GetType()]; ok { + if d._type.Accept(component.GetType()) { d.components = append(d.components, component) } } diff --git a/pkg/v2/document.go b/pkg/v2/document.go index 7a758e6a..a053865c 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -4,19 +4,14 @@ import "fmt" type document struct { value string - _type string - accept map[string]bool + _type DocumentType components []Component } func NewDocument(value string) *document { - accept := make(map[string]bool) - accept[Row] = true - return &document{ - _type: Document, - accept: accept, - value: value, + _type: Document, + value: value, } } @@ -27,13 +22,17 @@ func (d *document) Render() { } } +func (d *document) IsDrawable() bool { + return false +} + func (d *document) GetType() string { - return d._type + return d._type.String() } func (d *document) Add(components ...Component) { for _, component := range components { - if _, ok := d.accept[component.GetType()]; ok { + if d._type.Accept(component.GetType()) { d.components = append(d.components, component) } } diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go index 8f376a60..c21e6158 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/image.go @@ -7,7 +7,7 @@ import ( type image struct { path string - _type string + _type v2.DocumentType components []v2.Component } @@ -26,7 +26,7 @@ func (d *image) Render() { } func (d *image) GetType() string { - return d._type + return d._type.String() } func (d *image) Add(_ ...v2.Component) { diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 48a91a72..355013fe 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -7,18 +7,13 @@ import ( type row struct { height int - _type string - accept map[string]bool + _type v2.DocumentType components []v2.Component } func New(height int) *row { - accept := make(map[string]bool) - accept[v2.Col] = true - return &row{ _type: v2.Row, - accept: accept, height: height, } } @@ -31,12 +26,12 @@ func (d *row) Render() { } func (d *row) GetType() string { - return d._type + return d._type.String() } func (d *row) Add(components ...v2.Component) { for _, component := range components { - if _, ok := d.accept[component.GetType()]; ok { + if d._type.Accept(component.GetType()) { d.components = append(d.components, component) } } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go new file mode 100644 index 00000000..44fd8587 --- /dev/null +++ b/pkg/v2/text/text.go @@ -0,0 +1,34 @@ +package text + +import ( + "fmt" + v2 "github.com/johnfercher/maroto/pkg/v2" +) + +type text struct { + value string + _type v2.DocumentType + components []v2.Component +} + +func New(value string) *text { + return &text{ + _type: v2.Text, + value: value, + } +} + +func (d *text) Render() { + fmt.Println(d.value) + for _, component := range d.components { + component.Render() + } +} + +func (d *text) GetType() string { + return d._type.String() +} + +func (d *text) Add(_ ...v2.Component) { + return +} diff --git a/pkg/v2/types.go b/pkg/v2/types.go index 64aaad71..1ddc2d71 100644 --- a/pkg/v2/types.go +++ b/pkg/v2/types.go @@ -3,6 +3,28 @@ package v2 const ( Document = "document" Row = "row" + Page = "page" Col = "col" Image = "image" + Text = "text" ) + +type DocumentType string + +func (t DocumentType) String() string { + return string(t) +} + +func (t DocumentType) Accept(dt string) bool { + _, ok := buildAcceptedMap()[dt] + return ok +} + +func buildAcceptedMap() map[string][]string { + return map[string][]string{ + Document: {Row}, + Page: {Row}, + Row: {Col}, + Col: {Row, Image, Text}, + } +} From 5cc752157c477eb0e6856d79fb136370058f9793 Mon Sep 17 00:00:00 2001 From: John Fercher Date: Mon, 11 Sep 2023 23:31:00 -0300 Subject: [PATCH 03/24] keep --- cmd/main.go | 14 +++++++---- pkg/v2/col/col.go | 20 +++++++-------- pkg/v2/component.go | 4 ++- pkg/v2/context.go | 47 +++++++++++++++++++++++++++++++++++ pkg/v2/document.go | 56 ++++++++++++++++++++++++++++-------------- pkg/v2/image/image.go | 16 ++++++------ pkg/v2/row/row.go | 37 +++++++++++++++++----------- pkg/v2/text/text.go | 16 ++++++------ v2.pdf | Bin 0 -> 1064 bytes 9 files changed, 144 insertions(+), 66 deletions(-) create mode 100644 pkg/v2/context.go create mode 100644 v2.pdf diff --git a/cmd/main.go b/cmd/main.go index bc9f3a5f..92831dc3 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -5,18 +5,22 @@ import ( "github.com/johnfercher/maroto/pkg/v2/col" "github.com/johnfercher/maroto/pkg/v2/image" "github.com/johnfercher/maroto/pkg/v2/row" + "log" ) func main() { - pdf := v2.NewDocument("pdfzin") + pdf := v2.NewDocument() header := buildRow() - content := buildRow() - footer := buildRow() + //content := buildRow() + //footer := buildRow() - pdf.Add(header, content, footer) + pdf.Add(header /*content, footer*/) - pdf.Render() + err := pdf.Generate("v2.pdf") + if err != nil { + log.Fatal(err.Error()) + } } func buildRow() v2.Component { diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index 4f47723f..b7f7aaf6 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -1,7 +1,7 @@ package col import ( - "fmt" + "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" ) @@ -18,21 +18,21 @@ func New(size int) *col { } } -func (d *col) Render() { - fmt.Println(d.size) - for _, component := range d.components { - component.Render() +func (c *col) Render(fpdf fpdf.Fpdf, ctx v2.Context) { + ctx.Print(c.size) + for _, component := range c.components { + component.Render(fpdf, ctx) } } -func (d *col) GetType() string { - return d._type.String() +func (c *col) GetType() string { + return c._type.String() } -func (d *col) Add(components ...v2.Component) { +func (c *col) Add(components ...v2.Component) { for _, component := range components { - if d._type.Accept(component.GetType()) { - d.components = append(d.components, component) + if c._type.Accept(component.GetType()) { + c.components = append(c.components, component) } } } diff --git a/pkg/v2/component.go b/pkg/v2/component.go index 153d8000..d7fb8607 100644 --- a/pkg/v2/component.go +++ b/pkg/v2/component.go @@ -1,7 +1,9 @@ package v2 +import "github.com/johnfercher/maroto/internal/fpdf" + type Component interface { - Render() + Render(fpdf fpdf.Fpdf, ctx Context) GetType() string Add(component ...Component) } diff --git a/pkg/v2/context.go b/pkg/v2/context.go new file mode 100644 index 00000000..dd73b4d3 --- /dev/null +++ b/pkg/v2/context.go @@ -0,0 +1,47 @@ +package v2 + +import "fmt" + +type Context struct { + Coordinate *Coordinate + Dimensions *Dimensions + Margins *Margins +} + +func (c *Context) Print(label interface{}) { + fmt.Println(label) + c.Margins.Print() +} + +type Dimensions struct { + Width float64 + Height float64 +} + +func (c *Dimensions) Print() { + +} + +type Coordinate struct { + X float64 + Y float64 +} + +func (c *Coordinate) Print() { + +} + +type Margins struct { + Left float64 + Right float64 + Top float64 + Bottom float64 +} + +func (c *Margins) Print() { + if c == nil { + return + } + + fmt.Printf("Left: %1.f, Right: %1.f, Top: %1.f, Bottom: %1.f\n", c.Left, c.Right, c.Left, c.Bottom) +} diff --git a/pkg/v2/document.go b/pkg/v2/document.go index a053865c..b2c4e17e 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -1,35 +1,44 @@ package v2 -import "fmt" +import ( + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/jung-kurt/gofpdf" +) + +type Maroto interface { + Add(component ...Component) + Generate(file string) error +} type document struct { - value string + ctx Context _type DocumentType + fpdf fpdf.Fpdf components []Component } -func NewDocument(value string) *document { +func NewDocument() *document { + fpdf := gofpdf.NewCustom(&gofpdf.InitType{ + OrientationStr: "P", + UnitStr: "mm", + SizeStr: "A4", + FontDirStr: "", + }) + + width, height := fpdf.GetPageSize() + left, top, right, bottom := fpdf.GetMargins() + return &document{ + fpdf: fpdf, _type: Document, - value: value, + ctx: Context{ + Coordinate: &Coordinate{0, 0}, + Dimensions: &Dimensions{width, height}, + Margins: &Margins{left, right, top, bottom}, + }, } } -func (d *document) Render() { - fmt.Println(d.value) - for _, component := range d.components { - component.Render() - } -} - -func (d *document) IsDrawable() bool { - return false -} - -func (d *document) GetType() string { - return d._type.String() -} - func (d *document) Add(components ...Component) { for _, component := range components { if d._type.Accept(component.GetType()) { @@ -37,3 +46,12 @@ func (d *document) Add(components ...Component) { } } } + +func (d *document) Generate(file string) error { + d.ctx.Print(d._type) + for _, component := range d.components { + component.Render(d.fpdf, d.ctx) + } + + return d.fpdf.OutputFileAndClose(file) +} diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go index c21e6158..23b8556c 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/image.go @@ -1,7 +1,7 @@ package image import ( - "fmt" + "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" ) @@ -18,17 +18,17 @@ func New(path string) *image { } } -func (d *image) Render() { - fmt.Println(d.path) - for _, component := range d.components { - component.Render() +func (i *image) Render(fpdf fpdf.Fpdf, ctx v2.Context) { + ctx.Print(i.path) + for _, component := range i.components { + component.Render(fpdf, ctx) } } -func (d *image) GetType() string { - return d._type.String() +func (i *image) GetType() string { + return i._type.String() } -func (d *image) Add(_ ...v2.Component) { +func (i *image) Add(_ ...v2.Component) { return } diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 355013fe..22240eb0 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -1,38 +1,45 @@ package row import ( - "fmt" + "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" ) type row struct { - height int + height float64 _type v2.DocumentType components []v2.Component } -func New(height int) *row { +func New(height float64) *row { return &row{ _type: v2.Row, height: height, } } -func (d *row) Render() { - fmt.Println(d.height) - for _, component := range d.components { - component.Render() - } -} - -func (d *row) GetType() string { - return d._type.String() +func (r *row) GetType() string { + return r._type.String() } -func (d *row) Add(components ...v2.Component) { +func (r *row) Add(components ...v2.Component) { for _, component := range components { - if d._type.Accept(component.GetType()) { - d.components = append(d.components, component) + if r._type.Accept(component.GetType()) { + r.components = append(r.components, component) } } } + +func (r *row) Render(fpdf fpdf.Fpdf, ctx v2.Context) { + ctx.Print(r.height) + r.render(fpdf, ctx) + for _, component := range r.components { + component.Render(fpdf, ctx) + } +} + +func (r *row) render(fpdf fpdf.Fpdf, ctx v2.Context) { + fpdf.AddPage() + fpdf.SetFont("Arial", "B", 16) + fpdf.CellFormat(ctx.Dimensions.Width-ctx.Margins.Left-ctx.Margins.Right, r.height, "", "1", 0, "C", false, 0, "") +} diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index 44fd8587..ac513b14 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -1,7 +1,7 @@ package text import ( - "fmt" + "github.com/johnfercher/maroto/internal/fpdf" v2 "github.com/johnfercher/maroto/pkg/v2" ) @@ -18,17 +18,17 @@ func New(value string) *text { } } -func (d *text) Render() { - fmt.Println(d.value) - for _, component := range d.components { - component.Render() +func (t *text) Render(fpdf fpdf.Fpdf, ctx v2.Context) { + ctx.Print(t.value) + for _, component := range t.components { + component.Render(fpdf, ctx) } } -func (d *text) GetType() string { - return d._type.String() +func (t *text) GetType() string { + return t._type.String() } -func (d *text) Add(_ ...v2.Component) { +func (t *text) Add(_ ...v2.Component) { return } diff --git a/v2.pdf b/v2.pdf new file mode 100644 index 0000000000000000000000000000000000000000..41fdd1380271a767069f3728bb78bb2723f0da40 GIT binary patch literal 1064 zcmZ`&O=uHA6yAcpj9yf{=;a{>D$>mUWRqQq1(P&wtZhS5s2X$FWG8V;vRig1k_z=8 zqV(WF(3@vPw7rNTC?X04@lX&14e(3lG;{0x0w{`xJ^}Zc)ggNiILU4zi!Ub`!{|* zH(vdIbobl%%8{?D3#Y!H+jHW;V{)v#{AKO@;`;ul>B|F>)ahJXJTxSV4ReQOi#Gd6 z2nd~U>;OuFq5_l&O?xfD389nBcC3`whLVgn-PEJ10Y*%T8fKYnv7zq_n?>3PO<4gG zJD}sNaglMSY7M8nhD~U(RpH$sh*4mkQ5R`*+&a)%$35u=&IYh8iI_;QcAT2;Rf~*6 ziQ;&H&agHn$u)7JsqmW)zd3BDTSGF5o0@K`Hq&dGl~CfQX|Y&EwGB;4m@KZ^GOo31 zOi|+?Ix2|d^vrZ+j#W9Jzc{A7hUXXOtttzVEf(Vc7HGGsD2t Vsj2r3|hhDNyx? U?o0!2`Mlekp_(KT8J*6OzuuBD!vFvP literal 0 HcmV?d00001 From 8c0b7a1a063c801f4d71423594a8e7f7b19a0e55 Mon Sep 17 00:00:00 2001 From: John Fercher Date: Mon, 11 Sep 2023 23:32:31 -0300 Subject: [PATCH 04/24] keep --- pkg/v2/context.go | 4 ++++ pkg/v2/row/row.go | 2 +- v2.pdf | Bin 1064 -> 1064 bytes 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/pkg/v2/context.go b/pkg/v2/context.go index dd73b4d3..1cb4db5c 100644 --- a/pkg/v2/context.go +++ b/pkg/v2/context.go @@ -8,6 +8,10 @@ type Context struct { Margins *Margins } +func (c *Context) GetUsefulWidth() float64 { + return c.Dimensions.Width - c.Margins.Left - c.Margins.Right +} + func (c *Context) Print(label interface{}) { fmt.Println(label) c.Margins.Print() diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 22240eb0..d8d1c2a2 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -41,5 +41,5 @@ func (r *row) Render(fpdf fpdf.Fpdf, ctx v2.Context) { func (r *row) render(fpdf fpdf.Fpdf, ctx v2.Context) { fpdf.AddPage() fpdf.SetFont("Arial", "B", 16) - fpdf.CellFormat(ctx.Dimensions.Width-ctx.Margins.Left-ctx.Margins.Right, r.height, "", "1", 0, "C", false, 0, "") + fpdf.CellFormat(ctx.GetUsefulWidth(), r.height, "", "1", 0, "C", false, 0, "") } diff --git a/v2.pdf b/v2.pdf index 41fdd1380271a767069f3728bb78bb2723f0da40..e4183034863c9e2542fed59597ce6795a84a0d3f 100644 GIT binary patch delta 44 ycmZ3%v4Ug6MkaY9BU4Q-ec${Pm&B4(1q~M~BLgF214~0gBV%Kr+~x~R5sUyBQVZh% delta 44 ycmZ3%v4Ug6MkaX!V Date: Tue, 12 Sep 2023 09:57:38 -0300 Subject: [PATCH 05/24] fix broken accepted search on types --- cmd/main.go | 1 - go.mod | 2 +- pkg/v2/types.go | 8 ++++++-- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/cmd/main.go b/cmd/main.go index 92831dc3..4888fce2 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -14,7 +14,6 @@ func main() { header := buildRow() //content := buildRow() //footer := buildRow() - pdf.Add(header /*content, footer*/) err := pdf.Generate("v2.pdf") diff --git a/go.mod b/go.mod index cd133d47..20012a97 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/johnfercher/maroto -go 1.13 +go 1.18 require ( github.com/boombuler/barcode v1.0.1 diff --git a/pkg/v2/types.go b/pkg/v2/types.go index 1ddc2d71..f793ae57 100644 --- a/pkg/v2/types.go +++ b/pkg/v2/types.go @@ -1,5 +1,7 @@ package v2 +import "slices" + const ( Document = "document" Row = "row" @@ -16,8 +18,10 @@ func (t DocumentType) String() string { } func (t DocumentType) Accept(dt string) bool { - _, ok := buildAcceptedMap()[dt] - return ok + if val, ok := buildAcceptedMap()[t.String()]; ok { + return slices.Contains(val, dt) + } + return false } func buildAcceptedMap() map[string][]string { From 89c41a47ec182a3c0e8ec5117065f44fa1efb9bd Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 12:36:18 -0300 Subject: [PATCH 06/24] start grid height and width calculation --- cmd/main.go | 20 +++++++++-- go.mod | 7 +++- pkg/v2/col/col.go | 2 +- pkg/v2/component.go | 2 +- pkg/v2/context.go | 81 +++++++++++++++++++++++++++++++----------- pkg/v2/document.go | 14 ++++---- pkg/v2/image/image.go | 2 +- pkg/v2/row/row.go | 9 ++--- pkg/v2/text/text.go | 2 +- v2.pdf | Bin 1064 -> 1072 bytes 10 files changed, 102 insertions(+), 37 deletions(-) diff --git a/cmd/main.go b/cmd/main.go index 4888fce2..8a031341 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -5,6 +5,7 @@ import ( "github.com/johnfercher/maroto/pkg/v2/col" "github.com/johnfercher/maroto/pkg/v2/image" "github.com/johnfercher/maroto/pkg/v2/row" + "github.com/johnfercher/maroto/pkg/v2/text" "log" ) @@ -12,9 +13,9 @@ func main() { pdf := v2.NewDocument() header := buildRow() - //content := buildRow() + content := buildContent() //footer := buildRow() - pdf.Add(header /*content, footer*/) + pdf.Add(header, content /* footer*/) err := pdf.Generate("v2.pdf") if err != nil { @@ -36,3 +37,18 @@ func buildRow() v2.Component { row.Add(col1, col2, col3) return row } + +func buildContent() v2.Component { + row := row.New(20) + + tx := text.New("Hello World") + + col1 := col.New(4) + col1.Add(tx) + + col2 := col.New(4) + col3 := col.New(4) + + row.Add(col1, col2, col3) + return row +} diff --git a/go.mod b/go.mod index 20012a97..f5a0de01 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,12 @@ require ( github.com/google/uuid v1.3.0 github.com/jung-kurt/gofpdf v1.16.2 github.com/pkg/errors v0.9.1 + github.com/stretchr/testify v1.3.0 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245 // indirect github.com/stretchr/objx v0.2.0 // indirect - github.com/stretchr/testify v1.3.0 ) diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index b7f7aaf6..811700f8 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -18,7 +18,7 @@ func New(size int) *col { } } -func (c *col) Render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (c *col) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { ctx.Print(c.size) for _, component := range c.components { component.Render(fpdf, ctx) diff --git a/pkg/v2/component.go b/pkg/v2/component.go index d7fb8607..7b2978cc 100644 --- a/pkg/v2/component.go +++ b/pkg/v2/component.go @@ -3,7 +3,7 @@ package v2 import "github.com/johnfercher/maroto/internal/fpdf" type Component interface { - Render(fpdf fpdf.Fpdf, ctx Context) + Render(fpdf fpdf.Fpdf, ctx *Context) GetType() string Add(component ...Component) } diff --git a/pkg/v2/context.go b/pkg/v2/context.go index 1cb4db5c..bfc4c3e2 100644 --- a/pkg/v2/context.go +++ b/pkg/v2/context.go @@ -2,19 +2,14 @@ package v2 import "fmt" -type Context struct { - Coordinate *Coordinate - Dimensions *Dimensions - Margins *Margins -} +const LineHeight = 20 -func (c *Context) GetUsefulWidth() float64 { - return c.Dimensions.Width - c.Margins.Left - c.Margins.Right -} - -func (c *Context) Print(label interface{}) { - fmt.Println(label) - c.Margins.Print() +// region Types +type Context struct { + Coordinate *Coordinate + Dimensions *Dimensions + Margins *Margins + pageDimensions *Dimensions } type Dimensions struct { @@ -22,19 +17,11 @@ type Dimensions struct { Height float64 } -func (c *Dimensions) Print() { - -} - type Coordinate struct { X float64 Y float64 } -func (c *Coordinate) Print() { - -} - type Margins struct { Left float64 Right float64 @@ -42,6 +29,60 @@ type Margins struct { Bottom float64 } +// endregion + +func NewRootContext(pageWidth, pageHeight float64, margins *Margins) Context { + return Context{ + Coordinate: &Coordinate{0, 0}, + Dimensions: &Dimensions{0, 0}, + pageDimensions: &Dimensions{pageWidth, pageHeight}, + Margins: margins, + } +} + +func (c *Context) MaxHeight() float64 { + return c.pageDimensions.Height - c.Margins.Top - c.Margins.Bottom +} + +func (c *Context) MaxWidth() float64 { + return c.pageDimensions.Width - c.Margins.Left - c.Margins.Right +} + +func (c *Context) WithDimension(width, height float64) *Context { + c.Dimensions.Width = width + c.Dimensions.Height = height + return c +} + +func (c *Context) WithCoordinateOffset(x, y float64) *Context { + c.Coordinate.X = x + c.Coordinate.Y = y + return c +} + +func (c *Context) GetX() float64 { + baseX := c.Coordinate.X + c.Dimensions.Width + if baseX > c.MaxWidth() { + c.Coordinate.Y = c.Coordinate.Y + LineHeight + return 0 + } + return baseX +} + +func (c *Context) GetY() float64 { + baseY := c.Coordinate.Y + c.Dimensions.Height + if baseY > c.MaxHeight() { + // Verificar como indicar quebra de pagina + return 0 + } + return baseY +} + +func (c *Context) Print(label interface{}) { + fmt.Println(label) + c.Margins.Print() +} + func (c *Margins) Print() { if c == nil { return diff --git a/pkg/v2/document.go b/pkg/v2/document.go index b2c4e17e..df199303 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -27,15 +27,17 @@ func NewDocument() *document { width, height := fpdf.GetPageSize() left, top, right, bottom := fpdf.GetMargins() + fpdf.AddPage() return &document{ fpdf: fpdf, _type: Document, - ctx: Context{ - Coordinate: &Coordinate{0, 0}, - Dimensions: &Dimensions{width, height}, - Margins: &Margins{left, right, top, bottom}, - }, + ctx: NewRootContext(width, height, &Margins{ + Left: left, + Top: top, + Right: right, + Bottom: bottom, + }), } } @@ -50,7 +52,7 @@ func (d *document) Add(components ...Component) { func (d *document) Generate(file string) error { d.ctx.Print(d._type) for _, component := range d.components { - component.Render(d.fpdf, d.ctx) + component.Render(d.fpdf, &d.ctx) } return d.fpdf.OutputFileAndClose(file) diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go index 23b8556c..216b18ed 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/image.go @@ -18,7 +18,7 @@ func New(path string) *image { } } -func (i *image) Render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (i *image) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { ctx.Print(i.path) for _, component := range i.components { component.Render(fpdf, ctx) diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index d8d1c2a2..9f909d9c 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -30,16 +30,17 @@ func (r *row) Add(components ...v2.Component) { } } -func (r *row) Render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (r *row) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { ctx.Print(r.height) + ctx = ctx.WithDimension(ctx.MaxWidth(), r.height) r.render(fpdf, ctx) for _, component := range r.components { component.Render(fpdf, ctx) } } -func (r *row) render(fpdf fpdf.Fpdf, ctx v2.Context) { - fpdf.AddPage() +func (r *row) render(fpdf fpdf.Fpdf, ctx *v2.Context) { fpdf.SetFont("Arial", "B", 16) - fpdf.CellFormat(ctx.GetUsefulWidth(), r.height, "", "1", 0, "C", false, 0, "") + x, y := ctx.GetX(), ctx.GetY() + fpdf.CellFormat(x, y, "", "1", 0, "C", false, 0, "") } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index ac513b14..bac4e8ae 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -18,7 +18,7 @@ func New(value string) *text { } } -func (t *text) Render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (t *text) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { ctx.Print(t.value) for _, component := range t.components { component.Render(fpdf, ctx) diff --git a/v2.pdf b/v2.pdf index e4183034863c9e2542fed59597ce6795a84a0d3f..493df86595cb763461d67b7ab7e4a8b6bc74d26d 100644 GIT binary patch delta 268 zcmZ3%v4LYkeZ7&PogG(kNl|KIE>{KPk~4~YO@=&d0sDh%#21vjzO{B5i^qmHO!jM( z9g}w0vGqFIewUbjq(V(Cw?bVl?by%P%Cc1X>~_fEa3YR<1c**52H zwq9G#k)DkOGAm1jT+cg2ExhDuU6z&77yh8jKFd^jdi-~F1_rkO|648_+}!wQBcrmB zp^>qPvAHIfzHfetOJYf?f`*Hgk%5u1fu$i-Zt?}D$)Xkt1|Xo2r@#ef7#NtCnN6-> hw$d^)#gH;HGRF`zH!+xehuN9a*qlpM)z#mP3jk-rT5bRU delta 262 zcmdnMv4UeleZ8TvogG(kNl|KIE>{I3%Yof%n+$naAKVL`!@BPM$-{n^lo*9{BOkO| zcuX-_bKd<{zAOyC@!8(XCwCv1=cnkEwkiyu-PUk%8g=|F&9b4X)J9Y>ev}l?{!Ijg5>< zHM#VC^HW?BOHvgyT&#=?jEoH|4WV+AZ!k?3HBc}B0fjsTE-=Huz{J#Ias#uKmZ>?0 bl$oI=hM2jr(c~x0&YVV;T&k+B{%%|VdAM0V From 8bdbdde8f09291e1d7d0279510fb26d92beedb3c Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 12:41:32 -0300 Subject: [PATCH 07/24] remove pointer context, add line offset on row --- pkg/v2/col/col.go | 2 +- pkg/v2/component.go | 2 +- pkg/v2/context.go | 18 ++++++++++-------- pkg/v2/document.go | 2 +- pkg/v2/image/image.go | 2 +- pkg/v2/row/row.go | 5 +++-- pkg/v2/text/text.go | 2 +- v2.pdf | Bin 1072 -> 1074 bytes 8 files changed, 18 insertions(+), 15 deletions(-) diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index 811700f8..b7f7aaf6 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -18,7 +18,7 @@ func New(size int) *col { } } -func (c *col) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { +func (c *col) Render(fpdf fpdf.Fpdf, ctx v2.Context) { ctx.Print(c.size) for _, component := range c.components { component.Render(fpdf, ctx) diff --git a/pkg/v2/component.go b/pkg/v2/component.go index 7b2978cc..d7fb8607 100644 --- a/pkg/v2/component.go +++ b/pkg/v2/component.go @@ -3,7 +3,7 @@ package v2 import "github.com/johnfercher/maroto/internal/fpdf" type Component interface { - Render(fpdf fpdf.Fpdf, ctx *Context) + Render(fpdf fpdf.Fpdf, ctx Context) GetType() string Add(component ...Component) } diff --git a/pkg/v2/context.go b/pkg/v2/context.go index bfc4c3e2..95e8d0fa 100644 --- a/pkg/v2/context.go +++ b/pkg/v2/context.go @@ -48,16 +48,18 @@ func (c *Context) MaxWidth() float64 { return c.pageDimensions.Width - c.Margins.Left - c.Margins.Right } -func (c *Context) WithDimension(width, height float64) *Context { - c.Dimensions.Width = width - c.Dimensions.Height = height - return c +func (c *Context) WithDimension(width, height float64) Context { + ctx := *c + ctx.Dimensions.Width = width + ctx.Dimensions.Height = height + return ctx } -func (c *Context) WithCoordinateOffset(x, y float64) *Context { - c.Coordinate.X = x - c.Coordinate.Y = y - return c +func (c *Context) WithCoordinateOffset(x, y float64) Context { + ctx := *c + ctx.Coordinate.X = x + ctx.Coordinate.Y = y + return ctx } func (c *Context) GetX() float64 { diff --git a/pkg/v2/document.go b/pkg/v2/document.go index df199303..e354bbf6 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -52,7 +52,7 @@ func (d *document) Add(components ...Component) { func (d *document) Generate(file string) error { d.ctx.Print(d._type) for _, component := range d.components { - component.Render(d.fpdf, &d.ctx) + component.Render(d.fpdf, d.ctx) } return d.fpdf.OutputFileAndClose(file) diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go index 216b18ed..23b8556c 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/image.go @@ -18,7 +18,7 @@ func New(path string) *image { } } -func (i *image) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { +func (i *image) Render(fpdf fpdf.Fpdf, ctx v2.Context) { ctx.Print(i.path) for _, component := range i.components { component.Render(fpdf, ctx) diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 9f909d9c..2b0055a5 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -30,7 +30,7 @@ func (r *row) Add(components ...v2.Component) { } } -func (r *row) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { +func (r *row) Render(fpdf fpdf.Fpdf, ctx v2.Context) { ctx.Print(r.height) ctx = ctx.WithDimension(ctx.MaxWidth(), r.height) r.render(fpdf, ctx) @@ -39,8 +39,9 @@ func (r *row) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { } } -func (r *row) render(fpdf fpdf.Fpdf, ctx *v2.Context) { +func (r *row) render(fpdf fpdf.Fpdf, ctx v2.Context) { fpdf.SetFont("Arial", "B", 16) x, y := ctx.GetX(), ctx.GetY() fpdf.CellFormat(x, y, "", "1", 0, "C", false, 0, "") + fpdf.Ln(ctx.Dimensions.Height) } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index bac4e8ae..ac513b14 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -18,7 +18,7 @@ func New(value string) *text { } } -func (t *text) Render(fpdf fpdf.Fpdf, ctx *v2.Context) { +func (t *text) Render(fpdf fpdf.Fpdf, ctx v2.Context) { ctx.Print(t.value) for _, component := range t.components { component.Render(fpdf, ctx) diff --git a/v2.pdf b/v2.pdf index 493df86595cb763461d67b7ab7e4a8b6bc74d26d..14572f5970e54a716ade8869cbd3e0eebc1f1828 100644 GIT binary patch delta 247 zcmdnMv58|sL%p$`9anKlQEFl?R|VseGrD|Dh5{@B_k+){Mr^a+d^bu+;ov3inhVod zIv@U$P~rP}Cpf0*kz`23M?S4pU7xSJTa>)a!7TT# zw@+KfqON@fZxnZ?97+}wGuVA$|SS5*ku38pMim$;s5{O?*=P2voLO9 zWHB)`u$a7uNdm&S!8A$C!a%_Q1QhZVxWEhp0~0fg$qmfbn&ucXW=576V&*1BlbvTWa$FWr3Rf@<{XXZu|DPQ9sW&aXY$Hs@}( zUR%zQo{a@ED@%l2&pSmeyyR(JmX*>M{-Db~%T#%K{C9N*hX1VpTP_>i+|0(fg^|VB z#MpfDJ|+nW;}+8-F>?zA0}xQiQ{VzK3=B-n%qBN6TWgwP$e0 Date: Tue, 12 Sep 2023 13:38:33 -0300 Subject: [PATCH 08/24] start adding col children --- pkg/v2/col/col.go | 13 +++++++++++++ pkg/v2/context.go | 2 +- pkg/v2/document.go | 3 ++- pkg/v2/row/row.go | 5 +++-- v2.pdf | Bin 1074 -> 1123 bytes 5 files changed, 19 insertions(+), 4 deletions(-) diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index b7f7aaf6..e30a3298 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -20,9 +20,11 @@ func New(size int) *col { func (c *col) Render(fpdf fpdf.Fpdf, ctx v2.Context) { ctx.Print(c.size) + ctx = c.setRelativeDimension(ctx) for _, component := range c.components { component.Render(fpdf, ctx) } + c.render(fpdf, ctx) } func (c *col) GetType() string { @@ -36,3 +38,14 @@ func (c *col) Add(components ...v2.Component) { } } } + +func (c *col) render(fpdf fpdf.Fpdf, ctx v2.Context) { + fpdf.SetDrawColor(255, 0, 0) + fpdf.CellFormat(ctx.GetX(), ctx.GetY(), "", "1", 0, "C", false, 0, "") +} + +func (c *col) setRelativeDimension(ctx v2.Context) v2.Context { + parentWidth := ctx.Dimensions.Width + colDimension := parentWidth / float64(c.size) + return ctx.WithDimension(colDimension, ctx.Dimensions.Height) +} diff --git a/pkg/v2/context.go b/pkg/v2/context.go index 95e8d0fa..b58d9b79 100644 --- a/pkg/v2/context.go +++ b/pkg/v2/context.go @@ -74,7 +74,7 @@ func (c *Context) GetX() float64 { func (c *Context) GetY() float64 { baseY := c.Coordinate.Y + c.Dimensions.Height if baseY > c.MaxHeight() { - // Verificar como indicar quebra de pagina + //Verificar como indicar quebra de pagina return 0 } return baseY diff --git a/pkg/v2/document.go b/pkg/v2/document.go index e354bbf6..48e27981 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -52,7 +52,8 @@ func (d *document) Add(components ...Component) { func (d *document) Generate(file string) error { d.ctx.Print(d._type) for _, component := range d.components { - component.Render(d.fpdf, d.ctx) + ctx := d.ctx.WithDimension(d.ctx.MaxWidth(), d.ctx.MaxHeight()) + component.Render(d.fpdf, ctx) } return d.fpdf.OutputFileAndClose(file) diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 2b0055a5..b3e70c12 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -32,15 +32,16 @@ func (r *row) Add(components ...v2.Component) { func (r *row) Render(fpdf fpdf.Fpdf, ctx v2.Context) { ctx.Print(r.height) - ctx = ctx.WithDimension(ctx.MaxWidth(), r.height) - r.render(fpdf, ctx) + ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) for _, component := range r.components { component.Render(fpdf, ctx) } + r.render(fpdf, ctx) } func (r *row) render(fpdf fpdf.Fpdf, ctx v2.Context) { fpdf.SetFont("Arial", "B", 16) + fpdf.SetDrawColor(0, 0, 0) x, y := ctx.GetX(), ctx.GetY() fpdf.CellFormat(x, y, "", "1", 0, "C", false, 0, "") fpdf.Ln(ctx.Dimensions.Height) diff --git a/v2.pdf b/v2.pdf index 14572f5970e54a716ade8869cbd3e0eebc1f1828..9a0f3b47217f95893674772145e7fbf447d1ffba 100644 GIT binary patch delta 301 zcmdnQ@t9*meZ9GnogG(kNl|KIE>{KPl5>V$u7(1w5A9Z4NEg^lKItwkKuJ?~NO8m5{3hy86-AK3=(d1M^u@u;x={-wKZx7(j8_rE;t7rOZSWgY!W zlgqc#pB%JH-Ya&Nkymk}?wx#1b3^xFVf}*aN4(~8LbCG0=Wkd#ex2|vKwGF!dqJX8 zT+2+CKMc0}{(tLKQ;om>U(jFt+UZUIWBt42uFpT}_*e4Jy8m1Z4FCVn+!uaeGaKU; zMix^eBcsXtm?R*KTTBzhjg2f73_w63Pk{@}FfcGRG@snWY^iNxXoewYW^REYW^QRX S`5Ch_r-cQVs;aBM8y5i9n{jCX delta 252 zcmaFNv58|seZ7&fogG(kNl|KIE>{KPk~6w|O@;z20r!K?utsdN-+VVpNa5fm?wSkJ zSUMm6l2GCMdM7xh>5*he#791@Rb8L2yIYjJ@$XjdJvnu|)Y`4N)1sy3CFfqgbipk5 zuD4HH#-gr$1#c90rW{HZ6EoO-VdLUX(>-eIe(YXnQrKkw%AbLQf#LuE;O_=2Hk&hU zVPr8eG_aWbo=F12;AWmEZe(GgU;qLNc?w)$hJk^JnZ@MI%$C~5X66`jW=576V&*1B Slf_w_IgKs3R8?L5-M9eifLP`L From 2b550c403a492a9f5318dacc9f620bdbb50ecc49 Mon Sep 17 00:00:00 2001 From: John Fercher Date: Tue, 12 Sep 2023 14:11:02 -0300 Subject: [PATCH 09/24] Move context --- cmd/main.go | 9 ++-- pkg/v2/col/col.go | 24 +++++---- pkg/v2/component.go | 7 ++- pkg/v2/{ => context}/context.go | 31 ++--------- pkg/v2/context/context_test.go | 93 ++++++++++++++++++++++++++++++++ pkg/v2/context/coordinate.go | 16 ++++++ pkg/v2/context/dimensions.go | 16 ++++++ pkg/v2/context/margins.go | 18 +++++++ pkg/v2/document.go | 12 +++-- pkg/v2/image/image.go | 4 +- pkg/v2/row/row.go | 14 ++--- pkg/v2/text/text.go | 4 +- v2.pdf | Bin 1123 -> 1117 bytes 13 files changed, 192 insertions(+), 56 deletions(-) rename pkg/v2/{ => context}/context.go (79%) create mode 100644 pkg/v2/context/context_test.go create mode 100644 pkg/v2/context/coordinate.go create mode 100644 pkg/v2/context/dimensions.go create mode 100644 pkg/v2/context/margins.go diff --git a/cmd/main.go b/cmd/main.go index 8a031341..46078823 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -3,7 +3,6 @@ package main import ( "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/col" - "github.com/johnfercher/maroto/pkg/v2/image" "github.com/johnfercher/maroto/pkg/v2/row" "github.com/johnfercher/maroto/pkg/v2/text" "log" @@ -13,9 +12,9 @@ func main() { pdf := v2.NewDocument() header := buildRow() - content := buildContent() + //content := buildContent() //footer := buildRow() - pdf.Add(header, content /* footer*/) + pdf.Add(header /*content footer*/) err := pdf.Generate("v2.pdf") if err != nil { @@ -26,10 +25,10 @@ func main() { func buildRow() v2.Component { row := row.New(20) - image := image.New("image1") + //image := image.New("image1") col1 := col.New(4) - col1.Add(image) + //col1.Add(image) col2 := col.New(4) col3 := col.New(4) diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index e30a3298..b01e3c56 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -3,6 +3,7 @@ package col import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" ) type col struct { @@ -18,15 +19,6 @@ func New(size int) *col { } } -func (c *col) Render(fpdf fpdf.Fpdf, ctx v2.Context) { - ctx.Print(c.size) - ctx = c.setRelativeDimension(ctx) - for _, component := range c.components { - component.Render(fpdf, ctx) - } - c.render(fpdf, ctx) -} - func (c *col) GetType() string { return c._type.String() } @@ -39,12 +31,22 @@ func (c *col) Add(components ...v2.Component) { } } -func (c *col) render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (c *col) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { + ctx.Print(c.size) + ctx = c.setRelativeDimension(ctx) + for _, component := range c.components { + component.Render(fpdf, ctx) + } + c.render(fpdf, ctx) + return ctx.WithCoordinateOffset(ctx.GetX(), ctx.GetY()) +} + +func (c *col) render(fpdf fpdf.Fpdf, ctx context.Context) { fpdf.SetDrawColor(255, 0, 0) fpdf.CellFormat(ctx.GetX(), ctx.GetY(), "", "1", 0, "C", false, 0, "") } -func (c *col) setRelativeDimension(ctx v2.Context) v2.Context { +func (c *col) setRelativeDimension(ctx context.Context) context.Context { parentWidth := ctx.Dimensions.Width colDimension := parentWidth / float64(c.size) return ctx.WithDimension(colDimension, ctx.Dimensions.Height) diff --git a/pkg/v2/component.go b/pkg/v2/component.go index d7fb8607..6cf30717 100644 --- a/pkg/v2/component.go +++ b/pkg/v2/component.go @@ -1,9 +1,12 @@ package v2 -import "github.com/johnfercher/maroto/internal/fpdf" +import ( + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/v2/context" +) type Component interface { - Render(fpdf fpdf.Fpdf, ctx Context) + Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context GetType() string Add(component ...Component) } diff --git a/pkg/v2/context.go b/pkg/v2/context/context.go similarity index 79% rename from pkg/v2/context.go rename to pkg/v2/context/context.go index b58d9b79..18f4124b 100644 --- a/pkg/v2/context.go +++ b/pkg/v2/context/context.go @@ -1,4 +1,4 @@ -package v2 +package context import "fmt" @@ -12,23 +12,6 @@ type Context struct { pageDimensions *Dimensions } -type Dimensions struct { - Width float64 - Height float64 -} - -type Coordinate struct { - X float64 - Y float64 -} - -type Margins struct { - Left float64 - Right float64 - Top float64 - Bottom float64 -} - // endregion func NewRootContext(pageWidth, pageHeight float64, margins *Margins) Context { @@ -82,13 +65,9 @@ func (c *Context) GetY() float64 { func (c *Context) Print(label interface{}) { fmt.Println(label) - c.Margins.Print() -} -func (c *Margins) Print() { - if c == nil { - return - } - - fmt.Printf("Left: %1.f, Right: %1.f, Top: %1.f, Bottom: %1.f\n", c.Left, c.Right, c.Left, c.Bottom) + c.Coordinate.Print() + c.Dimensions.Print() + c.pageDimensions.Print() + c.Margins.Print() } diff --git a/pkg/v2/context/context_test.go b/pkg/v2/context/context_test.go new file mode 100644 index 00000000..0b7cfd9f --- /dev/null +++ b/pkg/v2/context/context_test.go @@ -0,0 +1,93 @@ +package context + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +const ( + SideSize = 1100.0 + MarginSize = 50.0 +) + +func TestNewRootContext(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + // Act + ctx := NewRootContext(width, height, margins) + + // Assert + assert.NotNil(t, ctx) +} + +func TestContext_MaxHeight(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + + // Act + maxHeight := ctx.MaxHeight() + + // Assert + assert.Equal(t, 1000.0, maxHeight) +} + +func TestContext_MaxWidth(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + + // Act + maxWidth := ctx.MaxWidth() + + // Assert + assert.Equal(t, 1000.0, maxWidth) +} + +func TestContext_GetX(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + + // Act + x := ctx.GetX() + + // Assert + assert.Equal(t, 0.0, x) +} diff --git a/pkg/v2/context/coordinate.go b/pkg/v2/context/coordinate.go new file mode 100644 index 00000000..f9b15a20 --- /dev/null +++ b/pkg/v2/context/coordinate.go @@ -0,0 +1,16 @@ +package context + +import "fmt" + +type Coordinate struct { + X float64 + Y float64 +} + +func (c *Coordinate) Print() { + if c == nil { + return + } + + fmt.Printf("(%1.f, %1.f)\n", c.X, c.Y) +} diff --git a/pkg/v2/context/dimensions.go b/pkg/v2/context/dimensions.go new file mode 100644 index 00000000..d6da7d6a --- /dev/null +++ b/pkg/v2/context/dimensions.go @@ -0,0 +1,16 @@ +package context + +import "fmt" + +type Dimensions struct { + Width float64 + Height float64 +} + +func (d *Dimensions) Print() { + if d == nil { + return + } + + fmt.Printf("Width: %1.f, Height: %1.f\n", d.Width, d.Height) +} diff --git a/pkg/v2/context/margins.go b/pkg/v2/context/margins.go new file mode 100644 index 00000000..b3255e21 --- /dev/null +++ b/pkg/v2/context/margins.go @@ -0,0 +1,18 @@ +package context + +import "fmt" + +type Margins struct { + Left float64 + Right float64 + Top float64 + Bottom float64 +} + +func (m *Margins) Print() { + if m == nil { + return + } + + fmt.Printf("Left: %1.f, Right: %1.f, Top: %1.f, Bottom: %1.f\n", m.Left, m.Right, m.Left, m.Bottom) +} diff --git a/pkg/v2/document.go b/pkg/v2/document.go index 48e27981..edff5e93 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -2,6 +2,7 @@ package v2 import ( "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/v2/context" "github.com/jung-kurt/gofpdf" ) @@ -11,7 +12,7 @@ type Maroto interface { } type document struct { - ctx Context + ctx context.Context _type DocumentType fpdf fpdf.Fpdf components []Component @@ -25,6 +26,8 @@ func NewDocument() *document { FontDirStr: "", }) + fpdf.SetFont("Arial", "B", 16) + width, height := fpdf.GetPageSize() left, top, right, bottom := fpdf.GetMargins() fpdf.AddPage() @@ -32,7 +35,7 @@ func NewDocument() *document { return &document{ fpdf: fpdf, _type: Document, - ctx: NewRootContext(width, height, &Margins{ + ctx: context.NewRootContext(width, height, &context.Margins{ Left: left, Top: top, Right: right, @@ -51,9 +54,10 @@ func (d *document) Add(components ...Component) { func (d *document) Generate(file string) error { d.ctx.Print(d._type) + ctx := d.ctx.WithDimension(d.ctx.MaxWidth(), d.ctx.MaxHeight()) + for _, component := range d.components { - ctx := d.ctx.WithDimension(d.ctx.MaxWidth(), d.ctx.MaxHeight()) - component.Render(d.fpdf, ctx) + ctx = component.Render(d.fpdf, ctx) } return d.fpdf.OutputFileAndClose(file) diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go index 23b8556c..034d6c9e 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/image.go @@ -3,6 +3,7 @@ package image import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" ) type image struct { @@ -18,11 +19,12 @@ func New(path string) *image { } } -func (i *image) Render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (i *image) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { ctx.Print(i.path) for _, component := range i.components { component.Render(fpdf, ctx) } + return ctx } func (i *image) GetType() string { diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index b3e70c12..c7b122cc 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -3,6 +3,7 @@ package row import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" ) type row struct { @@ -30,19 +31,20 @@ func (r *row) Add(components ...v2.Component) { } } -func (r *row) Render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { ctx.Print(r.height) - ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) + for _, component := range r.components { + ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) component.Render(fpdf, ctx) } + r.render(fpdf, ctx) + return ctx } -func (r *row) render(fpdf fpdf.Fpdf, ctx v2.Context) { - fpdf.SetFont("Arial", "B", 16) +func (r *row) render(fpdf fpdf.Fpdf, ctx context.Context) { fpdf.SetDrawColor(0, 0, 0) - x, y := ctx.GetX(), ctx.GetY() - fpdf.CellFormat(x, y, "", "1", 0, "C", false, 0, "") + //x, y := ctx.GetX(), ctx.GetY() fpdf.Ln(ctx.Dimensions.Height) } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index ac513b14..a2102ff1 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -3,6 +3,7 @@ package text import ( "github.com/johnfercher/maroto/internal/fpdf" v2 "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" ) type text struct { @@ -18,11 +19,12 @@ func New(value string) *text { } } -func (t *text) Render(fpdf fpdf.Fpdf, ctx v2.Context) { +func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { ctx.Print(t.value) for _, component := range t.components { component.Render(fpdf, ctx) } + return ctx } func (t *text) GetType() string { diff --git a/v2.pdf b/v2.pdf index 9a0f3b47217f95893674772145e7fbf447d1ffba..11f552632b8aca775cd87c9dfd2045290f156944 100644 GIT binary patch delta 292 zcmaFNahGF4eZ85PogG(kNl|KIE>{KPk~4;WEQUO-5AQ9n5SREYqwaS}>7d7yH!%r{ zoI+2{V&pp~E^st4ssH}>$Yg={PP(GhOi?g_J7;&kp Jy863u0RU05aRC4T delta 316 zcmcc1@t9*meZ9GnogG(kNl|KIE>{KPl5>V$u7(1w5A9Z4NEg^lKItwkKuJ?~NO8m5{3hy86-AK3=(d1M^u@u;x={-wKZx7(j8_rE;t7rOZSWgY!W zlgqc#pB%JH-Ya&Nkymk}?wx#1b3^xFVf}*aN4(~8LbCG0=Wkd#ex2|vKwGF!dqJX8 zT+2+CKMc0}{(tLKQ;om>U(jFt+UZUIWBt42uFpT}_*e4Jy8m1Z4FCVn+!uaevmxVV zMnxl2BO@bCE`8tp6qm%3R0RzeDKG iPhQJxt!aiKV`grFA!crAI9ZUzg~NhNRn^tsjSB#}o^#s( From 537c622e9cbbb43f7d2fb0c9dba27eec343138d6 Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 15:24:46 -0300 Subject: [PATCH 10/24] add context tests, fix side effect copy --- pkg/v2/col/col.go | 4 +- pkg/v2/context/context.go | 38 ++-- pkg/v2/context/context_test.go | 377 +++++++++++++++++++++++++++------ pkg/v2/row/row.go | 2 +- v2.pdf | Bin 1117 -> 1117 bytes 5 files changed, 346 insertions(+), 75 deletions(-) diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index b01e3c56..be872c71 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -38,12 +38,12 @@ func (c *col) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { component.Render(fpdf, ctx) } c.render(fpdf, ctx) - return ctx.WithCoordinateOffset(ctx.GetX(), ctx.GetY()) + return ctx.WithCoordinates(ctx.GetXOffset(), ctx.GetYOffset()) } func (c *col) render(fpdf fpdf.Fpdf, ctx context.Context) { fpdf.SetDrawColor(255, 0, 0) - fpdf.CellFormat(ctx.GetX(), ctx.GetY(), "", "1", 0, "C", false, 0, "") + fpdf.CellFormat(ctx.GetXOffset(), ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") } func (c *col) setRelativeDimension(ctx context.Context) context.Context { diff --git a/pkg/v2/context/context.go b/pkg/v2/context/context.go index 18f4124b..2113c117 100644 --- a/pkg/v2/context/context.go +++ b/pkg/v2/context/context.go @@ -1,6 +1,8 @@ package context -import "fmt" +import ( + "fmt" +) const LineHeight = 20 @@ -9,6 +11,7 @@ type Context struct { Coordinate *Coordinate Dimensions *Dimensions Margins *Margins + CurrentPage int pageDimensions *Dimensions } @@ -20,50 +23,51 @@ func NewRootContext(pageWidth, pageHeight float64, margins *Margins) Context { Dimensions: &Dimensions{0, 0}, pageDimensions: &Dimensions{pageWidth, pageHeight}, Margins: margins, + CurrentPage: 1, } } -func (c *Context) MaxHeight() float64 { +func (c Context) MaxHeight() float64 { return c.pageDimensions.Height - c.Margins.Top - c.Margins.Bottom } -func (c *Context) MaxWidth() float64 { +func (c Context) MaxWidth() float64 { return c.pageDimensions.Width - c.Margins.Left - c.Margins.Right } -func (c *Context) WithDimension(width, height float64) Context { - ctx := *c +func (c Context) WithDimension(width, height float64) Context { + ctx := c.copy() ctx.Dimensions.Width = width ctx.Dimensions.Height = height return ctx } -func (c *Context) WithCoordinateOffset(x, y float64) Context { - ctx := *c +func (c Context) WithCoordinates(x, y float64) Context { + ctx := c.copy() ctx.Coordinate.X = x ctx.Coordinate.Y = y return ctx } -func (c *Context) GetX() float64 { +func (c Context) GetXOffset() float64 { baseX := c.Coordinate.X + c.Dimensions.Width if baseX > c.MaxWidth() { c.Coordinate.Y = c.Coordinate.Y + LineHeight - return 0 + return c.Coordinate.X } return baseX } -func (c *Context) GetY() float64 { +func (c Context) GetYOffset() float64 { baseY := c.Coordinate.Y + c.Dimensions.Height if baseY > c.MaxHeight() { - //Verificar como indicar quebra de pagina + c.CurrentPage = c.CurrentPage + 1 return 0 } return baseY } -func (c *Context) Print(label interface{}) { +func (c Context) Print(label interface{}) { fmt.Println(label) c.Coordinate.Print() @@ -71,3 +75,13 @@ func (c *Context) Print(label interface{}) { c.pageDimensions.Print() c.Margins.Print() } + +func (c Context) copy() Context { + return Context{ + Coordinate: &Coordinate{c.Coordinate.X, c.Coordinate.Y}, + Dimensions: &Dimensions{c.Dimensions.Width, c.Dimensions.Height}, + Margins: c.Margins, + CurrentPage: c.CurrentPage, + pageDimensions: c.pageDimensions, + } +} diff --git a/pkg/v2/context/context_test.go b/pkg/v2/context/context_test.go index 0b7cfd9f..30d7fa85 100644 --- a/pkg/v2/context/context_test.go +++ b/pkg/v2/context/context_test.go @@ -11,83 +11,340 @@ const ( ) func TestNewRootContext(t *testing.T) { - // Arrange - width := SideSize - height := SideSize - - margins := &Margins{ - Left: MarginSize, - Right: MarginSize, - Top: MarginSize, - Bottom: MarginSize, - } - - // Act - ctx := NewRootContext(width, height, margins) - - // Assert - assert.NotNil(t, ctx) + t.Run("Should create a new root context without dimensions, and with correctly set page dimensions", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + // Act + ctx := NewRootContext(width, height, margins) + + // Assert + assert.NotNil(t, ctx) + assert.Equal(t, width, ctx.pageDimensions.Width) + assert.Equal(t, height, ctx.pageDimensions.Height) + assert.Zerof(t, ctx.Dimensions.Width, "Dimensions.Width should be zero") + assert.Zerof(t, ctx.Dimensions.Height, "Dimensions.Height should be zero") + assert.Zerof(t, ctx.Coordinate.X, "Coordinate.X should be zero") + assert.Zerof(t, ctx.Coordinate.Y, "Coordinate.Y should be zero") + }) +} + +func TestContext_MaxWidth(t *testing.T) { + t.Run("Should return the maximum available space inside margins", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + + // Act + maxWidth := ctx.MaxWidth() + + // Assert + assert.Equal(t, width-MarginSize-MarginSize, maxWidth) + }) + t.Run("Should return the maximum available space inside margins when child context is modified", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + + // Act + childCtx := ctx.WithDimension(100, 100) + maxWidth := childCtx.MaxWidth() + + // Assert + assert.Equal(t, width-MarginSize-MarginSize, maxWidth) + }) } func TestContext_MaxHeight(t *testing.T) { - // Arrange - width := SideSize - height := SideSize + t.Run("Should return the maximum available space inside margins", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + + // Act_ + maxHeight := ctx.MaxHeight() + + // Assert + assert.Equal(t, height-MarginSize-MarginSize, maxHeight) + }) + t.Run("Should return the maximum available space inside margins when child context is modified", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize - margins := &Margins{ - Left: MarginSize, - Right: MarginSize, - Top: MarginSize, - Bottom: MarginSize, - } + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } - ctx := NewRootContext(width, height, margins) + ctx := NewRootContext(width, height, margins) - // Act - maxHeight := ctx.MaxHeight() + // Act + childCtx := ctx.WithDimension(100, 100) + maxHeight := childCtx.MaxHeight() - // Assert - assert.Equal(t, 1000.0, maxHeight) + // Assert + assert.Equal(t, height-MarginSize-MarginSize, maxHeight) + }) } -func TestContext_MaxWidth(t *testing.T) { - // Arrange - width := SideSize - height := SideSize +func TestContext_WithCoordinateOffset(t *testing.T) { + t.Run("Should return a new context with the correct coordinate offset", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + + // Act + childCtx := ctx.WithCoordinates(100, 100) + + // Assert + assert.Equal(t, 100.0, childCtx.Coordinate.X) + assert.Equal(t, 100.0, childCtx.Coordinate.Y) + }) + t.Run("Should not modify the base context when creating a child context", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } - margins := &Margins{ - Left: MarginSize, - Right: MarginSize, - Top: MarginSize, - Bottom: MarginSize, - } + ctx := NewRootContext(width, height, margins) - ctx := NewRootContext(width, height, margins) + // Act + childCtx := ctx.WithCoordinates(100, 100) - // Act - maxWidth := ctx.MaxWidth() + // Assert + // region Base Context Assertions + assert.Equal(t, 0.0, ctx.Coordinate.X) + assert.Equal(t, 0.0, ctx.Coordinate.Y) + assert.Equal(t, 0.0, ctx.Dimensions.Width) + assert.Equal(t, 0.0, ctx.Dimensions.Height) + assert.Equal(t, width, ctx.pageDimensions.Width) + assert.Equal(t, height, ctx.pageDimensions.Height) + assert.Equal(t, margins, ctx.Margins) + // endregion + // region Child Context Assertions + assert.Equal(t, margins, childCtx.Margins) + assert.Equal(t, width, childCtx.pageDimensions.Width) + assert.Equal(t, height, childCtx.pageDimensions.Height) + assert.Equal(t, 100.0, childCtx.Coordinate.X) + assert.Equal(t, 100.0, childCtx.Coordinate.Y) + assert.Equal(t, 0.0, childCtx.Dimensions.Width) + assert.Equal(t, 0.0, childCtx.Dimensions.Height) + // endregion - // Assert - assert.Equal(t, 1000.0, maxWidth) + }) } -func TestContext_GetX(t *testing.T) { - // Arrange - width := SideSize - height := SideSize +func TestContext_WithDimension(t *testing.T) { + t.Run("Should return a new context with the correct dimensions", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + childWidth := 100.0 + childHeight := 100.0 + + // Act + childCtx := ctx.WithDimension(childWidth, childHeight) + + // Assert + assert.Equal(t, childWidth, childCtx.Dimensions.Width) + assert.Equal(t, childHeight, childCtx.Dimensions.Height) + }) + t.Run("Should not modify the base context when creating a child context", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + childWidth := 100.0 + childHeight := 100.0 + + // Act + childCtx := ctx.WithDimension(childWidth, childHeight) + + // Assert + // region Base Context Assertions + assert.Equal(t, 0.0, ctx.Coordinate.X) + assert.Equal(t, 0.0, ctx.Coordinate.Y) + assert.Equal(t, 0.0, ctx.Dimensions.Width) + assert.Equal(t, 0.0, ctx.Dimensions.Height) + assert.Equal(t, width, ctx.pageDimensions.Width) + assert.Equal(t, height, ctx.pageDimensions.Height) + assert.Equal(t, margins, ctx.Margins) + // endregion + // region Child Context Assertions + assert.Equal(t, margins, childCtx.Margins) + assert.Equal(t, width, childCtx.pageDimensions.Width) + assert.Equal(t, height, childCtx.pageDimensions.Height) + assert.Equal(t, 0.0, childCtx.Coordinate.X) + assert.Equal(t, 0.0, childCtx.Coordinate.Y) + assert.Equal(t, childWidth, childCtx.Dimensions.Width) + assert.Equal(t, childHeight, childCtx.Dimensions.Height) + // endregion + }) +} + +func TestContext_GetXOffset(t *testing.T) { + t.Run("Should return the maximum possible offset when smaller than max width", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + xOffset := 100.0 + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + ctx = ctx.WithCoordinates(xOffset, 0.0) + + // Act + result := ctx.GetXOffset() + + // Assert + assert.Equal(t, xOffset, result) + assert.Zerof(t, ctx.Coordinate.Y, "Y coordinate should be 0") + }) + t.Run("Should return parent coordinate and break to the next line when larger than max width", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + xOffset := 100.0 + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins).WithDimension(1100, 1100).WithCoordinates(xOffset, 0.0) + + // Act + result := ctx.GetXOffset() + + // Assert + assert.Equal(t, xOffset, result) + assert.Equal(t, float64(LineHeight), ctx.Coordinate.Y) + }) +} + +func TestContext_GetYOffset(t *testing.T) { + t.Run("Should return the maximum possible offset when smaller than max height", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + yOffset := 100.0 + + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } + + ctx := NewRootContext(width, height, margins) + ctx = ctx.WithCoordinates(0.0, yOffset) + + // Act + result := ctx.GetYOffset() + + // Assert + assert.Equal(t, yOffset, result) + assert.Zerof(t, ctx.Coordinate.X, "X coordinate should be 0") + }) + t.Run("Should return 0 and break to the next page when larger than max height", func(t *testing.T) { + // Arrange + width := SideSize + height := SideSize + yOffset := 100.0 - margins := &Margins{ - Left: MarginSize, - Right: MarginSize, - Top: MarginSize, - Bottom: MarginSize, - } + margins := &Margins{ + Left: MarginSize, + Right: MarginSize, + Top: MarginSize, + Bottom: MarginSize, + } - ctx := NewRootContext(width, height, margins) + ctx := NewRootContext(width, height, margins).WithDimension(1100, 1100).WithCoordinates(0.0, yOffset) - // Act - x := ctx.GetX() + // Act + result := ctx.GetYOffset() - // Assert - assert.Equal(t, 0.0, x) + // Assert + assert.Equal(t, float64(0), result) + assert.Equal(t, float64(0), ctx.Coordinate.X) + assert.Equal(t, 1, ctx.CurrentPage) + }) } diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index c7b122cc..b971de56 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -45,6 +45,6 @@ func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { func (r *row) render(fpdf fpdf.Fpdf, ctx context.Context) { fpdf.SetDrawColor(0, 0, 0) - //x, y := ctx.GetX(), ctx.GetY() + //x, y := ctx.GetXOffset(), ctx.GetYOffset() fpdf.Ln(ctx.Dimensions.Height) } diff --git a/v2.pdf b/v2.pdf index 11f552632b8aca775cd87c9dfd2045290f156944..e4aef02f480ee49693d0a0ba2a6ce304db12d27e 100644 GIT binary patch delta 45 ycmcc1ahGGmQziuy69XenE`8tp6qm%3R0RzeD Date: Tue, 12 Sep 2023 15:52:55 -0300 Subject: [PATCH 11/24] fix col percentage calculation --- pkg/v2/col/col.go | 7 ++++++- pkg/v2/row/row.go | 2 +- v2.pdf | Bin 1117 -> 1096 bytes 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index be872c71..b6ec414c 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -6,6 +6,10 @@ import ( "github.com/johnfercher/maroto/pkg/v2/context" ) +const ( + defaultGridSize = 12.0 +) + type col struct { size int _type v2.DocumentType @@ -48,6 +52,7 @@ func (c *col) render(fpdf fpdf.Fpdf, ctx context.Context) { func (c *col) setRelativeDimension(ctx context.Context) context.Context { parentWidth := ctx.Dimensions.Width - colDimension := parentWidth / float64(c.size) + percent := float64(c.size) / defaultGridSize + colDimension := parentWidth * percent return ctx.WithDimension(colDimension, ctx.Dimensions.Height) } diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index b971de56..99a156bf 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -34,8 +34,8 @@ func (r *row) Add(components ...v2.Component) { func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { ctx.Print(r.height) + ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) for _, component := range r.components { - ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) component.Render(fpdf, ctx) } diff --git a/v2.pdf b/v2.pdf index e4aef02f480ee49693d0a0ba2a6ce304db12d27e..926267959096d2077b1a3993655ce3a6bdcb298e 100644 GIT binary patch delta 293 zcmcc1ae`w)eZ7gPogG(kNl|KIE>{KPk~6kkOok$^5A9a(kp58l`E%T)unUadb9sBz z1a)%n?0ay9E2((bXF+%OJF>3E^YYA-t0itZy|#KZY46otUrIRFy3Ehsej#FaZ}z8y z4}3k&F#o<8=#f+;GHJ(O#h=?ZRAu{5=5}4Q=!eFv2gRbjH&%4Yh1yu1`%z%%t!baX zF~#%GHjwi53=9na{|igF#BMfZ+{~zGYHDO)rpcx6o1fy6Sdyxs;bLWEU}S7yX=r2! zmYdAVJW0&JNWlOE6!H|fzzhQe6H9~1Ynd&zjV&xO{KPk~4;WEQUO-5AQ9n5SREYqwaS}>7d7yH!%r{ zoI+2{V&pp~E^st4ssH}>$Yg={PP(GH2BwCFlV>nn hYMU4uV91%78)1lgw;t1ptzFcU1rY From 4efa2d06dd84f700dee71f341bd50707fe4fb565 Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 15:55:39 -0300 Subject: [PATCH 12/24] remove uncessesary context return from render --- pkg/v2/col/col.go | 4 ++-- pkg/v2/component.go | 2 +- pkg/v2/document.go | 2 +- pkg/v2/image/image.go | 4 ++-- pkg/v2/row/row.go | 4 ++-- pkg/v2/text/text.go | 4 ++-- v2.pdf | Bin 1096 -> 1096 bytes 7 files changed, 10 insertions(+), 10 deletions(-) diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index b6ec414c..9e620d29 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -35,14 +35,14 @@ func (c *col) Add(components ...v2.Component) { } } -func (c *col) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { +func (c *col) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(c.size) ctx = c.setRelativeDimension(ctx) for _, component := range c.components { component.Render(fpdf, ctx) } c.render(fpdf, ctx) - return ctx.WithCoordinates(ctx.GetXOffset(), ctx.GetYOffset()) + return } func (c *col) render(fpdf fpdf.Fpdf, ctx context.Context) { diff --git a/pkg/v2/component.go b/pkg/v2/component.go index 6cf30717..ba1413cc 100644 --- a/pkg/v2/component.go +++ b/pkg/v2/component.go @@ -6,7 +6,7 @@ import ( ) type Component interface { - Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context + Render(fpdf fpdf.Fpdf, ctx context.Context) GetType() string Add(component ...Component) } diff --git a/pkg/v2/document.go b/pkg/v2/document.go index edff5e93..caeedbd4 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -57,7 +57,7 @@ func (d *document) Generate(file string) error { ctx := d.ctx.WithDimension(d.ctx.MaxWidth(), d.ctx.MaxHeight()) for _, component := range d.components { - ctx = component.Render(d.fpdf, ctx) + component.Render(d.fpdf, ctx) } return d.fpdf.OutputFileAndClose(file) diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go index 034d6c9e..d00ef736 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/image.go @@ -19,12 +19,12 @@ func New(path string) *image { } } -func (i *image) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { +func (i *image) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(i.path) for _, component := range i.components { component.Render(fpdf, ctx) } - return ctx + return } func (i *image) GetType() string { diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 99a156bf..68833eb9 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -31,7 +31,7 @@ func (r *row) Add(components ...v2.Component) { } } -func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { +func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(r.height) ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) @@ -40,7 +40,7 @@ func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { } r.render(fpdf, ctx) - return ctx + return } func (r *row) render(fpdf fpdf.Fpdf, ctx context.Context) { diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index a2102ff1..476378a6 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -19,12 +19,12 @@ func New(value string) *text { } } -func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) context.Context { +func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(t.value) for _, component := range t.components { component.Render(fpdf, ctx) } - return ctx + return } func (t *text) GetType() string { diff --git a/v2.pdf b/v2.pdf index 926267959096d2077b1a3993655ce3a6bdcb298e..4c534566b7926560b4adeb5c268e4bd3d776dd93 100644 GIT binary patch delta 44 ycmX@Xae`yRMJ9O@6C+J7ec${Pm&B4(1q~M~BLgF214~0ALsL_r+~yBV5sUyR%?xP( delta 44 ycmX@Xae`yRMJ9P812au7ec${Pm&B4(1q~M~BLgF214~0ALsL_r+~yBV5sUyRZ46}q From ff53b30b7296333de03b164f654b9cfa7d01ed4e Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 17:19:48 -0300 Subject: [PATCH 13/24] add col tests --- internal/mocks/Fpdf.go | 5645 ++++++++++++++++++++++++++++++++++++++-- pkg/v2/col/col_test.go | 369 +++ pkg/v2/text/text.go | 18 +- 3 files changed, 5800 insertions(+), 232 deletions(-) create mode 100644 pkg/v2/col/col_test.go diff --git a/internal/mocks/Fpdf.go b/internal/mocks/Fpdf.go index 2bb79de2..1a0b7eb5 100644 --- a/internal/mocks/Fpdf.go +++ b/internal/mocks/Fpdf.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.2.1. DO NOT EDIT. +// Code generated by mockery v2.33.2. DO NOT EDIT. package mocks @@ -17,21 +17,120 @@ type Fpdf struct { mock.Mock } +type Fpdf_Expecter struct { + mock *mock.Mock +} + +func (_m *Fpdf) EXPECT() *Fpdf_Expecter { + return &Fpdf_Expecter{mock: &_m.Mock} +} + // AddFont provides a mock function with given fields: familyStr, styleStr, fileStr func (_m *Fpdf) AddFont(familyStr string, styleStr string, fileStr string) { _m.Called(familyStr, styleStr, fileStr) } +// Fpdf_AddFont_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFont' +type Fpdf_AddFont_Call struct { + *mock.Call +} + +// AddFont is a helper method to define mock.On call +// - familyStr string +// - styleStr string +// - fileStr string +func (_e *Fpdf_Expecter) AddFont(familyStr interface{}, styleStr interface{}, fileStr interface{}) *Fpdf_AddFont_Call { + return &Fpdf_AddFont_Call{Call: _e.mock.On("AddFont", familyStr, styleStr, fileStr)} +} + +func (_c *Fpdf_AddFont_Call) Run(run func(familyStr string, styleStr string, fileStr string)) *Fpdf_AddFont_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Fpdf_AddFont_Call) Return() *Fpdf_AddFont_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AddFont_Call) RunAndReturn(run func(string, string, string)) *Fpdf_AddFont_Call { + _c.Call.Return(run) + return _c +} + // AddFontFromBytes provides a mock function with given fields: familyStr, styleStr, jsonFileBytes, zFileBytes func (_m *Fpdf) AddFontFromBytes(familyStr string, styleStr string, jsonFileBytes []byte, zFileBytes []byte) { _m.Called(familyStr, styleStr, jsonFileBytes, zFileBytes) } +// Fpdf_AddFontFromBytes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFontFromBytes' +type Fpdf_AddFontFromBytes_Call struct { + *mock.Call +} + +// AddFontFromBytes is a helper method to define mock.On call +// - familyStr string +// - styleStr string +// - jsonFileBytes []byte +// - zFileBytes []byte +func (_e *Fpdf_Expecter) AddFontFromBytes(familyStr interface{}, styleStr interface{}, jsonFileBytes interface{}, zFileBytes interface{}) *Fpdf_AddFontFromBytes_Call { + return &Fpdf_AddFontFromBytes_Call{Call: _e.mock.On("AddFontFromBytes", familyStr, styleStr, jsonFileBytes, zFileBytes)} +} + +func (_c *Fpdf_AddFontFromBytes_Call) Run(run func(familyStr string, styleStr string, jsonFileBytes []byte, zFileBytes []byte)) *Fpdf_AddFontFromBytes_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]byte), args[3].([]byte)) + }) + return _c +} + +func (_c *Fpdf_AddFontFromBytes_Call) Return() *Fpdf_AddFontFromBytes_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AddFontFromBytes_Call) RunAndReturn(run func(string, string, []byte, []byte)) *Fpdf_AddFontFromBytes_Call { + _c.Call.Return(run) + return _c +} + // AddFontFromReader provides a mock function with given fields: familyStr, styleStr, r func (_m *Fpdf) AddFontFromReader(familyStr string, styleStr string, r io.Reader) { _m.Called(familyStr, styleStr, r) } +// Fpdf_AddFontFromReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFontFromReader' +type Fpdf_AddFontFromReader_Call struct { + *mock.Call +} + +// AddFontFromReader is a helper method to define mock.On call +// - familyStr string +// - styleStr string +// - r io.Reader +func (_e *Fpdf_Expecter) AddFontFromReader(familyStr interface{}, styleStr interface{}, r interface{}) *Fpdf_AddFontFromReader_Call { + return &Fpdf_AddFontFromReader_Call{Call: _e.mock.On("AddFontFromReader", familyStr, styleStr, r)} +} + +func (_c *Fpdf_AddFontFromReader_Call) Run(run func(familyStr string, styleStr string, r io.Reader)) *Fpdf_AddFontFromReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(io.Reader)) + }) + return _c +} + +func (_c *Fpdf_AddFontFromReader_Call) Return() *Fpdf_AddFontFromReader_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AddFontFromReader_Call) RunAndReturn(run func(string, string, io.Reader)) *Fpdf_AddFontFromReader_Call { + _c.Call.Return(run) + return _c +} + // AddLayer provides a mock function with given fields: name, visible func (_m *Fpdf) AddLayer(name string, visible bool) int { ret := _m.Called(name, visible) @@ -46,6 +145,35 @@ func (_m *Fpdf) AddLayer(name string, visible bool) int { return r0 } +// Fpdf_AddLayer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddLayer' +type Fpdf_AddLayer_Call struct { + *mock.Call +} + +// AddLayer is a helper method to define mock.On call +// - name string +// - visible bool +func (_e *Fpdf_Expecter) AddLayer(name interface{}, visible interface{}) *Fpdf_AddLayer_Call { + return &Fpdf_AddLayer_Call{Call: _e.mock.On("AddLayer", name, visible)} +} + +func (_c *Fpdf_AddLayer_Call) Run(run func(name string, visible bool)) *Fpdf_AddLayer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_AddLayer_Call) Return(layerID int) *Fpdf_AddLayer_Call { + _c.Call.Return(layerID) + return _c +} + +func (_c *Fpdf_AddLayer_Call) RunAndReturn(run func(string, bool) int) *Fpdf_AddLayer_Call { + _c.Call.Return(run) + return _c +} + // AddLink provides a mock function with given fields: func (_m *Fpdf) AddLink() int { ret := _m.Called() @@ -60,64 +188,459 @@ func (_m *Fpdf) AddLink() int { return r0 } +// Fpdf_AddLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddLink' +type Fpdf_AddLink_Call struct { + *mock.Call +} + +// AddLink is a helper method to define mock.On call +func (_e *Fpdf_Expecter) AddLink() *Fpdf_AddLink_Call { + return &Fpdf_AddLink_Call{Call: _e.mock.On("AddLink")} +} + +func (_c *Fpdf_AddLink_Call) Run(run func()) *Fpdf_AddLink_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_AddLink_Call) Return(_a0 int) *Fpdf_AddLink_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_AddLink_Call) RunAndReturn(run func() int) *Fpdf_AddLink_Call { + _c.Call.Return(run) + return _c +} + // AddPage provides a mock function with given fields: func (_m *Fpdf) AddPage() { _m.Called() } +// Fpdf_AddPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPage' +type Fpdf_AddPage_Call struct { + *mock.Call +} + +// AddPage is a helper method to define mock.On call +func (_e *Fpdf_Expecter) AddPage() *Fpdf_AddPage_Call { + return &Fpdf_AddPage_Call{Call: _e.mock.On("AddPage")} +} + +func (_c *Fpdf_AddPage_Call) Run(run func()) *Fpdf_AddPage_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_AddPage_Call) Return() *Fpdf_AddPage_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AddPage_Call) RunAndReturn(run func()) *Fpdf_AddPage_Call { + _c.Call.Return(run) + return _c +} + // AddPageFormat provides a mock function with given fields: orientationStr, size func (_m *Fpdf) AddPageFormat(orientationStr string, size gofpdf.SizeType) { _m.Called(orientationStr, size) } +// Fpdf_AddPageFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPageFormat' +type Fpdf_AddPageFormat_Call struct { + *mock.Call +} + +// AddPageFormat is a helper method to define mock.On call +// - orientationStr string +// - size gofpdf.SizeType +func (_e *Fpdf_Expecter) AddPageFormat(orientationStr interface{}, size interface{}) *Fpdf_AddPageFormat_Call { + return &Fpdf_AddPageFormat_Call{Call: _e.mock.On("AddPageFormat", orientationStr, size)} +} + +func (_c *Fpdf_AddPageFormat_Call) Run(run func(orientationStr string, size gofpdf.SizeType)) *Fpdf_AddPageFormat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(gofpdf.SizeType)) + }) + return _c +} + +func (_c *Fpdf_AddPageFormat_Call) Return() *Fpdf_AddPageFormat_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AddPageFormat_Call) RunAndReturn(run func(string, gofpdf.SizeType)) *Fpdf_AddPageFormat_Call { + _c.Call.Return(run) + return _c +} + // AddSpotColor provides a mock function with given fields: nameStr, c, m, y, k func (_m *Fpdf) AddSpotColor(nameStr string, c byte, m byte, y byte, k byte) { _m.Called(nameStr, c, m, y, k) } +// Fpdf_AddSpotColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddSpotColor' +type Fpdf_AddSpotColor_Call struct { + *mock.Call +} + +// AddSpotColor is a helper method to define mock.On call +// - nameStr string +// - c byte +// - m byte +// - y byte +// - k byte +func (_e *Fpdf_Expecter) AddSpotColor(nameStr interface{}, c interface{}, m interface{}, y interface{}, k interface{}) *Fpdf_AddSpotColor_Call { + return &Fpdf_AddSpotColor_Call{Call: _e.mock.On("AddSpotColor", nameStr, c, m, y, k)} +} + +func (_c *Fpdf_AddSpotColor_Call) Run(run func(nameStr string, c byte, m byte, y byte, k byte)) *Fpdf_AddSpotColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(byte), args[2].(byte), args[3].(byte), args[4].(byte)) + }) + return _c +} + +func (_c *Fpdf_AddSpotColor_Call) Return() *Fpdf_AddSpotColor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AddSpotColor_Call) RunAndReturn(run func(string, byte, byte, byte, byte)) *Fpdf_AddSpotColor_Call { + _c.Call.Return(run) + return _c +} + // AddUTF8Font provides a mock function with given fields: familyStr, styleStr, fileStr func (_m *Fpdf) AddUTF8Font(familyStr string, styleStr string, fileStr string) { _m.Called(familyStr, styleStr, fileStr) } +// Fpdf_AddUTF8Font_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUTF8Font' +type Fpdf_AddUTF8Font_Call struct { + *mock.Call +} + +// AddUTF8Font is a helper method to define mock.On call +// - familyStr string +// - styleStr string +// - fileStr string +func (_e *Fpdf_Expecter) AddUTF8Font(familyStr interface{}, styleStr interface{}, fileStr interface{}) *Fpdf_AddUTF8Font_Call { + return &Fpdf_AddUTF8Font_Call{Call: _e.mock.On("AddUTF8Font", familyStr, styleStr, fileStr)} +} + +func (_c *Fpdf_AddUTF8Font_Call) Run(run func(familyStr string, styleStr string, fileStr string)) *Fpdf_AddUTF8Font_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Fpdf_AddUTF8Font_Call) Return() *Fpdf_AddUTF8Font_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AddUTF8Font_Call) RunAndReturn(run func(string, string, string)) *Fpdf_AddUTF8Font_Call { + _c.Call.Return(run) + return _c +} + // AliasNbPages provides a mock function with given fields: aliasStr func (_m *Fpdf) AliasNbPages(aliasStr string) { _m.Called(aliasStr) } +// Fpdf_AliasNbPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AliasNbPages' +type Fpdf_AliasNbPages_Call struct { + *mock.Call +} + +// AliasNbPages is a helper method to define mock.On call +// - aliasStr string +func (_e *Fpdf_Expecter) AliasNbPages(aliasStr interface{}) *Fpdf_AliasNbPages_Call { + return &Fpdf_AliasNbPages_Call{Call: _e.mock.On("AliasNbPages", aliasStr)} +} + +func (_c *Fpdf_AliasNbPages_Call) Run(run func(aliasStr string)) *Fpdf_AliasNbPages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_AliasNbPages_Call) Return() *Fpdf_AliasNbPages_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_AliasNbPages_Call) RunAndReturn(run func(string)) *Fpdf_AliasNbPages_Call { + _c.Call.Return(run) + return _c +} + // Arc provides a mock function with given fields: x, y, rx, ry, degRotate, degStart, degEnd, styleStr func (_m *Fpdf) Arc(x float64, y float64, rx float64, ry float64, degRotate float64, degStart float64, degEnd float64, styleStr string) { _m.Called(x, y, rx, ry, degRotate, degStart, degEnd, styleStr) } +// Fpdf_Arc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Arc' +type Fpdf_Arc_Call struct { + *mock.Call +} + +// Arc is a helper method to define mock.On call +// - x float64 +// - y float64 +// - rx float64 +// - ry float64 +// - degRotate float64 +// - degStart float64 +// - degEnd float64 +// - styleStr string +func (_e *Fpdf_Expecter) Arc(x interface{}, y interface{}, rx interface{}, ry interface{}, degRotate interface{}, degStart interface{}, degEnd interface{}, styleStr interface{}) *Fpdf_Arc_Call { + return &Fpdf_Arc_Call{Call: _e.mock.On("Arc", x, y, rx, ry, degRotate, degStart, degEnd, styleStr)} +} + +func (_c *Fpdf_Arc_Call) Run(run func(x float64, y float64, rx float64, ry float64, degRotate float64, degStart float64, degEnd float64, styleStr string)) *Fpdf_Arc_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(float64), args[6].(float64), args[7].(string)) + }) + return _c +} + +func (_c *Fpdf_Arc_Call) Return() *Fpdf_Arc_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Arc_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, float64, float64, string)) *Fpdf_Arc_Call { + _c.Call.Return(run) + return _c +} + // ArcTo provides a mock function with given fields: x, y, rx, ry, degRotate, degStart, degEnd func (_m *Fpdf) ArcTo(x float64, y float64, rx float64, ry float64, degRotate float64, degStart float64, degEnd float64) { _m.Called(x, y, rx, ry, degRotate, degStart, degEnd) } +// Fpdf_ArcTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ArcTo' +type Fpdf_ArcTo_Call struct { + *mock.Call +} + +// ArcTo is a helper method to define mock.On call +// - x float64 +// - y float64 +// - rx float64 +// - ry float64 +// - degRotate float64 +// - degStart float64 +// - degEnd float64 +func (_e *Fpdf_Expecter) ArcTo(x interface{}, y interface{}, rx interface{}, ry interface{}, degRotate interface{}, degStart interface{}, degEnd interface{}) *Fpdf_ArcTo_Call { + return &Fpdf_ArcTo_Call{Call: _e.mock.On("ArcTo", x, y, rx, ry, degRotate, degStart, degEnd)} +} + +func (_c *Fpdf_ArcTo_Call) Run(run func(x float64, y float64, rx float64, ry float64, degRotate float64, degStart float64, degEnd float64)) *Fpdf_ArcTo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(float64), args[6].(float64)) + }) + return _c +} + +func (_c *Fpdf_ArcTo_Call) Return() *Fpdf_ArcTo_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ArcTo_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, float64, float64)) *Fpdf_ArcTo_Call { + _c.Call.Return(run) + return _c +} + // BeginLayer provides a mock function with given fields: id func (_m *Fpdf) BeginLayer(id int) { _m.Called(id) } +// Fpdf_BeginLayer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BeginLayer' +type Fpdf_BeginLayer_Call struct { + *mock.Call +} + +// BeginLayer is a helper method to define mock.On call +// - id int +func (_e *Fpdf_Expecter) BeginLayer(id interface{}) *Fpdf_BeginLayer_Call { + return &Fpdf_BeginLayer_Call{Call: _e.mock.On("BeginLayer", id)} +} + +func (_c *Fpdf_BeginLayer_Call) Run(run func(id int)) *Fpdf_BeginLayer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *Fpdf_BeginLayer_Call) Return() *Fpdf_BeginLayer_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_BeginLayer_Call) RunAndReturn(run func(int)) *Fpdf_BeginLayer_Call { + _c.Call.Return(run) + return _c +} + // Beziergon provides a mock function with given fields: points, styleStr func (_m *Fpdf) Beziergon(points []gofpdf.PointType, styleStr string) { _m.Called(points, styleStr) } +// Fpdf_Beziergon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Beziergon' +type Fpdf_Beziergon_Call struct { + *mock.Call +} + +// Beziergon is a helper method to define mock.On call +// - points []gofpdf.PointType +// - styleStr string +func (_e *Fpdf_Expecter) Beziergon(points interface{}, styleStr interface{}) *Fpdf_Beziergon_Call { + return &Fpdf_Beziergon_Call{Call: _e.mock.On("Beziergon", points, styleStr)} +} + +func (_c *Fpdf_Beziergon_Call) Run(run func(points []gofpdf.PointType, styleStr string)) *Fpdf_Beziergon_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]gofpdf.PointType), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_Beziergon_Call) Return() *Fpdf_Beziergon_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Beziergon_Call) RunAndReturn(run func([]gofpdf.PointType, string)) *Fpdf_Beziergon_Call { + _c.Call.Return(run) + return _c +} + // Bookmark provides a mock function with given fields: txtStr, level, y func (_m *Fpdf) Bookmark(txtStr string, level int, y float64) { _m.Called(txtStr, level, y) } +// Fpdf_Bookmark_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bookmark' +type Fpdf_Bookmark_Call struct { + *mock.Call +} + +// Bookmark is a helper method to define mock.On call +// - txtStr string +// - level int +// - y float64 +func (_e *Fpdf_Expecter) Bookmark(txtStr interface{}, level interface{}, y interface{}) *Fpdf_Bookmark_Call { + return &Fpdf_Bookmark_Call{Call: _e.mock.On("Bookmark", txtStr, level, y)} +} + +func (_c *Fpdf_Bookmark_Call) Run(run func(txtStr string, level int, y float64)) *Fpdf_Bookmark_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(int), args[2].(float64)) + }) + return _c +} + +func (_c *Fpdf_Bookmark_Call) Return() *Fpdf_Bookmark_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Bookmark_Call) RunAndReturn(run func(string, int, float64)) *Fpdf_Bookmark_Call { + _c.Call.Return(run) + return _c +} + // Cell provides a mock function with given fields: w, h, txtStr func (_m *Fpdf) Cell(w float64, h float64, txtStr string) { _m.Called(w, h, txtStr) } +// Fpdf_Cell_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cell' +type Fpdf_Cell_Call struct { + *mock.Call +} + +// Cell is a helper method to define mock.On call +// - w float64 +// - h float64 +// - txtStr string +func (_e *Fpdf_Expecter) Cell(w interface{}, h interface{}, txtStr interface{}) *Fpdf_Cell_Call { + return &Fpdf_Cell_Call{Call: _e.mock.On("Cell", w, h, txtStr)} +} + +func (_c *Fpdf_Cell_Call) Run(run func(w float64, h float64, txtStr string)) *Fpdf_Cell_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(string)) + }) + return _c +} + +func (_c *Fpdf_Cell_Call) Return() *Fpdf_Cell_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Cell_Call) RunAndReturn(run func(float64, float64, string)) *Fpdf_Cell_Call { + _c.Call.Return(run) + return _c +} + // CellFormat provides a mock function with given fields: w, h, txtStr, borderStr, ln, alignStr, fill, link, linkStr func (_m *Fpdf) CellFormat(w float64, h float64, txtStr string, borderStr string, ln int, alignStr string, fill bool, link int, linkStr string) { - _m.Called(int(w), int(h), txtStr, borderStr, ln, alignStr, fill, link, linkStr) + _m.Called(w, h, txtStr, borderStr, ln, alignStr, fill, link, linkStr) +} + +// Fpdf_CellFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CellFormat' +type Fpdf_CellFormat_Call struct { + *mock.Call +} + +// CellFormat is a helper method to define mock.On call +// - w float64 +// - h float64 +// - txtStr string +// - borderStr string +// - ln int +// - alignStr string +// - fill bool +// - link int +// - linkStr string +func (_e *Fpdf_Expecter) CellFormat(w interface{}, h interface{}, txtStr interface{}, borderStr interface{}, ln interface{}, alignStr interface{}, fill interface{}, link interface{}, linkStr interface{}) *Fpdf_CellFormat_Call { + return &Fpdf_CellFormat_Call{Call: _e.mock.On("CellFormat", w, h, txtStr, borderStr, ln, alignStr, fill, link, linkStr)} +} + +func (_c *Fpdf_CellFormat_Call) Run(run func(w float64, h float64, txtStr string, borderStr string, ln int, alignStr string, fill bool, link int, linkStr string)) *Fpdf_CellFormat_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(string), args[3].(string), args[4].(int), args[5].(string), args[6].(bool), args[7].(int), args[8].(string)) + }) + return _c +} + +func (_c *Fpdf_CellFormat_Call) Return() *Fpdf_CellFormat_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_CellFormat_Call) RunAndReturn(run func(float64, float64, string, string, int, string, bool, int, string)) *Fpdf_CellFormat_Call { + _c.Call.Return(run) + return _c } // Cellf provides a mock function with given fields: w, h, fmtStr, args @@ -128,61 +651,426 @@ func (_m *Fpdf) Cellf(w float64, h float64, fmtStr string, args ...interface{}) _m.Called(_ca...) } +// Fpdf_Cellf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cellf' +type Fpdf_Cellf_Call struct { + *mock.Call +} + +// Cellf is a helper method to define mock.On call +// - w float64 +// - h float64 +// - fmtStr string +// - args ...interface{} +func (_e *Fpdf_Expecter) Cellf(w interface{}, h interface{}, fmtStr interface{}, args ...interface{}) *Fpdf_Cellf_Call { + return &Fpdf_Cellf_Call{Call: _e.mock.On("Cellf", + append([]interface{}{w, h, fmtStr}, args...)...)} +} + +func (_c *Fpdf_Cellf_Call) Run(run func(w float64, h float64, fmtStr string, args ...interface{})) *Fpdf_Cellf_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(float64), args[1].(float64), args[2].(string), variadicArgs...) + }) + return _c +} + +func (_c *Fpdf_Cellf_Call) Return() *Fpdf_Cellf_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Cellf_Call) RunAndReturn(run func(float64, float64, string, ...interface{})) *Fpdf_Cellf_Call { + _c.Call.Return(run) + return _c +} + // Circle provides a mock function with given fields: x, y, r, styleStr func (_m *Fpdf) Circle(x float64, y float64, r float64, styleStr string) { _m.Called(x, y, r, styleStr) } +// Fpdf_Circle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Circle' +type Fpdf_Circle_Call struct { + *mock.Call +} + +// Circle is a helper method to define mock.On call +// - x float64 +// - y float64 +// - r float64 +// - styleStr string +func (_e *Fpdf_Expecter) Circle(x interface{}, y interface{}, r interface{}, styleStr interface{}) *Fpdf_Circle_Call { + return &Fpdf_Circle_Call{Call: _e.mock.On("Circle", x, y, r, styleStr)} +} + +func (_c *Fpdf_Circle_Call) Run(run func(x float64, y float64, r float64, styleStr string)) *Fpdf_Circle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(string)) + }) + return _c +} + +func (_c *Fpdf_Circle_Call) Return() *Fpdf_Circle_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Circle_Call) RunAndReturn(run func(float64, float64, float64, string)) *Fpdf_Circle_Call { + _c.Call.Return(run) + return _c +} + // ClearError provides a mock function with given fields: func (_m *Fpdf) ClearError() { _m.Called() } +// Fpdf_ClearError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearError' +type Fpdf_ClearError_Call struct { + *mock.Call +} + +// ClearError is a helper method to define mock.On call +func (_e *Fpdf_Expecter) ClearError() *Fpdf_ClearError_Call { + return &Fpdf_ClearError_Call{Call: _e.mock.On("ClearError")} +} + +func (_c *Fpdf_ClearError_Call) Run(run func()) *Fpdf_ClearError_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_ClearError_Call) Return() *Fpdf_ClearError_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClearError_Call) RunAndReturn(run func()) *Fpdf_ClearError_Call { + _c.Call.Return(run) + return _c +} + // ClipCircle provides a mock function with given fields: x, y, r, outline func (_m *Fpdf) ClipCircle(x float64, y float64, r float64, outline bool) { _m.Called(x, y, r, outline) } +// Fpdf_ClipCircle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClipCircle' +type Fpdf_ClipCircle_Call struct { + *mock.Call +} + +// ClipCircle is a helper method to define mock.On call +// - x float64 +// - y float64 +// - r float64 +// - outline bool +func (_e *Fpdf_Expecter) ClipCircle(x interface{}, y interface{}, r interface{}, outline interface{}) *Fpdf_ClipCircle_Call { + return &Fpdf_ClipCircle_Call{Call: _e.mock.On("ClipCircle", x, y, r, outline)} +} + +func (_c *Fpdf_ClipCircle_Call) Run(run func(x float64, y float64, r float64, outline bool)) *Fpdf_ClipCircle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(bool)) + }) + return _c +} + +func (_c *Fpdf_ClipCircle_Call) Return() *Fpdf_ClipCircle_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClipCircle_Call) RunAndReturn(run func(float64, float64, float64, bool)) *Fpdf_ClipCircle_Call { + _c.Call.Return(run) + return _c +} + // ClipEllipse provides a mock function with given fields: x, y, rx, ry, outline func (_m *Fpdf) ClipEllipse(x float64, y float64, rx float64, ry float64, outline bool) { _m.Called(x, y, rx, ry, outline) } +// Fpdf_ClipEllipse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClipEllipse' +type Fpdf_ClipEllipse_Call struct { + *mock.Call +} + +// ClipEllipse is a helper method to define mock.On call +// - x float64 +// - y float64 +// - rx float64 +// - ry float64 +// - outline bool +func (_e *Fpdf_Expecter) ClipEllipse(x interface{}, y interface{}, rx interface{}, ry interface{}, outline interface{}) *Fpdf_ClipEllipse_Call { + return &Fpdf_ClipEllipse_Call{Call: _e.mock.On("ClipEllipse", x, y, rx, ry, outline)} +} + +func (_c *Fpdf_ClipEllipse_Call) Run(run func(x float64, y float64, rx float64, ry float64, outline bool)) *Fpdf_ClipEllipse_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(bool)) + }) + return _c +} + +func (_c *Fpdf_ClipEllipse_Call) Return() *Fpdf_ClipEllipse_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClipEllipse_Call) RunAndReturn(run func(float64, float64, float64, float64, bool)) *Fpdf_ClipEllipse_Call { + _c.Call.Return(run) + return _c +} + // ClipEnd provides a mock function with given fields: func (_m *Fpdf) ClipEnd() { _m.Called() } +// Fpdf_ClipEnd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClipEnd' +type Fpdf_ClipEnd_Call struct { + *mock.Call +} + +// ClipEnd is a helper method to define mock.On call +func (_e *Fpdf_Expecter) ClipEnd() *Fpdf_ClipEnd_Call { + return &Fpdf_ClipEnd_Call{Call: _e.mock.On("ClipEnd")} +} + +func (_c *Fpdf_ClipEnd_Call) Run(run func()) *Fpdf_ClipEnd_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_ClipEnd_Call) Return() *Fpdf_ClipEnd_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClipEnd_Call) RunAndReturn(run func()) *Fpdf_ClipEnd_Call { + _c.Call.Return(run) + return _c +} + // ClipPolygon provides a mock function with given fields: points, outline func (_m *Fpdf) ClipPolygon(points []gofpdf.PointType, outline bool) { _m.Called(points, outline) } +// Fpdf_ClipPolygon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClipPolygon' +type Fpdf_ClipPolygon_Call struct { + *mock.Call +} + +// ClipPolygon is a helper method to define mock.On call +// - points []gofpdf.PointType +// - outline bool +func (_e *Fpdf_Expecter) ClipPolygon(points interface{}, outline interface{}) *Fpdf_ClipPolygon_Call { + return &Fpdf_ClipPolygon_Call{Call: _e.mock.On("ClipPolygon", points, outline)} +} + +func (_c *Fpdf_ClipPolygon_Call) Run(run func(points []gofpdf.PointType, outline bool)) *Fpdf_ClipPolygon_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]gofpdf.PointType), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_ClipPolygon_Call) Return() *Fpdf_ClipPolygon_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClipPolygon_Call) RunAndReturn(run func([]gofpdf.PointType, bool)) *Fpdf_ClipPolygon_Call { + _c.Call.Return(run) + return _c +} + // ClipRect provides a mock function with given fields: x, y, w, h, outline func (_m *Fpdf) ClipRect(x float64, y float64, w float64, h float64, outline bool) { _m.Called(x, y, w, h, outline) } -// ClipRoundedRect provides a mock function with given fields: x, y, w, h, r, outline -func (_m *Fpdf) ClipRoundedRect(x float64, y float64, w float64, h float64, r float64, outline bool) { - _m.Called(x, y, w, h, r, outline) +// Fpdf_ClipRect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClipRect' +type Fpdf_ClipRect_Call struct { + *mock.Call } -// ClipText provides a mock function with given fields: x, y, txtStr, outline -func (_m *Fpdf) ClipText(x float64, y float64, txtStr string, outline bool) { - _m.Called(x, y, txtStr, outline) +// ClipRect is a helper method to define mock.On call +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - outline bool +func (_e *Fpdf_Expecter) ClipRect(x interface{}, y interface{}, w interface{}, h interface{}, outline interface{}) *Fpdf_ClipRect_Call { + return &Fpdf_ClipRect_Call{Call: _e.mock.On("ClipRect", x, y, w, h, outline)} } -// Close provides a mock function with given fields: -func (_m *Fpdf) Close() { - _m.Called() +func (_c *Fpdf_ClipRect_Call) Run(run func(x float64, y float64, w float64, h float64, outline bool)) *Fpdf_ClipRect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(bool)) + }) + return _c } -// ClosePath provides a mock function with given fields: -func (_m *Fpdf) ClosePath() { +func (_c *Fpdf_ClipRect_Call) Return() *Fpdf_ClipRect_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClipRect_Call) RunAndReturn(run func(float64, float64, float64, float64, bool)) *Fpdf_ClipRect_Call { + _c.Call.Return(run) + return _c +} + +// ClipRoundedRect provides a mock function with given fields: x, y, w, h, r, outline +func (_m *Fpdf) ClipRoundedRect(x float64, y float64, w float64, h float64, r float64, outline bool) { + _m.Called(x, y, w, h, r, outline) +} + +// Fpdf_ClipRoundedRect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClipRoundedRect' +type Fpdf_ClipRoundedRect_Call struct { + *mock.Call +} + +// ClipRoundedRect is a helper method to define mock.On call +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - r float64 +// - outline bool +func (_e *Fpdf_Expecter) ClipRoundedRect(x interface{}, y interface{}, w interface{}, h interface{}, r interface{}, outline interface{}) *Fpdf_ClipRoundedRect_Call { + return &Fpdf_ClipRoundedRect_Call{Call: _e.mock.On("ClipRoundedRect", x, y, w, h, r, outline)} +} + +func (_c *Fpdf_ClipRoundedRect_Call) Run(run func(x float64, y float64, w float64, h float64, r float64, outline bool)) *Fpdf_ClipRoundedRect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(bool)) + }) + return _c +} + +func (_c *Fpdf_ClipRoundedRect_Call) Return() *Fpdf_ClipRoundedRect_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClipRoundedRect_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, bool)) *Fpdf_ClipRoundedRect_Call { + _c.Call.Return(run) + return _c +} + +// ClipText provides a mock function with given fields: x, y, txtStr, outline +func (_m *Fpdf) ClipText(x float64, y float64, txtStr string, outline bool) { + _m.Called(x, y, txtStr, outline) +} + +// Fpdf_ClipText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClipText' +type Fpdf_ClipText_Call struct { + *mock.Call +} + +// ClipText is a helper method to define mock.On call +// - x float64 +// - y float64 +// - txtStr string +// - outline bool +func (_e *Fpdf_Expecter) ClipText(x interface{}, y interface{}, txtStr interface{}, outline interface{}) *Fpdf_ClipText_Call { + return &Fpdf_ClipText_Call{Call: _e.mock.On("ClipText", x, y, txtStr, outline)} +} + +func (_c *Fpdf_ClipText_Call) Run(run func(x float64, y float64, txtStr string, outline bool)) *Fpdf_ClipText_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *Fpdf_ClipText_Call) Return() *Fpdf_ClipText_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClipText_Call) RunAndReturn(run func(float64, float64, string, bool)) *Fpdf_ClipText_Call { + _c.Call.Return(run) + return _c +} + +// Close provides a mock function with given fields: +func (_m *Fpdf) Close() { + _m.Called() +} + +// Fpdf_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type Fpdf_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *Fpdf_Expecter) Close() *Fpdf_Close_Call { + return &Fpdf_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *Fpdf_Close_Call) Run(run func()) *Fpdf_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_Close_Call) Return() *Fpdf_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Close_Call) RunAndReturn(run func()) *Fpdf_Close_Call { + _c.Call.Return(run) + return _c +} + +// ClosePath provides a mock function with given fields: +func (_m *Fpdf) ClosePath() { _m.Called() } +// Fpdf_ClosePath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClosePath' +type Fpdf_ClosePath_Call struct { + *mock.Call +} + +// ClosePath is a helper method to define mock.On call +func (_e *Fpdf_Expecter) ClosePath() *Fpdf_ClosePath_Call { + return &Fpdf_ClosePath_Call{Call: _e.mock.On("ClosePath")} +} + +func (_c *Fpdf_ClosePath_Call) Run(run func()) *Fpdf_ClosePath_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_ClosePath_Call) Return() *Fpdf_ClosePath_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ClosePath_Call) RunAndReturn(run func()) *Fpdf_ClosePath_Call { + _c.Call.Return(run) + return _c +} + // CreateTemplate provides a mock function with given fields: fn func (_m *Fpdf) CreateTemplate(fn func(*gofpdf.Tpl)) gofpdf.Template { ret := _m.Called(fn) @@ -199,6 +1087,34 @@ func (_m *Fpdf) CreateTemplate(fn func(*gofpdf.Tpl)) gofpdf.Template { return r0 } +// Fpdf_CreateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplate' +type Fpdf_CreateTemplate_Call struct { + *mock.Call +} + +// CreateTemplate is a helper method to define mock.On call +// - fn func(*gofpdf.Tpl) +func (_e *Fpdf_Expecter) CreateTemplate(fn interface{}) *Fpdf_CreateTemplate_Call { + return &Fpdf_CreateTemplate_Call{Call: _e.mock.On("CreateTemplate", fn)} +} + +func (_c *Fpdf_CreateTemplate_Call) Run(run func(fn func(*gofpdf.Tpl))) *Fpdf_CreateTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(*gofpdf.Tpl))) + }) + return _c +} + +func (_c *Fpdf_CreateTemplate_Call) Return(_a0 gofpdf.Template) *Fpdf_CreateTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_CreateTemplate_Call) RunAndReturn(run func(func(*gofpdf.Tpl)) gofpdf.Template) *Fpdf_CreateTemplate_Call { + _c.Call.Return(run) + return _c +} + // CreateTemplateCustom provides a mock function with given fields: corner, size, fn func (_m *Fpdf) CreateTemplateCustom(corner gofpdf.PointType, size gofpdf.SizeType, fn func(*gofpdf.Tpl)) gofpdf.Template { ret := _m.Called(corner, size, fn) @@ -215,46 +1131,334 @@ func (_m *Fpdf) CreateTemplateCustom(corner gofpdf.PointType, size gofpdf.SizeTy return r0 } +// Fpdf_CreateTemplateCustom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplateCustom' +type Fpdf_CreateTemplateCustom_Call struct { + *mock.Call +} + +// CreateTemplateCustom is a helper method to define mock.On call +// - corner gofpdf.PointType +// - size gofpdf.SizeType +// - fn func(*gofpdf.Tpl) +func (_e *Fpdf_Expecter) CreateTemplateCustom(corner interface{}, size interface{}, fn interface{}) *Fpdf_CreateTemplateCustom_Call { + return &Fpdf_CreateTemplateCustom_Call{Call: _e.mock.On("CreateTemplateCustom", corner, size, fn)} +} + +func (_c *Fpdf_CreateTemplateCustom_Call) Run(run func(corner gofpdf.PointType, size gofpdf.SizeType, fn func(*gofpdf.Tpl))) *Fpdf_CreateTemplateCustom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gofpdf.PointType), args[1].(gofpdf.SizeType), args[2].(func(*gofpdf.Tpl))) + }) + return _c +} + +func (_c *Fpdf_CreateTemplateCustom_Call) Return(_a0 gofpdf.Template) *Fpdf_CreateTemplateCustom_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_CreateTemplateCustom_Call) RunAndReturn(run func(gofpdf.PointType, gofpdf.SizeType, func(*gofpdf.Tpl)) gofpdf.Template) *Fpdf_CreateTemplateCustom_Call { + _c.Call.Return(run) + return _c +} + // Curve provides a mock function with given fields: x0, y0, cx, cy, x1, y1, styleStr func (_m *Fpdf) Curve(x0 float64, y0 float64, cx float64, cy float64, x1 float64, y1 float64, styleStr string) { _m.Called(x0, y0, cx, cy, x1, y1, styleStr) } +// Fpdf_Curve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Curve' +type Fpdf_Curve_Call struct { + *mock.Call +} + +// Curve is a helper method to define mock.On call +// - x0 float64 +// - y0 float64 +// - cx float64 +// - cy float64 +// - x1 float64 +// - y1 float64 +// - styleStr string +func (_e *Fpdf_Expecter) Curve(x0 interface{}, y0 interface{}, cx interface{}, cy interface{}, x1 interface{}, y1 interface{}, styleStr interface{}) *Fpdf_Curve_Call { + return &Fpdf_Curve_Call{Call: _e.mock.On("Curve", x0, y0, cx, cy, x1, y1, styleStr)} +} + +func (_c *Fpdf_Curve_Call) Run(run func(x0 float64, y0 float64, cx float64, cy float64, x1 float64, y1 float64, styleStr string)) *Fpdf_Curve_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(float64), args[6].(string)) + }) + return _c +} + +func (_c *Fpdf_Curve_Call) Return() *Fpdf_Curve_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Curve_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, float64, string)) *Fpdf_Curve_Call { + _c.Call.Return(run) + return _c +} + // CurveBezierCubic provides a mock function with given fields: x0, y0, cx0, cy0, cx1, cy1, x1, y1, styleStr func (_m *Fpdf) CurveBezierCubic(x0 float64, y0 float64, cx0 float64, cy0 float64, cx1 float64, cy1 float64, x1 float64, y1 float64, styleStr string) { _m.Called(x0, y0, cx0, cy0, cx1, cy1, x1, y1, styleStr) } +// Fpdf_CurveBezierCubic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurveBezierCubic' +type Fpdf_CurveBezierCubic_Call struct { + *mock.Call +} + +// CurveBezierCubic is a helper method to define mock.On call +// - x0 float64 +// - y0 float64 +// - cx0 float64 +// - cy0 float64 +// - cx1 float64 +// - cy1 float64 +// - x1 float64 +// - y1 float64 +// - styleStr string +func (_e *Fpdf_Expecter) CurveBezierCubic(x0 interface{}, y0 interface{}, cx0 interface{}, cy0 interface{}, cx1 interface{}, cy1 interface{}, x1 interface{}, y1 interface{}, styleStr interface{}) *Fpdf_CurveBezierCubic_Call { + return &Fpdf_CurveBezierCubic_Call{Call: _e.mock.On("CurveBezierCubic", x0, y0, cx0, cy0, cx1, cy1, x1, y1, styleStr)} +} + +func (_c *Fpdf_CurveBezierCubic_Call) Run(run func(x0 float64, y0 float64, cx0 float64, cy0 float64, cx1 float64, cy1 float64, x1 float64, y1 float64, styleStr string)) *Fpdf_CurveBezierCubic_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(float64), args[6].(float64), args[7].(float64), args[8].(string)) + }) + return _c +} + +func (_c *Fpdf_CurveBezierCubic_Call) Return() *Fpdf_CurveBezierCubic_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_CurveBezierCubic_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, float64, float64, float64, string)) *Fpdf_CurveBezierCubic_Call { + _c.Call.Return(run) + return _c +} + // CurveBezierCubicTo provides a mock function with given fields: cx0, cy0, cx1, cy1, x, y func (_m *Fpdf) CurveBezierCubicTo(cx0 float64, cy0 float64, cx1 float64, cy1 float64, x float64, y float64) { _m.Called(cx0, cy0, cx1, cy1, x, y) } +// Fpdf_CurveBezierCubicTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurveBezierCubicTo' +type Fpdf_CurveBezierCubicTo_Call struct { + *mock.Call +} + +// CurveBezierCubicTo is a helper method to define mock.On call +// - cx0 float64 +// - cy0 float64 +// - cx1 float64 +// - cy1 float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) CurveBezierCubicTo(cx0 interface{}, cy0 interface{}, cx1 interface{}, cy1 interface{}, x interface{}, y interface{}) *Fpdf_CurveBezierCubicTo_Call { + return &Fpdf_CurveBezierCubicTo_Call{Call: _e.mock.On("CurveBezierCubicTo", cx0, cy0, cx1, cy1, x, y)} +} + +func (_c *Fpdf_CurveBezierCubicTo_Call) Run(run func(cx0 float64, cy0 float64, cx1 float64, cy1 float64, x float64, y float64)) *Fpdf_CurveBezierCubicTo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(float64)) + }) + return _c +} + +func (_c *Fpdf_CurveBezierCubicTo_Call) Return() *Fpdf_CurveBezierCubicTo_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_CurveBezierCubicTo_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, float64)) *Fpdf_CurveBezierCubicTo_Call { + _c.Call.Return(run) + return _c +} + // CurveCubic provides a mock function with given fields: x0, y0, cx0, cy0, x1, y1, cx1, cy1, styleStr func (_m *Fpdf) CurveCubic(x0 float64, y0 float64, cx0 float64, cy0 float64, x1 float64, y1 float64, cx1 float64, cy1 float64, styleStr string) { _m.Called(x0, y0, cx0, cy0, x1, y1, cx1, cy1, styleStr) } +// Fpdf_CurveCubic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurveCubic' +type Fpdf_CurveCubic_Call struct { + *mock.Call +} + +// CurveCubic is a helper method to define mock.On call +// - x0 float64 +// - y0 float64 +// - cx0 float64 +// - cy0 float64 +// - x1 float64 +// - y1 float64 +// - cx1 float64 +// - cy1 float64 +// - styleStr string +func (_e *Fpdf_Expecter) CurveCubic(x0 interface{}, y0 interface{}, cx0 interface{}, cy0 interface{}, x1 interface{}, y1 interface{}, cx1 interface{}, cy1 interface{}, styleStr interface{}) *Fpdf_CurveCubic_Call { + return &Fpdf_CurveCubic_Call{Call: _e.mock.On("CurveCubic", x0, y0, cx0, cy0, x1, y1, cx1, cy1, styleStr)} +} + +func (_c *Fpdf_CurveCubic_Call) Run(run func(x0 float64, y0 float64, cx0 float64, cy0 float64, x1 float64, y1 float64, cx1 float64, cy1 float64, styleStr string)) *Fpdf_CurveCubic_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(float64), args[6].(float64), args[7].(float64), args[8].(string)) + }) + return _c +} + +func (_c *Fpdf_CurveCubic_Call) Return() *Fpdf_CurveCubic_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_CurveCubic_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, float64, float64, float64, string)) *Fpdf_CurveCubic_Call { + _c.Call.Return(run) + return _c +} + // CurveTo provides a mock function with given fields: cx, cy, x, y func (_m *Fpdf) CurveTo(cx float64, cy float64, x float64, y float64) { _m.Called(cx, cy, x, y) } +// Fpdf_CurveTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurveTo' +type Fpdf_CurveTo_Call struct { + *mock.Call +} + +// CurveTo is a helper method to define mock.On call +// - cx float64 +// - cy float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) CurveTo(cx interface{}, cy interface{}, x interface{}, y interface{}) *Fpdf_CurveTo_Call { + return &Fpdf_CurveTo_Call{Call: _e.mock.On("CurveTo", cx, cy, x, y)} +} + +func (_c *Fpdf_CurveTo_Call) Run(run func(cx float64, cy float64, x float64, y float64)) *Fpdf_CurveTo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64)) + }) + return _c +} + +func (_c *Fpdf_CurveTo_Call) Return() *Fpdf_CurveTo_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_CurveTo_Call) RunAndReturn(run func(float64, float64, float64, float64)) *Fpdf_CurveTo_Call { + _c.Call.Return(run) + return _c +} + // DrawPath provides a mock function with given fields: styleStr func (_m *Fpdf) DrawPath(styleStr string) { _m.Called(styleStr) } +// Fpdf_DrawPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DrawPath' +type Fpdf_DrawPath_Call struct { + *mock.Call +} + +// DrawPath is a helper method to define mock.On call +// - styleStr string +func (_e *Fpdf_Expecter) DrawPath(styleStr interface{}) *Fpdf_DrawPath_Call { + return &Fpdf_DrawPath_Call{Call: _e.mock.On("DrawPath", styleStr)} +} + +func (_c *Fpdf_DrawPath_Call) Run(run func(styleStr string)) *Fpdf_DrawPath_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_DrawPath_Call) Return() *Fpdf_DrawPath_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_DrawPath_Call) RunAndReturn(run func(string)) *Fpdf_DrawPath_Call { + _c.Call.Return(run) + return _c +} + // Ellipse provides a mock function with given fields: x, y, rx, ry, degRotate, styleStr func (_m *Fpdf) Ellipse(x float64, y float64, rx float64, ry float64, degRotate float64, styleStr string) { _m.Called(x, y, rx, ry, degRotate, styleStr) } +// Fpdf_Ellipse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ellipse' +type Fpdf_Ellipse_Call struct { + *mock.Call +} + +// Ellipse is a helper method to define mock.On call +// - x float64 +// - y float64 +// - rx float64 +// - ry float64 +// - degRotate float64 +// - styleStr string +func (_e *Fpdf_Expecter) Ellipse(x interface{}, y interface{}, rx interface{}, ry interface{}, degRotate interface{}, styleStr interface{}) *Fpdf_Ellipse_Call { + return &Fpdf_Ellipse_Call{Call: _e.mock.On("Ellipse", x, y, rx, ry, degRotate, styleStr)} +} + +func (_c *Fpdf_Ellipse_Call) Run(run func(x float64, y float64, rx float64, ry float64, degRotate float64, styleStr string)) *Fpdf_Ellipse_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(string)) + }) + return _c +} + +func (_c *Fpdf_Ellipse_Call) Return() *Fpdf_Ellipse_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Ellipse_Call) RunAndReturn(run func(float64, float64, float64, float64, float64, string)) *Fpdf_Ellipse_Call { + _c.Call.Return(run) + return _c +} + // EndLayer provides a mock function with given fields: func (_m *Fpdf) EndLayer() { _m.Called() } +// Fpdf_EndLayer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EndLayer' +type Fpdf_EndLayer_Call struct { + *mock.Call +} + +// EndLayer is a helper method to define mock.On call +func (_e *Fpdf_Expecter) EndLayer() *Fpdf_EndLayer_Call { + return &Fpdf_EndLayer_Call{Call: _e.mock.On("EndLayer")} +} + +func (_c *Fpdf_EndLayer_Call) Run(run func()) *Fpdf_EndLayer_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_EndLayer_Call) Return() *Fpdf_EndLayer_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_EndLayer_Call) RunAndReturn(run func()) *Fpdf_EndLayer_Call { + _c.Call.Return(run) + return _c +} + // Err provides a mock function with given fields: func (_m *Fpdf) Err() bool { ret := _m.Called() @@ -269,6 +1473,33 @@ func (_m *Fpdf) Err() bool { return r0 } +// Fpdf_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err' +type Fpdf_Err_Call struct { + *mock.Call +} + +// Err is a helper method to define mock.On call +func (_e *Fpdf_Expecter) Err() *Fpdf_Err_Call { + return &Fpdf_Err_Call{Call: _e.mock.On("Err")} +} + +func (_c *Fpdf_Err_Call) Run(run func()) *Fpdf_Err_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_Err_Call) Return(_a0 bool) *Fpdf_Err_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_Err_Call) RunAndReturn(run func() bool) *Fpdf_Err_Call { + _c.Call.Return(run) + return _c +} + // Error provides a mock function with given fields: func (_m *Fpdf) Error() error { ret := _m.Called() @@ -283,18 +1514,48 @@ func (_m *Fpdf) Error() error { return r0 } +// Fpdf_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error' +type Fpdf_Error_Call struct { + *mock.Call +} + +// Error is a helper method to define mock.On call +func (_e *Fpdf_Expecter) Error() *Fpdf_Error_Call { + return &Fpdf_Error_Call{Call: _e.mock.On("Error")} +} + +func (_c *Fpdf_Error_Call) Run(run func()) *Fpdf_Error_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_Error_Call) Return(_a0 error) *Fpdf_Error_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_Error_Call) RunAndReturn(run func() error) *Fpdf_Error_Call { + _c.Call.Return(run) + return _c +} + // GetAlpha provides a mock function with given fields: func (_m *Fpdf) GetAlpha() (float64, string) { ret := _m.Called() var r0 float64 + var r1 string + if rf, ok := ret.Get(0).(func() (float64, string)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() float64); ok { r0 = rf() } else { r0 = ret.Get(0).(float64) } - var r1 string if rf, ok := ret.Get(1).(func() string); ok { r1 = rf() } else { @@ -304,18 +1565,48 @@ func (_m *Fpdf) GetAlpha() (float64, string) { return r0, r1 } +// Fpdf_GetAlpha_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlpha' +type Fpdf_GetAlpha_Call struct { + *mock.Call +} + +// GetAlpha is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetAlpha() *Fpdf_GetAlpha_Call { + return &Fpdf_GetAlpha_Call{Call: _e.mock.On("GetAlpha")} +} + +func (_c *Fpdf_GetAlpha_Call) Run(run func()) *Fpdf_GetAlpha_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetAlpha_Call) Return(alpha float64, blendModeStr string) *Fpdf_GetAlpha_Call { + _c.Call.Return(alpha, blendModeStr) + return _c +} + +func (_c *Fpdf_GetAlpha_Call) RunAndReturn(run func() (float64, string)) *Fpdf_GetAlpha_Call { + _c.Call.Return(run) + return _c +} + // GetAutoPageBreak provides a mock function with given fields: func (_m *Fpdf) GetAutoPageBreak() (bool, float64) { ret := _m.Called() var r0 bool + var r1 float64 + if rf, ok := ret.Get(0).(func() (bool, float64)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() bool); ok { r0 = rf() } else { r0 = ret.Get(0).(bool) } - var r1 float64 if rf, ok := ret.Get(1).(func() float64); ok { r1 = rf() } else { @@ -325,6 +1616,33 @@ func (_m *Fpdf) GetAutoPageBreak() (bool, float64) { return r0, r1 } +// Fpdf_GetAutoPageBreak_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAutoPageBreak' +type Fpdf_GetAutoPageBreak_Call struct { + *mock.Call +} + +// GetAutoPageBreak is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetAutoPageBreak() *Fpdf_GetAutoPageBreak_Call { + return &Fpdf_GetAutoPageBreak_Call{Call: _e.mock.On("GetAutoPageBreak")} +} + +func (_c *Fpdf_GetAutoPageBreak_Call) Run(run func()) *Fpdf_GetAutoPageBreak_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetAutoPageBreak_Call) Return(auto bool, margin float64) *Fpdf_GetAutoPageBreak_Call { + _c.Call.Return(auto, margin) + return _c +} + +func (_c *Fpdf_GetAutoPageBreak_Call) RunAndReturn(run func() (bool, float64)) *Fpdf_GetAutoPageBreak_Call { + _c.Call.Return(run) + return _c +} + // GetCellMargin provides a mock function with given fields: func (_m *Fpdf) GetCellMargin() float64 { ret := _m.Called() @@ -339,6 +1657,33 @@ func (_m *Fpdf) GetCellMargin() float64 { return r0 } +// Fpdf_GetCellMargin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCellMargin' +type Fpdf_GetCellMargin_Call struct { + *mock.Call +} + +// GetCellMargin is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetCellMargin() *Fpdf_GetCellMargin_Call { + return &Fpdf_GetCellMargin_Call{Call: _e.mock.On("GetCellMargin")} +} + +func (_c *Fpdf_GetCellMargin_Call) Run(run func()) *Fpdf_GetCellMargin_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetCellMargin_Call) Return(_a0 float64) *Fpdf_GetCellMargin_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_GetCellMargin_Call) RunAndReturn(run func() float64) *Fpdf_GetCellMargin_Call { + _c.Call.Return(run) + return _c +} + // GetConversionRatio provides a mock function with given fields: func (_m *Fpdf) GetConversionRatio() float64 { ret := _m.Called() @@ -353,25 +1698,55 @@ func (_m *Fpdf) GetConversionRatio() float64 { return r0 } +// Fpdf_GetConversionRatio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConversionRatio' +type Fpdf_GetConversionRatio_Call struct { + *mock.Call +} + +// GetConversionRatio is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetConversionRatio() *Fpdf_GetConversionRatio_Call { + return &Fpdf_GetConversionRatio_Call{Call: _e.mock.On("GetConversionRatio")} +} + +func (_c *Fpdf_GetConversionRatio_Call) Run(run func()) *Fpdf_GetConversionRatio_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetConversionRatio_Call) Return(_a0 float64) *Fpdf_GetConversionRatio_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_GetConversionRatio_Call) RunAndReturn(run func() float64) *Fpdf_GetConversionRatio_Call { + _c.Call.Return(run) + return _c +} + // GetDrawColor provides a mock function with given fields: func (_m *Fpdf) GetDrawColor() (int, int, int) { ret := _m.Called() var r0 int + var r1 int + var r2 int + if rf, ok := ret.Get(0).(func() (int, int, int)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() int); ok { r0 = rf() } else { r0 = ret.Get(0).(int) } - var r1 int if rf, ok := ret.Get(1).(func() int); ok { r1 = rf() } else { r1 = ret.Get(1).(int) } - var r2 int if rf, ok := ret.Get(2).(func() int); ok { r2 = rf() } else { @@ -381,39 +1756,69 @@ func (_m *Fpdf) GetDrawColor() (int, int, int) { return r0, r1, r2 } +// Fpdf_GetDrawColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDrawColor' +type Fpdf_GetDrawColor_Call struct { + *mock.Call +} + +// GetDrawColor is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetDrawColor() *Fpdf_GetDrawColor_Call { + return &Fpdf_GetDrawColor_Call{Call: _e.mock.On("GetDrawColor")} +} + +func (_c *Fpdf_GetDrawColor_Call) Run(run func()) *Fpdf_GetDrawColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetDrawColor_Call) Return(_a0 int, _a1 int, _a2 int) *Fpdf_GetDrawColor_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *Fpdf_GetDrawColor_Call) RunAndReturn(run func() (int, int, int)) *Fpdf_GetDrawColor_Call { + _c.Call.Return(run) + return _c +} + // GetDrawSpotColor provides a mock function with given fields: func (_m *Fpdf) GetDrawSpotColor() (string, byte, byte, byte, byte) { ret := _m.Called() var r0 string + var r1 byte + var r2 byte + var r3 byte + var r4 byte + if rf, ok := ret.Get(0).(func() (string, byte, byte, byte, byte)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() } else { r0 = ret.Get(0).(string) } - var r1 byte if rf, ok := ret.Get(1).(func() byte); ok { r1 = rf() } else { r1 = ret.Get(1).(byte) } - var r2 byte if rf, ok := ret.Get(2).(func() byte); ok { r2 = rf() } else { r2 = ret.Get(2).(byte) } - var r3 byte if rf, ok := ret.Get(3).(func() byte); ok { r3 = rf() } else { r3 = ret.Get(3).(byte) } - var r4 byte if rf, ok := ret.Get(4).(func() byte); ok { r4 = rf() } else { @@ -423,25 +1828,55 @@ func (_m *Fpdf) GetDrawSpotColor() (string, byte, byte, byte, byte) { return r0, r1, r2, r3, r4 } -// GetFillColor provides a mock function with given fields: -func (_m *Fpdf) GetFillColor() (int, int, int) { - ret := _m.Called() +// Fpdf_GetDrawSpotColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDrawSpotColor' +type Fpdf_GetDrawSpotColor_Call struct { + *mock.Call +} - var r0 int +// GetDrawSpotColor is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetDrawSpotColor() *Fpdf_GetDrawSpotColor_Call { + return &Fpdf_GetDrawSpotColor_Call{Call: _e.mock.On("GetDrawSpotColor")} +} + +func (_c *Fpdf_GetDrawSpotColor_Call) Run(run func()) *Fpdf_GetDrawSpotColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetDrawSpotColor_Call) Return(name string, c byte, m byte, y byte, k byte) *Fpdf_GetDrawSpotColor_Call { + _c.Call.Return(name, c, m, y, k) + return _c +} + +func (_c *Fpdf_GetDrawSpotColor_Call) RunAndReturn(run func() (string, byte, byte, byte, byte)) *Fpdf_GetDrawSpotColor_Call { + _c.Call.Return(run) + return _c +} + +// GetFillColor provides a mock function with given fields: +func (_m *Fpdf) GetFillColor() (int, int, int) { + ret := _m.Called() + + var r0 int + var r1 int + var r2 int + if rf, ok := ret.Get(0).(func() (int, int, int)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() int); ok { r0 = rf() } else { r0 = ret.Get(0).(int) } - var r1 int if rf, ok := ret.Get(1).(func() int); ok { r1 = rf() } else { r1 = ret.Get(1).(int) } - var r2 int if rf, ok := ret.Get(2).(func() int); ok { r2 = rf() } else { @@ -451,39 +1886,69 @@ func (_m *Fpdf) GetFillColor() (int, int, int) { return r0, r1, r2 } +// Fpdf_GetFillColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFillColor' +type Fpdf_GetFillColor_Call struct { + *mock.Call +} + +// GetFillColor is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetFillColor() *Fpdf_GetFillColor_Call { + return &Fpdf_GetFillColor_Call{Call: _e.mock.On("GetFillColor")} +} + +func (_c *Fpdf_GetFillColor_Call) Run(run func()) *Fpdf_GetFillColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetFillColor_Call) Return(_a0 int, _a1 int, _a2 int) *Fpdf_GetFillColor_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *Fpdf_GetFillColor_Call) RunAndReturn(run func() (int, int, int)) *Fpdf_GetFillColor_Call { + _c.Call.Return(run) + return _c +} + // GetFillSpotColor provides a mock function with given fields: func (_m *Fpdf) GetFillSpotColor() (string, byte, byte, byte, byte) { ret := _m.Called() var r0 string + var r1 byte + var r2 byte + var r3 byte + var r4 byte + if rf, ok := ret.Get(0).(func() (string, byte, byte, byte, byte)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() } else { r0 = ret.Get(0).(string) } - var r1 byte if rf, ok := ret.Get(1).(func() byte); ok { r1 = rf() } else { r1 = ret.Get(1).(byte) } - var r2 byte if rf, ok := ret.Get(2).(func() byte); ok { r2 = rf() } else { r2 = ret.Get(2).(byte) } - var r3 byte if rf, ok := ret.Get(3).(func() byte); ok { r3 = rf() } else { r3 = ret.Get(3).(byte) } - var r4 byte if rf, ok := ret.Get(4).(func() byte); ok { r4 = rf() } else { @@ -493,6 +1958,33 @@ func (_m *Fpdf) GetFillSpotColor() (string, byte, byte, byte, byte) { return r0, r1, r2, r3, r4 } +// Fpdf_GetFillSpotColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFillSpotColor' +type Fpdf_GetFillSpotColor_Call struct { + *mock.Call +} + +// GetFillSpotColor is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetFillSpotColor() *Fpdf_GetFillSpotColor_Call { + return &Fpdf_GetFillSpotColor_Call{Call: _e.mock.On("GetFillSpotColor")} +} + +func (_c *Fpdf_GetFillSpotColor_Call) Run(run func()) *Fpdf_GetFillSpotColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetFillSpotColor_Call) Return(name string, c byte, m byte, y byte, k byte) *Fpdf_GetFillSpotColor_Call { + _c.Call.Return(name, c, m, y, k) + return _c +} + +func (_c *Fpdf_GetFillSpotColor_Call) RunAndReturn(run func() (string, byte, byte, byte, byte)) *Fpdf_GetFillSpotColor_Call { + _c.Call.Return(run) + return _c +} + // GetFontDesc provides a mock function with given fields: familyStr, styleStr func (_m *Fpdf) GetFontDesc(familyStr string, styleStr string) gofpdf.FontDescType { ret := _m.Called(familyStr, styleStr) @@ -507,18 +1999,50 @@ func (_m *Fpdf) GetFontDesc(familyStr string, styleStr string) gofpdf.FontDescTy return r0 } +// Fpdf_GetFontDesc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFontDesc' +type Fpdf_GetFontDesc_Call struct { + *mock.Call +} + +// GetFontDesc is a helper method to define mock.On call +// - familyStr string +// - styleStr string +func (_e *Fpdf_Expecter) GetFontDesc(familyStr interface{}, styleStr interface{}) *Fpdf_GetFontDesc_Call { + return &Fpdf_GetFontDesc_Call{Call: _e.mock.On("GetFontDesc", familyStr, styleStr)} +} + +func (_c *Fpdf_GetFontDesc_Call) Run(run func(familyStr string, styleStr string)) *Fpdf_GetFontDesc_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_GetFontDesc_Call) Return(_a0 gofpdf.FontDescType) *Fpdf_GetFontDesc_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_GetFontDesc_Call) RunAndReturn(run func(string, string) gofpdf.FontDescType) *Fpdf_GetFontDesc_Call { + _c.Call.Return(run) + return _c +} + // GetFontSize provides a mock function with given fields: func (_m *Fpdf) GetFontSize() (float64, float64) { ret := _m.Called() var r0 float64 + var r1 float64 + if rf, ok := ret.Get(0).(func() (float64, float64)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() float64); ok { r0 = rf() } else { r0 = ret.Get(0).(float64) } - var r1 float64 if rf, ok := ret.Get(1).(func() float64); ok { r1 = rf() } else { @@ -528,6 +2052,33 @@ func (_m *Fpdf) GetFontSize() (float64, float64) { return r0, r1 } +// Fpdf_GetFontSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFontSize' +type Fpdf_GetFontSize_Call struct { + *mock.Call +} + +// GetFontSize is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetFontSize() *Fpdf_GetFontSize_Call { + return &Fpdf_GetFontSize_Call{Call: _e.mock.On("GetFontSize")} +} + +func (_c *Fpdf_GetFontSize_Call) Run(run func()) *Fpdf_GetFontSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetFontSize_Call) Return(ptSize float64, unitSize float64) *Fpdf_GetFontSize_Call { + _c.Call.Return(ptSize, unitSize) + return _c +} + +func (_c *Fpdf_GetFontSize_Call) RunAndReturn(run func() (float64, float64)) *Fpdf_GetFontSize_Call { + _c.Call.Return(run) + return _c +} + // GetImageInfo provides a mock function with given fields: imageStr func (_m *Fpdf) GetImageInfo(imageStr string) *gofpdf.ImageInfoType { ret := _m.Called(imageStr) @@ -544,6 +2095,34 @@ func (_m *Fpdf) GetImageInfo(imageStr string) *gofpdf.ImageInfoType { return r0 } +// Fpdf_GetImageInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetImageInfo' +type Fpdf_GetImageInfo_Call struct { + *mock.Call +} + +// GetImageInfo is a helper method to define mock.On call +// - imageStr string +func (_e *Fpdf_Expecter) GetImageInfo(imageStr interface{}) *Fpdf_GetImageInfo_Call { + return &Fpdf_GetImageInfo_Call{Call: _e.mock.On("GetImageInfo", imageStr)} +} + +func (_c *Fpdf_GetImageInfo_Call) Run(run func(imageStr string)) *Fpdf_GetImageInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_GetImageInfo_Call) Return(info *gofpdf.ImageInfoType) *Fpdf_GetImageInfo_Call { + _c.Call.Return(info) + return _c +} + +func (_c *Fpdf_GetImageInfo_Call) RunAndReturn(run func(string) *gofpdf.ImageInfoType) *Fpdf_GetImageInfo_Call { + _c.Call.Return(run) + return _c +} + // GetLineWidth provides a mock function with given fields: func (_m *Fpdf) GetLineWidth() float64 { ret := _m.Called() @@ -558,32 +2137,62 @@ func (_m *Fpdf) GetLineWidth() float64 { return r0 } +// Fpdf_GetLineWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLineWidth' +type Fpdf_GetLineWidth_Call struct { + *mock.Call +} + +// GetLineWidth is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetLineWidth() *Fpdf_GetLineWidth_Call { + return &Fpdf_GetLineWidth_Call{Call: _e.mock.On("GetLineWidth")} +} + +func (_c *Fpdf_GetLineWidth_Call) Run(run func()) *Fpdf_GetLineWidth_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetLineWidth_Call) Return(_a0 float64) *Fpdf_GetLineWidth_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_GetLineWidth_Call) RunAndReturn(run func() float64) *Fpdf_GetLineWidth_Call { + _c.Call.Return(run) + return _c +} + // GetMargins provides a mock function with given fields: func (_m *Fpdf) GetMargins() (float64, float64, float64, float64) { ret := _m.Called() var r0 float64 + var r1 float64 + var r2 float64 + var r3 float64 + if rf, ok := ret.Get(0).(func() (float64, float64, float64, float64)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() float64); ok { r0 = rf() } else { r0 = ret.Get(0).(float64) } - var r1 float64 if rf, ok := ret.Get(1).(func() float64); ok { r1 = rf() } else { r1 = ret.Get(1).(float64) } - var r2 float64 if rf, ok := ret.Get(2).(func() float64); ok { r2 = rf() } else { r2 = ret.Get(2).(float64) } - var r3 float64 if rf, ok := ret.Get(3).(func() float64); ok { r3 = rf() } else { @@ -593,18 +2202,48 @@ func (_m *Fpdf) GetMargins() (float64, float64, float64, float64) { return r0, r1, r2, r3 } +// Fpdf_GetMargins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMargins' +type Fpdf_GetMargins_Call struct { + *mock.Call +} + +// GetMargins is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetMargins() *Fpdf_GetMargins_Call { + return &Fpdf_GetMargins_Call{Call: _e.mock.On("GetMargins")} +} + +func (_c *Fpdf_GetMargins_Call) Run(run func()) *Fpdf_GetMargins_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetMargins_Call) Return(left float64, top float64, right float64, bottom float64) *Fpdf_GetMargins_Call { + _c.Call.Return(left, top, right, bottom) + return _c +} + +func (_c *Fpdf_GetMargins_Call) RunAndReturn(run func() (float64, float64, float64, float64)) *Fpdf_GetMargins_Call { + _c.Call.Return(run) + return _c +} + // GetPageSize provides a mock function with given fields: func (_m *Fpdf) GetPageSize() (float64, float64) { ret := _m.Called() var r0 float64 + var r1 float64 + if rf, ok := ret.Get(0).(func() (float64, float64)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() float64); ok { r0 = rf() } else { r0 = ret.Get(0).(float64) } - var r1 float64 if rf, ok := ret.Get(1).(func() float64); ok { r1 = rf() } else { @@ -614,6 +2253,33 @@ func (_m *Fpdf) GetPageSize() (float64, float64) { return r0, r1 } +// Fpdf_GetPageSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPageSize' +type Fpdf_GetPageSize_Call struct { + *mock.Call +} + +// GetPageSize is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetPageSize() *Fpdf_GetPageSize_Call { + return &Fpdf_GetPageSize_Call{Call: _e.mock.On("GetPageSize")} +} + +func (_c *Fpdf_GetPageSize_Call) Run(run func()) *Fpdf_GetPageSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetPageSize_Call) Return(width float64, height float64) *Fpdf_GetPageSize_Call { + _c.Call.Return(width, height) + return _c +} + +func (_c *Fpdf_GetPageSize_Call) RunAndReturn(run func() (float64, float64)) *Fpdf_GetPageSize_Call { + _c.Call.Return(run) + return _c +} + // GetPageSizeStr provides a mock function with given fields: sizeStr func (_m *Fpdf) GetPageSizeStr(sizeStr string) gofpdf.SizeType { ret := _m.Called(sizeStr) @@ -628,6 +2294,34 @@ func (_m *Fpdf) GetPageSizeStr(sizeStr string) gofpdf.SizeType { return r0 } +// Fpdf_GetPageSizeStr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPageSizeStr' +type Fpdf_GetPageSizeStr_Call struct { + *mock.Call +} + +// GetPageSizeStr is a helper method to define mock.On call +// - sizeStr string +func (_e *Fpdf_Expecter) GetPageSizeStr(sizeStr interface{}) *Fpdf_GetPageSizeStr_Call { + return &Fpdf_GetPageSizeStr_Call{Call: _e.mock.On("GetPageSizeStr", sizeStr)} +} + +func (_c *Fpdf_GetPageSizeStr_Call) Run(run func(sizeStr string)) *Fpdf_GetPageSizeStr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_GetPageSizeStr_Call) Return(size gofpdf.SizeType) *Fpdf_GetPageSizeStr_Call { + _c.Call.Return(size) + return _c +} + +func (_c *Fpdf_GetPageSizeStr_Call) RunAndReturn(run func(string) gofpdf.SizeType) *Fpdf_GetPageSizeStr_Call { + _c.Call.Return(run) + return _c +} + // GetStringWidth provides a mock function with given fields: s func (_m *Fpdf) GetStringWidth(s string) float64 { ret := _m.Called(s) @@ -642,25 +2336,56 @@ func (_m *Fpdf) GetStringWidth(s string) float64 { return r0 } +// Fpdf_GetStringWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStringWidth' +type Fpdf_GetStringWidth_Call struct { + *mock.Call +} + +// GetStringWidth is a helper method to define mock.On call +// - s string +func (_e *Fpdf_Expecter) GetStringWidth(s interface{}) *Fpdf_GetStringWidth_Call { + return &Fpdf_GetStringWidth_Call{Call: _e.mock.On("GetStringWidth", s)} +} + +func (_c *Fpdf_GetStringWidth_Call) Run(run func(s string)) *Fpdf_GetStringWidth_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_GetStringWidth_Call) Return(_a0 float64) *Fpdf_GetStringWidth_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_GetStringWidth_Call) RunAndReturn(run func(string) float64) *Fpdf_GetStringWidth_Call { + _c.Call.Return(run) + return _c +} + // GetTextColor provides a mock function with given fields: func (_m *Fpdf) GetTextColor() (int, int, int) { ret := _m.Called() var r0 int + var r1 int + var r2 int + if rf, ok := ret.Get(0).(func() (int, int, int)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() int); ok { r0 = rf() } else { r0 = ret.Get(0).(int) } - var r1 int if rf, ok := ret.Get(1).(func() int); ok { r1 = rf() } else { r1 = ret.Get(1).(int) } - var r2 int if rf, ok := ret.Get(2).(func() int); ok { r2 = rf() } else { @@ -670,39 +2395,69 @@ func (_m *Fpdf) GetTextColor() (int, int, int) { return r0, r1, r2 } +// Fpdf_GetTextColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTextColor' +type Fpdf_GetTextColor_Call struct { + *mock.Call +} + +// GetTextColor is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetTextColor() *Fpdf_GetTextColor_Call { + return &Fpdf_GetTextColor_Call{Call: _e.mock.On("GetTextColor")} +} + +func (_c *Fpdf_GetTextColor_Call) Run(run func()) *Fpdf_GetTextColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetTextColor_Call) Return(_a0 int, _a1 int, _a2 int) *Fpdf_GetTextColor_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *Fpdf_GetTextColor_Call) RunAndReturn(run func() (int, int, int)) *Fpdf_GetTextColor_Call { + _c.Call.Return(run) + return _c +} + // GetTextSpotColor provides a mock function with given fields: func (_m *Fpdf) GetTextSpotColor() (string, byte, byte, byte, byte) { ret := _m.Called() var r0 string + var r1 byte + var r2 byte + var r3 byte + var r4 byte + if rf, ok := ret.Get(0).(func() (string, byte, byte, byte, byte)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() string); ok { r0 = rf() } else { r0 = ret.Get(0).(string) } - var r1 byte if rf, ok := ret.Get(1).(func() byte); ok { r1 = rf() } else { r1 = ret.Get(1).(byte) } - var r2 byte if rf, ok := ret.Get(2).(func() byte); ok { r2 = rf() } else { r2 = ret.Get(2).(byte) } - var r3 byte if rf, ok := ret.Get(3).(func() byte); ok { r3 = rf() } else { r3 = ret.Get(3).(byte) } - var r4 byte if rf, ok := ret.Get(4).(func() byte); ok { r4 = rf() } else { @@ -712,6 +2467,33 @@ func (_m *Fpdf) GetTextSpotColor() (string, byte, byte, byte, byte) { return r0, r1, r2, r3, r4 } +// Fpdf_GetTextSpotColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTextSpotColor' +type Fpdf_GetTextSpotColor_Call struct { + *mock.Call +} + +// GetTextSpotColor is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetTextSpotColor() *Fpdf_GetTextSpotColor_Call { + return &Fpdf_GetTextSpotColor_Call{Call: _e.mock.On("GetTextSpotColor")} +} + +func (_c *Fpdf_GetTextSpotColor_Call) Run(run func()) *Fpdf_GetTextSpotColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetTextSpotColor_Call) Return(name string, c byte, m byte, y byte, k byte) *Fpdf_GetTextSpotColor_Call { + _c.Call.Return(name, c, m, y, k) + return _c +} + +func (_c *Fpdf_GetTextSpotColor_Call) RunAndReturn(run func() (string, byte, byte, byte, byte)) *Fpdf_GetTextSpotColor_Call { + _c.Call.Return(run) + return _c +} + // GetX provides a mock function with given fields: func (_m *Fpdf) GetX() float64 { ret := _m.Called() @@ -726,18 +2508,48 @@ func (_m *Fpdf) GetX() float64 { return r0 } +// Fpdf_GetX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetX' +type Fpdf_GetX_Call struct { + *mock.Call +} + +// GetX is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetX() *Fpdf_GetX_Call { + return &Fpdf_GetX_Call{Call: _e.mock.On("GetX")} +} + +func (_c *Fpdf_GetX_Call) Run(run func()) *Fpdf_GetX_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetX_Call) Return(_a0 float64) *Fpdf_GetX_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_GetX_Call) RunAndReturn(run func() float64) *Fpdf_GetX_Call { + _c.Call.Return(run) + return _c +} + // GetXY provides a mock function with given fields: func (_m *Fpdf) GetXY() (float64, float64) { ret := _m.Called() var r0 float64 + var r1 float64 + if rf, ok := ret.Get(0).(func() (float64, float64)); ok { + return rf() + } if rf, ok := ret.Get(0).(func() float64); ok { r0 = rf() } else { r0 = ret.Get(0).(float64) } - var r1 float64 if rf, ok := ret.Get(1).(func() float64); ok { r1 = rf() } else { @@ -747,6 +2559,33 @@ func (_m *Fpdf) GetXY() (float64, float64) { return r0, r1 } +// Fpdf_GetXY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetXY' +type Fpdf_GetXY_Call struct { + *mock.Call +} + +// GetXY is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetXY() *Fpdf_GetXY_Call { + return &Fpdf_GetXY_Call{Call: _e.mock.On("GetXY")} +} + +func (_c *Fpdf_GetXY_Call) Run(run func()) *Fpdf_GetXY_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetXY_Call) Return(_a0 float64, _a1 float64) *Fpdf_GetXY_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Fpdf_GetXY_Call) RunAndReturn(run func() (float64, float64)) *Fpdf_GetXY_Call { + _c.Call.Return(run) + return _c +} + // GetY provides a mock function with given fields: func (_m *Fpdf) GetY() float64 { ret := _m.Called() @@ -761,6 +2600,33 @@ func (_m *Fpdf) GetY() float64 { return r0 } +// Fpdf_GetY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetY' +type Fpdf_GetY_Call struct { + *mock.Call +} + +// GetY is a helper method to define mock.On call +func (_e *Fpdf_Expecter) GetY() *Fpdf_GetY_Call { + return &Fpdf_GetY_Call{Call: _e.mock.On("GetY")} +} + +func (_c *Fpdf_GetY_Call) Run(run func()) *Fpdf_GetY_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_GetY_Call) Return(_a0 float64) *Fpdf_GetY_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_GetY_Call) RunAndReturn(run func() float64) *Fpdf_GetY_Call { + _c.Call.Return(run) + return _c +} + // HTMLBasicNew provides a mock function with given fields: func (_m *Fpdf) HTMLBasicNew() gofpdf.HTMLBasicType { ret := _m.Called() @@ -775,9 +2641,72 @@ func (_m *Fpdf) HTMLBasicNew() gofpdf.HTMLBasicType { return r0 } +// Fpdf_HTMLBasicNew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HTMLBasicNew' +type Fpdf_HTMLBasicNew_Call struct { + *mock.Call +} + +// HTMLBasicNew is a helper method to define mock.On call +func (_e *Fpdf_Expecter) HTMLBasicNew() *Fpdf_HTMLBasicNew_Call { + return &Fpdf_HTMLBasicNew_Call{Call: _e.mock.On("HTMLBasicNew")} +} + +func (_c *Fpdf_HTMLBasicNew_Call) Run(run func()) *Fpdf_HTMLBasicNew_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_HTMLBasicNew_Call) Return(html gofpdf.HTMLBasicType) *Fpdf_HTMLBasicNew_Call { + _c.Call.Return(html) + return _c +} + +func (_c *Fpdf_HTMLBasicNew_Call) RunAndReturn(run func() gofpdf.HTMLBasicType) *Fpdf_HTMLBasicNew_Call { + _c.Call.Return(run) + return _c +} + // Image provides a mock function with given fields: imageNameStr, x, y, w, h, flow, tp, link, linkStr func (_m *Fpdf) Image(imageNameStr string, x float64, y float64, w float64, h float64, flow bool, tp string, link int, linkStr string) { - _m.Called("", int(x), int(y), int(w), int(h)) + _m.Called(imageNameStr, x, y, w, h, flow, tp, link, linkStr) +} + +// Fpdf_Image_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Image' +type Fpdf_Image_Call struct { + *mock.Call +} + +// Image is a helper method to define mock.On call +// - imageNameStr string +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - flow bool +// - tp string +// - link int +// - linkStr string +func (_e *Fpdf_Expecter) Image(imageNameStr interface{}, x interface{}, y interface{}, w interface{}, h interface{}, flow interface{}, tp interface{}, link interface{}, linkStr interface{}) *Fpdf_Image_Call { + return &Fpdf_Image_Call{Call: _e.mock.On("Image", imageNameStr, x, y, w, h, flow, tp, link, linkStr)} +} + +func (_c *Fpdf_Image_Call) Run(run func(imageNameStr string, x float64, y float64, w float64, h float64, flow bool, tp string, link int, linkStr string)) *Fpdf_Image_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(bool), args[6].(string), args[7].(int), args[8].(string)) + }) + return _c +} + +func (_c *Fpdf_Image_Call) Return() *Fpdf_Image_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Image_Call) RunAndReturn(run func(string, float64, float64, float64, float64, bool, string, int, string)) *Fpdf_Image_Call { + _c.Call.Return(run) + return _c } // ImageOptions provides a mock function with given fields: imageNameStr, x, y, w, h, flow, options, link, linkStr @@ -785,6 +2714,42 @@ func (_m *Fpdf) ImageOptions(imageNameStr string, x float64, y float64, w float6 _m.Called(imageNameStr, x, y, w, h, flow, options, link, linkStr) } +// Fpdf_ImageOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageOptions' +type Fpdf_ImageOptions_Call struct { + *mock.Call +} + +// ImageOptions is a helper method to define mock.On call +// - imageNameStr string +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - flow bool +// - options gofpdf.ImageOptions +// - link int +// - linkStr string +func (_e *Fpdf_Expecter) ImageOptions(imageNameStr interface{}, x interface{}, y interface{}, w interface{}, h interface{}, flow interface{}, options interface{}, link interface{}, linkStr interface{}) *Fpdf_ImageOptions_Call { + return &Fpdf_ImageOptions_Call{Call: _e.mock.On("ImageOptions", imageNameStr, x, y, w, h, flow, options, link, linkStr)} +} + +func (_c *Fpdf_ImageOptions_Call) Run(run func(imageNameStr string, x float64, y float64, w float64, h float64, flow bool, options gofpdf.ImageOptions, link int, linkStr string)) *Fpdf_ImageOptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64), args[5].(bool), args[6].(gofpdf.ImageOptions), args[7].(int), args[8].(string)) + }) + return _c +} + +func (_c *Fpdf_ImageOptions_Call) Return() *Fpdf_ImageOptions_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_ImageOptions_Call) RunAndReturn(run func(string, float64, float64, float64, float64, bool, gofpdf.ImageOptions, int, string)) *Fpdf_ImageOptions_Call { + _c.Call.Return(run) + return _c +} + // ImageTypeFromMime provides a mock function with given fields: mimeStr func (_m *Fpdf) ImageTypeFromMime(mimeStr string) string { ret := _m.Called(mimeStr) @@ -799,24 +2764,185 @@ func (_m *Fpdf) ImageTypeFromMime(mimeStr string) string { return r0 } +// Fpdf_ImageTypeFromMime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImageTypeFromMime' +type Fpdf_ImageTypeFromMime_Call struct { + *mock.Call +} + +// ImageTypeFromMime is a helper method to define mock.On call +// - mimeStr string +func (_e *Fpdf_Expecter) ImageTypeFromMime(mimeStr interface{}) *Fpdf_ImageTypeFromMime_Call { + return &Fpdf_ImageTypeFromMime_Call{Call: _e.mock.On("ImageTypeFromMime", mimeStr)} +} + +func (_c *Fpdf_ImageTypeFromMime_Call) Run(run func(mimeStr string)) *Fpdf_ImageTypeFromMime_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_ImageTypeFromMime_Call) Return(tp string) *Fpdf_ImageTypeFromMime_Call { + _c.Call.Return(tp) + return _c +} + +func (_c *Fpdf_ImageTypeFromMime_Call) RunAndReturn(run func(string) string) *Fpdf_ImageTypeFromMime_Call { + _c.Call.Return(run) + return _c +} + // Line provides a mock function with given fields: x1, y1, x2, y2 func (_m *Fpdf) Line(x1 float64, y1 float64, x2 float64, y2 float64) { _m.Called(x1, y1, x2, y2) } -// LineTo provides a mock function with given fields: x, y -func (_m *Fpdf) LineTo(x float64, y float64) { - _m.Called(x, y) +// Fpdf_Line_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Line' +type Fpdf_Line_Call struct { + *mock.Call } -// LinearGradient provides a mock function with given fields: x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2 -func (_m *Fpdf) LinearGradient(x float64, y float64, w float64, h float64, r1 int, g1 int, b1 int, r2 int, g2 int, b2 int, x1 float64, y1 float64, x2 float64, y2 float64) { - _m.Called(x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2) +// Line is a helper method to define mock.On call +// - x1 float64 +// - y1 float64 +// - x2 float64 +// - y2 float64 +func (_e *Fpdf_Expecter) Line(x1 interface{}, y1 interface{}, x2 interface{}, y2 interface{}) *Fpdf_Line_Call { + return &Fpdf_Line_Call{Call: _e.mock.On("Line", x1, y1, x2, y2)} } -// Link provides a mock function with given fields: x, y, w, h, link -func (_m *Fpdf) Link(x float64, y float64, w float64, h float64, link int) { - _m.Called(x, y, w, h, link) +func (_c *Fpdf_Line_Call) Run(run func(x1 float64, y1 float64, x2 float64, y2 float64)) *Fpdf_Line_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64)) + }) + return _c +} + +func (_c *Fpdf_Line_Call) Return() *Fpdf_Line_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Line_Call) RunAndReturn(run func(float64, float64, float64, float64)) *Fpdf_Line_Call { + _c.Call.Return(run) + return _c +} + +// LineTo provides a mock function with given fields: x, y +func (_m *Fpdf) LineTo(x float64, y float64) { + _m.Called(x, y) +} + +// Fpdf_LineTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LineTo' +type Fpdf_LineTo_Call struct { + *mock.Call +} + +// LineTo is a helper method to define mock.On call +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) LineTo(x interface{}, y interface{}) *Fpdf_LineTo_Call { + return &Fpdf_LineTo_Call{Call: _e.mock.On("LineTo", x, y)} +} + +func (_c *Fpdf_LineTo_Call) Run(run func(x float64, y float64)) *Fpdf_LineTo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_LineTo_Call) Return() *Fpdf_LineTo_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_LineTo_Call) RunAndReturn(run func(float64, float64)) *Fpdf_LineTo_Call { + _c.Call.Return(run) + return _c +} + +// LinearGradient provides a mock function with given fields: x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2 +func (_m *Fpdf) LinearGradient(x float64, y float64, w float64, h float64, r1 int, g1 int, b1 int, r2 int, g2 int, b2 int, x1 float64, y1 float64, x2 float64, y2 float64) { + _m.Called(x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2) +} + +// Fpdf_LinearGradient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinearGradient' +type Fpdf_LinearGradient_Call struct { + *mock.Call +} + +// LinearGradient is a helper method to define mock.On call +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - r1 int +// - g1 int +// - b1 int +// - r2 int +// - g2 int +// - b2 int +// - x1 float64 +// - y1 float64 +// - x2 float64 +// - y2 float64 +func (_e *Fpdf_Expecter) LinearGradient(x interface{}, y interface{}, w interface{}, h interface{}, r1 interface{}, g1 interface{}, b1 interface{}, r2 interface{}, g2 interface{}, b2 interface{}, x1 interface{}, y1 interface{}, x2 interface{}, y2 interface{}) *Fpdf_LinearGradient_Call { + return &Fpdf_LinearGradient_Call{Call: _e.mock.On("LinearGradient", x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2)} +} + +func (_c *Fpdf_LinearGradient_Call) Run(run func(x float64, y float64, w float64, h float64, r1 int, g1 int, b1 int, r2 int, g2 int, b2 int, x1 float64, y1 float64, x2 float64, y2 float64)) *Fpdf_LinearGradient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(int), args[5].(int), args[6].(int), args[7].(int), args[8].(int), args[9].(int), args[10].(float64), args[11].(float64), args[12].(float64), args[13].(float64)) + }) + return _c +} + +func (_c *Fpdf_LinearGradient_Call) Return() *Fpdf_LinearGradient_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_LinearGradient_Call) RunAndReturn(run func(float64, float64, float64, float64, int, int, int, int, int, int, float64, float64, float64, float64)) *Fpdf_LinearGradient_Call { + _c.Call.Return(run) + return _c +} + +// Link provides a mock function with given fields: x, y, w, h, link +func (_m *Fpdf) Link(x float64, y float64, w float64, h float64, link int) { + _m.Called(x, y, w, h, link) +} + +// Fpdf_Link_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Link' +type Fpdf_Link_Call struct { + *mock.Call +} + +// Link is a helper method to define mock.On call +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - link int +func (_e *Fpdf_Expecter) Link(x interface{}, y interface{}, w interface{}, h interface{}, link interface{}) *Fpdf_Link_Call { + return &Fpdf_Link_Call{Call: _e.mock.On("Link", x, y, w, h, link)} +} + +func (_c *Fpdf_Link_Call) Run(run func(x float64, y float64, w float64, h float64, link int)) *Fpdf_Link_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(int)) + }) + return _c +} + +func (_c *Fpdf_Link_Call) Return() *Fpdf_Link_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Link_Call) RunAndReturn(run func(float64, float64, float64, float64, int)) *Fpdf_Link_Call { + _c.Call.Return(run) + return _c } // LinkString provides a mock function with given fields: x, y, w, h, linkStr @@ -824,21 +2950,143 @@ func (_m *Fpdf) LinkString(x float64, y float64, w float64, h float64, linkStr s _m.Called(x, y, w, h, linkStr) } +// Fpdf_LinkString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkString' +type Fpdf_LinkString_Call struct { + *mock.Call +} + +// LinkString is a helper method to define mock.On call +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - linkStr string +func (_e *Fpdf_Expecter) LinkString(x interface{}, y interface{}, w interface{}, h interface{}, linkStr interface{}) *Fpdf_LinkString_Call { + return &Fpdf_LinkString_Call{Call: _e.mock.On("LinkString", x, y, w, h, linkStr)} +} + +func (_c *Fpdf_LinkString_Call) Run(run func(x float64, y float64, w float64, h float64, linkStr string)) *Fpdf_LinkString_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(string)) + }) + return _c +} + +func (_c *Fpdf_LinkString_Call) Return() *Fpdf_LinkString_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_LinkString_Call) RunAndReturn(run func(float64, float64, float64, float64, string)) *Fpdf_LinkString_Call { + _c.Call.Return(run) + return _c +} + // Ln provides a mock function with given fields: h func (_m *Fpdf) Ln(h float64) { _m.Called(h) } +// Fpdf_Ln_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ln' +type Fpdf_Ln_Call struct { + *mock.Call +} + +// Ln is a helper method to define mock.On call +// - h float64 +func (_e *Fpdf_Expecter) Ln(h interface{}) *Fpdf_Ln_Call { + return &Fpdf_Ln_Call{Call: _e.mock.On("Ln", h)} +} + +func (_c *Fpdf_Ln_Call) Run(run func(h float64)) *Fpdf_Ln_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_Ln_Call) Return() *Fpdf_Ln_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Ln_Call) RunAndReturn(run func(float64)) *Fpdf_Ln_Call { + _c.Call.Return(run) + return _c +} + // MoveTo provides a mock function with given fields: x, y func (_m *Fpdf) MoveTo(x float64, y float64) { _m.Called(x, y) } +// Fpdf_MoveTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MoveTo' +type Fpdf_MoveTo_Call struct { + *mock.Call +} + +// MoveTo is a helper method to define mock.On call +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) MoveTo(x interface{}, y interface{}) *Fpdf_MoveTo_Call { + return &Fpdf_MoveTo_Call{Call: _e.mock.On("MoveTo", x, y)} +} + +func (_c *Fpdf_MoveTo_Call) Run(run func(x float64, y float64)) *Fpdf_MoveTo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_MoveTo_Call) Return() *Fpdf_MoveTo_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_MoveTo_Call) RunAndReturn(run func(float64, float64)) *Fpdf_MoveTo_Call { + _c.Call.Return(run) + return _c +} + // MultiCell provides a mock function with given fields: w, h, txtStr, borderStr, alignStr, fill func (_m *Fpdf) MultiCell(w float64, h float64, txtStr string, borderStr string, alignStr string, fill bool) { _m.Called(w, h, txtStr, borderStr, alignStr, fill) } +// Fpdf_MultiCell_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiCell' +type Fpdf_MultiCell_Call struct { + *mock.Call +} + +// MultiCell is a helper method to define mock.On call +// - w float64 +// - h float64 +// - txtStr string +// - borderStr string +// - alignStr string +// - fill bool +func (_e *Fpdf_Expecter) MultiCell(w interface{}, h interface{}, txtStr interface{}, borderStr interface{}, alignStr interface{}, fill interface{}) *Fpdf_MultiCell_Call { + return &Fpdf_MultiCell_Call{Call: _e.mock.On("MultiCell", w, h, txtStr, borderStr, alignStr, fill)} +} + +func (_c *Fpdf_MultiCell_Call) Run(run func(w float64, h float64, txtStr string, borderStr string, alignStr string, fill bool)) *Fpdf_MultiCell_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(string), args[3].(string), args[4].(string), args[5].(bool)) + }) + return _c +} + +func (_c *Fpdf_MultiCell_Call) Return() *Fpdf_MultiCell_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_MultiCell_Call) RunAndReturn(run func(float64, float64, string, string, string, bool)) *Fpdf_MultiCell_Call { + _c.Call.Return(run) + return _c +} + // Ok provides a mock function with given fields: func (_m *Fpdf) Ok() bool { ret := _m.Called() @@ -853,11 +3101,65 @@ func (_m *Fpdf) Ok() bool { return r0 } +// Fpdf_Ok_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Ok' +type Fpdf_Ok_Call struct { + *mock.Call +} + +// Ok is a helper method to define mock.On call +func (_e *Fpdf_Expecter) Ok() *Fpdf_Ok_Call { + return &Fpdf_Ok_Call{Call: _e.mock.On("Ok")} +} + +func (_c *Fpdf_Ok_Call) Run(run func()) *Fpdf_Ok_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_Ok_Call) Return(_a0 bool) *Fpdf_Ok_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_Ok_Call) RunAndReturn(run func() bool) *Fpdf_Ok_Call { + _c.Call.Return(run) + return _c +} + // OpenLayerPane provides a mock function with given fields: func (_m *Fpdf) OpenLayerPane() { _m.Called() } +// Fpdf_OpenLayerPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenLayerPane' +type Fpdf_OpenLayerPane_Call struct { + *mock.Call +} + +// OpenLayerPane is a helper method to define mock.On call +func (_e *Fpdf_Expecter) OpenLayerPane() *Fpdf_OpenLayerPane_Call { + return &Fpdf_OpenLayerPane_Call{Call: _e.mock.On("OpenLayerPane")} +} + +func (_c *Fpdf_OpenLayerPane_Call) Run(run func()) *Fpdf_OpenLayerPane_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_OpenLayerPane_Call) Return() *Fpdf_OpenLayerPane_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_OpenLayerPane_Call) RunAndReturn(run func()) *Fpdf_OpenLayerPane_Call { + _c.Call.Return(run) + return _c +} + // Output provides a mock function with given fields: w func (_m *Fpdf) Output(w io.Writer) error { ret := _m.Called(w) @@ -872,6 +3174,34 @@ func (_m *Fpdf) Output(w io.Writer) error { return r0 } +// Fpdf_Output_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Output' +type Fpdf_Output_Call struct { + *mock.Call +} + +// Output is a helper method to define mock.On call +// - w io.Writer +func (_e *Fpdf_Expecter) Output(w interface{}) *Fpdf_Output_Call { + return &Fpdf_Output_Call{Call: _e.mock.On("Output", w)} +} + +func (_c *Fpdf_Output_Call) Run(run func(w io.Writer)) *Fpdf_Output_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(io.Writer)) + }) + return _c +} + +func (_c *Fpdf_Output_Call) Return(_a0 error) *Fpdf_Output_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_Output_Call) RunAndReturn(run func(io.Writer) error) *Fpdf_Output_Call { + _c.Call.Return(run) + return _c +} + // OutputAndClose provides a mock function with given fields: w func (_m *Fpdf) OutputAndClose(w io.WriteCloser) error { ret := _m.Called(w) @@ -886,6 +3216,34 @@ func (_m *Fpdf) OutputAndClose(w io.WriteCloser) error { return r0 } +// Fpdf_OutputAndClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OutputAndClose' +type Fpdf_OutputAndClose_Call struct { + *mock.Call +} + +// OutputAndClose is a helper method to define mock.On call +// - w io.WriteCloser +func (_e *Fpdf_Expecter) OutputAndClose(w interface{}) *Fpdf_OutputAndClose_Call { + return &Fpdf_OutputAndClose_Call{Call: _e.mock.On("OutputAndClose", w)} +} + +func (_c *Fpdf_OutputAndClose_Call) Run(run func(w io.WriteCloser)) *Fpdf_OutputAndClose_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(io.WriteCloser)) + }) + return _c +} + +func (_c *Fpdf_OutputAndClose_Call) Return(_a0 error) *Fpdf_OutputAndClose_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_OutputAndClose_Call) RunAndReturn(run func(io.WriteCloser) error) *Fpdf_OutputAndClose_Call { + _c.Call.Return(run) + return _c +} + // OutputFileAndClose provides a mock function with given fields: fileStr func (_m *Fpdf) OutputFileAndClose(fileStr string) error { ret := _m.Called(fileStr) @@ -900,6 +3258,34 @@ func (_m *Fpdf) OutputFileAndClose(fileStr string) error { return r0 } +// Fpdf_OutputFileAndClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OutputFileAndClose' +type Fpdf_OutputFileAndClose_Call struct { + *mock.Call +} + +// OutputFileAndClose is a helper method to define mock.On call +// - fileStr string +func (_e *Fpdf_Expecter) OutputFileAndClose(fileStr interface{}) *Fpdf_OutputFileAndClose_Call { + return &Fpdf_OutputFileAndClose_Call{Call: _e.mock.On("OutputFileAndClose", fileStr)} +} + +func (_c *Fpdf_OutputFileAndClose_Call) Run(run func(fileStr string)) *Fpdf_OutputFileAndClose_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_OutputFileAndClose_Call) Return(_a0 error) *Fpdf_OutputFileAndClose_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_OutputFileAndClose_Call) RunAndReturn(run func(string) error) *Fpdf_OutputFileAndClose_Call { + _c.Call.Return(run) + return _c +} + // PageCount provides a mock function with given fields: func (_m *Fpdf) PageCount() int { ret := _m.Called() @@ -914,6 +3300,33 @@ func (_m *Fpdf) PageCount() int { return r0 } +// Fpdf_PageCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PageCount' +type Fpdf_PageCount_Call struct { + *mock.Call +} + +// PageCount is a helper method to define mock.On call +func (_e *Fpdf_Expecter) PageCount() *Fpdf_PageCount_Call { + return &Fpdf_PageCount_Call{Call: _e.mock.On("PageCount")} +} + +func (_c *Fpdf_PageCount_Call) Run(run func()) *Fpdf_PageCount_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_PageCount_Call) Return(_a0 int) *Fpdf_PageCount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_PageCount_Call) RunAndReturn(run func() int) *Fpdf_PageCount_Call { + _c.Call.Return(run) + return _c +} + // PageNo provides a mock function with given fields: func (_m *Fpdf) PageNo() int { ret := _m.Called() @@ -928,25 +3341,55 @@ func (_m *Fpdf) PageNo() int { return r0 } +// Fpdf_PageNo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PageNo' +type Fpdf_PageNo_Call struct { + *mock.Call +} + +// PageNo is a helper method to define mock.On call +func (_e *Fpdf_Expecter) PageNo() *Fpdf_PageNo_Call { + return &Fpdf_PageNo_Call{Call: _e.mock.On("PageNo")} +} + +func (_c *Fpdf_PageNo_Call) Run(run func()) *Fpdf_PageNo_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_PageNo_Call) Return(_a0 int) *Fpdf_PageNo_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_PageNo_Call) RunAndReturn(run func() int) *Fpdf_PageNo_Call { + _c.Call.Return(run) + return _c +} + // PageSize provides a mock function with given fields: pageNum func (_m *Fpdf) PageSize(pageNum int) (float64, float64, string) { ret := _m.Called(pageNum) var r0 float64 + var r1 float64 + var r2 string + if rf, ok := ret.Get(0).(func(int) (float64, float64, string)); ok { + return rf(pageNum) + } if rf, ok := ret.Get(0).(func(int) float64); ok { r0 = rf(pageNum) } else { r0 = ret.Get(0).(float64) } - var r1 float64 if rf, ok := ret.Get(1).(func(int) float64); ok { r1 = rf(pageNum) } else { r1 = ret.Get(1).(float64) } - var r2 string if rf, ok := ret.Get(2).(func(int) string); ok { r2 = rf(pageNum) } else { @@ -956,6 +3399,34 @@ func (_m *Fpdf) PageSize(pageNum int) (float64, float64, string) { return r0, r1, r2 } +// Fpdf_PageSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PageSize' +type Fpdf_PageSize_Call struct { + *mock.Call +} + +// PageSize is a helper method to define mock.On call +// - pageNum int +func (_e *Fpdf_Expecter) PageSize(pageNum interface{}) *Fpdf_PageSize_Call { + return &Fpdf_PageSize_Call{Call: _e.mock.On("PageSize", pageNum)} +} + +func (_c *Fpdf_PageSize_Call) Run(run func(pageNum int)) *Fpdf_PageSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *Fpdf_PageSize_Call) Return(wd float64, ht float64, unitStr string) *Fpdf_PageSize_Call { + _c.Call.Return(wd, ht, unitStr) + return _c +} + +func (_c *Fpdf_PageSize_Call) RunAndReturn(run func(int) (float64, float64, string)) *Fpdf_PageSize_Call { + _c.Call.Return(run) + return _c +} + // PointConvert provides a mock function with given fields: pt func (_m *Fpdf) PointConvert(pt float64) float64 { ret := _m.Called(pt) @@ -970,6 +3441,34 @@ func (_m *Fpdf) PointConvert(pt float64) float64 { return r0 } +// Fpdf_PointConvert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PointConvert' +type Fpdf_PointConvert_Call struct { + *mock.Call +} + +// PointConvert is a helper method to define mock.On call +// - pt float64 +func (_e *Fpdf_Expecter) PointConvert(pt interface{}) *Fpdf_PointConvert_Call { + return &Fpdf_PointConvert_Call{Call: _e.mock.On("PointConvert", pt)} +} + +func (_c *Fpdf_PointConvert_Call) Run(run func(pt float64)) *Fpdf_PointConvert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_PointConvert_Call) Return(u float64) *Fpdf_PointConvert_Call { + _c.Call.Return(u) + return _c +} + +func (_c *Fpdf_PointConvert_Call) RunAndReturn(run func(float64) float64) *Fpdf_PointConvert_Call { + _c.Call.Return(run) + return _c +} + // PointToUnitConvert provides a mock function with given fields: pt func (_m *Fpdf) PointToUnitConvert(pt float64) float64 { ret := _m.Called(pt) @@ -984,36 +3483,252 @@ func (_m *Fpdf) PointToUnitConvert(pt float64) float64 { return r0 } +// Fpdf_PointToUnitConvert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PointToUnitConvert' +type Fpdf_PointToUnitConvert_Call struct { + *mock.Call +} + +// PointToUnitConvert is a helper method to define mock.On call +// - pt float64 +func (_e *Fpdf_Expecter) PointToUnitConvert(pt interface{}) *Fpdf_PointToUnitConvert_Call { + return &Fpdf_PointToUnitConvert_Call{Call: _e.mock.On("PointToUnitConvert", pt)} +} + +func (_c *Fpdf_PointToUnitConvert_Call) Run(run func(pt float64)) *Fpdf_PointToUnitConvert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_PointToUnitConvert_Call) Return(u float64) *Fpdf_PointToUnitConvert_Call { + _c.Call.Return(u) + return _c +} + +func (_c *Fpdf_PointToUnitConvert_Call) RunAndReturn(run func(float64) float64) *Fpdf_PointToUnitConvert_Call { + _c.Call.Return(run) + return _c +} + // Polygon provides a mock function with given fields: points, styleStr func (_m *Fpdf) Polygon(points []gofpdf.PointType, styleStr string) { _m.Called(points, styleStr) } +// Fpdf_Polygon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Polygon' +type Fpdf_Polygon_Call struct { + *mock.Call +} + +// Polygon is a helper method to define mock.On call +// - points []gofpdf.PointType +// - styleStr string +func (_e *Fpdf_Expecter) Polygon(points interface{}, styleStr interface{}) *Fpdf_Polygon_Call { + return &Fpdf_Polygon_Call{Call: _e.mock.On("Polygon", points, styleStr)} +} + +func (_c *Fpdf_Polygon_Call) Run(run func(points []gofpdf.PointType, styleStr string)) *Fpdf_Polygon_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]gofpdf.PointType), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_Polygon_Call) Return() *Fpdf_Polygon_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Polygon_Call) RunAndReturn(run func([]gofpdf.PointType, string)) *Fpdf_Polygon_Call { + _c.Call.Return(run) + return _c +} + // RadialGradient provides a mock function with given fields: x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2, r func (_m *Fpdf) RadialGradient(x float64, y float64, w float64, h float64, r1 int, g1 int, b1 int, r2 int, g2 int, b2 int, x1 float64, y1 float64, x2 float64, y2 float64, r float64) { _m.Called(x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2, r) } +// Fpdf_RadialGradient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RadialGradient' +type Fpdf_RadialGradient_Call struct { + *mock.Call +} + +// RadialGradient is a helper method to define mock.On call +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - r1 int +// - g1 int +// - b1 int +// - r2 int +// - g2 int +// - b2 int +// - x1 float64 +// - y1 float64 +// - x2 float64 +// - y2 float64 +// - r float64 +func (_e *Fpdf_Expecter) RadialGradient(x interface{}, y interface{}, w interface{}, h interface{}, r1 interface{}, g1 interface{}, b1 interface{}, r2 interface{}, g2 interface{}, b2 interface{}, x1 interface{}, y1 interface{}, x2 interface{}, y2 interface{}, r interface{}) *Fpdf_RadialGradient_Call { + return &Fpdf_RadialGradient_Call{Call: _e.mock.On("RadialGradient", x, y, w, h, r1, g1, b1, r2, g2, b2, x1, y1, x2, y2, r)} +} + +func (_c *Fpdf_RadialGradient_Call) Run(run func(x float64, y float64, w float64, h float64, r1 int, g1 int, b1 int, r2 int, g2 int, b2 int, x1 float64, y1 float64, x2 float64, y2 float64, r float64)) *Fpdf_RadialGradient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(int), args[5].(int), args[6].(int), args[7].(int), args[8].(int), args[9].(int), args[10].(float64), args[11].(float64), args[12].(float64), args[13].(float64), args[14].(float64)) + }) + return _c +} + +func (_c *Fpdf_RadialGradient_Call) Return() *Fpdf_RadialGradient_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_RadialGradient_Call) RunAndReturn(run func(float64, float64, float64, float64, int, int, int, int, int, int, float64, float64, float64, float64, float64)) *Fpdf_RadialGradient_Call { + _c.Call.Return(run) + return _c +} + // RawWriteBuf provides a mock function with given fields: r func (_m *Fpdf) RawWriteBuf(r io.Reader) { _m.Called(r) } +// Fpdf_RawWriteBuf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RawWriteBuf' +type Fpdf_RawWriteBuf_Call struct { + *mock.Call +} + +// RawWriteBuf is a helper method to define mock.On call +// - r io.Reader +func (_e *Fpdf_Expecter) RawWriteBuf(r interface{}) *Fpdf_RawWriteBuf_Call { + return &Fpdf_RawWriteBuf_Call{Call: _e.mock.On("RawWriteBuf", r)} +} + +func (_c *Fpdf_RawWriteBuf_Call) Run(run func(r io.Reader)) *Fpdf_RawWriteBuf_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(io.Reader)) + }) + return _c +} + +func (_c *Fpdf_RawWriteBuf_Call) Return() *Fpdf_RawWriteBuf_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_RawWriteBuf_Call) RunAndReturn(run func(io.Reader)) *Fpdf_RawWriteBuf_Call { + _c.Call.Return(run) + return _c +} + // RawWriteStr provides a mock function with given fields: str func (_m *Fpdf) RawWriteStr(str string) { _m.Called(str) } +// Fpdf_RawWriteStr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RawWriteStr' +type Fpdf_RawWriteStr_Call struct { + *mock.Call +} + +// RawWriteStr is a helper method to define mock.On call +// - str string +func (_e *Fpdf_Expecter) RawWriteStr(str interface{}) *Fpdf_RawWriteStr_Call { + return &Fpdf_RawWriteStr_Call{Call: _e.mock.On("RawWriteStr", str)} +} + +func (_c *Fpdf_RawWriteStr_Call) Run(run func(str string)) *Fpdf_RawWriteStr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_RawWriteStr_Call) Return() *Fpdf_RawWriteStr_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_RawWriteStr_Call) RunAndReturn(run func(string)) *Fpdf_RawWriteStr_Call { + _c.Call.Return(run) + return _c +} + // Rect provides a mock function with given fields: x, y, w, h, styleStr func (_m *Fpdf) Rect(x float64, y float64, w float64, h float64, styleStr string) { _m.Called(x, y, w, h, styleStr) } +// Fpdf_Rect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Rect' +type Fpdf_Rect_Call struct { + *mock.Call +} + +// Rect is a helper method to define mock.On call +// - x float64 +// - y float64 +// - w float64 +// - h float64 +// - styleStr string +func (_e *Fpdf_Expecter) Rect(x interface{}, y interface{}, w interface{}, h interface{}, styleStr interface{}) *Fpdf_Rect_Call { + return &Fpdf_Rect_Call{Call: _e.mock.On("Rect", x, y, w, h, styleStr)} +} + +func (_c *Fpdf_Rect_Call) Run(run func(x float64, y float64, w float64, h float64, styleStr string)) *Fpdf_Rect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(string)) + }) + return _c +} + +func (_c *Fpdf_Rect_Call) Return() *Fpdf_Rect_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Rect_Call) RunAndReturn(run func(float64, float64, float64, float64, string)) *Fpdf_Rect_Call { + _c.Call.Return(run) + return _c +} + // RegisterAlias provides a mock function with given fields: alias, replacement func (_m *Fpdf) RegisterAlias(alias string, replacement string) { _m.Called(alias, replacement) } +// Fpdf_RegisterAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAlias' +type Fpdf_RegisterAlias_Call struct { + *mock.Call +} + +// RegisterAlias is a helper method to define mock.On call +// - alias string +// - replacement string +func (_e *Fpdf_Expecter) RegisterAlias(alias interface{}, replacement interface{}) *Fpdf_RegisterAlias_Call { + return &Fpdf_RegisterAlias_Call{Call: _e.mock.On("RegisterAlias", alias, replacement)} +} + +func (_c *Fpdf_RegisterAlias_Call) Run(run func(alias string, replacement string)) *Fpdf_RegisterAlias_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_RegisterAlias_Call) Return() *Fpdf_RegisterAlias_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_RegisterAlias_Call) RunAndReturn(run func(string, string)) *Fpdf_RegisterAlias_Call { + _c.Call.Return(run) + return _c +} + // RegisterImage provides a mock function with given fields: fileStr, tp func (_m *Fpdf) RegisterImage(fileStr string, tp string) *gofpdf.ImageInfoType { ret := _m.Called(fileStr, tp) @@ -1030,8 +3745,37 @@ func (_m *Fpdf) RegisterImage(fileStr string, tp string) *gofpdf.ImageInfoType { return r0 } -// RegisterImageOptions provides a mock function with given fields: fileStr, options -func (_m *Fpdf) RegisterImageOptions(fileStr string, options gofpdf.ImageOptions) *gofpdf.ImageInfoType { +// Fpdf_RegisterImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterImage' +type Fpdf_RegisterImage_Call struct { + *mock.Call +} + +// RegisterImage is a helper method to define mock.On call +// - fileStr string +// - tp string +func (_e *Fpdf_Expecter) RegisterImage(fileStr interface{}, tp interface{}) *Fpdf_RegisterImage_Call { + return &Fpdf_RegisterImage_Call{Call: _e.mock.On("RegisterImage", fileStr, tp)} +} + +func (_c *Fpdf_RegisterImage_Call) Run(run func(fileStr string, tp string)) *Fpdf_RegisterImage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_RegisterImage_Call) Return(info *gofpdf.ImageInfoType) *Fpdf_RegisterImage_Call { + _c.Call.Return(info) + return _c +} + +func (_c *Fpdf_RegisterImage_Call) RunAndReturn(run func(string, string) *gofpdf.ImageInfoType) *Fpdf_RegisterImage_Call { + _c.Call.Return(run) + return _c +} + +// RegisterImageOptions provides a mock function with given fields: fileStr, options +func (_m *Fpdf) RegisterImageOptions(fileStr string, options gofpdf.ImageOptions) *gofpdf.ImageInfoType { ret := _m.Called(fileStr, options) var r0 *gofpdf.ImageInfoType @@ -1046,9 +3790,38 @@ func (_m *Fpdf) RegisterImageOptions(fileStr string, options gofpdf.ImageOptions return r0 } +// Fpdf_RegisterImageOptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterImageOptions' +type Fpdf_RegisterImageOptions_Call struct { + *mock.Call +} + +// RegisterImageOptions is a helper method to define mock.On call +// - fileStr string +// - options gofpdf.ImageOptions +func (_e *Fpdf_Expecter) RegisterImageOptions(fileStr interface{}, options interface{}) *Fpdf_RegisterImageOptions_Call { + return &Fpdf_RegisterImageOptions_Call{Call: _e.mock.On("RegisterImageOptions", fileStr, options)} +} + +func (_c *Fpdf_RegisterImageOptions_Call) Run(run func(fileStr string, options gofpdf.ImageOptions)) *Fpdf_RegisterImageOptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(gofpdf.ImageOptions)) + }) + return _c +} + +func (_c *Fpdf_RegisterImageOptions_Call) Return(info *gofpdf.ImageInfoType) *Fpdf_RegisterImageOptions_Call { + _c.Call.Return(info) + return _c +} + +func (_c *Fpdf_RegisterImageOptions_Call) RunAndReturn(run func(string, gofpdf.ImageOptions) *gofpdf.ImageInfoType) *Fpdf_RegisterImageOptions_Call { + _c.Call.Return(run) + return _c +} + // RegisterImageOptionsReader provides a mock function with given fields: imgName, options, r func (_m *Fpdf) RegisterImageOptionsReader(imgName string, options gofpdf.ImageOptions, r io.Reader) *gofpdf.ImageInfoType { - ret := _m.Called("", options, "") + ret := _m.Called(imgName, options, r) var r0 *gofpdf.ImageInfoType if rf, ok := ret.Get(0).(func(string, gofpdf.ImageOptions, io.Reader) *gofpdf.ImageInfoType); ok { @@ -1062,6 +3835,36 @@ func (_m *Fpdf) RegisterImageOptionsReader(imgName string, options gofpdf.ImageO return r0 } +// Fpdf_RegisterImageOptionsReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterImageOptionsReader' +type Fpdf_RegisterImageOptionsReader_Call struct { + *mock.Call +} + +// RegisterImageOptionsReader is a helper method to define mock.On call +// - imgName string +// - options gofpdf.ImageOptions +// - r io.Reader +func (_e *Fpdf_Expecter) RegisterImageOptionsReader(imgName interface{}, options interface{}, r interface{}) *Fpdf_RegisterImageOptionsReader_Call { + return &Fpdf_RegisterImageOptionsReader_Call{Call: _e.mock.On("RegisterImageOptionsReader", imgName, options, r)} +} + +func (_c *Fpdf_RegisterImageOptionsReader_Call) Run(run func(imgName string, options gofpdf.ImageOptions, r io.Reader)) *Fpdf_RegisterImageOptionsReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(gofpdf.ImageOptions), args[2].(io.Reader)) + }) + return _c +} + +func (_c *Fpdf_RegisterImageOptionsReader_Call) Return(info *gofpdf.ImageInfoType) *Fpdf_RegisterImageOptionsReader_Call { + _c.Call.Return(info) + return _c +} + +func (_c *Fpdf_RegisterImageOptionsReader_Call) RunAndReturn(run func(string, gofpdf.ImageOptions, io.Reader) *gofpdf.ImageInfoType) *Fpdf_RegisterImageOptionsReader_Call { + _c.Call.Return(run) + return _c +} + // RegisterImageReader provides a mock function with given fields: imgName, tp, r func (_m *Fpdf) RegisterImageReader(imgName string, tp string, r io.Reader) *gofpdf.ImageInfoType { ret := _m.Called(imgName, tp, r) @@ -1078,81 +3881,541 @@ func (_m *Fpdf) RegisterImageReader(imgName string, tp string, r io.Reader) *gof return r0 } +// Fpdf_RegisterImageReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterImageReader' +type Fpdf_RegisterImageReader_Call struct { + *mock.Call +} + +// RegisterImageReader is a helper method to define mock.On call +// - imgName string +// - tp string +// - r io.Reader +func (_e *Fpdf_Expecter) RegisterImageReader(imgName interface{}, tp interface{}, r interface{}) *Fpdf_RegisterImageReader_Call { + return &Fpdf_RegisterImageReader_Call{Call: _e.mock.On("RegisterImageReader", imgName, tp, r)} +} + +func (_c *Fpdf_RegisterImageReader_Call) Run(run func(imgName string, tp string, r io.Reader)) *Fpdf_RegisterImageReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(io.Reader)) + }) + return _c +} + +func (_c *Fpdf_RegisterImageReader_Call) Return(info *gofpdf.ImageInfoType) *Fpdf_RegisterImageReader_Call { + _c.Call.Return(info) + return _c +} + +func (_c *Fpdf_RegisterImageReader_Call) RunAndReturn(run func(string, string, io.Reader) *gofpdf.ImageInfoType) *Fpdf_RegisterImageReader_Call { + _c.Call.Return(run) + return _c +} + // SVGBasicWrite provides a mock function with given fields: sb, scale func (_m *Fpdf) SVGBasicWrite(sb *gofpdf.SVGBasicType, scale float64) { _m.Called(sb, scale) } +// Fpdf_SVGBasicWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SVGBasicWrite' +type Fpdf_SVGBasicWrite_Call struct { + *mock.Call +} + +// SVGBasicWrite is a helper method to define mock.On call +// - sb *gofpdf.SVGBasicType +// - scale float64 +func (_e *Fpdf_Expecter) SVGBasicWrite(sb interface{}, scale interface{}) *Fpdf_SVGBasicWrite_Call { + return &Fpdf_SVGBasicWrite_Call{Call: _e.mock.On("SVGBasicWrite", sb, scale)} +} + +func (_c *Fpdf_SVGBasicWrite_Call) Run(run func(sb *gofpdf.SVGBasicType, scale float64)) *Fpdf_SVGBasicWrite_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*gofpdf.SVGBasicType), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_SVGBasicWrite_Call) Return() *Fpdf_SVGBasicWrite_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SVGBasicWrite_Call) RunAndReturn(run func(*gofpdf.SVGBasicType, float64)) *Fpdf_SVGBasicWrite_Call { + _c.Call.Return(run) + return _c +} + // SetAcceptPageBreakFunc provides a mock function with given fields: fnc func (_m *Fpdf) SetAcceptPageBreakFunc(fnc func() bool) { _m.Called(fnc) } +// Fpdf_SetAcceptPageBreakFunc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAcceptPageBreakFunc' +type Fpdf_SetAcceptPageBreakFunc_Call struct { + *mock.Call +} + +// SetAcceptPageBreakFunc is a helper method to define mock.On call +// - fnc func() bool +func (_e *Fpdf_Expecter) SetAcceptPageBreakFunc(fnc interface{}) *Fpdf_SetAcceptPageBreakFunc_Call { + return &Fpdf_SetAcceptPageBreakFunc_Call{Call: _e.mock.On("SetAcceptPageBreakFunc", fnc)} +} + +func (_c *Fpdf_SetAcceptPageBreakFunc_Call) Run(run func(fnc func() bool)) *Fpdf_SetAcceptPageBreakFunc_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func() bool)) + }) + return _c +} + +func (_c *Fpdf_SetAcceptPageBreakFunc_Call) Return() *Fpdf_SetAcceptPageBreakFunc_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetAcceptPageBreakFunc_Call) RunAndReturn(run func(func() bool)) *Fpdf_SetAcceptPageBreakFunc_Call { + _c.Call.Return(run) + return _c +} + // SetAlpha provides a mock function with given fields: alpha, blendModeStr func (_m *Fpdf) SetAlpha(alpha float64, blendModeStr string) { _m.Called(alpha, blendModeStr) } +// Fpdf_SetAlpha_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAlpha' +type Fpdf_SetAlpha_Call struct { + *mock.Call +} + +// SetAlpha is a helper method to define mock.On call +// - alpha float64 +// - blendModeStr string +func (_e *Fpdf_Expecter) SetAlpha(alpha interface{}, blendModeStr interface{}) *Fpdf_SetAlpha_Call { + return &Fpdf_SetAlpha_Call{Call: _e.mock.On("SetAlpha", alpha, blendModeStr)} +} + +func (_c *Fpdf_SetAlpha_Call) Run(run func(alpha float64, blendModeStr string)) *Fpdf_SetAlpha_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_SetAlpha_Call) Return() *Fpdf_SetAlpha_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetAlpha_Call) RunAndReturn(run func(float64, string)) *Fpdf_SetAlpha_Call { + _c.Call.Return(run) + return _c +} + // SetAuthor provides a mock function with given fields: authorStr, isUTF8 func (_m *Fpdf) SetAuthor(authorStr string, isUTF8 bool) { _m.Called(authorStr, isUTF8) } +// Fpdf_SetAuthor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAuthor' +type Fpdf_SetAuthor_Call struct { + *mock.Call +} + +// SetAuthor is a helper method to define mock.On call +// - authorStr string +// - isUTF8 bool +func (_e *Fpdf_Expecter) SetAuthor(authorStr interface{}, isUTF8 interface{}) *Fpdf_SetAuthor_Call { + return &Fpdf_SetAuthor_Call{Call: _e.mock.On("SetAuthor", authorStr, isUTF8)} +} + +func (_c *Fpdf_SetAuthor_Call) Run(run func(authorStr string, isUTF8 bool)) *Fpdf_SetAuthor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetAuthor_Call) Return() *Fpdf_SetAuthor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetAuthor_Call) RunAndReturn(run func(string, bool)) *Fpdf_SetAuthor_Call { + _c.Call.Return(run) + return _c +} + // SetAutoPageBreak provides a mock function with given fields: auto, margin func (_m *Fpdf) SetAutoPageBreak(auto bool, margin float64) { _m.Called(auto, margin) } +// Fpdf_SetAutoPageBreak_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAutoPageBreak' +type Fpdf_SetAutoPageBreak_Call struct { + *mock.Call +} + +// SetAutoPageBreak is a helper method to define mock.On call +// - auto bool +// - margin float64 +func (_e *Fpdf_Expecter) SetAutoPageBreak(auto interface{}, margin interface{}) *Fpdf_SetAutoPageBreak_Call { + return &Fpdf_SetAutoPageBreak_Call{Call: _e.mock.On("SetAutoPageBreak", auto, margin)} +} + +func (_c *Fpdf_SetAutoPageBreak_Call) Run(run func(auto bool, margin float64)) *Fpdf_SetAutoPageBreak_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetAutoPageBreak_Call) Return() *Fpdf_SetAutoPageBreak_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetAutoPageBreak_Call) RunAndReturn(run func(bool, float64)) *Fpdf_SetAutoPageBreak_Call { + _c.Call.Return(run) + return _c +} + // SetCatalogSort provides a mock function with given fields: flag func (_m *Fpdf) SetCatalogSort(flag bool) { _m.Called(flag) } +// Fpdf_SetCatalogSort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCatalogSort' +type Fpdf_SetCatalogSort_Call struct { + *mock.Call +} + +// SetCatalogSort is a helper method to define mock.On call +// - flag bool +func (_e *Fpdf_Expecter) SetCatalogSort(flag interface{}) *Fpdf_SetCatalogSort_Call { + return &Fpdf_SetCatalogSort_Call{Call: _e.mock.On("SetCatalogSort", flag)} +} + +func (_c *Fpdf_SetCatalogSort_Call) Run(run func(flag bool)) *Fpdf_SetCatalogSort_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetCatalogSort_Call) Return() *Fpdf_SetCatalogSort_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetCatalogSort_Call) RunAndReturn(run func(bool)) *Fpdf_SetCatalogSort_Call { + _c.Call.Return(run) + return _c +} + // SetCellMargin provides a mock function with given fields: margin func (_m *Fpdf) SetCellMargin(margin float64) { _m.Called(margin) } +// Fpdf_SetCellMargin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCellMargin' +type Fpdf_SetCellMargin_Call struct { + *mock.Call +} + +// SetCellMargin is a helper method to define mock.On call +// - margin float64 +func (_e *Fpdf_Expecter) SetCellMargin(margin interface{}) *Fpdf_SetCellMargin_Call { + return &Fpdf_SetCellMargin_Call{Call: _e.mock.On("SetCellMargin", margin)} +} + +func (_c *Fpdf_SetCellMargin_Call) Run(run func(margin float64)) *Fpdf_SetCellMargin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetCellMargin_Call) Return() *Fpdf_SetCellMargin_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetCellMargin_Call) RunAndReturn(run func(float64)) *Fpdf_SetCellMargin_Call { + _c.Call.Return(run) + return _c +} + // SetCompression provides a mock function with given fields: compress func (_m *Fpdf) SetCompression(compress bool) { _m.Called(compress) } +// Fpdf_SetCompression_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCompression' +type Fpdf_SetCompression_Call struct { + *mock.Call +} + +// SetCompression is a helper method to define mock.On call +// - compress bool +func (_e *Fpdf_Expecter) SetCompression(compress interface{}) *Fpdf_SetCompression_Call { + return &Fpdf_SetCompression_Call{Call: _e.mock.On("SetCompression", compress)} +} + +func (_c *Fpdf_SetCompression_Call) Run(run func(compress bool)) *Fpdf_SetCompression_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetCompression_Call) Return() *Fpdf_SetCompression_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetCompression_Call) RunAndReturn(run func(bool)) *Fpdf_SetCompression_Call { + _c.Call.Return(run) + return _c +} + // SetCreationDate provides a mock function with given fields: tm func (_m *Fpdf) SetCreationDate(tm time.Time) { _m.Called(tm) } +// Fpdf_SetCreationDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCreationDate' +type Fpdf_SetCreationDate_Call struct { + *mock.Call +} + +// SetCreationDate is a helper method to define mock.On call +// - tm time.Time +func (_e *Fpdf_Expecter) SetCreationDate(tm interface{}) *Fpdf_SetCreationDate_Call { + return &Fpdf_SetCreationDate_Call{Call: _e.mock.On("SetCreationDate", tm)} +} + +func (_c *Fpdf_SetCreationDate_Call) Run(run func(tm time.Time)) *Fpdf_SetCreationDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(time.Time)) + }) + return _c +} + +func (_c *Fpdf_SetCreationDate_Call) Return() *Fpdf_SetCreationDate_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetCreationDate_Call) RunAndReturn(run func(time.Time)) *Fpdf_SetCreationDate_Call { + _c.Call.Return(run) + return _c +} + // SetCreator provides a mock function with given fields: creatorStr, isUTF8 func (_m *Fpdf) SetCreator(creatorStr string, isUTF8 bool) { _m.Called(creatorStr, isUTF8) } +// Fpdf_SetCreator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCreator' +type Fpdf_SetCreator_Call struct { + *mock.Call +} + +// SetCreator is a helper method to define mock.On call +// - creatorStr string +// - isUTF8 bool +func (_e *Fpdf_Expecter) SetCreator(creatorStr interface{}, isUTF8 interface{}) *Fpdf_SetCreator_Call { + return &Fpdf_SetCreator_Call{Call: _e.mock.On("SetCreator", creatorStr, isUTF8)} +} + +func (_c *Fpdf_SetCreator_Call) Run(run func(creatorStr string, isUTF8 bool)) *Fpdf_SetCreator_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetCreator_Call) Return() *Fpdf_SetCreator_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetCreator_Call) RunAndReturn(run func(string, bool)) *Fpdf_SetCreator_Call { + _c.Call.Return(run) + return _c +} + // SetDashPattern provides a mock function with given fields: dashArray, dashPhase func (_m *Fpdf) SetDashPattern(dashArray []float64, dashPhase float64) { _m.Called(dashArray, dashPhase) } +// Fpdf_SetDashPattern_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDashPattern' +type Fpdf_SetDashPattern_Call struct { + *mock.Call +} + +// SetDashPattern is a helper method to define mock.On call +// - dashArray []float64 +// - dashPhase float64 +func (_e *Fpdf_Expecter) SetDashPattern(dashArray interface{}, dashPhase interface{}) *Fpdf_SetDashPattern_Call { + return &Fpdf_SetDashPattern_Call{Call: _e.mock.On("SetDashPattern", dashArray, dashPhase)} +} + +func (_c *Fpdf_SetDashPattern_Call) Run(run func(dashArray []float64, dashPhase float64)) *Fpdf_SetDashPattern_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]float64), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetDashPattern_Call) Return() *Fpdf_SetDashPattern_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetDashPattern_Call) RunAndReturn(run func([]float64, float64)) *Fpdf_SetDashPattern_Call { + _c.Call.Return(run) + return _c +} + // SetDisplayMode provides a mock function with given fields: zoomStr, layoutStr func (_m *Fpdf) SetDisplayMode(zoomStr string, layoutStr string) { _m.Called(zoomStr, layoutStr) } +// Fpdf_SetDisplayMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDisplayMode' +type Fpdf_SetDisplayMode_Call struct { + *mock.Call +} + +// SetDisplayMode is a helper method to define mock.On call +// - zoomStr string +// - layoutStr string +func (_e *Fpdf_Expecter) SetDisplayMode(zoomStr interface{}, layoutStr interface{}) *Fpdf_SetDisplayMode_Call { + return &Fpdf_SetDisplayMode_Call{Call: _e.mock.On("SetDisplayMode", zoomStr, layoutStr)} +} + +func (_c *Fpdf_SetDisplayMode_Call) Run(run func(zoomStr string, layoutStr string)) *Fpdf_SetDisplayMode_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_SetDisplayMode_Call) Return() *Fpdf_SetDisplayMode_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetDisplayMode_Call) RunAndReturn(run func(string, string)) *Fpdf_SetDisplayMode_Call { + _c.Call.Return(run) + return _c +} + // SetDrawColor provides a mock function with given fields: r, g, b func (_m *Fpdf) SetDrawColor(r int, g int, b int) { _m.Called(r, g, b) } +// Fpdf_SetDrawColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDrawColor' +type Fpdf_SetDrawColor_Call struct { + *mock.Call +} + +// SetDrawColor is a helper method to define mock.On call +// - r int +// - g int +// - b int +func (_e *Fpdf_Expecter) SetDrawColor(r interface{}, g interface{}, b interface{}) *Fpdf_SetDrawColor_Call { + return &Fpdf_SetDrawColor_Call{Call: _e.mock.On("SetDrawColor", r, g, b)} +} + +func (_c *Fpdf_SetDrawColor_Call) Run(run func(r int, g int, b int)) *Fpdf_SetDrawColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *Fpdf_SetDrawColor_Call) Return() *Fpdf_SetDrawColor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetDrawColor_Call) RunAndReturn(run func(int, int, int)) *Fpdf_SetDrawColor_Call { + _c.Call.Return(run) + return _c +} + // SetDrawSpotColor provides a mock function with given fields: nameStr, tint func (_m *Fpdf) SetDrawSpotColor(nameStr string, tint byte) { _m.Called(nameStr, tint) } +// Fpdf_SetDrawSpotColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDrawSpotColor' +type Fpdf_SetDrawSpotColor_Call struct { + *mock.Call +} + +// SetDrawSpotColor is a helper method to define mock.On call +// - nameStr string +// - tint byte +func (_e *Fpdf_Expecter) SetDrawSpotColor(nameStr interface{}, tint interface{}) *Fpdf_SetDrawSpotColor_Call { + return &Fpdf_SetDrawSpotColor_Call{Call: _e.mock.On("SetDrawSpotColor", nameStr, tint)} +} + +func (_c *Fpdf_SetDrawSpotColor_Call) Run(run func(nameStr string, tint byte)) *Fpdf_SetDrawSpotColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(byte)) + }) + return _c +} + +func (_c *Fpdf_SetDrawSpotColor_Call) Return() *Fpdf_SetDrawSpotColor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetDrawSpotColor_Call) RunAndReturn(run func(string, byte)) *Fpdf_SetDrawSpotColor_Call { + _c.Call.Return(run) + return _c +} + // SetError provides a mock function with given fields: err func (_m *Fpdf) SetError(err error) { _m.Called(err) } +// Fpdf_SetError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetError' +type Fpdf_SetError_Call struct { + *mock.Call +} + +// SetError is a helper method to define mock.On call +// - err error +func (_e *Fpdf_Expecter) SetError(err interface{}) *Fpdf_SetError_Call { + return &Fpdf_SetError_Call{Call: _e.mock.On("SetError", err)} +} + +func (_c *Fpdf_SetError_Call) Run(run func(err error)) *Fpdf_SetError_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(error)) + }) + return _c +} + +func (_c *Fpdf_SetError_Call) Return() *Fpdf_SetError_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetError_Call) RunAndReturn(run func(error)) *Fpdf_SetError_Call { + _c.Call.Return(run) + return _c +} + // SetErrorf provides a mock function with given fields: fmtStr, args func (_m *Fpdf) SetErrorf(fmtStr string, args ...interface{}) { var _ca []interface{} @@ -1161,69 +4424,474 @@ func (_m *Fpdf) SetErrorf(fmtStr string, args ...interface{}) { _m.Called(_ca...) } +// Fpdf_SetErrorf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetErrorf' +type Fpdf_SetErrorf_Call struct { + *mock.Call +} + +// SetErrorf is a helper method to define mock.On call +// - fmtStr string +// - args ...interface{} +func (_e *Fpdf_Expecter) SetErrorf(fmtStr interface{}, args ...interface{}) *Fpdf_SetErrorf_Call { + return &Fpdf_SetErrorf_Call{Call: _e.mock.On("SetErrorf", + append([]interface{}{fmtStr}, args...)...)} +} + +func (_c *Fpdf_SetErrorf_Call) Run(run func(fmtStr string, args ...interface{})) *Fpdf_SetErrorf_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string), variadicArgs...) + }) + return _c +} + +func (_c *Fpdf_SetErrorf_Call) Return() *Fpdf_SetErrorf_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetErrorf_Call) RunAndReturn(run func(string, ...interface{})) *Fpdf_SetErrorf_Call { + _c.Call.Return(run) + return _c +} + // SetFillColor provides a mock function with given fields: r, g, b func (_m *Fpdf) SetFillColor(r int, g int, b int) { _m.Called(r, g, b) } +// Fpdf_SetFillColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFillColor' +type Fpdf_SetFillColor_Call struct { + *mock.Call +} + +// SetFillColor is a helper method to define mock.On call +// - r int +// - g int +// - b int +func (_e *Fpdf_Expecter) SetFillColor(r interface{}, g interface{}, b interface{}) *Fpdf_SetFillColor_Call { + return &Fpdf_SetFillColor_Call{Call: _e.mock.On("SetFillColor", r, g, b)} +} + +func (_c *Fpdf_SetFillColor_Call) Run(run func(r int, g int, b int)) *Fpdf_SetFillColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *Fpdf_SetFillColor_Call) Return() *Fpdf_SetFillColor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFillColor_Call) RunAndReturn(run func(int, int, int)) *Fpdf_SetFillColor_Call { + _c.Call.Return(run) + return _c +} + // SetFillSpotColor provides a mock function with given fields: nameStr, tint func (_m *Fpdf) SetFillSpotColor(nameStr string, tint byte) { _m.Called(nameStr, tint) } +// Fpdf_SetFillSpotColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFillSpotColor' +type Fpdf_SetFillSpotColor_Call struct { + *mock.Call +} + +// SetFillSpotColor is a helper method to define mock.On call +// - nameStr string +// - tint byte +func (_e *Fpdf_Expecter) SetFillSpotColor(nameStr interface{}, tint interface{}) *Fpdf_SetFillSpotColor_Call { + return &Fpdf_SetFillSpotColor_Call{Call: _e.mock.On("SetFillSpotColor", nameStr, tint)} +} + +func (_c *Fpdf_SetFillSpotColor_Call) Run(run func(nameStr string, tint byte)) *Fpdf_SetFillSpotColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(byte)) + }) + return _c +} + +func (_c *Fpdf_SetFillSpotColor_Call) Return() *Fpdf_SetFillSpotColor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFillSpotColor_Call) RunAndReturn(run func(string, byte)) *Fpdf_SetFillSpotColor_Call { + _c.Call.Return(run) + return _c +} + // SetFont provides a mock function with given fields: familyStr, styleStr, size func (_m *Fpdf) SetFont(familyStr string, styleStr string, size float64) { _m.Called(familyStr, styleStr, size) } -// SetFontLoader provides a mock function with given fields: loader -func (_m *Fpdf) SetFontLoader(loader gofpdf.FontLoader) { - _m.Called(loader) +// Fpdf_SetFont_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFont' +type Fpdf_SetFont_Call struct { + *mock.Call } -// SetFontLocation provides a mock function with given fields: fontDirStr -func (_m *Fpdf) SetFontLocation(fontDirStr string) { - _m.Called(fontDirStr) +// SetFont is a helper method to define mock.On call +// - familyStr string +// - styleStr string +// - size float64 +func (_e *Fpdf_Expecter) SetFont(familyStr interface{}, styleStr interface{}, size interface{}) *Fpdf_SetFont_Call { + return &Fpdf_SetFont_Call{Call: _e.mock.On("SetFont", familyStr, styleStr, size)} } -// SetFontSize provides a mock function with given fields: size -func (_m *Fpdf) SetFontSize(size float64) { - _m.Called(size) +func (_c *Fpdf_SetFont_Call) Run(run func(familyStr string, styleStr string, size float64)) *Fpdf_SetFont_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(float64)) + }) + return _c } -// SetFontStyle provides a mock function with given fields: styleStr -func (_m *Fpdf) SetFontStyle(styleStr string) { - _m.Called(styleStr) +func (_c *Fpdf_SetFont_Call) Return() *Fpdf_SetFont_Call { + _c.Call.Return() + return _c } -// SetFontUnitSize provides a mock function with given fields: size -func (_m *Fpdf) SetFontUnitSize(size float64) { - _m.Called(size) +func (_c *Fpdf_SetFont_Call) RunAndReturn(run func(string, string, float64)) *Fpdf_SetFont_Call { + _c.Call.Return(run) + return _c } -// SetFooterFunc provides a mock function with given fields: fnc -func (_m *Fpdf) SetFooterFunc(fnc func()) { - _m.Called(fnc) +// SetFontLoader provides a mock function with given fields: loader +func (_m *Fpdf) SetFontLoader(loader gofpdf.FontLoader) { + _m.Called(loader) } -// SetFooterFuncLpi provides a mock function with given fields: fnc -func (_m *Fpdf) SetFooterFuncLpi(fnc func(bool)) { - _m.Called(fnc) +// Fpdf_SetFontLoader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFontLoader' +type Fpdf_SetFontLoader_Call struct { + *mock.Call } -// SetHeaderFunc provides a mock function with given fields: fnc -func (_m *Fpdf) SetHeaderFunc(fnc func()) { - _m.Called(fnc) +// SetFontLoader is a helper method to define mock.On call +// - loader gofpdf.FontLoader +func (_e *Fpdf_Expecter) SetFontLoader(loader interface{}) *Fpdf_SetFontLoader_Call { + return &Fpdf_SetFontLoader_Call{Call: _e.mock.On("SetFontLoader", loader)} } -// SetHeaderFuncMode provides a mock function with given fields: fnc, homeMode -func (_m *Fpdf) SetHeaderFuncMode(fnc func(), homeMode bool) { - _m.Called(fnc, homeMode) +func (_c *Fpdf_SetFontLoader_Call) Run(run func(loader gofpdf.FontLoader)) *Fpdf_SetFontLoader_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gofpdf.FontLoader)) + }) + return _c } -// SetHomeXY provides a mock function with given fields: -func (_m *Fpdf) SetHomeXY() { - _m.Called() +func (_c *Fpdf_SetFontLoader_Call) Return() *Fpdf_SetFontLoader_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFontLoader_Call) RunAndReturn(run func(gofpdf.FontLoader)) *Fpdf_SetFontLoader_Call { + _c.Call.Return(run) + return _c +} + +// SetFontLocation provides a mock function with given fields: fontDirStr +func (_m *Fpdf) SetFontLocation(fontDirStr string) { + _m.Called(fontDirStr) +} + +// Fpdf_SetFontLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFontLocation' +type Fpdf_SetFontLocation_Call struct { + *mock.Call +} + +// SetFontLocation is a helper method to define mock.On call +// - fontDirStr string +func (_e *Fpdf_Expecter) SetFontLocation(fontDirStr interface{}) *Fpdf_SetFontLocation_Call { + return &Fpdf_SetFontLocation_Call{Call: _e.mock.On("SetFontLocation", fontDirStr)} +} + +func (_c *Fpdf_SetFontLocation_Call) Run(run func(fontDirStr string)) *Fpdf_SetFontLocation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_SetFontLocation_Call) Return() *Fpdf_SetFontLocation_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFontLocation_Call) RunAndReturn(run func(string)) *Fpdf_SetFontLocation_Call { + _c.Call.Return(run) + return _c +} + +// SetFontSize provides a mock function with given fields: size +func (_m *Fpdf) SetFontSize(size float64) { + _m.Called(size) +} + +// Fpdf_SetFontSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFontSize' +type Fpdf_SetFontSize_Call struct { + *mock.Call +} + +// SetFontSize is a helper method to define mock.On call +// - size float64 +func (_e *Fpdf_Expecter) SetFontSize(size interface{}) *Fpdf_SetFontSize_Call { + return &Fpdf_SetFontSize_Call{Call: _e.mock.On("SetFontSize", size)} +} + +func (_c *Fpdf_SetFontSize_Call) Run(run func(size float64)) *Fpdf_SetFontSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetFontSize_Call) Return() *Fpdf_SetFontSize_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFontSize_Call) RunAndReturn(run func(float64)) *Fpdf_SetFontSize_Call { + _c.Call.Return(run) + return _c +} + +// SetFontStyle provides a mock function with given fields: styleStr +func (_m *Fpdf) SetFontStyle(styleStr string) { + _m.Called(styleStr) +} + +// Fpdf_SetFontStyle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFontStyle' +type Fpdf_SetFontStyle_Call struct { + *mock.Call +} + +// SetFontStyle is a helper method to define mock.On call +// - styleStr string +func (_e *Fpdf_Expecter) SetFontStyle(styleStr interface{}) *Fpdf_SetFontStyle_Call { + return &Fpdf_SetFontStyle_Call{Call: _e.mock.On("SetFontStyle", styleStr)} +} + +func (_c *Fpdf_SetFontStyle_Call) Run(run func(styleStr string)) *Fpdf_SetFontStyle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_SetFontStyle_Call) Return() *Fpdf_SetFontStyle_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFontStyle_Call) RunAndReturn(run func(string)) *Fpdf_SetFontStyle_Call { + _c.Call.Return(run) + return _c +} + +// SetFontUnitSize provides a mock function with given fields: size +func (_m *Fpdf) SetFontUnitSize(size float64) { + _m.Called(size) +} + +// Fpdf_SetFontUnitSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFontUnitSize' +type Fpdf_SetFontUnitSize_Call struct { + *mock.Call +} + +// SetFontUnitSize is a helper method to define mock.On call +// - size float64 +func (_e *Fpdf_Expecter) SetFontUnitSize(size interface{}) *Fpdf_SetFontUnitSize_Call { + return &Fpdf_SetFontUnitSize_Call{Call: _e.mock.On("SetFontUnitSize", size)} +} + +func (_c *Fpdf_SetFontUnitSize_Call) Run(run func(size float64)) *Fpdf_SetFontUnitSize_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetFontUnitSize_Call) Return() *Fpdf_SetFontUnitSize_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFontUnitSize_Call) RunAndReturn(run func(float64)) *Fpdf_SetFontUnitSize_Call { + _c.Call.Return(run) + return _c +} + +// SetFooterFunc provides a mock function with given fields: fnc +func (_m *Fpdf) SetFooterFunc(fnc func()) { + _m.Called(fnc) +} + +// Fpdf_SetFooterFunc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFooterFunc' +type Fpdf_SetFooterFunc_Call struct { + *mock.Call +} + +// SetFooterFunc is a helper method to define mock.On call +// - fnc func() +func (_e *Fpdf_Expecter) SetFooterFunc(fnc interface{}) *Fpdf_SetFooterFunc_Call { + return &Fpdf_SetFooterFunc_Call{Call: _e.mock.On("SetFooterFunc", fnc)} +} + +func (_c *Fpdf_SetFooterFunc_Call) Run(run func(fnc func())) *Fpdf_SetFooterFunc_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func())) + }) + return _c +} + +func (_c *Fpdf_SetFooterFunc_Call) Return() *Fpdf_SetFooterFunc_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFooterFunc_Call) RunAndReturn(run func(func())) *Fpdf_SetFooterFunc_Call { + _c.Call.Return(run) + return _c +} + +// SetFooterFuncLpi provides a mock function with given fields: fnc +func (_m *Fpdf) SetFooterFuncLpi(fnc func(bool)) { + _m.Called(fnc) +} + +// Fpdf_SetFooterFuncLpi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFooterFuncLpi' +type Fpdf_SetFooterFuncLpi_Call struct { + *mock.Call +} + +// SetFooterFuncLpi is a helper method to define mock.On call +// - fnc func(bool) +func (_e *Fpdf_Expecter) SetFooterFuncLpi(fnc interface{}) *Fpdf_SetFooterFuncLpi_Call { + return &Fpdf_SetFooterFuncLpi_Call{Call: _e.mock.On("SetFooterFuncLpi", fnc)} +} + +func (_c *Fpdf_SetFooterFuncLpi_Call) Run(run func(fnc func(bool))) *Fpdf_SetFooterFuncLpi_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(bool))) + }) + return _c +} + +func (_c *Fpdf_SetFooterFuncLpi_Call) Return() *Fpdf_SetFooterFuncLpi_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetFooterFuncLpi_Call) RunAndReturn(run func(func(bool))) *Fpdf_SetFooterFuncLpi_Call { + _c.Call.Return(run) + return _c +} + +// SetHeaderFunc provides a mock function with given fields: fnc +func (_m *Fpdf) SetHeaderFunc(fnc func()) { + _m.Called(fnc) +} + +// Fpdf_SetHeaderFunc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeaderFunc' +type Fpdf_SetHeaderFunc_Call struct { + *mock.Call +} + +// SetHeaderFunc is a helper method to define mock.On call +// - fnc func() +func (_e *Fpdf_Expecter) SetHeaderFunc(fnc interface{}) *Fpdf_SetHeaderFunc_Call { + return &Fpdf_SetHeaderFunc_Call{Call: _e.mock.On("SetHeaderFunc", fnc)} +} + +func (_c *Fpdf_SetHeaderFunc_Call) Run(run func(fnc func())) *Fpdf_SetHeaderFunc_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func())) + }) + return _c +} + +func (_c *Fpdf_SetHeaderFunc_Call) Return() *Fpdf_SetHeaderFunc_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetHeaderFunc_Call) RunAndReturn(run func(func())) *Fpdf_SetHeaderFunc_Call { + _c.Call.Return(run) + return _c +} + +// SetHeaderFuncMode provides a mock function with given fields: fnc, homeMode +func (_m *Fpdf) SetHeaderFuncMode(fnc func(), homeMode bool) { + _m.Called(fnc, homeMode) +} + +// Fpdf_SetHeaderFuncMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHeaderFuncMode' +type Fpdf_SetHeaderFuncMode_Call struct { + *mock.Call +} + +// SetHeaderFuncMode is a helper method to define mock.On call +// - fnc func() +// - homeMode bool +func (_e *Fpdf_Expecter) SetHeaderFuncMode(fnc interface{}, homeMode interface{}) *Fpdf_SetHeaderFuncMode_Call { + return &Fpdf_SetHeaderFuncMode_Call{Call: _e.mock.On("SetHeaderFuncMode", fnc, homeMode)} +} + +func (_c *Fpdf_SetHeaderFuncMode_Call) Run(run func(fnc func(), homeMode bool)) *Fpdf_SetHeaderFuncMode_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func()), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetHeaderFuncMode_Call) Return() *Fpdf_SetHeaderFuncMode_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetHeaderFuncMode_Call) RunAndReturn(run func(func(), bool)) *Fpdf_SetHeaderFuncMode_Call { + _c.Call.Return(run) + return _c +} + +// SetHomeXY provides a mock function with given fields: +func (_m *Fpdf) SetHomeXY() { + _m.Called() +} + +// Fpdf_SetHomeXY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHomeXY' +type Fpdf_SetHomeXY_Call struct { + *mock.Call +} + +// SetHomeXY is a helper method to define mock.On call +func (_e *Fpdf_Expecter) SetHomeXY() *Fpdf_SetHomeXY_Call { + return &Fpdf_SetHomeXY_Call{Call: _e.mock.On("SetHomeXY")} +} + +func (_c *Fpdf_SetHomeXY_Call) Run(run func()) *Fpdf_SetHomeXY_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_SetHomeXY_Call) Return() *Fpdf_SetHomeXY_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetHomeXY_Call) RunAndReturn(run func()) *Fpdf_SetHomeXY_Call { + _c.Call.Return(run) + return _c } // SetJavascript provides a mock function with given fields: script @@ -1231,234 +4899,1478 @@ func (_m *Fpdf) SetJavascript(script string) { _m.Called(script) } +// Fpdf_SetJavascript_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetJavascript' +type Fpdf_SetJavascript_Call struct { + *mock.Call +} + +// SetJavascript is a helper method to define mock.On call +// - script string +func (_e *Fpdf_Expecter) SetJavascript(script interface{}) *Fpdf_SetJavascript_Call { + return &Fpdf_SetJavascript_Call{Call: _e.mock.On("SetJavascript", script)} +} + +func (_c *Fpdf_SetJavascript_Call) Run(run func(script string)) *Fpdf_SetJavascript_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_SetJavascript_Call) Return() *Fpdf_SetJavascript_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetJavascript_Call) RunAndReturn(run func(string)) *Fpdf_SetJavascript_Call { + _c.Call.Return(run) + return _c +} + // SetKeywords provides a mock function with given fields: keywordsStr, isUTF8 func (_m *Fpdf) SetKeywords(keywordsStr string, isUTF8 bool) { _m.Called(keywordsStr, isUTF8) } +// Fpdf_SetKeywords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeywords' +type Fpdf_SetKeywords_Call struct { + *mock.Call +} + +// SetKeywords is a helper method to define mock.On call +// - keywordsStr string +// - isUTF8 bool +func (_e *Fpdf_Expecter) SetKeywords(keywordsStr interface{}, isUTF8 interface{}) *Fpdf_SetKeywords_Call { + return &Fpdf_SetKeywords_Call{Call: _e.mock.On("SetKeywords", keywordsStr, isUTF8)} +} + +func (_c *Fpdf_SetKeywords_Call) Run(run func(keywordsStr string, isUTF8 bool)) *Fpdf_SetKeywords_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetKeywords_Call) Return() *Fpdf_SetKeywords_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetKeywords_Call) RunAndReturn(run func(string, bool)) *Fpdf_SetKeywords_Call { + _c.Call.Return(run) + return _c +} + // SetLeftMargin provides a mock function with given fields: margin func (_m *Fpdf) SetLeftMargin(margin float64) { _m.Called(margin) } -// SetLineCapStyle provides a mock function with given fields: styleStr -func (_m *Fpdf) SetLineCapStyle(styleStr string) { - _m.Called(styleStr) +// Fpdf_SetLeftMargin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLeftMargin' +type Fpdf_SetLeftMargin_Call struct { + *mock.Call +} + +// SetLeftMargin is a helper method to define mock.On call +// - margin float64 +func (_e *Fpdf_Expecter) SetLeftMargin(margin interface{}) *Fpdf_SetLeftMargin_Call { + return &Fpdf_SetLeftMargin_Call{Call: _e.mock.On("SetLeftMargin", margin)} +} + +func (_c *Fpdf_SetLeftMargin_Call) Run(run func(margin float64)) *Fpdf_SetLeftMargin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetLeftMargin_Call) Return() *Fpdf_SetLeftMargin_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetLeftMargin_Call) RunAndReturn(run func(float64)) *Fpdf_SetLeftMargin_Call { + _c.Call.Return(run) + return _c +} + +// SetLineCapStyle provides a mock function with given fields: styleStr +func (_m *Fpdf) SetLineCapStyle(styleStr string) { + _m.Called(styleStr) +} + +// Fpdf_SetLineCapStyle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLineCapStyle' +type Fpdf_SetLineCapStyle_Call struct { + *mock.Call +} + +// SetLineCapStyle is a helper method to define mock.On call +// - styleStr string +func (_e *Fpdf_Expecter) SetLineCapStyle(styleStr interface{}) *Fpdf_SetLineCapStyle_Call { + return &Fpdf_SetLineCapStyle_Call{Call: _e.mock.On("SetLineCapStyle", styleStr)} +} + +func (_c *Fpdf_SetLineCapStyle_Call) Run(run func(styleStr string)) *Fpdf_SetLineCapStyle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_SetLineCapStyle_Call) Return() *Fpdf_SetLineCapStyle_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetLineCapStyle_Call) RunAndReturn(run func(string)) *Fpdf_SetLineCapStyle_Call { + _c.Call.Return(run) + return _c +} + +// SetLineJoinStyle provides a mock function with given fields: styleStr +func (_m *Fpdf) SetLineJoinStyle(styleStr string) { + _m.Called(styleStr) +} + +// Fpdf_SetLineJoinStyle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLineJoinStyle' +type Fpdf_SetLineJoinStyle_Call struct { + *mock.Call +} + +// SetLineJoinStyle is a helper method to define mock.On call +// - styleStr string +func (_e *Fpdf_Expecter) SetLineJoinStyle(styleStr interface{}) *Fpdf_SetLineJoinStyle_Call { + return &Fpdf_SetLineJoinStyle_Call{Call: _e.mock.On("SetLineJoinStyle", styleStr)} +} + +func (_c *Fpdf_SetLineJoinStyle_Call) Run(run func(styleStr string)) *Fpdf_SetLineJoinStyle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_SetLineJoinStyle_Call) Return() *Fpdf_SetLineJoinStyle_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetLineJoinStyle_Call) RunAndReturn(run func(string)) *Fpdf_SetLineJoinStyle_Call { + _c.Call.Return(run) + return _c +} + +// SetLineWidth provides a mock function with given fields: width +func (_m *Fpdf) SetLineWidth(width float64) { + _m.Called(width) +} + +// Fpdf_SetLineWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLineWidth' +type Fpdf_SetLineWidth_Call struct { + *mock.Call +} + +// SetLineWidth is a helper method to define mock.On call +// - width float64 +func (_e *Fpdf_Expecter) SetLineWidth(width interface{}) *Fpdf_SetLineWidth_Call { + return &Fpdf_SetLineWidth_Call{Call: _e.mock.On("SetLineWidth", width)} +} + +func (_c *Fpdf_SetLineWidth_Call) Run(run func(width float64)) *Fpdf_SetLineWidth_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetLineWidth_Call) Return() *Fpdf_SetLineWidth_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetLineWidth_Call) RunAndReturn(run func(float64)) *Fpdf_SetLineWidth_Call { + _c.Call.Return(run) + return _c +} + +// SetLink provides a mock function with given fields: link, y, page +func (_m *Fpdf) SetLink(link int, y float64, page int) { + _m.Called(link, y, page) +} + +// Fpdf_SetLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLink' +type Fpdf_SetLink_Call struct { + *mock.Call +} + +// SetLink is a helper method to define mock.On call +// - link int +// - y float64 +// - page int +func (_e *Fpdf_Expecter) SetLink(link interface{}, y interface{}, page interface{}) *Fpdf_SetLink_Call { + return &Fpdf_SetLink_Call{Call: _e.mock.On("SetLink", link, y, page)} +} + +func (_c *Fpdf_SetLink_Call) Run(run func(link int, y float64, page int)) *Fpdf_SetLink_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(float64), args[2].(int)) + }) + return _c +} + +func (_c *Fpdf_SetLink_Call) Return() *Fpdf_SetLink_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetLink_Call) RunAndReturn(run func(int, float64, int)) *Fpdf_SetLink_Call { + _c.Call.Return(run) + return _c +} + +// SetMargins provides a mock function with given fields: left, top, right +func (_m *Fpdf) SetMargins(left float64, top float64, right float64) { + _m.Called(left, top, right) +} + +// Fpdf_SetMargins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMargins' +type Fpdf_SetMargins_Call struct { + *mock.Call +} + +// SetMargins is a helper method to define mock.On call +// - left float64 +// - top float64 +// - right float64 +func (_e *Fpdf_Expecter) SetMargins(left interface{}, top interface{}, right interface{}) *Fpdf_SetMargins_Call { + return &Fpdf_SetMargins_Call{Call: _e.mock.On("SetMargins", left, top, right)} +} + +func (_c *Fpdf_SetMargins_Call) Run(run func(left float64, top float64, right float64)) *Fpdf_SetMargins_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetMargins_Call) Return() *Fpdf_SetMargins_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetMargins_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_SetMargins_Call { + _c.Call.Return(run) + return _c +} + +// SetPage provides a mock function with given fields: pageNum +func (_m *Fpdf) SetPage(pageNum int) { + _m.Called(pageNum) +} + +// Fpdf_SetPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPage' +type Fpdf_SetPage_Call struct { + *mock.Call +} + +// SetPage is a helper method to define mock.On call +// - pageNum int +func (_e *Fpdf_Expecter) SetPage(pageNum interface{}) *Fpdf_SetPage_Call { + return &Fpdf_SetPage_Call{Call: _e.mock.On("SetPage", pageNum)} +} + +func (_c *Fpdf_SetPage_Call) Run(run func(pageNum int)) *Fpdf_SetPage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int)) + }) + return _c +} + +func (_c *Fpdf_SetPage_Call) Return() *Fpdf_SetPage_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetPage_Call) RunAndReturn(run func(int)) *Fpdf_SetPage_Call { + _c.Call.Return(run) + return _c +} + +// SetPageBox provides a mock function with given fields: t, x, y, wd, ht +func (_m *Fpdf) SetPageBox(t string, x float64, y float64, wd float64, ht float64) { + _m.Called(t, x, y, wd, ht) +} + +// Fpdf_SetPageBox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPageBox' +type Fpdf_SetPageBox_Call struct { + *mock.Call +} + +// SetPageBox is a helper method to define mock.On call +// - t string +// - x float64 +// - y float64 +// - wd float64 +// - ht float64 +func (_e *Fpdf_Expecter) SetPageBox(t interface{}, x interface{}, y interface{}, wd interface{}, ht interface{}) *Fpdf_SetPageBox_Call { + return &Fpdf_SetPageBox_Call{Call: _e.mock.On("SetPageBox", t, x, y, wd, ht)} +} + +func (_c *Fpdf_SetPageBox_Call) Run(run func(t string, x float64, y float64, wd float64, ht float64)) *Fpdf_SetPageBox_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(float64), args[2].(float64), args[3].(float64), args[4].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetPageBox_Call) Return() *Fpdf_SetPageBox_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetPageBox_Call) RunAndReturn(run func(string, float64, float64, float64, float64)) *Fpdf_SetPageBox_Call { + _c.Call.Return(run) + return _c +} + +// SetPageBoxRec provides a mock function with given fields: t, pb +func (_m *Fpdf) SetPageBoxRec(t string, pb gofpdf.PageBox) { + _m.Called(t, pb) +} + +// Fpdf_SetPageBoxRec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPageBoxRec' +type Fpdf_SetPageBoxRec_Call struct { + *mock.Call +} + +// SetPageBoxRec is a helper method to define mock.On call +// - t string +// - pb gofpdf.PageBox +func (_e *Fpdf_Expecter) SetPageBoxRec(t interface{}, pb interface{}) *Fpdf_SetPageBoxRec_Call { + return &Fpdf_SetPageBoxRec_Call{Call: _e.mock.On("SetPageBoxRec", t, pb)} +} + +func (_c *Fpdf_SetPageBoxRec_Call) Run(run func(t string, pb gofpdf.PageBox)) *Fpdf_SetPageBoxRec_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(gofpdf.PageBox)) + }) + return _c +} + +func (_c *Fpdf_SetPageBoxRec_Call) Return() *Fpdf_SetPageBoxRec_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetPageBoxRec_Call) RunAndReturn(run func(string, gofpdf.PageBox)) *Fpdf_SetPageBoxRec_Call { + _c.Call.Return(run) + return _c +} + +// SetProtection provides a mock function with given fields: actionFlag, userPassStr, ownerPassStr +func (_m *Fpdf) SetProtection(actionFlag byte, userPassStr string, ownerPassStr string) { + _m.Called(actionFlag, userPassStr, ownerPassStr) +} + +// Fpdf_SetProtection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProtection' +type Fpdf_SetProtection_Call struct { + *mock.Call +} + +// SetProtection is a helper method to define mock.On call +// - actionFlag byte +// - userPassStr string +// - ownerPassStr string +func (_e *Fpdf_Expecter) SetProtection(actionFlag interface{}, userPassStr interface{}, ownerPassStr interface{}) *Fpdf_SetProtection_Call { + return &Fpdf_SetProtection_Call{Call: _e.mock.On("SetProtection", actionFlag, userPassStr, ownerPassStr)} +} + +func (_c *Fpdf_SetProtection_Call) Run(run func(actionFlag byte, userPassStr string, ownerPassStr string)) *Fpdf_SetProtection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(byte), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Fpdf_SetProtection_Call) Return() *Fpdf_SetProtection_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetProtection_Call) RunAndReturn(run func(byte, string, string)) *Fpdf_SetProtection_Call { + _c.Call.Return(run) + return _c +} + +// SetRightMargin provides a mock function with given fields: margin +func (_m *Fpdf) SetRightMargin(margin float64) { + _m.Called(margin) +} + +// Fpdf_SetRightMargin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRightMargin' +type Fpdf_SetRightMargin_Call struct { + *mock.Call +} + +// SetRightMargin is a helper method to define mock.On call +// - margin float64 +func (_e *Fpdf_Expecter) SetRightMargin(margin interface{}) *Fpdf_SetRightMargin_Call { + return &Fpdf_SetRightMargin_Call{Call: _e.mock.On("SetRightMargin", margin)} +} + +func (_c *Fpdf_SetRightMargin_Call) Run(run func(margin float64)) *Fpdf_SetRightMargin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetRightMargin_Call) Return() *Fpdf_SetRightMargin_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetRightMargin_Call) RunAndReturn(run func(float64)) *Fpdf_SetRightMargin_Call { + _c.Call.Return(run) + return _c +} + +// SetSubject provides a mock function with given fields: subjectStr, isUTF8 +func (_m *Fpdf) SetSubject(subjectStr string, isUTF8 bool) { + _m.Called(subjectStr, isUTF8) +} + +// Fpdf_SetSubject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSubject' +type Fpdf_SetSubject_Call struct { + *mock.Call +} + +// SetSubject is a helper method to define mock.On call +// - subjectStr string +// - isUTF8 bool +func (_e *Fpdf_Expecter) SetSubject(subjectStr interface{}, isUTF8 interface{}) *Fpdf_SetSubject_Call { + return &Fpdf_SetSubject_Call{Call: _e.mock.On("SetSubject", subjectStr, isUTF8)} +} + +func (_c *Fpdf_SetSubject_Call) Run(run func(subjectStr string, isUTF8 bool)) *Fpdf_SetSubject_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetSubject_Call) Return() *Fpdf_SetSubject_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetSubject_Call) RunAndReturn(run func(string, bool)) *Fpdf_SetSubject_Call { + _c.Call.Return(run) + return _c +} + +// SetTextColor provides a mock function with given fields: r, g, b +func (_m *Fpdf) SetTextColor(r int, g int, b int) { + _m.Called(r, g, b) +} + +// Fpdf_SetTextColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTextColor' +type Fpdf_SetTextColor_Call struct { + *mock.Call +} + +// SetTextColor is a helper method to define mock.On call +// - r int +// - g int +// - b int +func (_e *Fpdf_Expecter) SetTextColor(r interface{}, g interface{}, b interface{}) *Fpdf_SetTextColor_Call { + return &Fpdf_SetTextColor_Call{Call: _e.mock.On("SetTextColor", r, g, b)} +} + +func (_c *Fpdf_SetTextColor_Call) Run(run func(r int, g int, b int)) *Fpdf_SetTextColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(int), args[1].(int), args[2].(int)) + }) + return _c +} + +func (_c *Fpdf_SetTextColor_Call) Return() *Fpdf_SetTextColor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetTextColor_Call) RunAndReturn(run func(int, int, int)) *Fpdf_SetTextColor_Call { + _c.Call.Return(run) + return _c +} + +// SetTextSpotColor provides a mock function with given fields: nameStr, tint +func (_m *Fpdf) SetTextSpotColor(nameStr string, tint byte) { + _m.Called(nameStr, tint) +} + +// Fpdf_SetTextSpotColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTextSpotColor' +type Fpdf_SetTextSpotColor_Call struct { + *mock.Call +} + +// SetTextSpotColor is a helper method to define mock.On call +// - nameStr string +// - tint byte +func (_e *Fpdf_Expecter) SetTextSpotColor(nameStr interface{}, tint interface{}) *Fpdf_SetTextSpotColor_Call { + return &Fpdf_SetTextSpotColor_Call{Call: _e.mock.On("SetTextSpotColor", nameStr, tint)} +} + +func (_c *Fpdf_SetTextSpotColor_Call) Run(run func(nameStr string, tint byte)) *Fpdf_SetTextSpotColor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(byte)) + }) + return _c +} + +func (_c *Fpdf_SetTextSpotColor_Call) Return() *Fpdf_SetTextSpotColor_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetTextSpotColor_Call) RunAndReturn(run func(string, byte)) *Fpdf_SetTextSpotColor_Call { + _c.Call.Return(run) + return _c +} + +// SetTitle provides a mock function with given fields: titleStr, isUTF8 +func (_m *Fpdf) SetTitle(titleStr string, isUTF8 bool) { + _m.Called(titleStr, isUTF8) +} + +// Fpdf_SetTitle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTitle' +type Fpdf_SetTitle_Call struct { + *mock.Call +} + +// SetTitle is a helper method to define mock.On call +// - titleStr string +// - isUTF8 bool +func (_e *Fpdf_Expecter) SetTitle(titleStr interface{}, isUTF8 interface{}) *Fpdf_SetTitle_Call { + return &Fpdf_SetTitle_Call{Call: _e.mock.On("SetTitle", titleStr, isUTF8)} +} + +func (_c *Fpdf_SetTitle_Call) Run(run func(titleStr string, isUTF8 bool)) *Fpdf_SetTitle_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(bool)) + }) + return _c +} + +func (_c *Fpdf_SetTitle_Call) Return() *Fpdf_SetTitle_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetTitle_Call) RunAndReturn(run func(string, bool)) *Fpdf_SetTitle_Call { + _c.Call.Return(run) + return _c +} + +// SetTopMargin provides a mock function with given fields: margin +func (_m *Fpdf) SetTopMargin(margin float64) { + _m.Called(margin) +} + +// Fpdf_SetTopMargin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTopMargin' +type Fpdf_SetTopMargin_Call struct { + *mock.Call +} + +// SetTopMargin is a helper method to define mock.On call +// - margin float64 +func (_e *Fpdf_Expecter) SetTopMargin(margin interface{}) *Fpdf_SetTopMargin_Call { + return &Fpdf_SetTopMargin_Call{Call: _e.mock.On("SetTopMargin", margin)} +} + +func (_c *Fpdf_SetTopMargin_Call) Run(run func(margin float64)) *Fpdf_SetTopMargin_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetTopMargin_Call) Return() *Fpdf_SetTopMargin_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetTopMargin_Call) RunAndReturn(run func(float64)) *Fpdf_SetTopMargin_Call { + _c.Call.Return(run) + return _c +} + +// SetX provides a mock function with given fields: x +func (_m *Fpdf) SetX(x float64) { + _m.Called(x) +} + +// Fpdf_SetX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetX' +type Fpdf_SetX_Call struct { + *mock.Call +} + +// SetX is a helper method to define mock.On call +// - x float64 +func (_e *Fpdf_Expecter) SetX(x interface{}) *Fpdf_SetX_Call { + return &Fpdf_SetX_Call{Call: _e.mock.On("SetX", x)} +} + +func (_c *Fpdf_SetX_Call) Run(run func(x float64)) *Fpdf_SetX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetX_Call) Return() *Fpdf_SetX_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetX_Call) RunAndReturn(run func(float64)) *Fpdf_SetX_Call { + _c.Call.Return(run) + return _c +} + +// SetXY provides a mock function with given fields: x, y +func (_m *Fpdf) SetXY(x float64, y float64) { + _m.Called(x, y) +} + +// Fpdf_SetXY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXY' +type Fpdf_SetXY_Call struct { + *mock.Call +} + +// SetXY is a helper method to define mock.On call +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) SetXY(x interface{}, y interface{}) *Fpdf_SetXY_Call { + return &Fpdf_SetXY_Call{Call: _e.mock.On("SetXY", x, y)} +} + +func (_c *Fpdf_SetXY_Call) Run(run func(x float64, y float64)) *Fpdf_SetXY_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetXY_Call) Return() *Fpdf_SetXY_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetXY_Call) RunAndReturn(run func(float64, float64)) *Fpdf_SetXY_Call { + _c.Call.Return(run) + return _c +} + +// SetXmpMetadata provides a mock function with given fields: xmpStream +func (_m *Fpdf) SetXmpMetadata(xmpStream []byte) { + _m.Called(xmpStream) +} + +// Fpdf_SetXmpMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXmpMetadata' +type Fpdf_SetXmpMetadata_Call struct { + *mock.Call +} + +// SetXmpMetadata is a helper method to define mock.On call +// - xmpStream []byte +func (_e *Fpdf_Expecter) SetXmpMetadata(xmpStream interface{}) *Fpdf_SetXmpMetadata_Call { + return &Fpdf_SetXmpMetadata_Call{Call: _e.mock.On("SetXmpMetadata", xmpStream)} +} + +func (_c *Fpdf_SetXmpMetadata_Call) Run(run func(xmpStream []byte)) *Fpdf_SetXmpMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte)) + }) + return _c +} + +func (_c *Fpdf_SetXmpMetadata_Call) Return() *Fpdf_SetXmpMetadata_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetXmpMetadata_Call) RunAndReturn(run func([]byte)) *Fpdf_SetXmpMetadata_Call { + _c.Call.Return(run) + return _c +} + +// SetY provides a mock function with given fields: y +func (_m *Fpdf) SetY(y float64) { + _m.Called(y) +} + +// Fpdf_SetY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetY' +type Fpdf_SetY_Call struct { + *mock.Call +} + +// SetY is a helper method to define mock.On call +// - y float64 +func (_e *Fpdf_Expecter) SetY(y interface{}) *Fpdf_SetY_Call { + return &Fpdf_SetY_Call{Call: _e.mock.On("SetY", y)} +} + +func (_c *Fpdf_SetY_Call) Run(run func(y float64)) *Fpdf_SetY_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_SetY_Call) Return() *Fpdf_SetY_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_SetY_Call) RunAndReturn(run func(float64)) *Fpdf_SetY_Call { + _c.Call.Return(run) + return _c +} + +// SplitLines provides a mock function with given fields: txt, w +func (_m *Fpdf) SplitLines(txt []byte, w float64) [][]byte { + ret := _m.Called(txt, w) + + var r0 [][]byte + if rf, ok := ret.Get(0).(func([]byte, float64) [][]byte); ok { + r0 = rf(txt, w) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([][]byte) + } + } + + return r0 +} + +// Fpdf_SplitLines_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitLines' +type Fpdf_SplitLines_Call struct { + *mock.Call +} + +// SplitLines is a helper method to define mock.On call +// - txt []byte +// - w float64 +func (_e *Fpdf_Expecter) SplitLines(txt interface{}, w interface{}) *Fpdf_SplitLines_Call { + return &Fpdf_SplitLines_Call{Call: _e.mock.On("SplitLines", txt, w)} +} + +func (_c *Fpdf_SplitLines_Call) Run(run func(txt []byte, w float64)) *Fpdf_SplitLines_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_SplitLines_Call) Return(_a0 [][]byte) *Fpdf_SplitLines_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_SplitLines_Call) RunAndReturn(run func([]byte, float64) [][]byte) *Fpdf_SplitLines_Call { + _c.Call.Return(run) + return _c +} + +// String provides a mock function with given fields: +func (_m *Fpdf) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// Fpdf_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type Fpdf_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *Fpdf_Expecter) String() *Fpdf_String_Call { + return &Fpdf_String_Call{Call: _e.mock.On("String")} +} + +func (_c *Fpdf_String_Call) Run(run func()) *Fpdf_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_String_Call) Return(_a0 string) *Fpdf_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Fpdf_String_Call) RunAndReturn(run func() string) *Fpdf_String_Call { + _c.Call.Return(run) + return _c +} + +// Text provides a mock function with given fields: x, y, txtStr +func (_m *Fpdf) Text(x float64, y float64, txtStr string) { + _m.Called(x, y, txtStr) +} + +// Fpdf_Text_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Text' +type Fpdf_Text_Call struct { + *mock.Call +} + +// Text is a helper method to define mock.On call +// - x float64 +// - y float64 +// - txtStr string +func (_e *Fpdf_Expecter) Text(x interface{}, y interface{}, txtStr interface{}) *Fpdf_Text_Call { + return &Fpdf_Text_Call{Call: _e.mock.On("Text", x, y, txtStr)} +} + +func (_c *Fpdf_Text_Call) Run(run func(x float64, y float64, txtStr string)) *Fpdf_Text_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(string)) + }) + return _c +} + +func (_c *Fpdf_Text_Call) Return() *Fpdf_Text_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Text_Call) RunAndReturn(run func(float64, float64, string)) *Fpdf_Text_Call { + _c.Call.Return(run) + return _c +} + +// Transform provides a mock function with given fields: tm +func (_m *Fpdf) Transform(tm gofpdf.TransformMatrix) { + _m.Called(tm) +} + +// Fpdf_Transform_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Transform' +type Fpdf_Transform_Call struct { + *mock.Call +} + +// Transform is a helper method to define mock.On call +// - tm gofpdf.TransformMatrix +func (_e *Fpdf_Expecter) Transform(tm interface{}) *Fpdf_Transform_Call { + return &Fpdf_Transform_Call{Call: _e.mock.On("Transform", tm)} +} + +func (_c *Fpdf_Transform_Call) Run(run func(tm gofpdf.TransformMatrix)) *Fpdf_Transform_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gofpdf.TransformMatrix)) + }) + return _c +} + +func (_c *Fpdf_Transform_Call) Return() *Fpdf_Transform_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Transform_Call) RunAndReturn(run func(gofpdf.TransformMatrix)) *Fpdf_Transform_Call { + _c.Call.Return(run) + return _c +} + +// TransformBegin provides a mock function with given fields: +func (_m *Fpdf) TransformBegin() { + _m.Called() +} + +// Fpdf_TransformBegin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformBegin' +type Fpdf_TransformBegin_Call struct { + *mock.Call +} + +// TransformBegin is a helper method to define mock.On call +func (_e *Fpdf_Expecter) TransformBegin() *Fpdf_TransformBegin_Call { + return &Fpdf_TransformBegin_Call{Call: _e.mock.On("TransformBegin")} +} + +func (_c *Fpdf_TransformBegin_Call) Run(run func()) *Fpdf_TransformBegin_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_TransformBegin_Call) Return() *Fpdf_TransformBegin_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformBegin_Call) RunAndReturn(run func()) *Fpdf_TransformBegin_Call { + _c.Call.Return(run) + return _c +} + +// TransformEnd provides a mock function with given fields: +func (_m *Fpdf) TransformEnd() { + _m.Called() +} + +// Fpdf_TransformEnd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformEnd' +type Fpdf_TransformEnd_Call struct { + *mock.Call +} + +// TransformEnd is a helper method to define mock.On call +func (_e *Fpdf_Expecter) TransformEnd() *Fpdf_TransformEnd_Call { + return &Fpdf_TransformEnd_Call{Call: _e.mock.On("TransformEnd")} +} + +func (_c *Fpdf_TransformEnd_Call) Run(run func()) *Fpdf_TransformEnd_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Fpdf_TransformEnd_Call) Return() *Fpdf_TransformEnd_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformEnd_Call) RunAndReturn(run func()) *Fpdf_TransformEnd_Call { + _c.Call.Return(run) + return _c +} + +// TransformMirrorHorizontal provides a mock function with given fields: x +func (_m *Fpdf) TransformMirrorHorizontal(x float64) { + _m.Called(x) +} + +// Fpdf_TransformMirrorHorizontal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformMirrorHorizontal' +type Fpdf_TransformMirrorHorizontal_Call struct { + *mock.Call +} + +// TransformMirrorHorizontal is a helper method to define mock.On call +// - x float64 +func (_e *Fpdf_Expecter) TransformMirrorHorizontal(x interface{}) *Fpdf_TransformMirrorHorizontal_Call { + return &Fpdf_TransformMirrorHorizontal_Call{Call: _e.mock.On("TransformMirrorHorizontal", x)} +} + +func (_c *Fpdf_TransformMirrorHorizontal_Call) Run(run func(x float64)) *Fpdf_TransformMirrorHorizontal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformMirrorHorizontal_Call) Return() *Fpdf_TransformMirrorHorizontal_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformMirrorHorizontal_Call) RunAndReturn(run func(float64)) *Fpdf_TransformMirrorHorizontal_Call { + _c.Call.Return(run) + return _c +} + +// TransformMirrorLine provides a mock function with given fields: angle, x, y +func (_m *Fpdf) TransformMirrorLine(angle float64, x float64, y float64) { + _m.Called(angle, x, y) +} + +// Fpdf_TransformMirrorLine_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformMirrorLine' +type Fpdf_TransformMirrorLine_Call struct { + *mock.Call +} + +// TransformMirrorLine is a helper method to define mock.On call +// - angle float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformMirrorLine(angle interface{}, x interface{}, y interface{}) *Fpdf_TransformMirrorLine_Call { + return &Fpdf_TransformMirrorLine_Call{Call: _e.mock.On("TransformMirrorLine", angle, x, y)} +} + +func (_c *Fpdf_TransformMirrorLine_Call) Run(run func(angle float64, x float64, y float64)) *Fpdf_TransformMirrorLine_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformMirrorLine_Call) Return() *Fpdf_TransformMirrorLine_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformMirrorLine_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_TransformMirrorLine_Call { + _c.Call.Return(run) + return _c +} + +// TransformMirrorPoint provides a mock function with given fields: x, y +func (_m *Fpdf) TransformMirrorPoint(x float64, y float64) { + _m.Called(x, y) +} + +// Fpdf_TransformMirrorPoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformMirrorPoint' +type Fpdf_TransformMirrorPoint_Call struct { + *mock.Call +} + +// TransformMirrorPoint is a helper method to define mock.On call +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformMirrorPoint(x interface{}, y interface{}) *Fpdf_TransformMirrorPoint_Call { + return &Fpdf_TransformMirrorPoint_Call{Call: _e.mock.On("TransformMirrorPoint", x, y)} +} + +func (_c *Fpdf_TransformMirrorPoint_Call) Run(run func(x float64, y float64)) *Fpdf_TransformMirrorPoint_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformMirrorPoint_Call) Return() *Fpdf_TransformMirrorPoint_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformMirrorPoint_Call) RunAndReturn(run func(float64, float64)) *Fpdf_TransformMirrorPoint_Call { + _c.Call.Return(run) + return _c +} + +// TransformMirrorVertical provides a mock function with given fields: y +func (_m *Fpdf) TransformMirrorVertical(y float64) { + _m.Called(y) +} + +// Fpdf_TransformMirrorVertical_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformMirrorVertical' +type Fpdf_TransformMirrorVertical_Call struct { + *mock.Call +} + +// TransformMirrorVertical is a helper method to define mock.On call +// - y float64 +func (_e *Fpdf_Expecter) TransformMirrorVertical(y interface{}) *Fpdf_TransformMirrorVertical_Call { + return &Fpdf_TransformMirrorVertical_Call{Call: _e.mock.On("TransformMirrorVertical", y)} +} + +func (_c *Fpdf_TransformMirrorVertical_Call) Run(run func(y float64)) *Fpdf_TransformMirrorVertical_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformMirrorVertical_Call) Return() *Fpdf_TransformMirrorVertical_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformMirrorVertical_Call) RunAndReturn(run func(float64)) *Fpdf_TransformMirrorVertical_Call { + _c.Call.Return(run) + return _c +} + +// TransformRotate provides a mock function with given fields: angle, x, y +func (_m *Fpdf) TransformRotate(angle float64, x float64, y float64) { + _m.Called(angle, x, y) +} + +// Fpdf_TransformRotate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformRotate' +type Fpdf_TransformRotate_Call struct { + *mock.Call +} + +// TransformRotate is a helper method to define mock.On call +// - angle float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformRotate(angle interface{}, x interface{}, y interface{}) *Fpdf_TransformRotate_Call { + return &Fpdf_TransformRotate_Call{Call: _e.mock.On("TransformRotate", angle, x, y)} +} + +func (_c *Fpdf_TransformRotate_Call) Run(run func(angle float64, x float64, y float64)) *Fpdf_TransformRotate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformRotate_Call) Return() *Fpdf_TransformRotate_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformRotate_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_TransformRotate_Call { + _c.Call.Return(run) + return _c +} + +// TransformScale provides a mock function with given fields: scaleWd, scaleHt, x, y +func (_m *Fpdf) TransformScale(scaleWd float64, scaleHt float64, x float64, y float64) { + _m.Called(scaleWd, scaleHt, x, y) +} + +// Fpdf_TransformScale_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformScale' +type Fpdf_TransformScale_Call struct { + *mock.Call +} + +// TransformScale is a helper method to define mock.On call +// - scaleWd float64 +// - scaleHt float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformScale(scaleWd interface{}, scaleHt interface{}, x interface{}, y interface{}) *Fpdf_TransformScale_Call { + return &Fpdf_TransformScale_Call{Call: _e.mock.On("TransformScale", scaleWd, scaleHt, x, y)} +} + +func (_c *Fpdf_TransformScale_Call) Run(run func(scaleWd float64, scaleHt float64, x float64, y float64)) *Fpdf_TransformScale_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformScale_Call) Return() *Fpdf_TransformScale_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformScale_Call) RunAndReturn(run func(float64, float64, float64, float64)) *Fpdf_TransformScale_Call { + _c.Call.Return(run) + return _c +} + +// TransformScaleX provides a mock function with given fields: scaleWd, x, y +func (_m *Fpdf) TransformScaleX(scaleWd float64, x float64, y float64) { + _m.Called(scaleWd, x, y) +} + +// Fpdf_TransformScaleX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformScaleX' +type Fpdf_TransformScaleX_Call struct { + *mock.Call +} + +// TransformScaleX is a helper method to define mock.On call +// - scaleWd float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformScaleX(scaleWd interface{}, x interface{}, y interface{}) *Fpdf_TransformScaleX_Call { + return &Fpdf_TransformScaleX_Call{Call: _e.mock.On("TransformScaleX", scaleWd, x, y)} +} + +func (_c *Fpdf_TransformScaleX_Call) Run(run func(scaleWd float64, x float64, y float64)) *Fpdf_TransformScaleX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformScaleX_Call) Return() *Fpdf_TransformScaleX_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_TransformScaleX_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_TransformScaleX_Call { + _c.Call.Return(run) + return _c +} + +// TransformScaleXY provides a mock function with given fields: s, x, y +func (_m *Fpdf) TransformScaleXY(s float64, x float64, y float64) { + _m.Called(s, x, y) +} + +// Fpdf_TransformScaleXY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformScaleXY' +type Fpdf_TransformScaleXY_Call struct { + *mock.Call +} + +// TransformScaleXY is a helper method to define mock.On call +// - s float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformScaleXY(s interface{}, x interface{}, y interface{}) *Fpdf_TransformScaleXY_Call { + return &Fpdf_TransformScaleXY_Call{Call: _e.mock.On("TransformScaleXY", s, x, y)} +} + +func (_c *Fpdf_TransformScaleXY_Call) Run(run func(s float64, x float64, y float64)) *Fpdf_TransformScaleXY_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c +} + +func (_c *Fpdf_TransformScaleXY_Call) Return() *Fpdf_TransformScaleXY_Call { + _c.Call.Return() + return _c } -// SetLineJoinStyle provides a mock function with given fields: styleStr -func (_m *Fpdf) SetLineJoinStyle(styleStr string) { - _m.Called(styleStr) +func (_c *Fpdf_TransformScaleXY_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_TransformScaleXY_Call { + _c.Call.Return(run) + return _c } -// SetLineWidth provides a mock function with given fields: width -func (_m *Fpdf) SetLineWidth(width float64) { - _m.Called(width) +// TransformScaleY provides a mock function with given fields: scaleHt, x, y +func (_m *Fpdf) TransformScaleY(scaleHt float64, x float64, y float64) { + _m.Called(scaleHt, x, y) } -// SetLink provides a mock function with given fields: link, y, page -func (_m *Fpdf) SetLink(link int, y float64, page int) { - _m.Called(link, y, page) +// Fpdf_TransformScaleY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformScaleY' +type Fpdf_TransformScaleY_Call struct { + *mock.Call } -// SetMargins provides a mock function with given fields: left, top, right -func (_m *Fpdf) SetMargins(left float64, top float64, right float64) { - _m.Called(left, top, right) +// TransformScaleY is a helper method to define mock.On call +// - scaleHt float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformScaleY(scaleHt interface{}, x interface{}, y interface{}) *Fpdf_TransformScaleY_Call { + return &Fpdf_TransformScaleY_Call{Call: _e.mock.On("TransformScaleY", scaleHt, x, y)} } -// SetPage provides a mock function with given fields: pageNum -func (_m *Fpdf) SetPage(pageNum int) { - _m.Called(pageNum) +func (_c *Fpdf_TransformScaleY_Call) Run(run func(scaleHt float64, x float64, y float64)) *Fpdf_TransformScaleY_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c } -// SetPageBox provides a mock function with given fields: t, x, y, wd, ht -func (_m *Fpdf) SetPageBox(t string, x float64, y float64, wd float64, ht float64) { - _m.Called(t, x, y, wd, ht) +func (_c *Fpdf_TransformScaleY_Call) Return() *Fpdf_TransformScaleY_Call { + _c.Call.Return() + return _c } -// SetPageBoxRec provides a mock function with given fields: t, pb -func (_m *Fpdf) SetPageBoxRec(t string, pb gofpdf.PageBox) { - _m.Called(t, pb) +func (_c *Fpdf_TransformScaleY_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_TransformScaleY_Call { + _c.Call.Return(run) + return _c } -// SetProtection provides a mock function with given fields: actionFlag, userPassStr, ownerPassStr -func (_m *Fpdf) SetProtection(actionFlag byte, userPassStr string, ownerPassStr string) { - _m.Called(actionFlag, userPassStr, ownerPassStr) +// TransformSkew provides a mock function with given fields: angleX, angleY, x, y +func (_m *Fpdf) TransformSkew(angleX float64, angleY float64, x float64, y float64) { + _m.Called(angleX, angleY, x, y) } -// SetRightMargin provides a mock function with given fields: margin -func (_m *Fpdf) SetRightMargin(margin float64) { - _m.Called(margin) +// Fpdf_TransformSkew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformSkew' +type Fpdf_TransformSkew_Call struct { + *mock.Call } -// SetSubject provides a mock function with given fields: subjectStr, isUTF8 -func (_m *Fpdf) SetSubject(subjectStr string, isUTF8 bool) { - _m.Called(subjectStr, isUTF8) +// TransformSkew is a helper method to define mock.On call +// - angleX float64 +// - angleY float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformSkew(angleX interface{}, angleY interface{}, x interface{}, y interface{}) *Fpdf_TransformSkew_Call { + return &Fpdf_TransformSkew_Call{Call: _e.mock.On("TransformSkew", angleX, angleY, x, y)} } -// SetTextColor provides a mock function with given fields: r, g, b -func (_m *Fpdf) SetTextColor(r int, g int, b int) { - _m.Called(r, g, b) +func (_c *Fpdf_TransformSkew_Call) Run(run func(angleX float64, angleY float64, x float64, y float64)) *Fpdf_TransformSkew_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64), args[3].(float64)) + }) + return _c } -// SetTextSpotColor provides a mock function with given fields: nameStr, tint -func (_m *Fpdf) SetTextSpotColor(nameStr string, tint byte) { - _m.Called(nameStr, tint) +func (_c *Fpdf_TransformSkew_Call) Return() *Fpdf_TransformSkew_Call { + _c.Call.Return() + return _c } -// SetTitle provides a mock function with given fields: titleStr, isUTF8 -func (_m *Fpdf) SetTitle(titleStr string, isUTF8 bool) { - _m.Called(titleStr, isUTF8) +func (_c *Fpdf_TransformSkew_Call) RunAndReturn(run func(float64, float64, float64, float64)) *Fpdf_TransformSkew_Call { + _c.Call.Return(run) + return _c } -// SetTopMargin provides a mock function with given fields: margin -func (_m *Fpdf) SetTopMargin(margin float64) { - _m.Called(margin) +// TransformSkewX provides a mock function with given fields: angleX, x, y +func (_m *Fpdf) TransformSkewX(angleX float64, x float64, y float64) { + _m.Called(angleX, x, y) } -// SetX provides a mock function with given fields: x -func (_m *Fpdf) SetX(x float64) { - _m.Called(x) +// Fpdf_TransformSkewX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformSkewX' +type Fpdf_TransformSkewX_Call struct { + *mock.Call } -// SetXY provides a mock function with given fields: x, y -func (_m *Fpdf) SetXY(x float64, y float64) { - _m.Called(x, y) +// TransformSkewX is a helper method to define mock.On call +// - angleX float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformSkewX(angleX interface{}, x interface{}, y interface{}) *Fpdf_TransformSkewX_Call { + return &Fpdf_TransformSkewX_Call{Call: _e.mock.On("TransformSkewX", angleX, x, y)} } -// SetXmpMetadata provides a mock function with given fields: xmpStream -func (_m *Fpdf) SetXmpMetadata(xmpStream []byte) { - _m.Called(xmpStream) +func (_c *Fpdf_TransformSkewX_Call) Run(run func(angleX float64, x float64, y float64)) *Fpdf_TransformSkewX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c } -// SetY provides a mock function with given fields: y -func (_m *Fpdf) SetY(y float64) { - _m.Called(y) +func (_c *Fpdf_TransformSkewX_Call) Return() *Fpdf_TransformSkewX_Call { + _c.Call.Return() + return _c } -// SplitLines provides a mock function with given fields: txt, w -func (_m *Fpdf) SplitLines(txt []byte, w float64) [][]byte { - ret := _m.Called(txt, w) +func (_c *Fpdf_TransformSkewX_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_TransformSkewX_Call { + _c.Call.Return(run) + return _c +} - var r0 [][]byte - if rf, ok := ret.Get(0).(func([]byte, float64) [][]byte); ok { - r0 = rf(txt, w) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([][]byte) - } - } +// TransformSkewY provides a mock function with given fields: angleY, x, y +func (_m *Fpdf) TransformSkewY(angleY float64, x float64, y float64) { + _m.Called(angleY, x, y) +} - return r0 +// Fpdf_TransformSkewY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformSkewY' +type Fpdf_TransformSkewY_Call struct { + *mock.Call } -// String provides a mock function with given fields: -func (_m *Fpdf) String() string { - ret := _m.Called() +// TransformSkewY is a helper method to define mock.On call +// - angleY float64 +// - x float64 +// - y float64 +func (_e *Fpdf_Expecter) TransformSkewY(angleY interface{}, x interface{}, y interface{}) *Fpdf_TransformSkewY_Call { + return &Fpdf_TransformSkewY_Call{Call: _e.mock.On("TransformSkewY", angleY, x, y)} +} - var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() - } else { - r0 = ret.Get(0).(string) - } +func (_c *Fpdf_TransformSkewY_Call) Run(run func(angleY float64, x float64, y float64)) *Fpdf_TransformSkewY_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(float64)) + }) + return _c +} - return r0 +func (_c *Fpdf_TransformSkewY_Call) Return() *Fpdf_TransformSkewY_Call { + _c.Call.Return() + return _c } -// Text provides a mock function with given fields: x, y, txtStr -func (_m *Fpdf) Text(x float64, y float64, txtStr string) { - _m.Called(x, y, txtStr) +func (_c *Fpdf_TransformSkewY_Call) RunAndReturn(run func(float64, float64, float64)) *Fpdf_TransformSkewY_Call { + _c.Call.Return(run) + return _c } -// Transform provides a mock function with given fields: tm -func (_m *Fpdf) Transform(tm gofpdf.TransformMatrix) { - _m.Called(tm) +// TransformTranslate provides a mock function with given fields: tx, ty +func (_m *Fpdf) TransformTranslate(tx float64, ty float64) { + _m.Called(tx, ty) } -// TransformBegin provides a mock function with given fields: -func (_m *Fpdf) TransformBegin() { - _m.Called() +// Fpdf_TransformTranslate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformTranslate' +type Fpdf_TransformTranslate_Call struct { + *mock.Call } -// TransformEnd provides a mock function with given fields: -func (_m *Fpdf) TransformEnd() { - _m.Called() +// TransformTranslate is a helper method to define mock.On call +// - tx float64 +// - ty float64 +func (_e *Fpdf_Expecter) TransformTranslate(tx interface{}, ty interface{}) *Fpdf_TransformTranslate_Call { + return &Fpdf_TransformTranslate_Call{Call: _e.mock.On("TransformTranslate", tx, ty)} } -// TransformMirrorHorizontal provides a mock function with given fields: x -func (_m *Fpdf) TransformMirrorHorizontal(x float64) { - _m.Called(x) +func (_c *Fpdf_TransformTranslate_Call) Run(run func(tx float64, ty float64)) *Fpdf_TransformTranslate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64)) + }) + return _c } -// TransformMirrorLine provides a mock function with given fields: angle, x, y -func (_m *Fpdf) TransformMirrorLine(angle float64, x float64, y float64) { - _m.Called(angle, x, y) +func (_c *Fpdf_TransformTranslate_Call) Return() *Fpdf_TransformTranslate_Call { + _c.Call.Return() + return _c } -// TransformMirrorPoint provides a mock function with given fields: x, y -func (_m *Fpdf) TransformMirrorPoint(x float64, y float64) { - _m.Called(x, y) +func (_c *Fpdf_TransformTranslate_Call) RunAndReturn(run func(float64, float64)) *Fpdf_TransformTranslate_Call { + _c.Call.Return(run) + return _c } -// TransformMirrorVertical provides a mock function with given fields: y -func (_m *Fpdf) TransformMirrorVertical(y float64) { - _m.Called(y) +// TransformTranslateX provides a mock function with given fields: tx +func (_m *Fpdf) TransformTranslateX(tx float64) { + _m.Called(tx) } -// TransformRotate provides a mock function with given fields: angle, x, y -func (_m *Fpdf) TransformRotate(angle float64, x float64, y float64) { - _m.Called(angle, x, y) +// Fpdf_TransformTranslateX_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformTranslateX' +type Fpdf_TransformTranslateX_Call struct { + *mock.Call } -// TransformScale provides a mock function with given fields: scaleWd, scaleHt, x, y -func (_m *Fpdf) TransformScale(scaleWd float64, scaleHt float64, x float64, y float64) { - _m.Called(scaleWd, scaleHt, x, y) +// TransformTranslateX is a helper method to define mock.On call +// - tx float64 +func (_e *Fpdf_Expecter) TransformTranslateX(tx interface{}) *Fpdf_TransformTranslateX_Call { + return &Fpdf_TransformTranslateX_Call{Call: _e.mock.On("TransformTranslateX", tx)} } -// TransformScaleX provides a mock function with given fields: scaleWd, x, y -func (_m *Fpdf) TransformScaleX(scaleWd float64, x float64, y float64) { - _m.Called(scaleWd, x, y) +func (_c *Fpdf_TransformTranslateX_Call) Run(run func(tx float64)) *Fpdf_TransformTranslateX_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c } -// TransformScaleXY provides a mock function with given fields: s, x, y -func (_m *Fpdf) TransformScaleXY(s float64, x float64, y float64) { - _m.Called(s, x, y) +func (_c *Fpdf_TransformTranslateX_Call) Return() *Fpdf_TransformTranslateX_Call { + _c.Call.Return() + return _c } -// TransformScaleY provides a mock function with given fields: scaleHt, x, y -func (_m *Fpdf) TransformScaleY(scaleHt float64, x float64, y float64) { - _m.Called(scaleHt, x, y) +func (_c *Fpdf_TransformTranslateX_Call) RunAndReturn(run func(float64)) *Fpdf_TransformTranslateX_Call { + _c.Call.Return(run) + return _c } -// TransformSkew provides a mock function with given fields: angleX, angleY, x, y -func (_m *Fpdf) TransformSkew(angleX float64, angleY float64, x float64, y float64) { - _m.Called(angleX, angleY, x, y) +// TransformTranslateY provides a mock function with given fields: ty +func (_m *Fpdf) TransformTranslateY(ty float64) { + _m.Called(ty) } -// TransformSkewX provides a mock function with given fields: angleX, x, y -func (_m *Fpdf) TransformSkewX(angleX float64, x float64, y float64) { - _m.Called(angleX, x, y) +// Fpdf_TransformTranslateY_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformTranslateY' +type Fpdf_TransformTranslateY_Call struct { + *mock.Call } -// TransformSkewY provides a mock function with given fields: angleY, x, y -func (_m *Fpdf) TransformSkewY(angleY float64, x float64, y float64) { - _m.Called(angleY, x, y) +// TransformTranslateY is a helper method to define mock.On call +// - ty float64 +func (_e *Fpdf_Expecter) TransformTranslateY(ty interface{}) *Fpdf_TransformTranslateY_Call { + return &Fpdf_TransformTranslateY_Call{Call: _e.mock.On("TransformTranslateY", ty)} } -// TransformTranslate provides a mock function with given fields: tx, ty -func (_m *Fpdf) TransformTranslate(tx float64, ty float64) { - _m.Called(tx, ty) +func (_c *Fpdf_TransformTranslateY_Call) Run(run func(ty float64)) *Fpdf_TransformTranslateY_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c } -// TransformTranslateX provides a mock function with given fields: tx -func (_m *Fpdf) TransformTranslateX(tx float64) { - _m.Called(tx) +func (_c *Fpdf_TransformTranslateY_Call) Return() *Fpdf_TransformTranslateY_Call { + _c.Call.Return() + return _c } -// TransformTranslateY provides a mock function with given fields: ty -func (_m *Fpdf) TransformTranslateY(ty float64) { - _m.Called(ty) +func (_c *Fpdf_TransformTranslateY_Call) RunAndReturn(run func(float64)) *Fpdf_TransformTranslateY_Call { + _c.Call.Return(run) + return _c } // UnicodeTranslatorFromDescriptor provides a mock function with given fields: cpStr @@ -1477,6 +6389,34 @@ func (_m *Fpdf) UnicodeTranslatorFromDescriptor(cpStr string) func(string) strin return r0 } +// Fpdf_UnicodeTranslatorFromDescriptor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnicodeTranslatorFromDescriptor' +type Fpdf_UnicodeTranslatorFromDescriptor_Call struct { + *mock.Call +} + +// UnicodeTranslatorFromDescriptor is a helper method to define mock.On call +// - cpStr string +func (_e *Fpdf_Expecter) UnicodeTranslatorFromDescriptor(cpStr interface{}) *Fpdf_UnicodeTranslatorFromDescriptor_Call { + return &Fpdf_UnicodeTranslatorFromDescriptor_Call{Call: _e.mock.On("UnicodeTranslatorFromDescriptor", cpStr)} +} + +func (_c *Fpdf_UnicodeTranslatorFromDescriptor_Call) Run(run func(cpStr string)) *Fpdf_UnicodeTranslatorFromDescriptor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Fpdf_UnicodeTranslatorFromDescriptor_Call) Return(rep func(string) string) *Fpdf_UnicodeTranslatorFromDescriptor_Call { + _c.Call.Return(rep) + return _c +} + +func (_c *Fpdf_UnicodeTranslatorFromDescriptor_Call) RunAndReturn(run func(string) func(string) string) *Fpdf_UnicodeTranslatorFromDescriptor_Call { + _c.Call.Return(run) + return _c +} + // UnitToPointConvert provides a mock function with given fields: u func (_m *Fpdf) UnitToPointConvert(u float64) float64 { ret := _m.Called(u) @@ -1491,36 +6431,242 @@ func (_m *Fpdf) UnitToPointConvert(u float64) float64 { return r0 } +// Fpdf_UnitToPointConvert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnitToPointConvert' +type Fpdf_UnitToPointConvert_Call struct { + *mock.Call +} + +// UnitToPointConvert is a helper method to define mock.On call +// - u float64 +func (_e *Fpdf_Expecter) UnitToPointConvert(u interface{}) *Fpdf_UnitToPointConvert_Call { + return &Fpdf_UnitToPointConvert_Call{Call: _e.mock.On("UnitToPointConvert", u)} +} + +func (_c *Fpdf_UnitToPointConvert_Call) Run(run func(u float64)) *Fpdf_UnitToPointConvert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64)) + }) + return _c +} + +func (_c *Fpdf_UnitToPointConvert_Call) Return(pt float64) *Fpdf_UnitToPointConvert_Call { + _c.Call.Return(pt) + return _c +} + +func (_c *Fpdf_UnitToPointConvert_Call) RunAndReturn(run func(float64) float64) *Fpdf_UnitToPointConvert_Call { + _c.Call.Return(run) + return _c +} + // UseTemplate provides a mock function with given fields: t func (_m *Fpdf) UseTemplate(t gofpdf.Template) { _m.Called(t) } +// Fpdf_UseTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseTemplate' +type Fpdf_UseTemplate_Call struct { + *mock.Call +} + +// UseTemplate is a helper method to define mock.On call +// - t gofpdf.Template +func (_e *Fpdf_Expecter) UseTemplate(t interface{}) *Fpdf_UseTemplate_Call { + return &Fpdf_UseTemplate_Call{Call: _e.mock.On("UseTemplate", t)} +} + +func (_c *Fpdf_UseTemplate_Call) Run(run func(t gofpdf.Template)) *Fpdf_UseTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gofpdf.Template)) + }) + return _c +} + +func (_c *Fpdf_UseTemplate_Call) Return() *Fpdf_UseTemplate_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_UseTemplate_Call) RunAndReturn(run func(gofpdf.Template)) *Fpdf_UseTemplate_Call { + _c.Call.Return(run) + return _c +} + // UseTemplateScaled provides a mock function with given fields: t, corner, size func (_m *Fpdf) UseTemplateScaled(t gofpdf.Template, corner gofpdf.PointType, size gofpdf.SizeType) { _m.Called(t, corner, size) } +// Fpdf_UseTemplateScaled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseTemplateScaled' +type Fpdf_UseTemplateScaled_Call struct { + *mock.Call +} + +// UseTemplateScaled is a helper method to define mock.On call +// - t gofpdf.Template +// - corner gofpdf.PointType +// - size gofpdf.SizeType +func (_e *Fpdf_Expecter) UseTemplateScaled(t interface{}, corner interface{}, size interface{}) *Fpdf_UseTemplateScaled_Call { + return &Fpdf_UseTemplateScaled_Call{Call: _e.mock.On("UseTemplateScaled", t, corner, size)} +} + +func (_c *Fpdf_UseTemplateScaled_Call) Run(run func(t gofpdf.Template, corner gofpdf.PointType, size gofpdf.SizeType)) *Fpdf_UseTemplateScaled_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(gofpdf.Template), args[1].(gofpdf.PointType), args[2].(gofpdf.SizeType)) + }) + return _c +} + +func (_c *Fpdf_UseTemplateScaled_Call) Return() *Fpdf_UseTemplateScaled_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_UseTemplateScaled_Call) RunAndReturn(run func(gofpdf.Template, gofpdf.PointType, gofpdf.SizeType)) *Fpdf_UseTemplateScaled_Call { + _c.Call.Return(run) + return _c +} + // Write provides a mock function with given fields: h, txtStr func (_m *Fpdf) Write(h float64, txtStr string) { _m.Called(h, txtStr) } +// Fpdf_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type Fpdf_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - h float64 +// - txtStr string +func (_e *Fpdf_Expecter) Write(h interface{}, txtStr interface{}) *Fpdf_Write_Call { + return &Fpdf_Write_Call{Call: _e.mock.On("Write", h, txtStr)} +} + +func (_c *Fpdf_Write_Call) Run(run func(h float64, txtStr string)) *Fpdf_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(string)) + }) + return _c +} + +func (_c *Fpdf_Write_Call) Return() *Fpdf_Write_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Write_Call) RunAndReturn(run func(float64, string)) *Fpdf_Write_Call { + _c.Call.Return(run) + return _c +} + // WriteAligned provides a mock function with given fields: width, lineHeight, textStr, alignStr func (_m *Fpdf) WriteAligned(width float64, lineHeight float64, textStr string, alignStr string) { _m.Called(width, lineHeight, textStr, alignStr) } +// Fpdf_WriteAligned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteAligned' +type Fpdf_WriteAligned_Call struct { + *mock.Call +} + +// WriteAligned is a helper method to define mock.On call +// - width float64 +// - lineHeight float64 +// - textStr string +// - alignStr string +func (_e *Fpdf_Expecter) WriteAligned(width interface{}, lineHeight interface{}, textStr interface{}, alignStr interface{}) *Fpdf_WriteAligned_Call { + return &Fpdf_WriteAligned_Call{Call: _e.mock.On("WriteAligned", width, lineHeight, textStr, alignStr)} +} + +func (_c *Fpdf_WriteAligned_Call) Run(run func(width float64, lineHeight float64, textStr string, alignStr string)) *Fpdf_WriteAligned_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(float64), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *Fpdf_WriteAligned_Call) Return() *Fpdf_WriteAligned_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_WriteAligned_Call) RunAndReturn(run func(float64, float64, string, string)) *Fpdf_WriteAligned_Call { + _c.Call.Return(run) + return _c +} + // WriteLinkID provides a mock function with given fields: h, displayStr, linkID func (_m *Fpdf) WriteLinkID(h float64, displayStr string, linkID int) { _m.Called(h, displayStr, linkID) } +// Fpdf_WriteLinkID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteLinkID' +type Fpdf_WriteLinkID_Call struct { + *mock.Call +} + +// WriteLinkID is a helper method to define mock.On call +// - h float64 +// - displayStr string +// - linkID int +func (_e *Fpdf_Expecter) WriteLinkID(h interface{}, displayStr interface{}, linkID interface{}) *Fpdf_WriteLinkID_Call { + return &Fpdf_WriteLinkID_Call{Call: _e.mock.On("WriteLinkID", h, displayStr, linkID)} +} + +func (_c *Fpdf_WriteLinkID_Call) Run(run func(h float64, displayStr string, linkID int)) *Fpdf_WriteLinkID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(string), args[2].(int)) + }) + return _c +} + +func (_c *Fpdf_WriteLinkID_Call) Return() *Fpdf_WriteLinkID_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_WriteLinkID_Call) RunAndReturn(run func(float64, string, int)) *Fpdf_WriteLinkID_Call { + _c.Call.Return(run) + return _c +} + // WriteLinkString provides a mock function with given fields: h, displayStr, targetStr func (_m *Fpdf) WriteLinkString(h float64, displayStr string, targetStr string) { _m.Called(h, displayStr, targetStr) } +// Fpdf_WriteLinkString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteLinkString' +type Fpdf_WriteLinkString_Call struct { + *mock.Call +} + +// WriteLinkString is a helper method to define mock.On call +// - h float64 +// - displayStr string +// - targetStr string +func (_e *Fpdf_Expecter) WriteLinkString(h interface{}, displayStr interface{}, targetStr interface{}) *Fpdf_WriteLinkString_Call { + return &Fpdf_WriteLinkString_Call{Call: _e.mock.On("WriteLinkString", h, displayStr, targetStr)} +} + +func (_c *Fpdf_WriteLinkString_Call) Run(run func(h float64, displayStr string, targetStr string)) *Fpdf_WriteLinkString_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *Fpdf_WriteLinkString_Call) Return() *Fpdf_WriteLinkString_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_WriteLinkString_Call) RunAndReturn(run func(float64, string, string)) *Fpdf_WriteLinkString_Call { + _c.Call.Return(run) + return _c +} + // Writef provides a mock function with given fields: h, fmtStr, args func (_m *Fpdf) Writef(h float64, fmtStr string, args ...interface{}) { var _ca []interface{} @@ -1528,3 +6674,54 @@ func (_m *Fpdf) Writef(h float64, fmtStr string, args ...interface{}) { _ca = append(_ca, args...) _m.Called(_ca...) } + +// Fpdf_Writef_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Writef' +type Fpdf_Writef_Call struct { + *mock.Call +} + +// Writef is a helper method to define mock.On call +// - h float64 +// - fmtStr string +// - args ...interface{} +func (_e *Fpdf_Expecter) Writef(h interface{}, fmtStr interface{}, args ...interface{}) *Fpdf_Writef_Call { + return &Fpdf_Writef_Call{Call: _e.mock.On("Writef", + append([]interface{}{h, fmtStr}, args...)...)} +} + +func (_c *Fpdf_Writef_Call) Run(run func(h float64, fmtStr string, args ...interface{})) *Fpdf_Writef_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(float64), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *Fpdf_Writef_Call) Return() *Fpdf_Writef_Call { + _c.Call.Return() + return _c +} + +func (_c *Fpdf_Writef_Call) RunAndReturn(run func(float64, string, ...interface{})) *Fpdf_Writef_Call { + _c.Call.Return(run) + return _c +} + +// NewFpdf creates a new instance of Fpdf. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewFpdf(t interface { + mock.TestingT + Cleanup(func()) +}) *Fpdf { + mock := &Fpdf{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/v2/col/col_test.go b/pkg/v2/col/col_test.go new file mode 100644 index 00000000..ce51304b --- /dev/null +++ b/pkg/v2/col/col_test.go @@ -0,0 +1,369 @@ +package col + +import ( + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/internal/mocks" + v2 "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/text" + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNew(t *testing.T) { + t.Run("should success create a new col", func(t *testing.T) { + // arrange + size := 12 + // act + col := New(size) + + // assert + assert.NotNil(t, col) + assert.Equal(t, size, col.size) + assert.Equal(t, "col", col._type.String()) + }) +} + +func TestCol_GetType(t *testing.T) { + t.Run("should success get type", func(t *testing.T) { + // arrange + size := 12 + col := New(size) + + // act + _type := col.GetType() + + // assert + assert.Equal(t, "col", _type) + }) +} + +func TestCol_Add(t *testing.T) { + t.Run("should add component when is a valid child", func(t *testing.T) { + // arrange + size := 12 + col := New(size) + txt := text.New("test") + + // act + col.Add(txt) + + // assert + assert.Equal(t, 1, len(col.components)) + assert.Equal(t, txt, col.components[0]) + }) + t.Run("should not add component when is not a valid child", func(t *testing.T) { + // arrange + size := 12 + col := New(size) + invalid := &invalidComponent{_type: v2.Page} + + // act + col.Add(invalid) + + // assert + assert.Equal(t, 0, len(col.components)) + }) +} + +func TestCol_Render(t *testing.T) { + t.Run("should render col with 100% parent width when col size is 12", func(t *testing.T) { + // arrange + col := New(12) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 80.0 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + + }) + t.Run("should render col with 91% parent width when col size is 11", func(t *testing.T) { + // arrange + col := New(11) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 72.8 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + }) + t.Run("should render col with 83% parent width when col size is 10", func(t *testing.T) { + // arrange + col := New(10) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 66.4 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + }) + t.Run("should render col with 75% parent width when col size is 9", func(t *testing.T) { + // arrange + col := New(9) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 60.0 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + }) + t.Run("should render col with 66% parent width when col size is 8", func(t *testing.T) { + // arrange + col := New(8) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 53.333333333333336 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + }) + t.Run("should render col with 60% parent width when col size is 7", func(t *testing.T) { + // arrange + col := New(7) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 48.0 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + }) + t.Run("should render col with 50% parent width when col size is 6", func(t *testing.T) { + // arrange + col := New(6) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 40.0 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + + }) + t.Run("should render col with 40% parent width when col size is 5", func(t *testing.T) { + // arrange + col := New(5) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 33.333333333333336 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + }) + t.Run("should render col with 30% parent width when col size is 4", func(t *testing.T) { + // arrange + col := New(4) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 26.666666666666664 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + + }) + t.Run("should render col with 25% parent width when col size is 3", func(t *testing.T) { + // arrange + col := New(3) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 20.0 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + + }) + t.Run("should render col with 20% parent width when col size is 2", func(t *testing.T) { + // arrange + col := New(2) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 13.333333333333332 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + + }) + t.Run("should render col with 10% parent width when col size is 1", func(t *testing.T) { + // arrange + col := New(1) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + + expectedSizeX := 6.666666666666666 + pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + + // act + col.Render(pdf, ctx) + + // assert + + }) + t.Run("should render child components with width matching col width", func(t *testing.T) { + // arrange + col := New(12) + child := text.New("test") + col.Add(child) + pdf := mocks.NewFpdf(t) + + ctx := context.NewRootContext(100, 100, &context.Margins{ + Left: 10, + Right: 10, + Top: 10, + Bottom: 10, + }).WithDimension(80, 80) + pdf.EXPECT().SetDrawColor(255, 0, 0) + pdf.EXPECT().CellFormat(ctx.GetXOffset(), ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") + pdf.EXPECT().Text(ctx.GetXOffset(), ctx.GetYOffset(), "test") + // act + col.Render(pdf, ctx) + + // assert + + }) +} + +// region Test Support +type invalidComponent struct { + _type v2.DocumentType +} + +func (i *invalidComponent) Render(fpdf fpdf.Fpdf, ctx context.Context) { + return +} + +func (i *invalidComponent) GetType() string { + return i._type.String() +} + +func (i *invalidComponent) Add(_ ...v2.Component) { + return +} + +// endregion diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index 476378a6..0835b67d 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -19,14 +19,6 @@ func New(value string) *text { } } -func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) { - ctx.Print(t.value) - for _, component := range t.components { - component.Render(fpdf, ctx) - } - return -} - func (t *text) GetType() string { return t._type.String() } @@ -34,3 +26,13 @@ func (t *text) GetType() string { func (t *text) Add(_ ...v2.Component) { return } + +func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) { + ctx.Print(t.value) + t.render(fpdf, ctx) + return +} + +func (t *text) render(fpdf fpdf.Fpdf, ctx context.Context) { + fpdf.Text(ctx.GetXOffset(), ctx.GetYOffset(), t.value) +} From 8d6c36ca5998fdf6b4a97f473076b5542e2fa9e6 Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 17:21:29 -0300 Subject: [PATCH 14/24] fix col test cases values --- pkg/v2/col/col_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pkg/v2/col/col_test.go b/pkg/v2/col/col_test.go index ce51304b..ae0788dd 100644 --- a/pkg/v2/col/col_test.go +++ b/pkg/v2/col/col_test.go @@ -102,7 +102,7 @@ func TestCol_Render(t *testing.T) { }).WithDimension(80, 80) pdf.EXPECT().SetDrawColor(255, 0, 0) - expectedSizeX := 72.8 + expectedSizeX := 73.33333333333333 pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") // act @@ -123,7 +123,7 @@ func TestCol_Render(t *testing.T) { }).WithDimension(80, 80) pdf.EXPECT().SetDrawColor(255, 0, 0) - expectedSizeX := 66.4 + expectedSizeX := 66.66666666666667 pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") // act @@ -165,7 +165,7 @@ func TestCol_Render(t *testing.T) { }).WithDimension(80, 80) pdf.EXPECT().SetDrawColor(255, 0, 0) - expectedSizeX := 53.333333333333336 + expectedSizeX := 53.33333333333333 pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") // act @@ -186,7 +186,7 @@ func TestCol_Render(t *testing.T) { }).WithDimension(80, 80) pdf.EXPECT().SetDrawColor(255, 0, 0) - expectedSizeX := 48.0 + expectedSizeX := 46.66666666666667 pdf.EXPECT().CellFormat(expectedSizeX, ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") // act From 2dc182fc0479781a1d68db0c093ea475238d2222 Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 22:50:44 -0300 Subject: [PATCH 15/24] add text and image features using new interfaces --- v2.pdf | Bin 1096 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 v2.pdf diff --git a/v2.pdf b/v2.pdf deleted file mode 100644 index 4c534566b7926560b4adeb5c268e4bd3d776dd93..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1096 zcmZ`&%WD%s7~ks25f8-*1rf$Wr3IUPZ?Yv;%&QHxwx(4JA;M;N61Pou%I-wc`WFcH zQg4C^#e*QCUTmo-crVg}f=Un7s~52zDn9Br$@XE2%QCa`ecyhM-|shFqp3`<98r;q zB}|KxC>|HbXQl}jN3AkJu=>PfSO#wni8&I`ns1W;D@{X^dJOyl*7&)<9}&;tS@1c`7YB=e$NbXolRp-p&Q6WoKAc`y*zCTu9vqu{|M2Fec;B1NX?dvU zEPdu=e?8~XPXs~O+B({qD)3>#-omjs4EsO|kT~Qz0nT#>bGU%SB&~7GkT^^n*GkYj z&P(9aO+BK-a7>dUF|&Yn(b8MfW&lvg!V_C1iwAAq6WIWFaC%dmsx4hPl*BfuwMEs!x#=RWfBo)^$x& zAYhm}|MTq@jP5De)O^xnR)v1vTU4sk%!4GR{VzC6Mh6)>c3 zzM)*|J}Dsy$B?x1U_;kc9hdO7O_hKc{$Ov%rkNm@7MmoQ`)x58p(Rd@?T<5bn4~2x zYQP=cwlUv=iF~;Hpe=WnK+9r|QieH1aPPBTiDJ%AgVTUnK5NVtGi21&l^)5Uzx*;m APyhe` From f1b8a6f78273cf8a2b7de7e7d667e04af46f2b01 Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 22:51:40 -0300 Subject: [PATCH 16/24] add text and image features using new interfaces --- cmd/main.go | 6 +++++- pkg/v2/image/image.go | 30 +++++++++++++++++++++++++----- pkg/v2/text/text.go | 25 +++++++++++++++++++++++-- v2.pdf | Bin 0 -> 205131 bytes 4 files changed, 53 insertions(+), 8 deletions(-) create mode 100644 v2.pdf diff --git a/cmd/main.go b/cmd/main.go index 46078823..738c6d5e 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -3,6 +3,7 @@ package main import ( "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/col" + "github.com/johnfercher/maroto/pkg/v2/image" "github.com/johnfercher/maroto/pkg/v2/row" "github.com/johnfercher/maroto/pkg/v2/text" "log" @@ -28,10 +29,13 @@ func buildRow() v2.Component { //image := image.New("image1") col1 := col.New(4) - //col1.Add(image) + col1.Add(text.New("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec ac condimentum sem. ")) col2 := col.New(4) + col2.Add(image.NewFromFile("internal/assets/images/biplane.jpg")) + col3 := col.New(4) + col3.Add(text.New("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec ac condimentum sem. ")) row.Add(col1, col2, col3) return row diff --git a/pkg/v2/image/image.go b/pkg/v2/image/image.go index d00ef736..e1bb8de4 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/image.go @@ -1,30 +1,50 @@ package image import ( + "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/props" "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/text" ) type image struct { path string _type v2.DocumentType components []v2.Component + prop props.Rect } -func New(path string) *image { +func NewFromFile(path string, imageProps ...props.Rect) *image { + prop := props.Rect{} + if len(imageProps) > 0 { + prop = imageProps[0] + } + prop.MakeValid() + return &image{ _type: v2.Image, path: path, + prop: prop, } } func (i *image) Render(fpdf fpdf.Fpdf, ctx context.Context) { - ctx.Print(i.path) - for _, component := range i.components { - component.Render(fpdf, ctx) + math := internal.NewMath(fpdf) + img := internal.NewImage(fpdf, math) + err := img.AddFromFile( + i.path, + internal.Cell{fpdf.GetX() - ctx.Margins.Left, + fpdf.GetY() - ctx.Margins.Top, + ctx.Dimensions.Width, + ctx.Dimensions.Height}, + i.prop) + if err != nil { + fpdf.ClearError() + txt := text.New("Failed to render image") + txt.Render(fpdf, ctx) } - return } func (i *image) GetType() string { diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index 0835b67d..ea19f187 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -1,7 +1,10 @@ package text import ( + "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/consts" + "github.com/johnfercher/maroto/pkg/props" v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" ) @@ -10,12 +13,20 @@ type text struct { value string _type v2.DocumentType components []v2.Component + prop props.Text } -func New(value string) *text { +func New(value string, textProps ...props.Text) *text { + prop := props.Text{} + if len(textProps) > 0 { + prop = textProps[0] + } + prop.MakeValid(consts.Arial) + return &text{ _type: v2.Text, value: value, + prop: prop, } } @@ -34,5 +45,15 @@ func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) { } func (t *text) render(fpdf fpdf.Fpdf, ctx context.Context) { - fpdf.Text(ctx.GetXOffset(), ctx.GetYOffset(), t.value) + font := internal.NewFont(fpdf, 2, consts.Arial, consts.Normal) + math := internal.NewMath(fpdf) + text := internal.NewText(fpdf, math, font) + + text.Add( + t.value, + internal.Cell{fpdf.GetX() - ctx.Margins.Left, + fpdf.GetY() - ctx.Margins.Top, + ctx.Dimensions.Width, + ctx.Dimensions.Height}, + t.prop) } diff --git a/v2.pdf b/v2.pdf new file mode 100644 index 0000000000000000000000000000000000000000..a4d753148b3967abaf58847aa2283bea51a04ebb GIT binary patch literal 205131 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
    U_4BDI7qD8Akd^g>wy4ZFj?=}NEHIdO@)A8cf8 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 literal 0 HcmV?d00001 From 359182aeaff2a536c15b4c8b77604fbac9c4155a Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 23:03:22 -0300 Subject: [PATCH 17/24] add base64image and signature types --- pkg/v2/image/base64image.go | 61 +++++++++++++++++++++++++ pkg/v2/image/{image.go => fileimage.go} | 14 +++--- pkg/v2/signature/signature.go | 54 ++++++++++++++++++++++ pkg/v2/types.go | 15 +++--- 4 files changed, 130 insertions(+), 14 deletions(-) create mode 100644 pkg/v2/image/base64image.go rename pkg/v2/image/{image.go => fileimage.go} (74%) create mode 100644 pkg/v2/signature/signature.go diff --git a/pkg/v2/image/base64image.go b/pkg/v2/image/base64image.go new file mode 100644 index 00000000..6c77d2a5 --- /dev/null +++ b/pkg/v2/image/base64image.go @@ -0,0 +1,61 @@ +package image + +import ( + "github.com/johnfercher/maroto/internal" + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/consts" + "github.com/johnfercher/maroto/pkg/props" + "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/text" +) + +type base64Image struct { + path string + extension consts.Extension + _type v2.DocumentType + components []v2.Component + prop props.Rect +} + +func NewFromBase64(path string, extension consts.Extension, imageProps ...props.Rect) *base64Image { + prop := props.Rect{} + if len(imageProps) > 0 { + prop = imageProps[0] + } + prop.MakeValid() + + return &base64Image{ + _type: v2.Image, + path: path, + prop: prop, + extension: extension, + } +} + +func (i *base64Image) Render(fpdf fpdf.Fpdf, ctx context.Context) { + math := internal.NewMath(fpdf) + img := internal.NewImage(fpdf, math) + err := img.AddFromBase64( + i.path, + internal.Cell{fpdf.GetX() - ctx.Margins.Left, + fpdf.GetY() - ctx.Margins.Top, + ctx.Dimensions.Width, + ctx.Dimensions.Height}, + i.prop, + i.extension, + ) + if err != nil { + fpdf.ClearError() + txt := text.New("Failed to render fileImage") + txt.Render(fpdf, ctx) + } +} + +func (i *base64Image) GetType() string { + return i._type.String() +} + +func (i *base64Image) Add(_ ...v2.Component) { + return +} diff --git a/pkg/v2/image/image.go b/pkg/v2/image/fileimage.go similarity index 74% rename from pkg/v2/image/image.go rename to pkg/v2/image/fileimage.go index e1bb8de4..ea135501 100644 --- a/pkg/v2/image/image.go +++ b/pkg/v2/image/fileimage.go @@ -9,28 +9,28 @@ import ( "github.com/johnfercher/maroto/pkg/v2/text" ) -type image struct { +type fileImage struct { path string _type v2.DocumentType components []v2.Component prop props.Rect } -func NewFromFile(path string, imageProps ...props.Rect) *image { +func NewFromFile(path string, imageProps ...props.Rect) *fileImage { prop := props.Rect{} if len(imageProps) > 0 { prop = imageProps[0] } prop.MakeValid() - return &image{ + return &fileImage{ _type: v2.Image, path: path, prop: prop, } } -func (i *image) Render(fpdf fpdf.Fpdf, ctx context.Context) { +func (i *fileImage) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) img := internal.NewImage(fpdf, math) err := img.AddFromFile( @@ -42,15 +42,15 @@ func (i *image) Render(fpdf fpdf.Fpdf, ctx context.Context) { i.prop) if err != nil { fpdf.ClearError() - txt := text.New("Failed to render image") + txt := text.New("Failed to render fileImage") txt.Render(fpdf, ctx) } } -func (i *image) GetType() string { +func (i *fileImage) GetType() string { return i._type.String() } -func (i *image) Add(_ ...v2.Component) { +func (i *fileImage) Add(_ ...v2.Component) { return } diff --git a/pkg/v2/signature/signature.go b/pkg/v2/signature/signature.go new file mode 100644 index 00000000..1fed9c39 --- /dev/null +++ b/pkg/v2/signature/signature.go @@ -0,0 +1,54 @@ +package signature + +import ( + "github.com/johnfercher/maroto/internal" + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/consts" + "github.com/johnfercher/maroto/pkg/props" + v2 "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" +) + +type signature struct { + value string + _type v2.DocumentType + components []v2.Component + prop props.Text +} + +func New(value string, textProps ...props.Text) *signature { + prop := props.Text{} + if len(textProps) > 0 { + prop = textProps[0] + } + prop.MakeValid(consts.Arial) + + return &signature{ + _type: v2.Signature, + value: value, + prop: prop, + } +} + +func (s *signature) Render(fpdf fpdf.Fpdf, ctx context.Context) { + font := internal.NewFont(fpdf, 2, consts.Arial, consts.Normal) + math := internal.NewMath(fpdf) + text := internal.NewText(fpdf, math, font) + signature := internal.NewSignature(fpdf, math, text) + + signature.AddSpaceFor( + s.value, + internal.Cell{fpdf.GetX() - ctx.Margins.Left, + fpdf.GetY() - ctx.Margins.Top, + ctx.Dimensions.Width, + ctx.Dimensions.Height}, + s.prop) +} + +func (s *signature) GetType() string { + return s._type.String() +} + +func (s *signature) Add(_ ...v2.Component) { + return +} diff --git a/pkg/v2/types.go b/pkg/v2/types.go index f793ae57..a6651e67 100644 --- a/pkg/v2/types.go +++ b/pkg/v2/types.go @@ -3,12 +3,13 @@ package v2 import "slices" const ( - Document = "document" - Row = "row" - Page = "page" - Col = "col" - Image = "image" - Text = "text" + Document = "document" + Row = "row" + Page = "page" + Col = "col" + Image = "image" + Text = "text" + Signature = "signature" ) type DocumentType string @@ -29,6 +30,6 @@ func buildAcceptedMap() map[string][]string { Document: {Row}, Page: {Row}, Row: {Col}, - Col: {Row, Image, Text}, + Col: {Row, Image, Text, Signature}, } } From c801f4eda25d349fba0ff7eba4df2b9c01cb8f65 Mon Sep 17 00:00:00 2001 From: John Fercher Date: Tue, 12 Sep 2023 23:07:01 -0300 Subject: [PATCH 18/24] Add codes --- cmd/main.go | 14 ++++--- pkg/v2/code/barcode/barcode.go | 55 +++++++++++++++++++++++++++ pkg/v2/code/matrixcode/matrixcode.go | 48 +++++++++++++++++++++++ pkg/v2/code/qrcode/qrcode.go | 48 +++++++++++++++++++++++ pkg/v2/types.go | 4 +- v2.pdf | Bin 205131 -> 208820 bytes 6 files changed, 163 insertions(+), 6 deletions(-) create mode 100644 pkg/v2/code/barcode/barcode.go create mode 100644 pkg/v2/code/matrixcode/matrixcode.go create mode 100644 pkg/v2/code/qrcode/qrcode.go diff --git a/cmd/main.go b/cmd/main.go index 738c6d5e..72552e94 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -2,6 +2,9 @@ package main import ( "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/code/barcode" + "github.com/johnfercher/maroto/pkg/v2/code/matrixcode" + "github.com/johnfercher/maroto/pkg/v2/code/qrcode" "github.com/johnfercher/maroto/pkg/v2/col" "github.com/johnfercher/maroto/pkg/v2/image" "github.com/johnfercher/maroto/pkg/v2/row" @@ -13,9 +16,9 @@ func main() { pdf := v2.NewDocument() header := buildRow() - //content := buildContent() + content := buildContent() //footer := buildRow() - pdf.Add(header /*content footer*/) + pdf.Add(header, content /*content footer*/) err := pdf.Generate("v2.pdf") if err != nil { @@ -44,13 +47,14 @@ func buildRow() v2.Component { func buildContent() v2.Component { row := row.New(20) - tx := text.New("Hello World") - col1 := col.New(4) - col1.Add(tx) + col1.Add(barcode.New("barcode")) col2 := col.New(4) + col2.Add(qrcode.New("qrcode")) + col3 := col.New(4) + col3.Add(matrixcode.New("qrcode")) row.Add(col1, col2, col3) return row diff --git a/pkg/v2/code/barcode/barcode.go b/pkg/v2/code/barcode/barcode.go new file mode 100644 index 00000000..3440c8b1 --- /dev/null +++ b/pkg/v2/code/barcode/barcode.go @@ -0,0 +1,55 @@ +package barcode + +import ( + "github.com/johnfercher/maroto/internal" + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/props" + "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/text" +) + +type barcode struct { + code string + _type v2.DocumentType + components []v2.Component + prop props.Barcode +} + +func New(code string, barcodeProps ...props.Barcode) *barcode { + prop := props.Barcode{} + if len(barcodeProps) > 0 { + prop = barcodeProps[0] + } + prop.MakeValid() + + return &barcode{ + _type: v2.Leaf, + code: code, + prop: prop, + } +} + +func (i *barcode) Render(fpdf fpdf.Fpdf, ctx context.Context) { + math := internal.NewMath(fpdf) + + code := internal.NewCode(fpdf, math) + err := code.AddBar(i.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, + fpdf.GetY() - ctx.Margins.Top, + ctx.Dimensions.Width, + ctx.Dimensions.Height}, i.prop) + + if err != nil { + fpdf.ClearError() + txt := text.New("Failed to render code") + txt.Render(fpdf, ctx) + } +} + +func (i *barcode) GetType() string { + return i._type.String() +} + +func (i *barcode) Add(_ ...v2.Component) { + return +} diff --git a/pkg/v2/code/matrixcode/matrixcode.go b/pkg/v2/code/matrixcode/matrixcode.go new file mode 100644 index 00000000..8d4ae54a --- /dev/null +++ b/pkg/v2/code/matrixcode/matrixcode.go @@ -0,0 +1,48 @@ +package matrixcode + +import ( + "github.com/johnfercher/maroto/internal" + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/props" + "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" +) + +type matrixCode struct { + code string + _type v2.DocumentType + components []v2.Component + prop props.Rect +} + +func New(code string, barcodeProps ...props.Rect) *matrixCode { + prop := props.Rect{} + if len(barcodeProps) > 0 { + prop = barcodeProps[0] + } + prop.MakeValid() + + return &matrixCode{ + _type: v2.Leaf, + code: code, + prop: prop, + } +} + +func (i *matrixCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { + math := internal.NewMath(fpdf) + + code := internal.NewCode(fpdf, math) + code.AddDataMatrix(i.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, + fpdf.GetY() - ctx.Margins.Top, + ctx.Dimensions.Width, + ctx.Dimensions.Height}, i.prop) +} + +func (i *matrixCode) GetType() string { + return i._type.String() +} + +func (i *matrixCode) Add(_ ...v2.Component) { + return +} diff --git a/pkg/v2/code/qrcode/qrcode.go b/pkg/v2/code/qrcode/qrcode.go new file mode 100644 index 00000000..90a97258 --- /dev/null +++ b/pkg/v2/code/qrcode/qrcode.go @@ -0,0 +1,48 @@ +package qrcode + +import ( + "github.com/johnfercher/maroto/internal" + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/props" + "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" +) + +type qrCode struct { + code string + _type v2.DocumentType + components []v2.Component + prop props.Rect +} + +func New(code string, barcodeProps ...props.Rect) *qrCode { + prop := props.Rect{} + if len(barcodeProps) > 0 { + prop = barcodeProps[0] + } + prop.MakeValid() + + return &qrCode{ + _type: v2.Leaf, + code: code, + prop: prop, + } +} + +func (i *qrCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { + math := internal.NewMath(fpdf) + + code := internal.NewCode(fpdf, math) + code.AddQr(i.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, + fpdf.GetY() - ctx.Margins.Top, + ctx.Dimensions.Width, + ctx.Dimensions.Height}, i.prop) +} + +func (i *qrCode) GetType() string { + return i._type.String() +} + +func (i *qrCode) Add(_ ...v2.Component) { + return +} diff --git a/pkg/v2/types.go b/pkg/v2/types.go index a6651e67..6e5c0c3e 100644 --- a/pkg/v2/types.go +++ b/pkg/v2/types.go @@ -10,6 +10,7 @@ const ( Image = "image" Text = "text" Signature = "signature" + Leaf = "leaf" ) type DocumentType string @@ -30,6 +31,7 @@ func buildAcceptedMap() map[string][]string { Document: {Row}, Page: {Row}, Row: {Col}, - Col: {Row, Image, Text, Signature}, + Leaf: {}, + Col: {Row, Image, Text, Signature, Leaf}, } } diff --git a/v2.pdf b/v2.pdf index a4d753148b3967abaf58847aa2283bea51a04ebb..6ae1ee3672bdb348189516c666f24b8d56beebe9 100644 GIT binary patch delta 3318 zcmdUxd0Z369>6CF=MoB0IRz2{IfRINkm4ZzH z5fQDWiax-K7E!4u*osy~i>N3@lkWnElPpd}pTV z67ys`Gk-hDM}@OyAsdqt<&q7^X4)6Zn{jth)5e!uc8N1|UR-aLZLNC03As|9Z_$5# zS;gMKvuDk!^8~I&^fOt*lUx^e4h9WsKJG8~JN>U)^V8UmJF`G_LjRLS#Q)@6n<2Bu+e%Y5WDH0kF}w6-m+g;N8DCV`&bqL*`{k1} z(92?o2<`0qroit#&pyr%1Cq9)gsnz>+dVB$@2#!$nE@AMlTLRNVjo_x3N)DqU>sftN;@KVMgBYMgWExNpPtYsL4=zl_uk zZe4k8PC$-di_g0oU47&AVk_^s9chuTTBqV3ox5+k@qV$bMEdQ5ZS${3R&Kaqv5tRc zl1hG*udy++_Ge}W{=@?S!i;5})-^q}H8ckdN4WFlF>9lfI2gk9Q><4cE{&JSl+#xAj~PoOd}(v)uhQLQ*5o- zcDB|wHXO&9&K!Gp2OAp~p{qNJ5d^_@7JG?s&zU>|rx_X=GL4v)#>STTG@EJopO=6? zF~JLfWdLX(ooTZp0^_c07CD+11_Cs~#MBHT=`a>rwasFc~x| zV+IR&gP<(7+HoZWZBro#3gvg(IYF?yYzYK)TOn8+a<6PmL@DfVYM-=^rq)&a3<$?Q z9?cqWY9CE3OcO(3MSd6iH3Y|(mq2iMb9BFAtngTwMmKiNXv*F^EAlU_X~v;ipVaE{ zjB}w7lvjj9@Z)O;W}g3PGL_AyB8yf^4m*B73fpoq4-Rb^JF71hwpOw^Y#W z=>>sfXhYdBk_SPc`Kg;D=e6@lHUtm3<9K`MY}L!x_TRWuBU(m|MxUx88z4}>Hv)n7 zKG{<^n&!n&T^*ycX{|U!_TAW`Err18mFlKu7X&>{2P4w^JG2ucS$6yUaOXJ)RxgG? zncCkq-arm1mmDzhfuLju^>dd(5cjVOMA>UckFxQ4Dt2x`1OyNWjUY%otbKGZEyi0t zf0MU{nuX@v8EM||J|d5ce7k*8l0q7bh?JHLt|Lyt^A@8C@vk`I3;u68G6QCRYmV|R zKensS3Ta+F6y2;7=rRWxNnBCIIlW-Rq8EcDn=CIaUVxkWZC~0N)@`9$PMkfvzojW~ zr?GeEx#VW;optezk*zDP=@id6)P$%eCtrPdAkJBMyf=(UUH@gDd*ugr$xU8%nj3Y< zNc!`-=tYq=|44SUFMM>;V^2r^ps`9kRElpr65Sl2h%J-UW~`p&)^udU{^4NDB+a78 z0Jj>K&H1^fvD5EmgRZeq72C9}`$2eccSuApt1X;R_iVS_d)t4GME%40+fUn4+z%gY zOdSj_8{_OpAvm~{TFw`f$o8?o)MvvHW@iU<$6x05$y#37?+&}MNs(ZdsrS@WR-(7+ zklRFXGWJt}tz# zYFkiHyfS0Y-5qN{zw_8<-o|9>@_P`>t=#6V;=XokXOSXn8$oP=|;RPV_tF;$z2DosM!ZNg}rWNH4uE7^-l`y8JDS^9^ISm!~P9( z$c730CZH2j(4h{*FU(<-_~*zsa3D0k3tCE$bpA|p21Kfk{{ig2w zy1PT|yYqt7dH3=1`N~8xTWeFYvS{hbQ+wjBnL6!!_}%issUIFYF?COy@e^D-RDHc6 z|J$&Y;14%%4E@NGk!8uCQI%e6$zV9zP&XY8$_YWZ3s7+s#>4o6C{!SlVT4?aqf!j# z%Y~9CT#QPjQBpz{DHqB)!nXk;DK5sPI8I39VvNT}Q9e%aFsV!|lZm3FVj(7%;xZW@ zPaGAB_~If3hao0~RCW`(UyPI};^V*5i3w^9|LKQg_OmN^w$qlN}dQU(oiW2cnCK{p`dQ4R3dMtCN4_B!Kh5Bmp5cf5|cJ3%A*h} Ph!Bd9>C@)~%|-qV#4)y8 delta 703 zcmdmTpXc-;o(XmJ#-;{#c3j0JMX8CoTosH-%Pc-Evm03 z6bqWqn6{=bvMKY7(6LurI4?L(eBplQo2;nkozf7M!g|J+FAfMfFR9PB;*2d@D;dr% zzqTTp%X?K|aMrmCAu4`+*KK`*t|?#CdVj%u&(A$?QjdMvBA2%1Y2nS}xn@%$x0P3P z|6|<#cYe&7^E-FF30pZkr`^_T_Pk|V{dQNMc)UgPj*j(8jj!@8U(6T!Zho`va8GDj z>+|f|H!rT-c=@;L`rNZ$4c8}!-K&4JmtQO84eR|2weDB6+GT_|9{ot&)Rq{c*(M-Z z8*tJ!?TTc$yzto>Z40f^OTC>x#N9T0{zQ83#;eku$(wIININ+FzsKJs^*srt7o*Hv zpZ@6DdG4V1w_m*#UlY;~aNiA>cqI0_F$2T@|8I+KtmR70OMwP8kd>d5#kF|`lP_cQ zU4izy0*pY+wEeCC^A~AG^XX~2%qol)(|dH8o%M`NER9Vxx%7SWQ(O{DQWZ2@tc(nd zj14Rejf|jjz&M1OXgU3#E^~&70ha+BD43a=8k;JlDZs=`4a^n5vI=<+F(U&LV+*6{ zv-FrP>rE|9P$hvX%`8nZ#LO)XQN@6Un3-UTnVTY+S5lOinUh+?Wn;soADmg0s$giq xr5}`^U!q{CV4x7hrSGYdmzJ+!0p@@cW@1rEMNw)R7tnMIQ$sFQRabvEE&x-U5ZeF% From 1da8227bf54b0fffb4a753f5089ee8d78ca63514 Mon Sep 17 00:00:00 2001 From: Felipe Amaral Date: Tue, 12 Sep 2023 23:21:29 -0300 Subject: [PATCH 19/24] refactor receiver names --- cmd/main.go | 6 +++--- pkg/v2/code/barcode/barcode.go | 14 +++++++------- pkg/v2/code/matrixcode/matrixcode.go | 14 +++++++------- pkg/v2/code/qrcode/qrcode.go | 14 +++++++------- pkg/v2/col/col.go | 3 ++- pkg/v2/col/col_test.go | 4 ++-- pkg/v2/component.go | 2 +- pkg/v2/image/base64image.go | 16 ++++++++-------- pkg/v2/image/fileimage.go | 14 +++++++------- pkg/v2/row/row.go | 3 ++- pkg/v2/signature/signature.go | 4 ++-- pkg/v2/text/text.go | 4 ++-- v2.pdf | Bin 208820 -> 208820 bytes 13 files changed, 50 insertions(+), 48 deletions(-) diff --git a/cmd/main.go b/cmd/main.go index 72552e94..b1c68d23 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -27,7 +27,7 @@ func main() { } func buildRow() v2.Component { - row := row.New(20) + r := row.New(20) //image := image.New("image1") @@ -40,8 +40,8 @@ func buildRow() v2.Component { col3 := col.New(4) col3.Add(text.New("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec ac condimentum sem. ")) - row.Add(col1, col2, col3) - return row + r.Add(col1, col2, col3) + return r } func buildContent() v2.Component { diff --git a/pkg/v2/code/barcode/barcode.go b/pkg/v2/code/barcode/barcode.go index 3440c8b1..1a9c6a5e 100644 --- a/pkg/v2/code/barcode/barcode.go +++ b/pkg/v2/code/barcode/barcode.go @@ -30,14 +30,14 @@ func New(code string, barcodeProps ...props.Barcode) *barcode { } } -func (i *barcode) Render(fpdf fpdf.Fpdf, ctx context.Context) { +func (b *barcode) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) code := internal.NewCode(fpdf, math) - err := code.AddBar(i.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, + err := code.AddBar(b.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, fpdf.GetY() - ctx.Margins.Top, ctx.Dimensions.Width, - ctx.Dimensions.Height}, i.prop) + ctx.Dimensions.Height}, b.prop) if err != nil { fpdf.ClearError() @@ -46,10 +46,10 @@ func (i *barcode) Render(fpdf fpdf.Fpdf, ctx context.Context) { } } -func (i *barcode) GetType() string { - return i._type.String() +func (b *barcode) GetType() string { + return b._type.String() } -func (i *barcode) Add(_ ...v2.Component) { - return +func (b *barcode) Add(component ...v2.Component) v2.Component { + return b } diff --git a/pkg/v2/code/matrixcode/matrixcode.go b/pkg/v2/code/matrixcode/matrixcode.go index 8d4ae54a..64f5705e 100644 --- a/pkg/v2/code/matrixcode/matrixcode.go +++ b/pkg/v2/code/matrixcode/matrixcode.go @@ -29,20 +29,20 @@ func New(code string, barcodeProps ...props.Rect) *matrixCode { } } -func (i *matrixCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { +func (m *matrixCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) code := internal.NewCode(fpdf, math) - code.AddDataMatrix(i.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, + code.AddDataMatrix(m.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, fpdf.GetY() - ctx.Margins.Top, ctx.Dimensions.Width, - ctx.Dimensions.Height}, i.prop) + ctx.Dimensions.Height}, m.prop) } -func (i *matrixCode) GetType() string { - return i._type.String() +func (m *matrixCode) GetType() string { + return m._type.String() } -func (i *matrixCode) Add(_ ...v2.Component) { - return +func (m *matrixCode) Add(component ...v2.Component) v2.Component { + return m } diff --git a/pkg/v2/code/qrcode/qrcode.go b/pkg/v2/code/qrcode/qrcode.go index 90a97258..78e85cb6 100644 --- a/pkg/v2/code/qrcode/qrcode.go +++ b/pkg/v2/code/qrcode/qrcode.go @@ -29,20 +29,20 @@ func New(code string, barcodeProps ...props.Rect) *qrCode { } } -func (i *qrCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { +func (q *qrCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) code := internal.NewCode(fpdf, math) - code.AddQr(i.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, + code.AddQr(q.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, fpdf.GetY() - ctx.Margins.Top, ctx.Dimensions.Width, - ctx.Dimensions.Height}, i.prop) + ctx.Dimensions.Height}, q.prop) } -func (i *qrCode) GetType() string { - return i._type.String() +func (q *qrCode) GetType() string { + return q._type.String() } -func (i *qrCode) Add(_ ...v2.Component) { - return +func (q *qrCode) Add(component ...v2.Component) v2.Component { + return q } diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index 9e620d29..36cb75f0 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -27,12 +27,13 @@ func (c *col) GetType() string { return c._type.String() } -func (c *col) Add(components ...v2.Component) { +func (c *col) Add(components ...v2.Component) v2.Component { for _, component := range components { if c._type.Accept(component.GetType()) { c.components = append(c.components, component) } } + return c } func (c *col) Render(fpdf fpdf.Fpdf, ctx context.Context) { diff --git a/pkg/v2/col/col_test.go b/pkg/v2/col/col_test.go index ae0788dd..35389b61 100644 --- a/pkg/v2/col/col_test.go +++ b/pkg/v2/col/col_test.go @@ -362,8 +362,8 @@ func (i *invalidComponent) GetType() string { return i._type.String() } -func (i *invalidComponent) Add(_ ...v2.Component) { - return +func (i *invalidComponent) Add(component ...v2.Component) v2.Component { + return nil } // endregion diff --git a/pkg/v2/component.go b/pkg/v2/component.go index ba1413cc..a11c5c9c 100644 --- a/pkg/v2/component.go +++ b/pkg/v2/component.go @@ -8,5 +8,5 @@ import ( type Component interface { Render(fpdf fpdf.Fpdf, ctx context.Context) GetType() string - Add(component ...Component) + Add(components ...Component) Component } diff --git a/pkg/v2/image/base64image.go b/pkg/v2/image/base64image.go index 6c77d2a5..5b309851 100644 --- a/pkg/v2/image/base64image.go +++ b/pkg/v2/image/base64image.go @@ -33,17 +33,17 @@ func NewFromBase64(path string, extension consts.Extension, imageProps ...props. } } -func (i *base64Image) Render(fpdf fpdf.Fpdf, ctx context.Context) { +func (b *base64Image) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) img := internal.NewImage(fpdf, math) err := img.AddFromBase64( - i.path, + b.path, internal.Cell{fpdf.GetX() - ctx.Margins.Left, fpdf.GetY() - ctx.Margins.Top, ctx.Dimensions.Width, ctx.Dimensions.Height}, - i.prop, - i.extension, + b.prop, + b.extension, ) if err != nil { fpdf.ClearError() @@ -52,10 +52,10 @@ func (i *base64Image) Render(fpdf fpdf.Fpdf, ctx context.Context) { } } -func (i *base64Image) GetType() string { - return i._type.String() +func (b *base64Image) GetType() string { + return b._type.String() } -func (i *base64Image) Add(_ ...v2.Component) { - return +func (b *base64Image) Add(_ ...v2.Component) v2.Component { + return b } diff --git a/pkg/v2/image/fileimage.go b/pkg/v2/image/fileimage.go index ea135501..1475a736 100644 --- a/pkg/v2/image/fileimage.go +++ b/pkg/v2/image/fileimage.go @@ -30,16 +30,16 @@ func NewFromFile(path string, imageProps ...props.Rect) *fileImage { } } -func (i *fileImage) Render(fpdf fpdf.Fpdf, ctx context.Context) { +func (f *fileImage) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) img := internal.NewImage(fpdf, math) err := img.AddFromFile( - i.path, + f.path, internal.Cell{fpdf.GetX() - ctx.Margins.Left, fpdf.GetY() - ctx.Margins.Top, ctx.Dimensions.Width, ctx.Dimensions.Height}, - i.prop) + f.prop) if err != nil { fpdf.ClearError() txt := text.New("Failed to render fileImage") @@ -47,10 +47,10 @@ func (i *fileImage) Render(fpdf fpdf.Fpdf, ctx context.Context) { } } -func (i *fileImage) GetType() string { - return i._type.String() +func (f *fileImage) GetType() string { + return f._type.String() } -func (i *fileImage) Add(_ ...v2.Component) { - return +func (f *fileImage) Add(_ ...v2.Component) v2.Component { + return f } diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 68833eb9..27caa627 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -23,12 +23,13 @@ func (r *row) GetType() string { return r._type.String() } -func (r *row) Add(components ...v2.Component) { +func (r *row) Add(components ...v2.Component) v2.Component { for _, component := range components { if r._type.Accept(component.GetType()) { r.components = append(r.components, component) } } + return r } func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { diff --git a/pkg/v2/signature/signature.go b/pkg/v2/signature/signature.go index 1fed9c39..7877d412 100644 --- a/pkg/v2/signature/signature.go +++ b/pkg/v2/signature/signature.go @@ -49,6 +49,6 @@ func (s *signature) GetType() string { return s._type.String() } -func (s *signature) Add(_ ...v2.Component) { - return +func (s *signature) Add(_ ...v2.Component) v2.Component { + return s } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index ea19f187..ab8e1c2d 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -34,8 +34,8 @@ func (t *text) GetType() string { return t._type.String() } -func (t *text) Add(_ ...v2.Component) { - return +func (t *text) Add(_ ...v2.Component) v2.Component { + return t } func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) { diff --git a/v2.pdf b/v2.pdf index 6ae1ee3672bdb348189516c666f24b8d56beebe9..6344fbc009b389ab94619291a83193254fd61330 100644 GIT binary patch delta 189 zcmdmTpJ&T`o()f!H`j1XVVUg1VX)bOH=B8~0Iy;5U4izy0*pY+wEeCCvzYYc)dEJF zpE9SjO#iIS>@qz=hgpBRsSdN@^yxaxR*aU@FY7QHFc}(5XVGOgU^Jg@3Zg8gr|B|h zDHvKB8)$Or`{t*(B$lKqXt-Dz85kKGSQ;7`8H41uf6!%CVAL|RP%r=ig**i=Fv9?( S235?+z|73TXu6d?a}@x_=QD2r delta 191 zcmdmTpJ&T`o()f!w|A>EXRu7J;4s+ygn0_fWMLk|%_}*wn5RdnGaEI#@U*+|Faj~t zb{8IIG3n`_wV7R}XXr5NPdC+JHk>|PhuMnB&|vx{9cBYY^XV+QK+0meDTuP1o~Fy3 zrC?xcXrjrb@0*|El30?epy6U=WME`$U}Vf%LY@K_m| Date: Tue, 12 Sep 2023 23:51:26 -0300 Subject: [PATCH 20/24] add page component --- cmd/main.go | 8 ++++++-- pkg/v2/context/context.go | 12 ++++++++++++ pkg/v2/page/page.go | 39 ++++++++++++++++++++++++++++++++++++++ pkg/v2/row/row.go | 5 ++++- pkg/v2/types.go | 4 ++-- v2.pdf | Bin 208820 -> 212002 bytes 6 files changed, 63 insertions(+), 5 deletions(-) create mode 100644 pkg/v2/page/page.go diff --git a/cmd/main.go b/cmd/main.go index b1c68d23..0d76e604 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -7,6 +7,7 @@ import ( "github.com/johnfercher/maroto/pkg/v2/code/qrcode" "github.com/johnfercher/maroto/pkg/v2/col" "github.com/johnfercher/maroto/pkg/v2/image" + "github.com/johnfercher/maroto/pkg/v2/page" "github.com/johnfercher/maroto/pkg/v2/row" "github.com/johnfercher/maroto/pkg/v2/text" "log" @@ -17,8 +18,11 @@ func main() { header := buildRow() content := buildContent() - //footer := buildRow() - pdf.Add(header, content /*content footer*/) + p := page.New().Add( + content, content, content, content, content, content, content, content, + content, content, content, content, content, content, content, content, + ) + pdf.Add(header, p /*content footer*/) err := pdf.Generate("v2.pdf") if err != nil { diff --git a/pkg/v2/context/context.go b/pkg/v2/context/context.go index 2113c117..63d7903d 100644 --- a/pkg/v2/context/context.go +++ b/pkg/v2/context/context.go @@ -2,6 +2,7 @@ package context import ( "fmt" + "math" ) const LineHeight = 20 @@ -67,6 +68,17 @@ func (c Context) GetYOffset() float64 { return baseY } +func (c Context) NewPage(pageCount int) Context { + ctx := c.copy() + ctx.CurrentPage = int(math.Max(float64(pageCount), float64(c.CurrentPage+1))) + ctx.Coordinate.X = 0 + ctx.Coordinate.Y = 0 + return ctx +} + +func (c Context) GetCurrentPage() int { + return c.CurrentPage +} func (c Context) Print(label interface{}) { fmt.Println(label) diff --git a/pkg/v2/page/page.go b/pkg/v2/page/page.go new file mode 100644 index 00000000..0403e669 --- /dev/null +++ b/pkg/v2/page/page.go @@ -0,0 +1,39 @@ +package page + +import ( + "github.com/johnfercher/maroto/internal/fpdf" + v2 "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/context" +) + +type page struct { + _type v2.DocumentType + components []v2.Component +} + +func New() *page { + return &page{ + _type: v2.Page, + } +} + +func (p *page) Render(fpdf fpdf.Fpdf, ctx context.Context) { + fpdf.AddPage() + ctx = ctx.NewPage(fpdf.PageNo()) + for _, component := range p.components { + component.Render(fpdf, ctx) + } +} + +func (p *page) GetType() string { + return p._type.String() +} + +func (p *page) Add(components ...v2.Component) v2.Component { + for _, component := range components { + if p._type.Accept(component.GetType()) { + p.components = append(p.components, component) + } + } + return p +} diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 27caa627..16027d5f 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -34,8 +34,11 @@ func (r *row) Add(components ...v2.Component) v2.Component { func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(r.height) - ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) + if ctx.GetYOffset() == 0 && ctx.GetCurrentPage() >= fpdf.PageCount() { + fpdf.AddPage() + ctx = ctx.NewPage(fpdf.PageNo()) + } for _, component := range r.components { component.Render(fpdf, ctx) } diff --git a/pkg/v2/types.go b/pkg/v2/types.go index 6e5c0c3e..8f9f91c6 100644 --- a/pkg/v2/types.go +++ b/pkg/v2/types.go @@ -10,7 +10,7 @@ const ( Image = "image" Text = "text" Signature = "signature" - Leaf = "leaf" + Leaf = "leaf" ) type DocumentType string @@ -28,7 +28,7 @@ func (t DocumentType) Accept(dt string) bool { func buildAcceptedMap() map[string][]string { return map[string][]string{ - Document: {Row}, + Document: {Row, Page}, Page: {Row}, Row: {Col}, Leaf: {}, diff --git a/v2.pdf b/v2.pdf index 6344fbc009b389ab94619291a83193254fd61330..ad9090d69f7f25fcceb0807ced8a8cc63a0fa78e 100644 GIT binary patch delta 2489 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 From c5a6e9ab0a783a4f517bc8a527ddd937d9f59a69 Mon Sep 17 00:00:00 2001 From: John Fercher Date: Wed, 13 Sep 2023 00:56:52 -0300 Subject: [PATCH 21/24] Add get structure --- cmd/main.go | 4 +- go.mod | 8 ++-- go.sum | 12 ++++++ pkg/v2/code/barcode/barcode.go | 12 +++++- pkg/v2/code/matrixcode/matrixcode.go | 12 +++++- pkg/v2/code/qrcode/qrcode.go | 12 +++++- pkg/v2/col/col.go | 18 +++++++++ pkg/v2/component.go | 8 ++++ pkg/v2/document.go | 27 +++++++++++-- pkg/v2/document_test.go | 58 +++++++++++++++++++++++++++ pkg/v2/image/base64image.go | 21 ++++++++-- pkg/v2/image/fileimage.go | 10 +++++ pkg/v2/page/page.go | 16 ++++++++ pkg/v2/row/row.go | 18 +++++++++ pkg/v2/signature/signature.go | 10 +++++ pkg/v2/text/text.go | 10 +++++ pkg/v2/types.go | 21 +++++----- v2.pdf | Bin 212002 -> 212002 bytes 18 files changed, 252 insertions(+), 25 deletions(-) create mode 100644 pkg/v2/document_test.go diff --git a/cmd/main.go b/cmd/main.go index 0d76e604..7b1833ae 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -14,7 +14,7 @@ import ( ) func main() { - pdf := v2.NewDocument() + pdf := v2.NewDocument("v2.pdf") header := buildRow() content := buildContent() @@ -24,7 +24,7 @@ func main() { ) pdf.Add(header, p /*content footer*/) - err := pdf.Generate("v2.pdf") + err := pdf.Generate() if err != nil { log.Fatal(err.Error()) } diff --git a/go.mod b/go.mod index f5a0de01..b425b1e9 100644 --- a/go.mod +++ b/go.mod @@ -1,18 +1,20 @@ module github.com/johnfercher/maroto -go 1.18 +go 1.21.1 require ( github.com/boombuler/barcode v1.0.1 github.com/google/uuid v1.3.0 + github.com/johnfercher/go-tree v1.0.2 github.com/jung-kurt/gofpdf v1.16.2 github.com/pkg/errors v0.9.1 - github.com/stretchr/testify v1.3.0 + github.com/stretchr/testify v1.8.4 ) require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245 // indirect - github.com/stretchr/objx v0.2.0 // indirect + github.com/stretchr/objx v0.5.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 0c170f49..451e813c 100644 --- a/go.sum +++ b/go.sum @@ -6,6 +6,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/johnfercher/go-tree v1.0.2 h1:9dZVcUjTAOpjC1Qemuxtl/xJRJjRpc3GOLOc/BOTyo0= +github.com/johnfercher/go-tree v1.0.2/go.mod h1:DUO6QkXIFh1K7jeGBIkLCZaeUgnkdQAsB64FDSoHswg= github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= github.com/jung-kurt/gofpdf v1.16.2 h1:jgbatWHfRlPYiK85qgevsZTHviWXKwB1TTiKdz5PtRc= github.com/jung-kurt/gofpdf v1.16.2/go.mod h1:1hl7y57EsiPAkLbOwzpzqgx1A30nQCk/YmFV8S2vmK0= @@ -23,8 +25,18 @@ github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245/go.mod h1:pQAZ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.2.0 h1:Hbg2NidpLE8veEBkEZTL3CvlkUIVzuU9jDplZO54c48= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/v2/code/barcode/barcode.go b/pkg/v2/code/barcode/barcode.go index 1a9c6a5e..5816f83b 100644 --- a/pkg/v2/code/barcode/barcode.go +++ b/pkg/v2/code/barcode/barcode.go @@ -1,6 +1,7 @@ package barcode import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" @@ -24,7 +25,7 @@ func New(code string, barcodeProps ...props.Barcode) *barcode { prop.MakeValid() return &barcode{ - _type: v2.Leaf, + _type: v2.Barcode, code: code, prop: prop, } @@ -53,3 +54,12 @@ func (b *barcode) GetType() string { func (b *barcode) Add(component ...v2.Component) v2.Component { return b } + +func (b *barcode) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(b._type), + Value: b.code, + } + + return tree.NewNode(0, str) +} diff --git a/pkg/v2/code/matrixcode/matrixcode.go b/pkg/v2/code/matrixcode/matrixcode.go index 64f5705e..c2e8b31a 100644 --- a/pkg/v2/code/matrixcode/matrixcode.go +++ b/pkg/v2/code/matrixcode/matrixcode.go @@ -1,6 +1,7 @@ package matrixcode import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" @@ -23,7 +24,7 @@ func New(code string, barcodeProps ...props.Rect) *matrixCode { prop.MakeValid() return &matrixCode{ - _type: v2.Leaf, + _type: v2.MatrixCode, code: code, prop: prop, } @@ -46,3 +47,12 @@ func (m *matrixCode) GetType() string { func (m *matrixCode) Add(component ...v2.Component) v2.Component { return m } + +func (m *matrixCode) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(m._type), + Value: m.code, + } + + return tree.NewNode(0, str) +} diff --git a/pkg/v2/code/qrcode/qrcode.go b/pkg/v2/code/qrcode/qrcode.go index 78e85cb6..34063f95 100644 --- a/pkg/v2/code/qrcode/qrcode.go +++ b/pkg/v2/code/qrcode/qrcode.go @@ -1,6 +1,7 @@ package qrcode import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" @@ -23,7 +24,7 @@ func New(code string, barcodeProps ...props.Rect) *qrCode { prop.MakeValid() return &qrCode{ - _type: v2.Leaf, + _type: v2.QrCode, code: code, prop: prop, } @@ -46,3 +47,12 @@ func (q *qrCode) GetType() string { func (q *qrCode) Add(component ...v2.Component) v2.Component { return q } + +func (q *qrCode) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(q._type), + Value: q.code, + } + + return tree.NewNode(0, str) +} diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index 36cb75f0..a2ac0cb8 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -1,6 +1,8 @@ package col import ( + "fmt" + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" @@ -36,6 +38,22 @@ func (c *col) Add(components ...v2.Component) v2.Component { return c } +func (c *col) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(c._type), + Value: fmt.Sprintf("%d", c.size), + } + + node := tree.NewNode(0, str) + + for _, c := range c.components { + inner := c.GetStructure() + node.AddNext(inner) + } + + return node +} + func (c *col) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(c.size) ctx = c.setRelativeDimension(ctx) diff --git a/pkg/v2/component.go b/pkg/v2/component.go index a11c5c9c..9bf66581 100644 --- a/pkg/v2/component.go +++ b/pkg/v2/component.go @@ -1,6 +1,7 @@ package v2 import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2/context" ) @@ -9,4 +10,11 @@ type Component interface { Render(fpdf fpdf.Fpdf, ctx context.Context) GetType() string Add(components ...Component) Component + GetStructure() *tree.Node[Structure] +} + +type Structure struct { + Type string + Value string + Props map[string]string } diff --git a/pkg/v2/document.go b/pkg/v2/document.go index caeedbd4..f63984ea 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -1,6 +1,7 @@ package v2 import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2/context" "github.com/jung-kurt/gofpdf" @@ -8,17 +9,19 @@ import ( type Maroto interface { Add(component ...Component) - Generate(file string) error + Generate() error + GetStructure() *tree.Node[Structure] } type document struct { + file string ctx context.Context _type DocumentType fpdf fpdf.Fpdf components []Component } -func NewDocument() *document { +func NewDocument(file string) *document { fpdf := gofpdf.NewCustom(&gofpdf.InitType{ OrientationStr: "P", UnitStr: "mm", @@ -33,6 +36,7 @@ func NewDocument() *document { fpdf.AddPage() return &document{ + file: file, fpdf: fpdf, _type: Document, ctx: context.NewRootContext(width, height, &context.Margins{ @@ -52,7 +56,7 @@ func (d *document) Add(components ...Component) { } } -func (d *document) Generate(file string) error { +func (d *document) Generate() error { d.ctx.Print(d._type) ctx := d.ctx.WithDimension(d.ctx.MaxWidth(), d.ctx.MaxHeight()) @@ -60,5 +64,20 @@ func (d *document) Generate(file string) error { component.Render(d.fpdf, ctx) } - return d.fpdf.OutputFileAndClose(file) + return d.fpdf.OutputFileAndClose(d.file) +} + +func (d *document) GetStructure() *tree.Node[Structure] { + str := Structure{ + Type: string(d._type), + Value: d.file, + } + node := tree.NewNode(0, str) + + for _, c := range d.components { + inner := c.GetStructure() + node.AddNext(inner) + } + + return node } diff --git a/pkg/v2/document_test.go b/pkg/v2/document_test.go new file mode 100644 index 00000000..40e6ee85 --- /dev/null +++ b/pkg/v2/document_test.go @@ -0,0 +1,58 @@ +package v2_test + +import ( + "fmt" + "github.com/johnfercher/maroto/pkg/consts" + v2 "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/v2/code/barcode" + "github.com/johnfercher/maroto/pkg/v2/code/matrixcode" + "github.com/johnfercher/maroto/pkg/v2/code/qrcode" + "github.com/johnfercher/maroto/pkg/v2/col" + "github.com/johnfercher/maroto/pkg/v2/image" + "github.com/johnfercher/maroto/pkg/v2/row" + "github.com/johnfercher/maroto/pkg/v2/signature" + "github.com/johnfercher/maroto/pkg/v2/text" + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNewDocument(t *testing.T) { + // Act + sut := v2.NewDocument("file.pdf") + + // Assert + assert.NotNil(t, sut) + assert.Equal(t, "*v2.document", fmt.Sprintf("%T", sut)) +} + +func TestDocument_GetStructure(t *testing.T) { + // Arrange + p := v2.NewDocument("file.txt") + + r1 := row.New(10) + r1c1 := col.New(4).Add(barcode.New("barcode")) + r1c2 := col.New(4).Add(matrixcode.New("matrixcode")) + r1c3 := col.New(4).Add(qrcode.New("qrcode")) + r1.Add(r1c1, r1c2, r1c3) + + r2 := row.New(10) + r2c1 := col.New(3).Add(image.NewFromFile("file.png")) + r2c2 := col.New(3).Add(image.NewFromBase64("base64string", consts.Png)) + r2c3 := col.New(3).Add(signature.New("signature")) + r2c4 := col.New(3).Add(text.New("text")) + r2.Add(r2c1, r2c2, r2c3, r2c4) + + p.Add(r1, r2) + + // Act + nodeDocument := p.GetStructure() + + // Assert Document + assert.NotNil(t, nodeDocument) + _, document := nodeDocument.Get() + assert.Equal(t, "document", document.Type) + assert.Equal(t, "file.txt", document.Value) + + nodeRows := nodeDocument.GetNexts() + assert.Equal(t, 2, len(nodeRows)) +} diff --git a/pkg/v2/image/base64image.go b/pkg/v2/image/base64image.go index 5b309851..f27457c0 100644 --- a/pkg/v2/image/base64image.go +++ b/pkg/v2/image/base64image.go @@ -1,6 +1,7 @@ package image import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/consts" @@ -11,7 +12,7 @@ import ( ) type base64Image struct { - path string + base64 string extension consts.Extension _type v2.DocumentType components []v2.Component @@ -27,7 +28,7 @@ func NewFromBase64(path string, extension consts.Extension, imageProps ...props. return &base64Image{ _type: v2.Image, - path: path, + base64: path, prop: prop, extension: extension, } @@ -37,7 +38,7 @@ func (b *base64Image) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) img := internal.NewImage(fpdf, math) err := img.AddFromBase64( - b.path, + b.base64, internal.Cell{fpdf.GetX() - ctx.Margins.Left, fpdf.GetY() - ctx.Margins.Top, ctx.Dimensions.Width, @@ -59,3 +60,17 @@ func (b *base64Image) GetType() string { func (b *base64Image) Add(_ ...v2.Component) v2.Component { return b } + +func (b *base64Image) GetStructure() *tree.Node[v2.Structure] { + trimLength := 10 + if len(b.base64) < trimLength { + trimLength = len(b.base64) + } + + str := v2.Structure{ + Type: string(b._type), + Value: b.base64[:trimLength], + } + + return tree.NewNode(0, str) +} diff --git a/pkg/v2/image/fileimage.go b/pkg/v2/image/fileimage.go index 1475a736..ec8a321d 100644 --- a/pkg/v2/image/fileimage.go +++ b/pkg/v2/image/fileimage.go @@ -1,6 +1,7 @@ package image import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" @@ -54,3 +55,12 @@ func (f *fileImage) GetType() string { func (f *fileImage) Add(_ ...v2.Component) v2.Component { return f } + +func (f *fileImage) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(f._type), + Value: f.path, + } + + return tree.NewNode(0, str) +} diff --git a/pkg/v2/page/page.go b/pkg/v2/page/page.go index 0403e669..bc6cce54 100644 --- a/pkg/v2/page/page.go +++ b/pkg/v2/page/page.go @@ -1,6 +1,7 @@ package page import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" @@ -37,3 +38,18 @@ func (p *page) Add(components ...v2.Component) v2.Component { } return p } + +func (p *page) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(p._type), + } + + node := tree.NewNode(0, str) + + for _, c := range p.components { + inner := c.GetStructure() + node.AddNext(inner) + } + + return node +} diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 16027d5f..eb4e73ce 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -1,6 +1,8 @@ package row import ( + "fmt" + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" @@ -32,6 +34,22 @@ func (r *row) Add(components ...v2.Component) v2.Component { return r } +func (r *row) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(r._type), + Value: fmt.Sprintf("%2.f", r.height), + } + + node := tree.NewNode(0, str) + + for _, c := range r.components { + inner := c.GetStructure() + node.AddNext(inner) + } + + return node +} + func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(r.height) ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) diff --git a/pkg/v2/signature/signature.go b/pkg/v2/signature/signature.go index 7877d412..9586c7a1 100644 --- a/pkg/v2/signature/signature.go +++ b/pkg/v2/signature/signature.go @@ -1,6 +1,7 @@ package signature import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/consts" @@ -52,3 +53,12 @@ func (s *signature) GetType() string { func (s *signature) Add(_ ...v2.Component) v2.Component { return s } + +func (s *signature) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(s._type), + Value: s.value, + } + + return tree.NewNode(0, str) +} diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index ab8e1c2d..54188fd1 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -1,6 +1,7 @@ package text import ( + "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/consts" @@ -38,6 +39,15 @@ func (t *text) Add(_ ...v2.Component) v2.Component { return t } +func (t *text) GetStructure() *tree.Node[v2.Structure] { + str := v2.Structure{ + Type: string(t._type), + Value: t.value, + } + + return tree.NewNode(0, str) +} + func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) { ctx.Print(t.value) t.render(fpdf, ctx) diff --git a/pkg/v2/types.go b/pkg/v2/types.go index 8f9f91c6..8423910d 100644 --- a/pkg/v2/types.go +++ b/pkg/v2/types.go @@ -3,14 +3,16 @@ package v2 import "slices" const ( - Document = "document" - Row = "row" - Page = "page" - Col = "col" - Image = "image" - Text = "text" - Signature = "signature" - Leaf = "leaf" + Document = "document" + Row = "row" + Page = "page" + Col = "col" + Image = "image" + Text = "text" + Signature = "signature" + Barcode = "barcode" + QrCode = "qrcode" + MatrixCode = "matrixcode" ) type DocumentType string @@ -31,7 +33,6 @@ func buildAcceptedMap() map[string][]string { Document: {Row, Page}, Page: {Row}, Row: {Col}, - Leaf: {}, - Col: {Row, Image, Text, Signature, Leaf}, + Col: {Row, Image, Text, Signature, Barcode, QrCode, MatrixCode}, } } diff --git a/v2.pdf b/v2.pdf index ad9090d69f7f25fcceb0807ced8a8cc63a0fa78e..88a58cc3501b45a02fe27095e46f8b5ec0f7db88 100644 GIT binary patch delta 340 zcmZ4VgJ;nXo(+dNHme9`uuRtDG1z>FBZqnNX90uFaXeF5ntMdsdqf$5m}z^DD6_f@ zqv13&WB`0i1}2t9rkY&(zWFIG yi6yBD8ZK5w21dpPmWEKd?R-|u`HbSm<^~D|AfS+^zy)R)m>5}_OrK)S+y?*)h+{hd delta 350 zcmZ4VgJ;nXo(+dNHplR0Gf&p$HQ4-JU@FVx;{pbo4{>C&H1~+M_lPnAG1K-QQD$|S z>GzG8jiv`$0tshhW+O(U=@ZPE4H*rmKQLl81dBt3rVE0kq2h2&Fv-n^SoOlpL^jOG zj5&EaNIi-q*hF+=Vb*;%2dc)d1uTW^G`IlF!7Y}|>B>e%#-@e_#+qFEzWFIGi6yBD u8ZK5w21dpPmWEKd?R-|u`HbR*hUN+eAfS+^zy)R)m>3&dOrK)S+y?-|eq@0F From 0d2fe48639773f8afa25c5dc108d5fa679c5dec5 Mon Sep 17 00:00:00 2001 From: John Fercher Date: Wed, 13 Sep 2023 09:43:51 -0300 Subject: [PATCH 22/24] Limit pdf structure errors at compilation time --- cmd/main.go | 8 ++-- internal/signature_test.go | 12 +++--- pkg/pdf/example_test.go | 30 +++++++------- pkg/pdf/pdf_test.go | 56 +++++++++++++-------------- pkg/v2/code/barcode/barcode.go | 11 +++--- pkg/v2/code/matrixcode/matrixcode.go | 11 +++--- pkg/v2/code/qrcode/qrcode.go | 11 +++--- pkg/v2/col/col.go | 21 +++++----- pkg/v2/col/col_test.go | 13 ++++--- pkg/v2/component.go | 20 ---------- pkg/v2/document.go | 44 ++++++++++----------- pkg/v2/domain.go | 46 ++++++++++++++++++++++ pkg/v2/image/base64image.go | 13 +++---- pkg/v2/image/fileimage.go | 11 +++--- pkg/v2/page/page.go | 25 ++++++------ pkg/v2/row/row.go | 30 +++++++------- pkg/v2/signature/signature.go | 11 +++--- pkg/v2/text/text.go | 11 +++--- pkg/v2/{ => types}/types.go | 2 +- v2.pdf | Bin 212002 -> 212002 bytes 20 files changed, 207 insertions(+), 179 deletions(-) delete mode 100644 pkg/v2/component.go create mode 100644 pkg/v2/domain.go rename pkg/v2/{ => types}/types.go (98%) diff --git a/cmd/main.go b/cmd/main.go index 7b1833ae..ade8d2c5 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -22,7 +22,9 @@ func main() { content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, ) - pdf.Add(header, p /*content footer*/) + + pdf.Add(header /*content footer*/) + pdf.ForceAddPage(p) err := pdf.Generate() if err != nil { @@ -30,7 +32,7 @@ func main() { } } -func buildRow() v2.Component { +func buildRow() v2.Row { r := row.New(20) //image := image.New("image1") @@ -48,7 +50,7 @@ func buildRow() v2.Component { return r } -func buildContent() v2.Component { +func buildContent() v2.Row { row := row.New(20) col1 := col.New(4) diff --git a/internal/signature_test.go b/internal/signature_test.go index 163ec096..d72cbc1a 100644 --- a/internal/signature_test.go +++ b/internal/signature_test.go @@ -30,7 +30,7 @@ func TestSignature_AddSpaceFor_DefaultMargins(t *testing.T) { math.On("GetWidthPerCol", mock.Anything).Return(50.0) text := &mocks.Text{} - text.On("Add", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything) + text.On("AddRenderable", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything) signature := internal.NewSignature(pdf, math, text) @@ -40,8 +40,8 @@ func TestSignature_AddSpaceFor_DefaultMargins(t *testing.T) { // Assert pdf.AssertNumberOfCalls(t, "Line", 1) pdf.AssertCalled(t, "Line", 19.0, 15.0, 13.0, 15.0) - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "label", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "label", internal.Cell{ 5.0, 7.0, 2.0, @@ -67,7 +67,7 @@ func TestSignature_AddSpaceFor_NotDefaultMargins(t *testing.T) { math.On("GetWidthPerCol", mock.Anything).Return(50.0) text := &mocks.Text{} - text.On("Add", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything) + text.On("AddRenderable", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything) signature := internal.NewSignature(pdf, math, text) @@ -77,8 +77,8 @@ func TestSignature_AddSpaceFor_NotDefaultMargins(t *testing.T) { // Assert pdf.AssertNumberOfCalls(t, "Line", 1) pdf.AssertCalled(t, "Line", 26.0, 15.0, 23.0, 15.0) - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "label", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "label", internal.Cell{ 2.0, 7.0, 5.0, diff --git a/pkg/pdf/example_test.go b/pkg/pdf/example_test.go index 6f51d0f3..87f8a5bc 100644 --- a/pkg/pdf/example_test.go +++ b/pkg/pdf/example_test.go @@ -36,10 +36,10 @@ func ExampleNewMarotoCustomSize() { func ExamplePdfMaroto_AddPage() { m := pdf.NewMaroto(consts.Portrait, consts.A4) - // Add rows, cols and components + // AddRenderable rows, cols and components m.AddPage() - // Add rows, col and components in a new page + // AddRenderable rows, col and components in a new page // Do more things and save... } @@ -51,14 +51,14 @@ func ExamplePdfMaroto_Row() { // Warning: There is no way to use a row inside a row or a row inside a col. m.Row(rowHeight, func() { m.Col(12, func() { - // Add a component + // AddRenderable a component }) }) // Warning: There is no way to use a row inside a row or a row inside a col. m.Row(rowHeight, func() { m.Col(12, func() { - // Add another component + // AddRenderable another component }) }) @@ -75,7 +75,7 @@ func ExamplePdfMaroto_Col() { // Warning: There is no way to use a row inside a row or a row inside a col. m.Row(rowHeight, func() { m.Col(12, func() { - // Add Image, Text, Signature, QrCode or Barcode... + // AddRenderable Image, Text, Signature, QrCode or Barcode... }) }) @@ -83,10 +83,10 @@ func ExamplePdfMaroto_Col() { // Warning: There is no way to use a row inside a row or a row inside a col. m.Row(rowHeight, func() { m.Col(6, func() { - // Add Image, Text, Signature, QrCode or Barcode... + // AddRenderable Image, Text, Signature, QrCode or Barcode... }) m.Col(6, func() { - // Add Image, Text, Signature, QrCode or Barcode... + // AddRenderable Image, Text, Signature, QrCode or Barcode... }) }) @@ -240,7 +240,7 @@ func ExamplePdfMaroto_TableList() { // TableList have to be used at same level as row m.Row(10, func() { m.Col(12, func() { - // Add a component + // AddRenderable a component }) }) @@ -507,12 +507,12 @@ func ExamplePdfMaroto_SetBorder() { m := pdf.NewMaroto(consts.Portrait, consts.A4) m.SetBorder(true) - // Add some Rows, Cols, Lines and etc... + // AddRenderable some Rows, Cols, Lines and etc... // Here will be drawn borders in every cell. m.SetBorder(false) - // Add some Rows, Cols, Lines and etc... + // AddRenderable some Rows, Cols, Lines and etc... // Here will not be drawn borders. // Do more things and save... @@ -557,7 +557,7 @@ func ExamplePdfMaroto_SetBackgroundColor() { // This Row will be filled with the color. m.Row(20, func() { m.Col(12, func() { - // Add components. + // AddRenderable components. }) }) @@ -567,7 +567,7 @@ func ExamplePdfMaroto_SetBackgroundColor() { // This Row will not be filled with the color. m.Row(20, func() { m.Col(12, func() { - // Add components. + // AddRenderable components. }) }) @@ -609,7 +609,7 @@ func ExamplePdfMaroto_GetCurrentPage() { // Index here will be 0. _ = m.GetCurrentPage() - // Add Rows, Cols and Components. + // AddRenderable Rows, Cols and Components. // Index here will not be 0. _ = m.GetCurrentPage() @@ -625,12 +625,12 @@ func ExamplePdfMaroto_GetCurrentOffset() { // Offset here will be 0. _ = m.GetCurrentOffset() - // Add Rows, Cols and Components until maroto add a new page. + // AddRenderable Rows, Cols and Components until maroto add a new page. // Offset here will not be 0. _ = m.GetCurrentOffset() - // Add Rows, Cols and Components to maroto add a new page. + // AddRenderable Rows, Cols and Components to maroto add a new page. // Offset here will be 0. _ = m.GetCurrentOffset() diff --git a/pkg/pdf/pdf_test.go b/pkg/pdf/pdf_test.go index 42b08d64..31e38316 100644 --- a/pkg/pdf/pdf_test.go +++ b/pkg/pdf/pdf_test.go @@ -533,8 +533,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "One text inside one column, inside a row, without props", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text1", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text1", internal.Cell{ X: 0.0, Y: 0.0, Width: 80.0, @@ -559,8 +559,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Two different text inside one colum, inside one row", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 2) - text.AssertCalled(t, "Add", "Text2", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 2) + text.AssertCalled(t, "AddRenderable", "Text2", internal.Cell{ X: 0.0, Y: 0.0, Width: 80.0, @@ -573,7 +573,7 @@ func TestFpdfMaroto_Text(t *testing.T) { Extrapolate: false, Size: 10.0, }) - text.AssertCalled(t, "Add", "Text3", internal.Cell{ + text.AssertCalled(t, "AddRenderable", "Text3", internal.Cell{ X: 0.0, Y: 5.0, Width: 80.0, @@ -605,8 +605,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Two different text with different columns, inside one row", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 2) - text.AssertCalled(t, "Add", "Text4", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 2) + text.AssertCalled(t, "AddRenderable", "Text4", internal.Cell{ X: 0.0, Y: 0.0, Width: 80.0, @@ -619,7 +619,7 @@ func TestFpdfMaroto_Text(t *testing.T) { Extrapolate: false, Size: 10.0, }) - text.AssertCalled(t, "Add", "Text5", internal.Cell{ + text.AssertCalled(t, "AddRenderable", "Text5", internal.Cell{ X: 80.0, Y: 4.4, Width: 80.0, @@ -653,8 +653,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Two different text with different columns, inside one row", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 2) - text.AssertCalled(t, "Add", "Text6", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 2) + text.AssertCalled(t, "AddRenderable", "Text6", internal.Cell{ X: 0.0, Y: 0.0, Width: 80.0, @@ -667,7 +667,7 @@ func TestFpdfMaroto_Text(t *testing.T) { Extrapolate: false, Size: 10.0, }) - text.AssertCalled(t, "Add", "Text7", internal.Cell{ + text.AssertCalled(t, "AddRenderable", "Text7", internal.Cell{ X: 0.0, Y: 40.0, Width: 80.0, @@ -701,8 +701,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Left-indented text", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text", internal.Cell{ X: 10.0, Y: 0.0, Width: 70.0, @@ -728,8 +728,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Right-indented text", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text", internal.Cell{ X: 0.0, Y: 0.0, Width: 70.0, @@ -755,8 +755,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Left- and right-indented text", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text", internal.Cell{ X: 10.0, Y: 0.0, Width: 60.0, @@ -784,8 +784,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Left-indent larger than col width", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text", internal.Cell{ X: 80.0, Y: 0.0, Width: 0.0, @@ -811,8 +811,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Right-indent larger than col width", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text", internal.Cell{ X: 0.0, Y: 0.0, Width: 0.0, @@ -838,8 +838,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "Indents larger than col width", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text", internal.Cell{ X: 40.0, Y: 0.0, Width: 0.0, @@ -867,8 +867,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "When top is greater than row height", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text8", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text8", internal.Cell{ X: 0.0, Y: 40.0, Width: 80.0, @@ -894,8 +894,8 @@ func TestFpdfMaroto_Text(t *testing.T) { { "custom color", func(t *testing.T, text *mocks.Text) { - text.AssertNumberOfCalls(t, "Add", 1) - text.AssertCalled(t, "Add", "Text1", internal.Cell{ + text.AssertNumberOfCalls(t, "AddRenderable", 1) + text.AssertCalled(t, "AddRenderable", "Text1", internal.Cell{ X: 0.0, Y: 0.0, Width: 80.0, @@ -2307,7 +2307,7 @@ func baseMathTest() *mocks.Math { func baseTextTest() *mocks.Text { text := &mocks.Text{} - text.On("Add", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything) + text.On("AddRenderable", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything) text.On("GetLinesQuantity", mock.Anything, mock.Anything, mock.Anything).Return(1) return text } diff --git a/pkg/v2/code/barcode/barcode.go b/pkg/v2/code/barcode/barcode.go index 5816f83b..e4b99706 100644 --- a/pkg/v2/code/barcode/barcode.go +++ b/pkg/v2/code/barcode/barcode.go @@ -8,16 +8,17 @@ import ( "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" "github.com/johnfercher/maroto/pkg/v2/text" + "github.com/johnfercher/maroto/pkg/v2/types" ) type barcode struct { code string - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + components []v2.Node prop props.Barcode } -func New(code string, barcodeProps ...props.Barcode) *barcode { +func New(code string, barcodeProps ...props.Barcode) v2.Component { prop := props.Barcode{} if len(barcodeProps) > 0 { prop = barcodeProps[0] @@ -25,7 +26,7 @@ func New(code string, barcodeProps ...props.Barcode) *barcode { prop.MakeValid() return &barcode{ - _type: v2.Barcode, + _type: types.Barcode, code: code, prop: prop, } @@ -51,7 +52,7 @@ func (b *barcode) GetType() string { return b._type.String() } -func (b *barcode) Add(component ...v2.Component) v2.Component { +func (b *barcode) Add(component ...v2.Node) v2.Node { return b } diff --git a/pkg/v2/code/matrixcode/matrixcode.go b/pkg/v2/code/matrixcode/matrixcode.go index c2e8b31a..e95fe514 100644 --- a/pkg/v2/code/matrixcode/matrixcode.go +++ b/pkg/v2/code/matrixcode/matrixcode.go @@ -7,16 +7,17 @@ import ( "github.com/johnfercher/maroto/pkg/props" "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" ) type matrixCode struct { code string - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + components []v2.Node prop props.Rect } -func New(code string, barcodeProps ...props.Rect) *matrixCode { +func New(code string, barcodeProps ...props.Rect) v2.Component { prop := props.Rect{} if len(barcodeProps) > 0 { prop = barcodeProps[0] @@ -24,7 +25,7 @@ func New(code string, barcodeProps ...props.Rect) *matrixCode { prop.MakeValid() return &matrixCode{ - _type: v2.MatrixCode, + _type: types.MatrixCode, code: code, prop: prop, } @@ -44,7 +45,7 @@ func (m *matrixCode) GetType() string { return m._type.String() } -func (m *matrixCode) Add(component ...v2.Component) v2.Component { +func (m *matrixCode) Add(component ...v2.Node) v2.Node { return m } diff --git a/pkg/v2/code/qrcode/qrcode.go b/pkg/v2/code/qrcode/qrcode.go index 34063f95..2a824542 100644 --- a/pkg/v2/code/qrcode/qrcode.go +++ b/pkg/v2/code/qrcode/qrcode.go @@ -7,16 +7,17 @@ import ( "github.com/johnfercher/maroto/pkg/props" "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" ) type qrCode struct { code string - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + components []v2.Node prop props.Rect } -func New(code string, barcodeProps ...props.Rect) *qrCode { +func New(code string, barcodeProps ...props.Rect) v2.Component { prop := props.Rect{} if len(barcodeProps) > 0 { prop = barcodeProps[0] @@ -24,7 +25,7 @@ func New(code string, barcodeProps ...props.Rect) *qrCode { prop.MakeValid() return &qrCode{ - _type: v2.QrCode, + _type: types.QrCode, code: code, prop: prop, } @@ -44,7 +45,7 @@ func (q *qrCode) GetType() string { return q._type.String() } -func (q *qrCode) Add(component ...v2.Component) v2.Component { +func (q *qrCode) Add(component ...v2.Node) v2.Node { return q } diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index a2ac0cb8..f1b1e3f6 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -6,6 +6,7 @@ import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" ) const ( @@ -14,13 +15,14 @@ const ( type col struct { size int - _type v2.DocumentType + _type types.DocumentType components []v2.Component + rows []v2.Row } -func New(size int) *col { +func New(size int) v2.Col { return &col{ - _type: v2.Col, + _type: types.Col, size: size, } } @@ -29,12 +31,13 @@ func (c *col) GetType() string { return c._type.String() } -func (c *col) Add(components ...v2.Component) v2.Component { - for _, component := range components { - if c._type.Accept(component.GetType()) { - c.components = append(c.components, component) - } - } +func (c *col) Add(components ...v2.Component) v2.Col { + c.components = append(c.components, components...) + return c +} + +func (c *col) AddInner(rows ...v2.Row) v2.Col { + c.rows = append(c.rows, rows...) return c } diff --git a/pkg/v2/col/col_test.go b/pkg/v2/col/col_test.go index 35389b61..129763de 100644 --- a/pkg/v2/col/col_test.go +++ b/pkg/v2/col/col_test.go @@ -6,6 +6,7 @@ import ( v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" "github.com/johnfercher/maroto/pkg/v2/text" + "github.com/johnfercher/maroto/pkg/v2/types" "github.com/stretchr/testify/assert" "testing" ) @@ -46,7 +47,7 @@ func TestCol_Add(t *testing.T) { txt := text.New("test") // act - col.Add(txt) + col.AddRenderable(txt) // assert assert.Equal(t, 1, len(col.components)) @@ -56,10 +57,10 @@ func TestCol_Add(t *testing.T) { // arrange size := 12 col := New(size) - invalid := &invalidComponent{_type: v2.Page} + invalid := &invalidComponent{_type: types.Page} // act - col.Add(invalid) + col.AddRenderable(invalid) // assert assert.Equal(t, 0, len(col.components)) @@ -329,7 +330,7 @@ func TestCol_Render(t *testing.T) { // arrange col := New(12) child := text.New("test") - col.Add(child) + col.AddRenderable(child) pdf := mocks.NewFpdf(t) ctx := context.NewRootContext(100, 100, &context.Margins{ @@ -351,7 +352,7 @@ func TestCol_Render(t *testing.T) { // region Test Support type invalidComponent struct { - _type v2.DocumentType + _type types.DocumentType } func (i *invalidComponent) Render(fpdf fpdf.Fpdf, ctx context.Context) { @@ -362,7 +363,7 @@ func (i *invalidComponent) GetType() string { return i._type.String() } -func (i *invalidComponent) Add(component ...v2.Component) v2.Component { +func (i *invalidComponent) Add(component ...v2.Node) v2.Node { return nil } diff --git a/pkg/v2/component.go b/pkg/v2/component.go deleted file mode 100644 index 9bf66581..00000000 --- a/pkg/v2/component.go +++ /dev/null @@ -1,20 +0,0 @@ -package v2 - -import ( - "github.com/johnfercher/go-tree/tree" - "github.com/johnfercher/maroto/internal/fpdf" - "github.com/johnfercher/maroto/pkg/v2/context" -) - -type Component interface { - Render(fpdf fpdf.Fpdf, ctx context.Context) - GetType() string - Add(components ...Component) Component - GetStructure() *tree.Node[Structure] -} - -type Structure struct { - Type string - Value string - Props map[string]string -} diff --git a/pkg/v2/document.go b/pkg/v2/document.go index f63984ea..169f8868 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -4,21 +4,17 @@ import ( "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" "github.com/jung-kurt/gofpdf" ) -type Maroto interface { - Add(component ...Component) - Generate() error - GetStructure() *tree.Node[Structure] -} - type document struct { - file string - ctx context.Context - _type DocumentType - fpdf fpdf.Fpdf - components []Component + file string + ctx context.Context + _type types.DocumentType + fpdf fpdf.Fpdf + pages []Page + rows []Row } func NewDocument(file string) *document { @@ -38,7 +34,7 @@ func NewDocument(file string) *document { return &document{ file: file, fpdf: fpdf, - _type: Document, + _type: types.Document, ctx: context.NewRootContext(width, height, &context.Margins{ Left: left, Top: top, @@ -48,20 +44,24 @@ func NewDocument(file string) *document { } } -func (d *document) Add(components ...Component) { - for _, component := range components { - if d._type.Accept(component.GetType()) { - d.components = append(d.components, component) - } - } +func (d *document) ForceAddPage(pages ...Page) { + d.pages = append(d.pages, pages...) +} + +func (d *document) Add(rows ...Row) { + d.rows = append(d.rows, rows...) } func (d *document) Generate() error { d.ctx.Print(d._type) ctx := d.ctx.WithDimension(d.ctx.MaxWidth(), d.ctx.MaxHeight()) - for _, component := range d.components { - component.Render(d.fpdf, ctx) + for _, row := range d.rows { + row.Render(d.fpdf, ctx) + } + + for _, page := range d.pages { + page.Render(d.fpdf, ctx) } return d.fpdf.OutputFileAndClose(d.file) @@ -74,8 +74,8 @@ func (d *document) GetStructure() *tree.Node[Structure] { } node := tree.NewNode(0, str) - for _, c := range d.components { - inner := c.GetStructure() + for _, r := range d.rows { + inner := r.GetStructure() node.AddNext(inner) } diff --git a/pkg/v2/domain.go b/pkg/v2/domain.go new file mode 100644 index 00000000..442cf67c --- /dev/null +++ b/pkg/v2/domain.go @@ -0,0 +1,46 @@ +package v2 + +import ( + "github.com/johnfercher/go-tree/tree" + "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/v2/context" +) + +type Maroto interface { + Generate() error + ForceAddPage(pages ...Page) + Add(rows ...Row) + GetStructure() *tree.Node[Structure] +} + +type Node interface { + Render(fpdf fpdf.Fpdf, ctx context.Context) + GetStructure() *tree.Node[Structure] +} + +type Component interface { + Node + GetType() string // Just to differentiate from Node +} + +type Page interface { + Node + Add(rows ...Row) Page +} + +type Row interface { + Node + Add(cols ...Col) +} + +type Col interface { + Node + Add(component ...Component) Col + AddInner(rows ...Row) Col +} + +type Structure struct { + Type string + Value string + Props map[string]string +} diff --git a/pkg/v2/image/base64image.go b/pkg/v2/image/base64image.go index f27457c0..a7bf7f2c 100644 --- a/pkg/v2/image/base64image.go +++ b/pkg/v2/image/base64image.go @@ -9,17 +9,18 @@ import ( "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" "github.com/johnfercher/maroto/pkg/v2/text" + "github.com/johnfercher/maroto/pkg/v2/types" ) type base64Image struct { base64 string extension consts.Extension - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + components []v2.Node prop props.Rect } -func NewFromBase64(path string, extension consts.Extension, imageProps ...props.Rect) *base64Image { +func NewFromBase64(path string, extension consts.Extension, imageProps ...props.Rect) v2.Component { prop := props.Rect{} if len(imageProps) > 0 { prop = imageProps[0] @@ -27,7 +28,7 @@ func NewFromBase64(path string, extension consts.Extension, imageProps ...props. prop.MakeValid() return &base64Image{ - _type: v2.Image, + _type: types.Image, base64: path, prop: prop, extension: extension, @@ -57,10 +58,6 @@ func (b *base64Image) GetType() string { return b._type.String() } -func (b *base64Image) Add(_ ...v2.Component) v2.Component { - return b -} - func (b *base64Image) GetStructure() *tree.Node[v2.Structure] { trimLength := 10 if len(b.base64) < trimLength { diff --git a/pkg/v2/image/fileimage.go b/pkg/v2/image/fileimage.go index ec8a321d..e3e2aa3b 100644 --- a/pkg/v2/image/fileimage.go +++ b/pkg/v2/image/fileimage.go @@ -8,16 +8,17 @@ import ( "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" "github.com/johnfercher/maroto/pkg/v2/text" + "github.com/johnfercher/maroto/pkg/v2/types" ) type fileImage struct { path string - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + components []v2.Node prop props.Rect } -func NewFromFile(path string, imageProps ...props.Rect) *fileImage { +func NewFromFile(path string, imageProps ...props.Rect) v2.Component { prop := props.Rect{} if len(imageProps) > 0 { prop = imageProps[0] @@ -25,7 +26,7 @@ func NewFromFile(path string, imageProps ...props.Rect) *fileImage { prop.MakeValid() return &fileImage{ - _type: v2.Image, + _type: types.Image, path: path, prop: prop, } @@ -52,7 +53,7 @@ func (f *fileImage) GetType() string { return f._type.String() } -func (f *fileImage) Add(_ ...v2.Component) v2.Component { +func (f *fileImage) Add(_ ...v2.Node) v2.Node { return f } diff --git a/pkg/v2/page/page.go b/pkg/v2/page/page.go index bc6cce54..9ba5b289 100644 --- a/pkg/v2/page/page.go +++ b/pkg/v2/page/page.go @@ -5,24 +5,25 @@ import ( "github.com/johnfercher/maroto/internal/fpdf" v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" ) type page struct { - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + rows []v2.Row } -func New() *page { +func New() v2.Page { return &page{ - _type: v2.Page, + _type: types.Page, } } func (p *page) Render(fpdf fpdf.Fpdf, ctx context.Context) { fpdf.AddPage() ctx = ctx.NewPage(fpdf.PageNo()) - for _, component := range p.components { - component.Render(fpdf, ctx) + for _, row := range p.rows { + row.Render(fpdf, ctx) } } @@ -30,12 +31,8 @@ func (p *page) GetType() string { return p._type.String() } -func (p *page) Add(components ...v2.Component) v2.Component { - for _, component := range components { - if p._type.Accept(component.GetType()) { - p.components = append(p.components, component) - } - } +func (p *page) Add(rows ...v2.Row) v2.Page { + p.rows = append(p.rows, rows...) return p } @@ -46,8 +43,8 @@ func (p *page) GetStructure() *tree.Node[v2.Structure] { node := tree.NewNode(0, str) - for _, c := range p.components { - inner := c.GetStructure() + for _, r := range p.rows { + inner := r.GetStructure() node.AddNext(inner) } diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index eb4e73ce..69715741 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -6,17 +6,22 @@ import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" ) type row struct { - height float64 - _type v2.DocumentType - components []v2.Component + height float64 + _type types.DocumentType + cols []v2.Col } -func New(height float64) *row { +func (r *row) Add(cols ...v2.Col) { + r.cols = append(r.cols, cols...) +} + +func New(height float64) v2.Row { return &row{ - _type: v2.Row, + _type: types.Row, height: height, } } @@ -25,15 +30,6 @@ func (r *row) GetType() string { return r._type.String() } -func (r *row) Add(components ...v2.Component) v2.Component { - for _, component := range components { - if r._type.Accept(component.GetType()) { - r.components = append(r.components, component) - } - } - return r -} - func (r *row) GetStructure() *tree.Node[v2.Structure] { str := v2.Structure{ Type: string(r._type), @@ -42,7 +38,7 @@ func (r *row) GetStructure() *tree.Node[v2.Structure] { node := tree.NewNode(0, str) - for _, c := range r.components { + for _, c := range r.cols { inner := c.GetStructure() node.AddNext(inner) } @@ -57,8 +53,8 @@ func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { fpdf.AddPage() ctx = ctx.NewPage(fpdf.PageNo()) } - for _, component := range r.components { - component.Render(fpdf, ctx) + for _, col := range r.cols { + col.Render(fpdf, ctx) } r.render(fpdf, ctx) diff --git a/pkg/v2/signature/signature.go b/pkg/v2/signature/signature.go index 9586c7a1..5206a086 100644 --- a/pkg/v2/signature/signature.go +++ b/pkg/v2/signature/signature.go @@ -8,16 +8,17 @@ import ( "github.com/johnfercher/maroto/pkg/props" v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" ) type signature struct { value string - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + components []v2.Node prop props.Text } -func New(value string, textProps ...props.Text) *signature { +func New(value string, textProps ...props.Text) v2.Component { prop := props.Text{} if len(textProps) > 0 { prop = textProps[0] @@ -25,7 +26,7 @@ func New(value string, textProps ...props.Text) *signature { prop.MakeValid(consts.Arial) return &signature{ - _type: v2.Signature, + _type: types.Signature, value: value, prop: prop, } @@ -50,7 +51,7 @@ func (s *signature) GetType() string { return s._type.String() } -func (s *signature) Add(_ ...v2.Component) v2.Component { +func (s *signature) Add(_ ...v2.Node) v2.Node { return s } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index 54188fd1..720e5eb5 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -8,16 +8,17 @@ import ( "github.com/johnfercher/maroto/pkg/props" v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/types" ) type text struct { value string - _type v2.DocumentType - components []v2.Component + _type types.DocumentType + components []v2.Node prop props.Text } -func New(value string, textProps ...props.Text) *text { +func New(value string, textProps ...props.Text) v2.Component { prop := props.Text{} if len(textProps) > 0 { prop = textProps[0] @@ -25,7 +26,7 @@ func New(value string, textProps ...props.Text) *text { prop.MakeValid(consts.Arial) return &text{ - _type: v2.Text, + _type: types.Text, value: value, prop: prop, } @@ -35,7 +36,7 @@ func (t *text) GetType() string { return t._type.String() } -func (t *text) Add(_ ...v2.Component) v2.Component { +func (t *text) Add(_ ...v2.Node) v2.Node { return t } diff --git a/pkg/v2/types.go b/pkg/v2/types/types.go similarity index 98% rename from pkg/v2/types.go rename to pkg/v2/types/types.go index 8423910d..df25b5d8 100644 --- a/pkg/v2/types.go +++ b/pkg/v2/types/types.go @@ -1,4 +1,4 @@ -package v2 +package types import "slices" diff --git a/v2.pdf b/v2.pdf index 88a58cc3501b45a02fe27095e46f8b5ec0f7db88..a9dfd247d664ecfea1cde2535765d2a2e3f2acee 100644 GIT binary patch delta 355 zcmZ4VgJ;nXo(+dNHplR0Gf&p$HQ4-JU@FVx;{pbo4{>C&H1~+M_lPnAG1K-QQD$|S z>4BEaMvO+&CzvxEG8#^QV8m=V{k{>i5lkE`@Yx)w1}cf9e)?uZxZdf4#z0Nj2qZFBZqnNX90uFaXeF5ntMdsdqf$5m}z^DD6_iE z^nP<@qv`jJfW$!{i_vKM1aoFXumF_JXgtjfD00~ZA-mZS$c6}i25CnSaMSP`G(FG~ zs*TZbdWspd<@D!9%v#8LASytXB3St3K^8-u1a}QA From 5f00f8c2fa9e71da6a514fc76d30d52120f1633a Mon Sep 17 00:00:00 2001 From: John Fercher Date: Wed, 13 Sep 2023 19:25:20 -0300 Subject: [PATCH 23/24] keep --- cmd/main.go | 20 +++++---- internal/examples/pdfs/imagegrid.pdf | Bin 220408 -> 220408 bytes pkg/v2/code/barcode/barcode.go | 14 ++++--- pkg/v2/code/matrixcode/matrixcode.go | 12 +++--- pkg/v2/code/qrcode/qrcode.go | 12 +++--- pkg/v2/col/col.go | 22 +++++----- pkg/v2/col/col_test.go | 4 +- pkg/v2/document.go | 59 +++++++++++++++++++++++---- pkg/v2/{ => domain}/domain.go | 3 +- pkg/v2/image/base64image.go | 10 ++--- pkg/v2/image/fileimage.go | 12 +++--- pkg/v2/page/page.go | 18 ++++---- pkg/v2/row/row.go | 34 +++++++++------ pkg/v2/signature/signature.go | 12 +++--- pkg/v2/text/text.go | 14 +++---- v2.pdf | Bin 212002 -> 214957 bytes 16 files changed, 153 insertions(+), 93 deletions(-) rename pkg/v2/{ => domain}/domain.go (95%) diff --git a/cmd/main.go b/cmd/main.go index ade8d2c5..faa8371f 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -6,8 +6,8 @@ import ( "github.com/johnfercher/maroto/pkg/v2/code/matrixcode" "github.com/johnfercher/maroto/pkg/v2/code/qrcode" "github.com/johnfercher/maroto/pkg/v2/col" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/image" - "github.com/johnfercher/maroto/pkg/v2/page" "github.com/johnfercher/maroto/pkg/v2/row" "github.com/johnfercher/maroto/pkg/v2/text" "log" @@ -18,13 +18,17 @@ func main() { header := buildRow() content := buildContent() - p := page.New().Add( + + pdf.Add(header /*content footer*/) + pdf.Add( + content, content, content, content, content, content, content, content, + content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, content, ) - pdf.Add(header /*content footer*/) - pdf.ForceAddPage(p) + //pdf.Add() + //pdf.ForceAddPage(p) err := pdf.Generate() if err != nil { @@ -32,8 +36,8 @@ func main() { } } -func buildRow() v2.Row { - r := row.New(20) +func buildRow() domain.Row { + r := row.New(70) //image := image.New("image1") @@ -50,8 +54,8 @@ func buildRow() v2.Row { return r } -func buildContent() v2.Row { - row := row.New(20) +func buildContent() domain.Row { + row := row.New(70) col1 := col.New(4) col1.Add(barcode.New("barcode")) diff --git a/internal/examples/pdfs/imagegrid.pdf b/internal/examples/pdfs/imagegrid.pdf index f5acbc4b9344dce7d0fc5d38828e98cb460740d8..925e66d576e398512752becbd7f5983939e0baf6 100644 GIT binary patch delta 711 zcmV;&0yzEnxefTa4Umt2ORm#e5JmeLMNQz=t^cR{^gep@5O)Ge93vqi1RbW293RpE zyFuKyPc7|LwF%yx2tJ(%J>mQ5uQz!8clJr9o6mYqj_&i#E;5yJ_AO+hzQuesmH-YU zg0~s|c{>pj5&U-|BqI2D;3Xa}NTE7pD29W(qcXfKW8m8jKEU>WcP;1+FU*SC)c&Fk&9kkZaGiN0)Kyj z_a_#@CdieO%aQ3f0A@#awz?BEVNyi^yJMwNK?Gw^D8Um5N_P<>D#=_D`!$0d1g%7I zCOw9*$_gix+>u~^fs*chk3a*>r4&3cTACqPvDm7gNq|=gWB!hWWbEiz9X#ePzgA}$ zcsPob`ZEN>!64XiuuY&==-koZ&PeVo&k(E%Tm!2>lTe=6LsP?2i{~=vTCQ&(>{!^@ zLsLbU2swtZhG3%Tv}Ylfl}q>gB0g^Mu@K6I!N#Kv&X>u5=E<^eeQCLdl%CI5SDC~v zHl5GxO*1*%+hDB00N9CO8({sFh>j6h^U^?rV7m{u0i1kXsH$LA+GwLci(pltOvt>a zz!;;v^RD2LJX@eDiGzqECDjoJgJ8$OHi2d?)hu+3U^o~A+YYt?oC960^BBPDfIBc{ zFM;hPs6@9Ss)RO-%;&B^Ske6F{GBe^p07&@lNcWY_z?gA|NkxH`p1K<0*9>v0f(&u z0=KOK1L9X%I50A1IAUUBG&D0YWH@3rH8n9aW;r=HHDoX~GBaZ}GG#YrWHT``AT}T{ zAW{l1Nnv7SG-hNpH#ucFVmUHnHZnLfVPRu6Gcsf{G-5PlVPP>fIWT50HJ9jG17;;T tF*7kaGBPwUDGD!5Z)8MabY&nYL^?7sGBYqaF*7kaGBPwUw{u$qg#j7fICua6 delta 711 zcmV;&0yzEnxefTa4Umt2JFe7P5JmGIMNQz=tuLXa?h13xDC1l!+#m7p2CFe_^H55Ge+ zq(;?%fWQ(}nh9v26I*~sU{q?r_!VB?GY8Qu!)=Jlag^ETG|h1iwsEGxWsch<1pj}7 zj~5ogB8Zif(~#*e0A@orZuuZ6!k}~qHp2|11b0R!SAqiwN)Hh|Dv4MU`!j?UK` zaC0g090qu_L0^LouoJ;H!1^l@og-+)O9OR+?LOQFFtUE3s)CWxdK>*)1gipNLgqaM zjnUI89txhxb8}QBF%U7NpgiNC6YMzHCeVnbnuX30bO)Va+rc(~v7>3LI0vvg;BpMv zOJI8mGSFHgWv0f(&u z0=KOK1L9X%F)=qVFlI7gVqrHqIAdcnW;SLxH8VJ4W;Zc4V`ea6HZo>6Vr4QgAT}T{ zAW{l1NiZ`sGdD9hWH&iwF)(9dG%;pnH8y5BFg0Q_V>vZpVm2~4Fg7@0VVCGy17;;O tF)=YPGc_?eDGD!5Z)8MabY&nYL^?7sGBYqVF)=YPGc_?ew{u$qg#k+lD%}78 diff --git a/pkg/v2/code/barcode/barcode.go b/pkg/v2/code/barcode/barcode.go index e4b99706..31f85e06 100644 --- a/pkg/v2/code/barcode/barcode.go +++ b/pkg/v2/code/barcode/barcode.go @@ -1,12 +1,13 @@ package barcode import ( + "fmt" "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" - "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/text" "github.com/johnfercher/maroto/pkg/v2/types" ) @@ -14,11 +15,11 @@ import ( type barcode struct { code string _type types.DocumentType - components []v2.Node + components []domain.Node prop props.Barcode } -func New(code string, barcodeProps ...props.Barcode) v2.Component { +func New(code string, barcodeProps ...props.Barcode) domain.Component { prop := props.Barcode{} if len(barcodeProps) > 0 { prop = barcodeProps[0] @@ -36,6 +37,7 @@ func (b *barcode) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) code := internal.NewCode(fpdf, math) + fmt.Println(fpdf.GetX()-ctx.Margins.Left, fpdf.GetY()-ctx.Margins.Top) err := code.AddBar(b.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, fpdf.GetY() - ctx.Margins.Top, ctx.Dimensions.Width, @@ -52,12 +54,12 @@ func (b *barcode) GetType() string { return b._type.String() } -func (b *barcode) Add(component ...v2.Node) v2.Node { +func (b *barcode) Add(component ...domain.Node) domain.Node { return b } -func (b *barcode) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (b *barcode) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(b._type), Value: b.code, } diff --git a/pkg/v2/code/matrixcode/matrixcode.go b/pkg/v2/code/matrixcode/matrixcode.go index e95fe514..a4a26023 100644 --- a/pkg/v2/code/matrixcode/matrixcode.go +++ b/pkg/v2/code/matrixcode/matrixcode.go @@ -5,19 +5,19 @@ import ( "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" - "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/types" ) type matrixCode struct { code string _type types.DocumentType - components []v2.Node + components []domain.Node prop props.Rect } -func New(code string, barcodeProps ...props.Rect) v2.Component { +func New(code string, barcodeProps ...props.Rect) domain.Component { prop := props.Rect{} if len(barcodeProps) > 0 { prop = barcodeProps[0] @@ -45,12 +45,12 @@ func (m *matrixCode) GetType() string { return m._type.String() } -func (m *matrixCode) Add(component ...v2.Node) v2.Node { +func (m *matrixCode) Add(component ...domain.Node) domain.Node { return m } -func (m *matrixCode) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (m *matrixCode) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(m._type), Value: m.code, } diff --git a/pkg/v2/code/qrcode/qrcode.go b/pkg/v2/code/qrcode/qrcode.go index 2a824542..f1826442 100644 --- a/pkg/v2/code/qrcode/qrcode.go +++ b/pkg/v2/code/qrcode/qrcode.go @@ -5,19 +5,19 @@ import ( "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" - "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/types" ) type qrCode struct { code string _type types.DocumentType - components []v2.Node + components []domain.Node prop props.Rect } -func New(code string, barcodeProps ...props.Rect) v2.Component { +func New(code string, barcodeProps ...props.Rect) domain.Component { prop := props.Rect{} if len(barcodeProps) > 0 { prop = barcodeProps[0] @@ -45,12 +45,12 @@ func (q *qrCode) GetType() string { return q._type.String() } -func (q *qrCode) Add(component ...v2.Node) v2.Node { +func (q *qrCode) Add(component ...domain.Node) domain.Node { return q } -func (q *qrCode) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (q *qrCode) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(q._type), Value: q.code, } diff --git a/pkg/v2/col/col.go b/pkg/v2/col/col.go index f1b1e3f6..6d2e5192 100644 --- a/pkg/v2/col/col.go +++ b/pkg/v2/col/col.go @@ -4,8 +4,8 @@ import ( "fmt" "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" - "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/types" ) @@ -16,11 +16,11 @@ const ( type col struct { size int _type types.DocumentType - components []v2.Component - rows []v2.Row + components []domain.Component + rows []domain.Row } -func New(size int) v2.Col { +func New(size int) domain.Col { return &col{ _type: types.Col, size: size, @@ -31,18 +31,18 @@ func (c *col) GetType() string { return c._type.String() } -func (c *col) Add(components ...v2.Component) v2.Col { +func (c *col) Add(components ...domain.Component) domain.Col { c.components = append(c.components, components...) return c } -func (c *col) AddInner(rows ...v2.Row) v2.Col { +func (c *col) AddInner(rows ...domain.Row) domain.Col { c.rows = append(c.rows, rows...) return c } -func (c *col) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (c *col) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(c._type), Value: fmt.Sprintf("%d", c.size), } @@ -58,17 +58,17 @@ func (c *col) GetStructure() *tree.Node[v2.Structure] { } func (c *col) Render(fpdf fpdf.Fpdf, ctx context.Context) { - ctx.Print(c.size) + //ctx.Print(c.size) ctx = c.setRelativeDimension(ctx) + c.render(fpdf, ctx) for _, component := range c.components { component.Render(fpdf, ctx) } - c.render(fpdf, ctx) + return } func (c *col) render(fpdf fpdf.Fpdf, ctx context.Context) { - fpdf.SetDrawColor(255, 0, 0) fpdf.CellFormat(ctx.GetXOffset(), ctx.GetYOffset(), "", "1", 0, "C", false, 0, "") } diff --git a/pkg/v2/col/col_test.go b/pkg/v2/col/col_test.go index 129763de..c9e2e241 100644 --- a/pkg/v2/col/col_test.go +++ b/pkg/v2/col/col_test.go @@ -3,8 +3,8 @@ package col import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/internal/mocks" - v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/text" "github.com/johnfercher/maroto/pkg/v2/types" "github.com/stretchr/testify/assert" @@ -363,7 +363,7 @@ func (i *invalidComponent) GetType() string { return i._type.String() } -func (i *invalidComponent) Add(component ...v2.Node) v2.Node { +func (i *invalidComponent) Add(component ...domain.Node) domain.Node { return nil } diff --git a/pkg/v2/document.go b/pkg/v2/document.go index 169f8868..50d4622f 100644 --- a/pkg/v2/document.go +++ b/pkg/v2/document.go @@ -1,9 +1,15 @@ package v2 import ( + "fmt" "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" + "github.com/johnfercher/maroto/pkg/color" + "github.com/johnfercher/maroto/pkg/v2/col" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" + "github.com/johnfercher/maroto/pkg/v2/page" + "github.com/johnfercher/maroto/pkg/v2/row" "github.com/johnfercher/maroto/pkg/v2/types" "github.com/jung-kurt/gofpdf" ) @@ -13,8 +19,8 @@ type document struct { ctx context.Context _type types.DocumentType fpdf fpdf.Fpdf - pages []Page - rows []Row + pages []domain.Page + rows []domain.Row } func NewDocument(file string) *document { @@ -44,31 +50,66 @@ func NewDocument(file string) *document { } } -func (d *document) ForceAddPage(pages ...Page) { +func (d *document) ForceAddPage(pages ...domain.Page) { d.pages = append(d.pages, pages...) } -func (d *document) Add(rows ...Row) { +func (d *document) Add(rows ...domain.Row) { d.rows = append(d.rows, rows...) } func (d *document) Generate() error { - d.ctx.Print(d._type) + //d.ctx.Print(d._type) ctx := d.ctx.WithDimension(d.ctx.MaxWidth(), d.ctx.MaxHeight()) - for _, row := range d.rows { - row.Render(d.fpdf, ctx) + maxHeight := d.ctx.MaxHeight() + currentHeight := 0.0 + var buf []domain.Row + for _, dRow := range d.rows { + height := dRow.GetHeight() + if currentHeight+height >= maxHeight { + p := page.New() + p.Add(buf...) + + c := col.New(12) + lastRowHeight := maxHeight - currentHeight + fmt.Printf("lastrow: %f, maxHeight: %f, currentHeight: %f, x: %f, y: %f\n", lastRowHeight, maxHeight, currentHeight, d.fpdf.GetX(), d.fpdf.GetY()) + r := row.New(lastRowHeight, color.Color{255, 0, 0}) + r.Add(c) + p.Add(r) + + d.pages = append(d.pages, p) + buf = nil + currentHeight = 0 + } + + currentHeight += height + buf = append(buf, dRow) } + p := page.New() + p.Add(buf...) + d.pages = append(d.pages, p) + for _, page := range d.pages { page.Render(d.fpdf, ctx) } + fmt.Println(len(d.pages)) + + /*for _, dRow := range d.rows { + dRow.Render(d.fpdf, ctx) + } + + for _, page := range d.pages { + page.Render(d.fpdf, ctx) + }*/ + return d.fpdf.OutputFileAndClose(d.file) } -func (d *document) GetStructure() *tree.Node[Structure] { - str := Structure{ +func (d *document) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(d._type), Value: d.file, } diff --git a/pkg/v2/domain.go b/pkg/v2/domain/domain.go similarity index 95% rename from pkg/v2/domain.go rename to pkg/v2/domain/domain.go index 442cf67c..e618a5a6 100644 --- a/pkg/v2/domain.go +++ b/pkg/v2/domain/domain.go @@ -1,4 +1,4 @@ -package v2 +package domain import ( "github.com/johnfercher/go-tree/tree" @@ -31,6 +31,7 @@ type Page interface { type Row interface { Node Add(cols ...Col) + GetHeight() float64 } type Col interface { diff --git a/pkg/v2/image/base64image.go b/pkg/v2/image/base64image.go index a7bf7f2c..479b87cb 100644 --- a/pkg/v2/image/base64image.go +++ b/pkg/v2/image/base64image.go @@ -6,8 +6,8 @@ import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/consts" "github.com/johnfercher/maroto/pkg/props" - "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/text" "github.com/johnfercher/maroto/pkg/v2/types" ) @@ -16,11 +16,11 @@ type base64Image struct { base64 string extension consts.Extension _type types.DocumentType - components []v2.Node + components []domain.Node prop props.Rect } -func NewFromBase64(path string, extension consts.Extension, imageProps ...props.Rect) v2.Component { +func NewFromBase64(path string, extension consts.Extension, imageProps ...props.Rect) domain.Component { prop := props.Rect{} if len(imageProps) > 0 { prop = imageProps[0] @@ -58,13 +58,13 @@ func (b *base64Image) GetType() string { return b._type.String() } -func (b *base64Image) GetStructure() *tree.Node[v2.Structure] { +func (b *base64Image) GetStructure() *tree.Node[domain.Structure] { trimLength := 10 if len(b.base64) < trimLength { trimLength = len(b.base64) } - str := v2.Structure{ + str := domain.Structure{ Type: string(b._type), Value: b.base64[:trimLength], } diff --git a/pkg/v2/image/fileimage.go b/pkg/v2/image/fileimage.go index e3e2aa3b..aec445ca 100644 --- a/pkg/v2/image/fileimage.go +++ b/pkg/v2/image/fileimage.go @@ -5,8 +5,8 @@ import ( "github.com/johnfercher/maroto/internal" "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/props" - "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/text" "github.com/johnfercher/maroto/pkg/v2/types" ) @@ -14,11 +14,11 @@ import ( type fileImage struct { path string _type types.DocumentType - components []v2.Node + components []domain.Node prop props.Rect } -func NewFromFile(path string, imageProps ...props.Rect) v2.Component { +func NewFromFile(path string, imageProps ...props.Rect) domain.Component { prop := props.Rect{} if len(imageProps) > 0 { prop = imageProps[0] @@ -53,12 +53,12 @@ func (f *fileImage) GetType() string { return f._type.String() } -func (f *fileImage) Add(_ ...v2.Node) v2.Node { +func (f *fileImage) Add(_ ...domain.Node) domain.Node { return f } -func (f *fileImage) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (f *fileImage) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(f._type), Value: f.path, } diff --git a/pkg/v2/page/page.go b/pkg/v2/page/page.go index 9ba5b289..07be7a5f 100644 --- a/pkg/v2/page/page.go +++ b/pkg/v2/page/page.go @@ -3,41 +3,43 @@ package page import ( "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" - v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/types" ) type page struct { _type types.DocumentType - rows []v2.Row + rows []domain.Row } -func New() v2.Page { +func New() domain.Page { return &page{ _type: types.Page, } } func (p *page) Render(fpdf fpdf.Fpdf, ctx context.Context) { - fpdf.AddPage() - ctx = ctx.NewPage(fpdf.PageNo()) + //ctx = ctx.NewPage(fpdf.PageNo()) + for _, row := range p.rows { row.Render(fpdf, ctx) } + //fpdf.AddPage() + } func (p *page) GetType() string { return p._type.String() } -func (p *page) Add(rows ...v2.Row) v2.Page { +func (p *page) Add(rows ...domain.Row) domain.Page { p.rows = append(p.rows, rows...) return p } -func (p *page) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (p *page) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(p._type), } diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index 69715741..fb02704d 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -4,25 +4,37 @@ import ( "fmt" "github.com/johnfercher/go-tree/tree" "github.com/johnfercher/maroto/internal/fpdf" - "github.com/johnfercher/maroto/pkg/v2" + "github.com/johnfercher/maroto/pkg/color" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/types" ) type row struct { height float64 _type types.DocumentType - cols []v2.Col + cols []domain.Col + color color.Color } -func (r *row) Add(cols ...v2.Col) { +func (r *row) GetHeight() float64 { + return r.height +} + +func (r *row) Add(cols ...domain.Col) { r.cols = append(r.cols, cols...) } -func New(height float64) v2.Row { +func New(height float64, c ...color.Color) domain.Row { + cx := color.NewBlack() + if len(c) > 0 { + cx = c[0] + } + return &row{ _type: types.Row, height: height, + color: cx, } } @@ -30,8 +42,8 @@ func (r *row) GetType() string { return r._type.String() } -func (r *row) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (r *row) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(r._type), Value: fmt.Sprintf("%2.f", r.height), } @@ -47,12 +59,11 @@ func (r *row) GetStructure() *tree.Node[v2.Structure] { } func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { - ctx.Print(r.height) + //ctx.Print(r.height) ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) - if ctx.GetYOffset() == 0 && ctx.GetCurrentPage() >= fpdf.PageCount() { - fpdf.AddPage() - ctx = ctx.NewPage(fpdf.PageNo()) - } + + fpdf.SetDrawColor(r.color.Red, r.color.Green, r.color.Blue) + for _, col := range r.cols { col.Render(fpdf, ctx) } @@ -62,7 +73,6 @@ func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { } func (r *row) render(fpdf fpdf.Fpdf, ctx context.Context) { - fpdf.SetDrawColor(0, 0, 0) //x, y := ctx.GetXOffset(), ctx.GetYOffset() fpdf.Ln(ctx.Dimensions.Height) } diff --git a/pkg/v2/signature/signature.go b/pkg/v2/signature/signature.go index 5206a086..2435c773 100644 --- a/pkg/v2/signature/signature.go +++ b/pkg/v2/signature/signature.go @@ -6,19 +6,19 @@ import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/consts" "github.com/johnfercher/maroto/pkg/props" - v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/types" ) type signature struct { value string _type types.DocumentType - components []v2.Node + components []domain.Node prop props.Text } -func New(value string, textProps ...props.Text) v2.Component { +func New(value string, textProps ...props.Text) domain.Component { prop := props.Text{} if len(textProps) > 0 { prop = textProps[0] @@ -51,12 +51,12 @@ func (s *signature) GetType() string { return s._type.String() } -func (s *signature) Add(_ ...v2.Node) v2.Node { +func (s *signature) Add(_ ...domain.Node) domain.Node { return s } -func (s *signature) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (s *signature) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(s._type), Value: s.value, } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index 720e5eb5..f8c3ea15 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -6,19 +6,19 @@ import ( "github.com/johnfercher/maroto/internal/fpdf" "github.com/johnfercher/maroto/pkg/consts" "github.com/johnfercher/maroto/pkg/props" - v2 "github.com/johnfercher/maroto/pkg/v2" "github.com/johnfercher/maroto/pkg/v2/context" + "github.com/johnfercher/maroto/pkg/v2/domain" "github.com/johnfercher/maroto/pkg/v2/types" ) type text struct { value string _type types.DocumentType - components []v2.Node + components []domain.Node prop props.Text } -func New(value string, textProps ...props.Text) v2.Component { +func New(value string, textProps ...props.Text) domain.Component { prop := props.Text{} if len(textProps) > 0 { prop = textProps[0] @@ -36,12 +36,12 @@ func (t *text) GetType() string { return t._type.String() } -func (t *text) Add(_ ...v2.Node) v2.Node { +func (t *text) Add(_ ...domain.Node) domain.Node { return t } -func (t *text) GetStructure() *tree.Node[v2.Structure] { - str := v2.Structure{ +func (t *text) GetStructure() *tree.Node[domain.Structure] { + str := domain.Structure{ Type: string(t._type), Value: t.value, } @@ -50,7 +50,7 @@ func (t *text) GetStructure() *tree.Node[v2.Structure] { } func (t *text) Render(fpdf fpdf.Fpdf, ctx context.Context) { - ctx.Print(t.value) + //ctx.Print(t.value) t.render(fpdf, ctx) return } diff --git a/v2.pdf b/v2.pdf index a9dfd247d664ecfea1cde2535765d2a2e3f2acee..1fe79e7c940994d1203e00dad3bbf995db61e9f3 100644 GIT binary patch delta 5892 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 Date: Wed, 13 Sep 2023 20:40:25 -0300 Subject: [PATCH 24/24] fix auto page break positioning --- pkg/v2/code/barcode/barcode.go | 11 ++++++----- pkg/v2/code/matrixcode/matrixcode.go | 9 +++++---- pkg/v2/code/qrcode/qrcode.go | 9 +++++---- pkg/v2/image/base64image.go | 7 +++---- pkg/v2/image/fileimage.go | 7 +++---- pkg/v2/row/row.go | 3 +-- pkg/v2/signature/signature.go | 8 +++----- pkg/v2/text/text.go | 8 +++----- v2.pdf | Bin 214957 -> 214933 bytes 9 files changed, 29 insertions(+), 33 deletions(-) diff --git a/pkg/v2/code/barcode/barcode.go b/pkg/v2/code/barcode/barcode.go index 31f85e06..d573b760 100644 --- a/pkg/v2/code/barcode/barcode.go +++ b/pkg/v2/code/barcode/barcode.go @@ -37,11 +37,12 @@ func (b *barcode) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) code := internal.NewCode(fpdf, math) - fmt.Println(fpdf.GetX()-ctx.Margins.Left, fpdf.GetY()-ctx.Margins.Top) - err := code.AddBar(b.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, - fpdf.GetY() - ctx.Margins.Top, - ctx.Dimensions.Width, - ctx.Dimensions.Height}, b.prop) + x := fpdf.GetX() - ctx.Margins.Left - ctx.Dimensions.Width + y := fpdf.GetY() - ctx.Margins.Top + fmt.Println(x, y) + err := code.AddBar(b.code, + internal.Cell{x, y, ctx.Dimensions.Width, ctx.Dimensions.Height}, + b.prop) if err != nil { fpdf.ClearError() diff --git a/pkg/v2/code/matrixcode/matrixcode.go b/pkg/v2/code/matrixcode/matrixcode.go index a4a26023..8502560c 100644 --- a/pkg/v2/code/matrixcode/matrixcode.go +++ b/pkg/v2/code/matrixcode/matrixcode.go @@ -35,10 +35,11 @@ func (m *matrixCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) code := internal.NewCode(fpdf, math) - code.AddDataMatrix(m.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, - fpdf.GetY() - ctx.Margins.Top, - ctx.Dimensions.Width, - ctx.Dimensions.Height}, m.prop) + x := fpdf.GetX() - ctx.Margins.Left - ctx.Dimensions.Width + y := fpdf.GetY() - ctx.Margins.Top + code.AddDataMatrix(m.code, + internal.Cell{x, y, ctx.Dimensions.Width, ctx.Dimensions.Height}, + m.prop) } func (m *matrixCode) GetType() string { diff --git a/pkg/v2/code/qrcode/qrcode.go b/pkg/v2/code/qrcode/qrcode.go index f1826442..aba82143 100644 --- a/pkg/v2/code/qrcode/qrcode.go +++ b/pkg/v2/code/qrcode/qrcode.go @@ -35,10 +35,11 @@ func (q *qrCode) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) code := internal.NewCode(fpdf, math) - code.AddQr(q.code, internal.Cell{fpdf.GetX() - ctx.Margins.Left, - fpdf.GetY() - ctx.Margins.Top, - ctx.Dimensions.Width, - ctx.Dimensions.Height}, q.prop) + x := fpdf.GetX() - ctx.Margins.Left - ctx.Dimensions.Width + y := fpdf.GetY() - ctx.Margins.Top + code.AddQr(q.code, + internal.Cell{x, y, ctx.Dimensions.Width, ctx.Dimensions.Height}, + q.prop) } func (q *qrCode) GetType() string { diff --git a/pkg/v2/image/base64image.go b/pkg/v2/image/base64image.go index 479b87cb..2c7e3124 100644 --- a/pkg/v2/image/base64image.go +++ b/pkg/v2/image/base64image.go @@ -38,12 +38,11 @@ func NewFromBase64(path string, extension consts.Extension, imageProps ...props. func (b *base64Image) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) img := internal.NewImage(fpdf, math) + x := fpdf.GetX() - ctx.Margins.Left - ctx.Dimensions.Width + y := fpdf.GetY() - ctx.Margins.Top err := img.AddFromBase64( b.base64, - internal.Cell{fpdf.GetX() - ctx.Margins.Left, - fpdf.GetY() - ctx.Margins.Top, - ctx.Dimensions.Width, - ctx.Dimensions.Height}, + internal.Cell{x, y, ctx.Dimensions.Width, ctx.Dimensions.Height}, b.prop, b.extension, ) diff --git a/pkg/v2/image/fileimage.go b/pkg/v2/image/fileimage.go index aec445ca..5fe0ac37 100644 --- a/pkg/v2/image/fileimage.go +++ b/pkg/v2/image/fileimage.go @@ -35,12 +35,11 @@ func NewFromFile(path string, imageProps ...props.Rect) domain.Component { func (f *fileImage) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) img := internal.NewImage(fpdf, math) + x := fpdf.GetX() - ctx.Margins.Left - ctx.Dimensions.Width + y := fpdf.GetY() - ctx.Margins.Top err := img.AddFromFile( f.path, - internal.Cell{fpdf.GetX() - ctx.Margins.Left, - fpdf.GetY() - ctx.Margins.Top, - ctx.Dimensions.Width, - ctx.Dimensions.Height}, + internal.Cell{x, y, ctx.Dimensions.Width, ctx.Dimensions.Height}, f.prop) if err != nil { fpdf.ClearError() diff --git a/pkg/v2/row/row.go b/pkg/v2/row/row.go index fb02704d..52cbca1f 100644 --- a/pkg/v2/row/row.go +++ b/pkg/v2/row/row.go @@ -61,14 +61,13 @@ func (r *row) GetStructure() *tree.Node[domain.Structure] { func (r *row) Render(fpdf fpdf.Fpdf, ctx context.Context) { //ctx.Print(r.height) ctx = ctx.WithDimension(ctx.Dimensions.Width, r.height) - fpdf.SetDrawColor(r.color.Red, r.color.Green, r.color.Blue) for _, col := range r.cols { col.Render(fpdf, ctx) } - r.render(fpdf, ctx) + return } diff --git a/pkg/v2/signature/signature.go b/pkg/v2/signature/signature.go index 2435c773..3557b12a 100644 --- a/pkg/v2/signature/signature.go +++ b/pkg/v2/signature/signature.go @@ -37,13 +37,11 @@ func (s *signature) Render(fpdf fpdf.Fpdf, ctx context.Context) { math := internal.NewMath(fpdf) text := internal.NewText(fpdf, math, font) signature := internal.NewSignature(fpdf, math, text) - + x := fpdf.GetX() - ctx.Margins.Left - ctx.Dimensions.Width + y := fpdf.GetY() - ctx.Margins.Top signature.AddSpaceFor( s.value, - internal.Cell{fpdf.GetX() - ctx.Margins.Left, - fpdf.GetY() - ctx.Margins.Top, - ctx.Dimensions.Width, - ctx.Dimensions.Height}, + internal.Cell{x, y, ctx.Dimensions.Width, ctx.Dimensions.Height}, s.prop) } diff --git a/pkg/v2/text/text.go b/pkg/v2/text/text.go index f8c3ea15..5276e579 100644 --- a/pkg/v2/text/text.go +++ b/pkg/v2/text/text.go @@ -59,12 +59,10 @@ func (t *text) render(fpdf fpdf.Fpdf, ctx context.Context) { font := internal.NewFont(fpdf, 2, consts.Arial, consts.Normal) math := internal.NewMath(fpdf) text := internal.NewText(fpdf, math, font) - + x := fpdf.GetX() - ctx.Margins.Left - ctx.Dimensions.Width + y := fpdf.GetY() - ctx.Margins.Top text.Add( t.value, - internal.Cell{fpdf.GetX() - ctx.Margins.Left, - fpdf.GetY() - ctx.Margins.Top, - ctx.Dimensions.Width, - ctx.Dimensions.Height}, + internal.Cell{x, y, ctx.Dimensions.Width, ctx.Dimensions.Height}, t.prop) } diff --git a/v2.pdf b/v2.pdf index 1fe79e7c940994d1203e00dad3bbf995db61e9f3..421c1487152d1179dbc5f4f99c17cab3bb0d81b2 100644 GIT binary patch delta 5265 zcmZ46&pWlBcS1wGiJcu+aY<2XVlGz&Sc*Z1$sSL^mEMQm9e z!|{*lZ~g?qZJoJO*2_QKsJJme#JOnZ;f#B)&A(P(<@nFf@txVK_e1H983%vvUu>2a z>wa>glh@AQht9Sny=s(RCU@*rCv!kShk^9NEVBj9E<5BdC@S6g%NDP0rq1Q|=nC`E zCm|1dCRyrlcvrxES#m~l$BN!Hi~aYRe%qQcW!)s>wAB+gT%Xc#LGjR(Z%J&`)l<@c zM>g-bTYIgR@$>Psmzi$8O5ECZwuZa%;`aXs?i=iGUww16-ZJsn$q9@y_4yVzzVqeo zdvW^hWhS%QhYy}+AA518&Z^+Wdn8J)V;qYEDf7c#9> zo|RUA=XA2lBE5xOK69O2F3gZg{#01c)Rd{B$g9k@`bl+?&XHTma+ZmD$sf0Vz45S! z)x14u&ZLCxcDuXwOgq$VWvXnSy5UeK_vZ7q6EzlX64x@lnw9K1vFc&e)P(7Y_B+0( z&N!k}G-si(_}S!ybLZWobu3$F%=C1r;ty4sx!z3lv%A8)Chp8%moGPVEbM;vQ`y1K z)Aoayz_b?{1;02Zd{3=lEt>MsL}APB-|9M-KY#vO7dzujA%kdfR)JgN9JYw^9j%PA zN{7CF&}Crw|3AK>XU*iDOr7;c$f;z>l=E3KhCJ=>>$vthi2U8C^E2v_-do+X`x@SU z72#4fnZB=X=G81GJwJF?x+9vRdfd>p=tTRS>(#gPX#s{_(EzRaEIwN~G@|MVA5 z|Mef{w8$uz3C0+%x4E7af3ho0CG2Xi;;xXFN;}V<%5qVQ+}UsCrnA@Tyk4@z;mg`K z>b%E&HmJ8sH^+5fKUdB(xqfMMbeBhTbo=+PZu5zv#pjGdvY!Y>^UXeW*oykMOOXnm|)AY-5}3tlT;MTb7m*IV+F!R#|vCMo;5AaGrz0v(tJVrw4h=&$30=C zS0`Lw2`b7b@8H~-d_%pZur_C#<;{Kf|MzznED$l^-O|9W*Aw<2_Yk*=lM+u;@Gogl zglu|Z88rDU%V>lQst9?=);*d-22&3C&e1a(A%iJG__#+SWKb1Zs=T8SGN>ZNhJQ3d z233Rv3ywy}po)-2QQ^t8!j+>H`(Ucr8%2BS%~3js7teNGaS%B0v3lO3xC8foy;-&E z)T>3?k5)Fmo7bmsVv%@!e3}vqoBqu?X&fQ1=KoTxi4~~Ri8%A{{HKph{_{6hmTu8L z>f*aMF4En6dgdjmZ4!PK?rH*JE<4tIc)97$Kczi7x8Hvk&VQtlB%pFsFrAs z>;6QR^Z6fkc~k_pD2LyWeqvX1`_Bb~&fWD}w;FA~{p!QLO;ySJQqM)Ud$jf4c();N z-yi0cDXkf|i)4=2a3{Z#oS@A5+ptVPR9nokis?x$uk{J%!;%6^qq6eit7Kf5y4yd2 zl>BE-{OC0GGtY_NQe_j`+maRPnL!;to@Cv0uGG8~=ui!im7kQwWvF1FkiWS{ypM5n zwPFU#=5?}XnKw&GPGM<&tlIuql@W-Uwm(*7{x3a!i8Hg-bPH!@qv?yBn2i`Mr}H{7 zCxZo8ErF&4O~3ERY&!jsBTzw+Gjj~1`SkP7%o$2X2F8}AmYQ7pzWFIGi6yBD8ZK5w z21dpPmWIXwpU&*cY+Vm@CkVi#fJ}1>H01^c zhDIhB>I{tyG1ZxyW2&<-H9)rm=tyITSUtjGBV!AwAd;Acu^EPDOG6AXV`DQ6#~7QK zV2W897@?Tw2=uVAr3I=WP|U={*c3$}NX*m_Q_OPuL^o#PdIJ*+bmgX|1{i^1YHEQY zW@cz=g09!h$P~kmX2zx%;bU%U3=Ui$hh9(A<#?zzS RnLW4+Ee*L;RbBnvxBxCK(B1$5 delta 5310 zcmbQ*&%3stcS1wGg`FK&aY<2XVlGz&kl90Irm>~YvF4v zuRf8WQ+LJl)I@^$?-+bF2=kX|XmW13$q~MpQC8{D*9JbphwsEy5;s}~8VD_y(@5s?zukO-M__w1n$|2fz&9x0P^A+`febfIToc6uIwAxtW^67-haf~wc?_F=)?l6o0 z^7LCKD!bv+~4xUxm*8Q_q&xB?A6BhCF&GQQjJAO!tw@>oF%Cn>| z$@J+n{8`UYtvtg`=#oLw2CseU$DG#KKAR}~%t$Ogx?ff= zyr4MasJpC-+&Za$Qhr#bV!ktQ5)eD1y*P2ZeSt-6Ql=B-;@R?4Y z%eMqS&R8fcel|Jb-0sD?)8;sxIisSqw_R(}neb-Y!{6O(Sj8`WS*k7}=q!Hrb9zsW zJUk6)wljDvbm}h)PVvWceFPHE2Jd>A3M|XKdhqr$Z>o%V#T71qZB>RcrZCSJF%kAB` zq>b{U@(Yz8{OO!t3#j~rf8VDTtSUW!{ z?!cX&CsNY36@6W_yZbroq&Xo1PZmhW$KT>=ZJxbtb(@ab|8x8gU$=ZnKD30bep$bH z#m}CrT?_A>WPf(zyY=&XS5j77>AJdGuuqP$g;OxkxMr8{X~BoNxAxuF_et_!^gzYa zc!FzCeIvifyiEt*Gu}`5wKcX_lZ}I8k!FBv!^KIri*nOedg!tJRo_!{aE7PH>7Jw3 zPX&8=BigUdWX_%){qB1rbDaDKyS2%G0uJ5U$<`TtN<%3?MSaQBEoK#u9~_(WnnTDn z;&p8?cA-1$*YVluEY-&`O*iE*>J z;uMz6S+ZxDH#13Qur!}mZ9lEb2*ga=PpdNjm!2Nw%xpA0!HGGB(QoBTK{SuU(j}>rGLmfU@S6Xvz%?42?|8 z(bWOXz|d=GZf=R8&cf6JUChYX5Nby~%uPU78Dm;(WMP7-+0qC@%-Glh!_mejW|(4@ zhNyb$fgU!tv_usIikX<0VrT{mVTxH=VCXe9FvAoxMUMmn15+~t<9hUBD%uO*pVqt1zgs#`p%n}w&itr?10t^ULg+_)ZhKA