alexbrainman / printer Goto Github PK

print.exe -l
fatal error: checkptr: unsafe pointer conversion

goroutine 1 [running]:
runtime.throw(0x50d846, 0x23)
        c:/go/src/runtime/panic.go:1116 +0x79 fp=0xc000107d20 sp=0xc000107cf0 pc=0x4332f9
runtime.checkptrAlignment(0xc000108000, 0x4dc5a0, 0x1)
        c:/go/src/runtime/checkptr.go:20 +0xd0 fp=0xc000107d50 sp=0xc000107d20 pc=0x406820
github.com/alexbrainman/printer.ReadNames(0xc000010109, 0xc000010120, 0xc00001c100, 0xc000107ee8, 0x45dd05)
        C:/MyGo/src/github.com/alexbrainman/printer/printer.go:145 +0xda fp=0xc000107e48 sp=0xc000107d50 pc=0x4c83ba
main.listPrinters(0xc00004a060, 0xc0000044b0)
        C:/MyGo/src/github.com/alexbrainman/printer/cmd/print/print.go:36 +0x3b fp=0xc000107f28 sp=0xc000107e48 pc=0x4ca07b
main.main()
        C:/MyGo/src/github.com/alexbrainman/printer/cmd/print/print.go:145 +0x197 fp=0xc000107f88 sp=0xc000107f28 pc=0x4caf67
runtime.main()
        c:/go/src/runtime/proc.go:203 +0x212 fp=0xc000107fe0 sp=0xc000107f88 pc=0x4359c2
runtime.goexit()
        c:/go/src/runtime/asm_amd64.s:1373 +0x1 fp=0xc000107fe8 sp=0xc000107fe0 pc=0x45dc41

type PRINTER_INFO_5 struct {
	PrinterName              *uint16
	PortName                 *uint16
	Attributes               uint32
	DeviceNotSelectedTimeout uint32
	TransmissionRetryTimeout uint32
}

buf extent C00007C000 -> C00007C558
p.PrinterName for printer  0 @ C00007C504
p.PrinterName for printer  1 @ C00007C4C8
p.PrinterName for printer  2 @ C00007C48C
p.PrinterName for printer  3 @ C00007C406
p.PrinterName for printer  4 @ C00007C3C0
p.PrinterName for printer  5 @ C00007C29A
p.PrinterName for printer  6 @ C00007C254
p.PrinterName for printer  7 @ C00007C20E
p.PrinterName for printer  8 @ C00007C1EE
p.PrinterName for printer  9 @ C00007C192

	go clean --modcache

package main

import (
    "bytes"
    "flag"
    "fmt"
    "log"
    "runtime"
    "time"

    prt "github.com/alexbrainman/printer"

    "github.com/jung-kurt/gofpdf"
)

func main() {
    log.SetFlags(log.LstdFlags | log.Llongfile)
    printFormat := flag.String("format", "pdf", "print the pdf content")
    savePDF := flag.Bool("s", false, "save pdf only")
    flag.Parse()

    // pdf output
    if *savePDF {
        // create pdf
        pdf := newReport()

        // Save pdf to disc
        pdf.OutputFileAndClose("report.pdf")
    } else {
        var buf []byte
        var datatype string

        // switch between formats
        switch *printFormat {
        case "text":
            buf = []byte("Text report")
            datatype = "text"
        case "pdf":
            // create pdf
            pdf := newReport()
            var b bytes.Buffer
            err := pdf.Output(&b)
            if err != nil {
                fmt.Println(err)
            }
            buf = b.Bytes()
            datatype = "raw"
        }

        // send content to printer
        fmt.Println(string(buf))
        printContent(datatype, buf)
    }
}

func newReport() *gofpdf.Fpdf {
    pdf := gofpdf.NewCustom(&gofpdf.InitType{
        UnitStr:        "mm",
        Size:           gofpdf.SizeType{Wd: 62, Ht: 90},
        OrientationStr: "P",
    })

    // Pagebreak
    pdf.SetAutoPageBreak(false, 0)

    // Fileinformations
    pdf.SetTitle("Test PDF", true)

    // Page Margin
    pdf.SetMargins(1, 1, 1)

    // We start by adding a new page to the document.
    pdf.AddPage()

    // UTF8 from File
    trans := pdf.UnicodeTranslatorFromDescriptor("")

    // Title
    pdf.SetFont("Arial", "B", 6)
    pdf.CellFormat(0, 2, trans("Test PDF"), "", 0, "C", false, 0, "")

    // The `Ln()` function moves the current position to a new line, with
    // an optional line height parameter.
    pdf.Ln(-1)

    pdf.SetFont("Arial", "", 5)
    pdf.CellFormat(0, 2, time.Now().Format("02.01.2006   15:04"), "", 0, "C", false, 0, "")
    pdf.Ln(-1)
    pdf.SetFont("Arial", "B", 5)
    pdf.CellFormat(0, 2, trans("new text in pdf"), "", 0, "C", false, 0, "")
    pdf.Ln(3)

    return pdf
}

func printContent(datatype string, content []byte) {
    if runtime.GOOS == "windows" {
        name, err := prt.Default() // returns name of Default Printer as string
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println(name)
        p, err := prt.Open(name) // Opens the named printer and returns a *Printer
        if err != nil {
            fmt.Println(err)
        }

        err = p.StartDocument("test", datatype)
        if err != nil {
            fmt.Println(err)
        }
        err = p.StartPage() // begin a new page
        if err != nil {
            fmt.Println(err)
        }

        n, err := p.Write(content) // Send some text to the printer
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println("Num of bytes written to printer:", n)

        err = p.EndPage() // end of page
        if err != nil {
            fmt.Println(err)
        }
        err = p.EndDocument() // end of document
        if err != nil {
            fmt.Println(err)
        }
        err = p.Close() // close the resource
        if err != nil {
            fmt.Println(err)
        }
    }
}

package main

import (
	"fmt"
	"log"

	"github.com/alexbrainman/printer"
)

func main() {
	testWindowPrinter()
}

func testWindowPrinter() {
	printLines("你好", "世界") // HERE, I got bad prints
	printLines("hello", "world")
}

func printLines(lines ...string) error {
	var defaultPrinter, err = printer.Default()
	if err != nil {
		log.Println(1, err.Error())
		return err
	}

	p, err := printer.Open(defaultPrinter)
	if err != nil {
		log.Println(2, err.Error())
		return err
	}
	defer p.Close()

	err = p.StartRawDocument("test")
	if err != nil {
		log.Println(3, err.Error())
		return err
	}
	defer p.EndDocument()

	err = p.StartPage()
	if err != nil {
		log.Println(4, err.Error())
		return err
	}

	for i := range lines {
		fmt.Fprintf(p, "%s\r\n", lines[i])
	}

	err = p.EndPage()
	if err != nil {
		log.Println(5, err.Error())
		return err
	}

	return nil
}