what about my code to support full page water mark

```go

func drawText_offset(p *creator.Paragraph, c *creator.Creator, offsetX float64, offsetY float64, att *text_attributes) {
// Change to times bold font (default is helvetica).
p.SetFont(getFontByName(font))
p.SetFontSize(att.FontSize)
p.SetPos(offsetX, offsetY)
p.SetColor(creator.ColorRGBFromHex("#" + att.FontColor))
p.SetAngle(att.Angle)

// Encountering problem with tiles and text watermark. Contributions welcome.
//if tiles {
// repeatTiles(p, c)
// return
//}

_ = c.Draw(p)
}

func markPDF(inputPath string, outputPath string, watermark string) error {
debugInfo(fmt.Sprintf("Input PDF: %v", inputPath))

c := creator.New()
var watermarkImg *creator.Image
var para *creator.Paragraph

isImageMark := isImageMark(watermark)
watermarkIsATemplate := isWatermarkATemplate(watermark)

// Read the input pdf file.
f, err := os.Open(inputPath)
fatalIfError(err, fmt.Sprintf("Failed to open the source file. [%s]", err))
defer f.Close()

pdfReader, err := pdf.NewPdfReader(f)
fatalIfError(err, fmt.Sprintf("Failed to parse the source file. [%s]", err))

numPages, err := pdfReader.GetNumPages()
fatalIfError(err, fmt.Sprintf("Failed to get PageCount of the source file. [%s]", err))

// Prepare data to insert into the template.
rec := Recipient{
Pages: numPages,
Filename: filepath.Base(inputPath[:len(inputPath)-len(filepath.Ext(inputPath))]),
}
var t *template.Template
if !isImageMark && watermarkIsATemplate {
t = template.Must(template.New("watermark").Parse(watermark))
}

for i := 0; i < numPages; i++ {
pageNum := i + 1
rec.Page = pageNum

// Read the page.
page, err := pdfReader.GetPage(pageNum)
fatalIfError(err, fmt.Sprintf("Failed to read page from source. [%s]", err))

// Add to creator.
c.AddPage(page)

// Calculate the position on first page
if pageNum == 1 {
debugInfo(fmt.Sprintf("Page Width : %v", c.Context().PageWidth))
debugInfo(fmt.Sprintf("Page Height : %v", c.Context().PageHeight))
}

if isImageMark {
if pageNum == 1 {
watermarkImg, err = creator.NewImageFromFile(watermark)
fatalIfError(err, fmt.Sprintf("Failed to load watermark image. [%s]", err))
adjustImagePosition(watermarkImg, c)
}

drawImage(watermarkImg, c)

}
var need_draw_text = !isImageMark || full
if need_draw_text {
var attr text_attributes
var text = watermark
if full {
attr.Alpha = float64(water_mark_config.Outdevconf.MaskConf.Alpha)
attr.Angle = float64(water_mark_config.Outdevconf.MaskConf.Angle)
attr.FontSize = float64(water_mark_config.Outdevconf.MaskConf.Fontsize)
attr.FontColor = water_mark_config.Outdevconf.MaskConf.Fontcolor[1:]
text = water_mark_config.Outdevconf.MaskText
}
if pageNum == 1 {
para = creator.NewParagraph(text)
adjustTextPosition(para, c)
}

if watermarkIsATemplate {
applyTemplate(t, &rec, para)
}
if full {
var gap_y = c.Context().PageHeight / 2
var gap_x = c.Context().PageWidth / 4
for x := 0; x < int(c.Context().PageWidth); x = x + int(gap_x) {
for y := 0; y < int(c.Context().PageHeight); y = y + int(gap_y) {
if x%2 == 0 {
drawText_offset(para, c, float64(x), float64(y), &attr)
} else {
drawText_offset(para, c, float64(x), float64(y+int(gap_y)/2), &attr)
}
}
}
} else {
drawText(para, c)
}
}
}

err = c.WriteToFile(outputPath)
return err
}
```