def draw_footer(self, canvas):
canvas.saveState()
footerwidth = self.dina4[0] - (2 * self.left)
canvas.setFillColorCMYK(1, 0.5, 0, 0)
canvas.rect(0, 0, width=self.dina4[0], height=50, fill=True)
canvas.setFillColorCMYK(0, 0, 0, 0)
canvas.setFont(self.font_bold, 14)
x = self.dina4[0]/2
canvas.drawCentredString(x, 25, 'www.imko.de')
canvas.linkURL('http://www.imko.de', (0, 50, self.dina4[1], 0))
canvas.restoreState()
def titlePage(self, canvas, doc):
canvas.saveState()
canvas.setFont('Times-Bold',32)
canvas.drawCentredString(self.pageWidth / 2.0, self.pageHeight - 108, self.mainTitle)
canvas.setFont('Times-Bold',16)
canvas.drawCentredString(self.pageWidth / 2.0, self.pageHeight - 130, self.subTitleText)
canvas.restoreState()
def beforePage(self):
if self.pageheader is None:
return
canvas = self.canv
canvas.drawCentredString(canvas._pagesize[0] / 2.0,
canvas._pagesize[1] - 0.5*inch,
self.pageheader)
def archive_watermark_page(archive_date):
"""Return PDF object with archiving watermark.
Args:
archive_date (datetime.datetime): Date of archiving.
Returns:
PyPDF2.pdf.PageObject: Page with just the archive watermark.
"""
size = {"width": 20 * pagesizes.inch, "height": 18 * pagesizes.inch}
font = {
"name": "Helvetica",
"size": 256,
"color": colors.red.clone(alpha=0.20),
"start_x": size["width"] * 0.50,
"start_y": size["height"] * 0.45,
}
text_lines = ["ARCHIVED", archive_date.strftime("%Y-%m-%d")]
packet = io.BytesIO()
canvas = reportlab.pdfgen.canvas.Canvas(
filename=packet, pagesize=(size["width"], size["height"]), bottomup=0
)
canvas.setFillColor(font["color"])
canvas.setFont(psfontname=font["name"], size=font["size"])
for i, line in enumerate(text_lines):
canvas.drawCentredString(
x=font["start_x"], y=(font["start_y"] + canvas._leading * i), text=line
)
canvas.save()
packet.seek(0)
watermark_page = PyPDF2.PdfFileReader(packet).getPage(0)
return watermark_page
def docPage(canvas, doc):
canvas.saveState()
canvas.setFont('Times-Bold', 10)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - (.25 * inch),
Title)
canvas.setFont('Times-Roman', 9)
canvas.drawString(7 * inch, .75 * inch, "Page %d" % (doc.page, ))
canvas.restoreState()
def __unicode__(self):
return u"Could Not Match Problem: %d" % self.file.id
def render(self, Story):
return self.render_pdf(Story)
def render_pdf(self, Story):
Story.append(
Paragraph(
"<strong>Files that couldn't be matched against a database, but probably should have been found:</strong>",
styleH))
for file in self.files:
Story.append(Paragraph("%s" % file.filename, styleN))
Story.append(
Paragraph(
"Movies should NOT have 'blueray', 'hdtv', 'tv', '480p' or any of that shit in their names. We can tell, honestly, from the file size, and I can't keep up with the extra fluff to strip it out; I can't catch everything.",
styleN))
return Story
def draw_code128_sdaps_info(canvas, survey, page):
# The page number is one based here already
# The survey_id is a 32bit number, which means we need
# 10 decimal digits to encode it, then we need to encode the
# the page with at least 3 digits(just in case someone is insane enough
# to have a questionnaire with more than 99 pages.
# So use 10+4 digits
barcode_value = "%010d%04d" % (survey.survey_id, page)
barcode = createBarcodeDrawing("Code128",
value=barcode_value,
barWidth=defs.code128_barwidth / 25.4 * 72.0,
height=defs.code128_height / 25.4 * 72.0,
quiet=False)
y = survey.defs.paper_height - defs.corner_mark_bottom
x = survey.defs.paper_width - defs.corner_mark_right
barcode_y = y - defs.code128_vpad - defs.code128_height
barcode_x = x - defs.code128_hpad
# The barcode should be flush left.
barcode_x = barcode_x - barcode.width / mm
renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)
# Label
text_x = barcode_x + barcode.width / mm / 2.0
text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0
canvas.saveState()
canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
canvas.restoreState()
def myLaterPages(canvas, doc):
PAGE_HEIGHT,PAGE_WIDTH = letter
canvas.saveState()
canvas.setPageSize(landscape(letter))
canvas.drawImage(frunt_pag2, 0,0, PAGE_WIDTH,PAGE_HEIGHT )
canvas.setStrokeColorRGB(0,1,1,alpha=0.1)
ficha_no = doc.page-1
#canvas.setStrokeColorRGB(0.7,0.7,0.7)
canvas.setFillColorRGB(0,0,0)
SHOW_GRID = False
if SHOW_GRID:
n = 5
s = 200
canvas.setFillColorRGB(0,0,1)
canvas.setFont('Helvetica',1)
for x in range(s):
for y in range(s):
canvas.rect(x*n,y*n, width=n, height=n, stroke=1)
canvas.drawString(x*n,y*n,"%s,%s" % ((x*n),(y*n)) )
# for i in range(s):
# x= i*n
# y=x
# canvas.drawString(x,0,"%s" % (x)) #horizontal
# canvas.drawString(0,y+1,"%s" % (x)) # vertical
# canvas.drawString(x,600,"%s" % (x)) #horizontal
# canvas.drawString(990,y,"%s" % (x)) # vertical
#
# canvas.setStrokeColorRGB(0,0,1,alpha=0.7)
# canvas.setFont('Helvetica',1)
# for i in range(610):
# #canvas.rect(35,i*2, width=0.5, height=0.5, stroke=1)
# canvas.drawString(35,i,"%s -" % (i,) )
canvas.setFont('Helvetica',7)
LINE_1 = 508
#fecha_elaboracion = doc.fecha_elaboracion
#if not fecha_elaboracion:
# fecha_elaboracion = datetime.today()
canvas.drawCentredString(137,LINE_1,str(fecha_elaboracion.year))
canvas.drawCentredString(162,LINE_1,str(fecha_elaboracion.month))
canvas.drawCentredString(180,LINE_1,str(fecha_elaboracion.day))
canvas.drawCentredString(290,LINE_1,"VALLE DEL CAUCA")
canvas.drawCentredString(740,LINE_1,"Ficha No. %s" % (int(ficha_no)+int(no_ficha_inicial)-1))
canvas.setFont('Helvetica',5)
canvas.drawString(75,115, "Elaboro: %s" % elaboro)
canvas.drawString(215,115, "Reviso: %s" % reviso)
canvas.restoreState()
def myFirstPage(canvas, doc):
canvas.saveState()
canvas.setFont('Times-Bold', 16)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 108, Title)
canvas.setFont('Times-Roman', 9)
canvas.drawString(inch, 0.75 * inch, "First Page / %s" % pageinfo)
canvas.restoreState()
def header(canvas, doc, content):
canvas.saveState()
w, h = content.wrap(doc.width, doc.topMargin)
canvas.setFont('Helvetica-Bold', 18)
canvas.drawCentredString(doc.width / 2 + 75,
doc.height + doc.topMargin - h, content.text)
canvas.restoreState()
def el_encogedor_de_fuentes_de_doraemon(canvas, fuente, tamannoini, xini, xfin, y, texto, alineacion = -1):
"""
Comenzando por el tamaño inicial "tamannoini", encoge el texto
hasta que quepa en los límites fijados y después lo escribe.
Convierte el texto por si está en una codificación no soportada.
Al finalizar, devuelve las propiedades de texto del canvas a
su estado original y la fuente a su tamaño inicial.
NO AVANZA LÍNEA.
Si alineacion == -1: Alineación a la izquierda. Si 0, centrado y si 1, a la derecha.
"""
# PLAN: No estaría mal pasar un tamaño mínimo de fuente, y si se alcanza o se supera, cortar la línea con
# agregarFila y el último tamaño de fuente válido. Claro que entonces habría que devolver también las líneas
# avanzadas, etc...
canvas.saveState()
size = tamannoini
texto = escribe(texto)
while canvas.stringWidth(texto, fuente, size) > (xfin - xini) and size > 4:
size -= 1
canvas.setFont(fuente, size)
if alineacion == -1:
canvas.drawString(xini, y, texto)
elif alineacion == 1:
canvas.drawRightString(xfin, y, texto)
elif alineacion == 0:
canvas.drawCentredString((xfin + xini) / 2.0, y, texto)
else:
print "geninformes.py::el_encogedor_de_fuentes_de_doraemon -> Error alineación. Uso alineación a la izquierda por defecto."
canvas.drawString(xini, y, texto)
canvas.restoreState()
def myFirstPage(canvas, doc):
canvas.saveState()
canvas.setFont('Helvetica-Bold', 16)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 108, Title)
canvas.setFont('Helvetica', 10)
canvas.drawString(inch, 0.75 * inch, "OSMJ / %s" % pageinfo)
canvas.restoreState()
def myFirstPage(self, canvas, doc):
canvas.saveState()
canvas.drawImage("Logo.png", 10, 24 * cm)
canvas.setFont('Times-Bold', 20)
canvas.drawCentredString(1 * self.PageWidth / 2, self.PageHeight - 30,
self.Title)
canvas.setFont('Helvetica', 9)
canvas.drawString(inch, 0.75 * inch, "Page 1 / %s" % self.pageinfo)
canvas.setFont("Helvetica", 12)
x = 3 * cm
y = self.PageHeight - 8 * cm
canvas.drawString(x, y, "Professeur : " + self.rapport.prof)
canvas.drawString(x, y - 2 * cm, "Lieu : " + self.rapport.lieu)
canvas.drawString(x, y - 1 * cm, "Matière : " + self.rapport.matiere)
canvas.drawString(
x, y - 3 * cm, "Date : " + str(self.rapport.hoy.day) + "/" +
str(self.rapport.hoy.month) + "/" + str(self.rapport.hoy.year) +
" à " + str(self.rapport.hour) + "h" + str(self.rapport.minute))
canvas.drawRightString(
20 * cm, y,
"Eleve : " + self.rapport.prenom + " " + self.rapport.nom)
canvas.drawRightString(20 * cm, y - 1 * cm,
"Classe : " + self.rapport.classe)
canvas.drawString(
x, y - 4 * cm,
"Punition demandée par l'enseignant : " + self.rapport.punition)
canvas.drawString(
x, y - 5 * cm,
"Sanction demandée par l'enseignant : " + self.rapport.sanction)
canvas.drawString(x, y - 6 * cm,
"Décision de la Direction, ou du CPE : ")
canvas.drawString(x, y - 8 * cm, "Motifs : ")
canvas.restoreState()
def draw_code128_sdaps_info(canvas, survey, page):
# The page number is one based here already
# The survey_id is a 32bit number, which means we need
# 10 decimal digits to encode it, then we need to encode the
# the page with at least 3 digits(just in case someone is insane enough
# to have a questionnaire with more than 99 pages.
# So use 10+4 digits
barcode_value = "%010d%04d" % (survey.survey_id, page)
barcode = createBarcodeDrawing("Code128",
value=barcode_value,
barWidth=defs.code128_barwidth / 25.4 *
72.0,
height=defs.code128_height / 25.4 * 72.0,
quiet=False)
y = survey.defs.paper_height - defs.corner_mark_bottom
x = survey.defs.paper_width - defs.corner_mark_right
barcode_y = y - defs.code128_vpad - defs.code128_height
barcode_x = x - defs.code128_hpad
# The barcode should be flush left.
barcode_x = barcode_x - barcode.width / mm
renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)
# Label
text_x = barcode_x + barcode.width / mm / 2.0
text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0
canvas.saveState()
canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
canvas.restoreState()
def myFirstPage(canvas, doc):
canvas.saveState()
canvas.setFont('Times-Bold',16)
canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT-108, Title)
canvas.setFont('Times-Roman',9)
canvas.drawString(inch, 0.75 * inch,"First Page / %s" % pageinfo)
canvas.restoreState()
def _build_header_canvas(canvas, doc):
"""
Draw the document header.
Local function to be passed later to output_doc.build().
Reportlab automatically passes args when called.
"""
# The header function to be passed later to output_doc.build()
# Set up positions
header_y_position = (11 * units.inch) - 45
page_number = doc.page
if page_number % 2 == 0:
# Left-hand page
page_number_x_position = 60
else:
# Right-hand page
page_number_x_position = (8.5 * units.inch) - 60
canvas.saveState()
canvas.setFont(self.paragraph_style.fontName,
self.paragraph_style.fontSize)
if self.title:
canvas.drawCentredString((8.5 * units.inch) / 2,
header_y_position,
self.title)
canvas.drawString(page_number_x_position, header_y_position,
str(page_number))
canvas.restoreState()
def myPage(canvas, doc):
canvas.saveState() # save the current state
canvas.setFont('InconsolataBold', 16) # set the font for the name
canvas.drawString(
.4 * inch,
HEIGHT - (.4 * inch),
contact['name']) # draw the name on top left page 1
canvas.setFont('Inconsolata', 8) # sets the font for contact
canvas.drawRightString(
WIDTH - (.4 * inch),
HEIGHT - (.4 * inch),
contact['website'])
canvas.line(.4 * inch, HEIGHT - (.47 * inch),
WIDTH - (.4 * inch), HEIGHT - (.47 * inch))
canvas.drawString(
.4 * inch,
HEIGHT - (.6 * inch),
contact['phone'])
canvas.drawCentredString(
WIDTH / 2.0,
HEIGHT - (.6 * inch),
contact['address'])
canvas.drawRightString(
WIDTH - (.4 * inch),
HEIGHT - (.6 * inch),
contact['email'])
# restore the state to what it was when saved
canvas.restoreState()
def docPage(canvas,doc):
canvas.saveState()
canvas.setFont('Times-Bold', 10)
canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT - (.25 * inch), Title)
canvas.setFont('Times-Roman',9)
canvas.drawString(7 * inch, .75 * inch, "Page %d" % (doc.page,))
canvas.restoreState()
def draw_code128_global_id(canvas, survey):
if survey.global_id is None:
raise AssertionError
# Only allow ascii
barcode_value = survey.global_id.encode('ascii')
barcode = createBarcodeDrawing("Code128",
value=barcode_value,
barWidth=defs.code128_barwidth / 25.4 *
72.0,
height=defs.code128_height / 25.4 * 72.0,
quiet=False)
y = survey.defs.paper_height - defs.corner_mark_bottom
x = (survey.defs.paper_width - defs.corner_mark_right +
defs.corner_mark_left) / 2
barcode_y = y - defs.code128_vpad - defs.code128_height
barcode_x = x
# Center
barcode_x = barcode_x - barcode.width / mm / 2.0
renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)
# Label
text_x = barcode_x + barcode.width / mm / 2.0
text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0
canvas.saveState()
canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
canvas.restoreState()
def _draw_subsection(canvas, yc, title_left, title_middle, title_right, text_tuples):
if title_left or title_middle or title_right:
canvas.setFont(SUBSECTION_TITLE_FONT, SUBSECTION_FONT_SIZE)
title_y = yc - SUBSECTION_FONT_SIZE
if title_left:
title_x = H_TEXT_MARGIN
canvas.drawString(title_x, title_y, title_left)
if title_middle:
title_x = RESUME_PAGE_SIZE[0] / 2
canvas.drawCentredString(title_x, title_y, title_middle)
if title_right:
title_x = RESUME_PAGE_SIZE[0] - H_TEXT_MARGIN
canvas.drawRightString(title_x, title_y, title_right)
yc = title_y - V_SEPARATOR
canvas.setFont(SUBSECTION_FONT, SUBSECTION_FONT_SIZE)
for (draw_bullet, text) in text_tuples:
if draw_bullet:
text = u"• " + unicode(text)
lines = _break_text(text, RESUME_PAGE_SIZE[0] - (2*H_TEXT_MARGIN + SUBSECTION_H_INDENT), SUBSECTION_FONT, SUBSECTION_FONT_SIZE)
line_x = H_TEXT_MARGIN + SUBSECTION_H_INDENT
for line in lines:
line_y = yc - SUBSECTION_FONT_SIZE
canvas.drawString(line_x, line_y, line)
yc = line_y - V_SEPARATOR
return yc - SUBSECTION_V_SPACER
def draw_code128_questionnaire_id(canvas, survey, id):
# Only supports ascii for now (see also defs.py)
barcode_value = unicode(id).encode('ascii')
barcode = createBarcodeDrawing("Code128",
value=barcode_value,
barWidth=defs.code128_barwidth / 25.4 *
72.0,
height=defs.code128_height / 25.4 * 72.0,
quiet=False)
y = survey.defs.paper_height - defs.corner_mark_bottom
x = defs.corner_mark_left
barcode_y = y - defs.code128_vpad - defs.code128_height
barcode_x = x + defs.code128_hpad
# The barcode should be flush left.
barcode_x = barcode_x
renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)
# Label
text_x = barcode_x + barcode.width / mm / 2.0
text_y = barcode_y + defs.code128_height + 1 + \
defs.code128_text_font_size / 72.0 * 25.4 / 2.0
canvas.saveState()
canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
canvas.restoreState()
def add_page_number(canvas, doc):
canvas.saveState()
canvas.setFont('Times-Roman', 10)
canvas.setTitle('Report Agrisurvey')
page_number_text = "pagina %d" % (doc.page)
canvas.drawCentredString(0.75 * inch, 0.75 * inch, page_number_text)
canvas.restoreState()
def writeText(canvas, style, string, size, vpos, width, **kwargs):
"""
Wrapper function to conveniently write text and return how much vertical space it took up.
"""
align = kwargs.get('align', 'centre')
if align == 'centre' or align == 'center':
hpos = kwargs.get('hpos', width / 2)
elif align == 'left':
hpos = kwargs.get('hpos', 0)
elif align == 'right':
hpos = kwargs.get('hpos', width)
spacing = kwargs.get('spacing', style.lineSpacing)
canvas.setFont(style.font, size)
if align == 'centre' or align == 'center':
canvas.drawCentredString(hpos, vpos - (0.75 * size * spacing), string)
elif align == 'left':
canvas.drawString(hpos, vpos - (0.75 * size * spacing), string)
elif align == 'right':
canvas.drawString(hpos - canvas.stringWidth(string),
vpos - (0.75 * size * spacing), string)
return size * style.lineSpacing
def draw_code128_global_id(canvas, survey):
if survey.global_id is None:
raise AssertionError
# Only allow ascii
barcode_value = survey.global_id.encode('ascii')
barcode = createBarcodeDrawing("Code128",
value=barcode_value,
barWidth=defs.code128_barwidth / 25.4 * 72.0,
height=defs.code128_height / 25.4 * 72.0,
quiet=False)
y = survey.defs.paper_height - defs.corner_mark_bottom
x = (survey.defs.paper_width - defs.corner_mark_right + defs.corner_mark_left) / 2
barcode_y = y - defs.code128_vpad - defs.code128_height
barcode_x = x
# Center
barcode_x = barcode_x - barcode.width / mm / 2.0
renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)
# Label
text_x = barcode_x + barcode.width / mm / 2.0
text_y = barcode_y + defs.code128_height + 1 + defs.code128_text_font_size / 72.0 * 25.4 / 2.0
canvas.saveState()
canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
canvas.restoreState()
def generate_employee_handout(name, home_address, office_address, home_map,
office_map, canvas):
# Add Generic Company logo for the lolz
company_logo = "generic-logo-hi.png"
canvas.drawImage(company_logo, 15, 750, width=100, height=30)
# header text
canvas.setFont("Helvetica-Bold", 20, leading=None)
canvas.drawCentredString(380, 755,
"Direct Debit Banking Services Locations")
# Add name
canvas.setFont("Helvetica-Bold", 20, leading=None)
canvas.drawString(25, 700, "Name: " + name)
# add office details and map image
canvas.setFont("Helvetica-Bold", 16, leading=None)
canvas.drawString(25, 630, "Office: " + office_address)
canvas.drawImage(office_map, 25, 425, width=200, height=200)
# add home details and map image
canvas.setFont("Helvetica-Bold", 16, leading=None)
canvas.drawString(25, 365, "Home: " + home_address)
canvas.drawImage(home_map, 25, 160, width=200, height=200)
# add footer with time
formatted_time = time.ctime()
canvas.setFont("Helvetica", 10, leading=None)
canvas.drawCentredString(520, 15, formatted_time)
# save pdf
canvas.showPage()
print("PDF completed")
def draw_code128_questionnaire_id(canvas, survey, id):
# Only supports ascii for now (see also defs.py)
barcode_value = unicode(id).encode('ascii')
barcode = createBarcodeDrawing("Code128",
value=barcode_value,
barWidth=defs.code128_barwidth / 25.4 * 72.0,
height=defs.code128_height / 25.4 * 72.0,
quiet=False)
y = survey.defs.paper_height - defs.corner_mark_bottom
x = defs.corner_mark_left
barcode_y = y - defs.code128_vpad - defs.code128_height
barcode_x = x + defs.code128_hpad
# The barcode should be flush left.
barcode_x = barcode_x
renderPDF.draw(barcode, canvas, barcode_x * mm, barcode_y * mm)
# Label
text_x = barcode_x + barcode.width / mm / 2.0
text_y = barcode_y + defs.code128_height + 1 + \
defs.code128_text_font_size / 72.0 * 25.4 / 2.0
canvas.saveState()
canvas.setFont(defs.code128_text_font, defs.code128_text_font_size)
canvas.drawCentredString(text_x * mm, text_y * mm, barcode_value)
canvas.restoreState()
def _draw_back(self, canvas):
# Draw red border
self._draw_single_border(canvas, self.WIDTH, self.WIDTH, self.HEIGHT)
# Parchment background
self._draw_single_background(canvas, self.WIDTH, self.BORDER_BACK,
self.WIDTH, self.HEIGHT)
# Title
canvas.setFillColor("black")
title_font_height = self.fonts.set_font(canvas, "title")
title_line_bottom = self.HEIGHT - self.BORDER_BACK[
Border.TOP] - self.TITLE_BAR_HEIGHT
title_bottom = title_line_bottom + (self.TITLE_BAR_HEIGHT -
title_font_height) / 2
canvas.drawCentredString(self.WIDTH + self.BASE_WIDTH / 2,
title_bottom, self.title.upper())
# Subtitle
subtitle_line_bottom = title_line_bottom - self.STANDARD_BORDER
canvas.setFillColor(self.BORDER_COLOR)
canvas.rect(self.WIDTH,
subtitle_line_bottom,
self.BASE_WIDTH,
self.STANDARD_BORDER,
stroke=0,
fill=1)
canvas.setFillColor("white")
subtitle_font_height = self.fonts.set_font(canvas, "subtitle")
subtitle_bottom = subtitle_line_bottom + (self.STANDARD_BORDER -
subtitle_font_height) / 2
canvas.drawCentredString(self.WIDTH + self.BASE_WIDTH / 2,
subtitle_bottom, self.subtitle)
def ref_ticker(canvas, feature, cLen, Y0, nudge, offset):
"""Draw contig separators."""
# get contig name
name = feature.qualifiers.get('id')[0]
# take start and end points
location = feature.location
Zs = location.nofuzzy_start
Ze = location.nofuzzy_end
# calculate loop offset coordinates
loop_offZs = offset_coord(Zs, cLen, offset)
loop_offZe = offset_coord(Ze, cLen, offset)
# calculate nudge offset coordinates
offZs = nudge_coord(loop_offZs, nudge)
offZe = nudge_coord(loop_offZe, nudge)
xs, xe = offZs*u, offZe*u
xmid = (xe+xs)/2
# set Y axis coordinates
y0 = Y0+dop*3
# draw
canvas.setLineWidth(2)
ttl = canvas.beginPath()
ttl.moveTo(xs,y0+w)
ttl.lineTo(xs,y0+w+h*2)
ttl.lineTo(xe,y0+w+h*2)
ttl.lineTo(xe,y0+w)
canvas.drawPath(ttl, stroke=1, fill=0)
canvas.setFont(bFont, NfSize)
canvas.drawCentredString(xmid, y0+h*5, name)
canvas.setFont(rFont, NfSize)
ttl.close()
def myFirstPage(self, canvas, doc):
Title = "SOLICITUD DE PAGO"
canvas.saveState()
canvas.setFont('Times-Bold', 16)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 50, Title)
stylo = ParagraphStyle('firma_style',
alignment=TA_CENTER,
fontSize=6,
fontName="Times-Roman")
stylo2 = ParagraphStyle('firma_style',
alignment=TA_CENTER,
fontSize=8,
fontName="Times-Bold")
dta = [
(Paragraph('', stylo2), Paragraph('RECIBIÓ',
stylo2), Paragraph('', stylo2)),
(Paragraph('', stylo), Paragraph(' ',
stylo), Paragraph('', stylo)),
]
tabla = Table(dta, colWidths=[6 * cm, 6 * cm, 6 * cm])
tabla.wrapOn(canvas, PAGE_WIDTH, PAGE_HEIGHT)
tabla.drawOn(canvas, 50, 19.5 * cm)
canvas.restoreState()
def _draw_front(self, canvas):
canvas.saveState()
# Set card orientation
if self.front_orientation == Orientation.TURN90:
canvas.rotate(90)
canvas.translate(0, -self.WIDTH)
width = self.HEIGHT
height = self.WIDTH
else:
width = self.WIDTH
height = self.HEIGHT
# Draw red border
self._draw_single_border(canvas, 0, width, height)
# Parchment background
self._draw_single_background(canvas, 0, self.BORDER_FRONT, width, height)
# D&D logo
dnd_logo = svg2rlg("logo.svg")
if dnd_logo is not None:
factor = self.LOGO_WIDTH/dnd_logo.width
dnd_logo.width *= factor
dnd_logo.height *= factor
dnd_logo.scale(factor, factor)
logo_margin = (self.BORDER_FRONT[Border.TOP]-dnd_logo.height)/2
renderPDF.draw(dnd_logo, canvas,
(width-self.LOGO_WIDTH)/2,
height - self.BORDER_FRONT[Border.TOP] + logo_margin,
)
# Titles
canvas.setFillColor("black")
title_height = self.fonts.set_font(canvas, "title")
canvas.drawCentredString(width * 0.5, self.FRONT_MARGINS[Border.BOTTOM], self.title.upper())
# Artist
if self.artist:
canvas.setFillColor("white")
artist_font_height = self.fonts.set_font(canvas, "artist")
canvas.drawCentredString(width/2,
self.BORDER_FRONT[Border.BOTTOM] - artist_font_height - 1*mm,
"Artist: {}".format(self.artist))
# Image
image_bottom = self.FRONT_MARGINS[Border.BOTTOM] + title_height + 1*mm
canvas.drawImage(self.front_image_path,
self.FRONT_MARGINS[Border.LEFT], image_bottom,
width=width \
- self.FRONT_MARGINS[Border.LEFT] \
- self.FRONT_MARGINS[Border.RIGHT],
height=height \
- image_bottom \
- self.FRONT_MARGINS[Border.TOP],
preserveAspectRatio=True, mask='auto')
canvas.restoreState()
def draw_watermark(self, canvas):
if self._watermark:
canvas.saveState()
canvas.rotate(60)
canvas.setFillColorRGB(0.9, 0.9, 0.9)
canvas.setFont('%s' % self.style.fontName, 120)
canvas.drawCentredString(195*mm, -30*mm, self._watermark)
canvas.restoreState()
def __call__(self, canvas, doc):
canvas.saveState()
w, h = canvas._pagesize
font_size = random_integer_from_list(self.config['text']['font_size'])
line_y = random_integer_from_list(self.config['text']['bottom_margin'])
canvas.setFontSize(font_size)
canvas.drawCentredString(w / 2, line_y, str(canvas.getPageNumber()))
canvas.restoreState()
def docPage(canvas, doc):
canvas.saveState()
canvas.setFont('Times-Bold', 10)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - (.25 * inch),
Title)
canvas.setFont('Times-Roman', 9)
canvas.drawString(7 * inch, .75 * inch, "Page %d" % (doc.page, ))
canvas.restoreState()
def myFirstPage(canvas, doc):
canvas.saveState()
canvas.setFont('Times-Italic', 50)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 200, Title)
canvas.setFont('Times-Roman', 10)
canvas.drawString(inch, 0.75 * inch,
"Genéré par MasterCOM Software - Tous droits réservés")
canvas.restoreState()
def draw_watermark(self, canvas):
if self._watermark:
canvas.saveState()
canvas.rotate(60)
canvas.setFillColorRGB(0.9, 0.9, 0.9)
canvas.setFont('%s' % self.style.fontName, 120)
canvas.drawCentredString(195 * mm, -30 * mm, self._watermark)
canvas.restoreState()
def draw_heading(self, canvas):
text = {'de': 'T3P-Konfiguration', 'en': 'T3P-Configuration'}
canvas.saveState()
canvas.setFont(self.font_bold, 14)
canvas.setFillColorRGB(255, 255, 255)
x = self.dina4[0]/2
canvas.drawCentredString(x, 800, text[self.lang])
canvas.restoreState()
def titlePage(canvas, doc):
canvas.saveState()
canvas.setFont('Times-Bold', 32)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 108,
mainTitleText)
canvas.setFont('Times-Bold', 16)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 130, subTitleText)
canvas.restoreState()
def create_first_page(canvas, doc):
canvas.saveState()
canvas.setFont('Helvetica', 16)
canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT-58, TITLE)
canvas.setFont('Helvetica', 10)
canvas.drawString(BORDER_HORIZONTAL, BORDER_VERTICAL, TITLE)
canvas.drawRightString(PAGE_WIDTH-BORDER_HORIZONTAL , BORDER_VERTICAL, "Seite 1")
canvas.restoreState()
def framePage(canvas, title, pos):
canvas.setFont('Times-Roman', 15)
canvas.drawString(inch, pos * inch, title)
canvas.setFont('Times-Roman', 10)
canvas.drawCentredString(4.135 * inch, 0.75 * inch,
'Página %d' % canvas.getPageNumber())
#reset carefully afterwards
canvas.setLineWidth(1)
canvas.setStrokeColorRGB(0, 0, 0)
def myFirstPage(canvas, doc):
PAGE_HEIGHT,PAGE_WIDTH = letter
canvas.saveState()
canvas.setPageSize(landscape(letter))
canvas.setFont('Helvetica',20)
canvas.drawCentredString(380,340,"FICHAS DE PRIORIZACION PROGRAMA COLOMBIA MAYOR")
canvas.drawCentredString(380,320,"TOTAL CEDULAS:" + str(len(doc.rows)))
canvas.restoreState()
def _add_page_numbers(self, canvas, doc):
"""This is a callback function that will be used to add page numbers, if self.page_numbers is True."""
canvas.saveState()
canvas.setFont(self.font, self.font_size)
page_number_text = f"{doc.page}"
canvas.drawCentredString(0.75 * reportlab.lib.units.inch,
0.75 * reportlab.lib.units.inch,
page_number_text)
canvas.restoreState()
def page_template(self, canvas, doc):
canvas.saveState()
canvas.setFont(self.fontName,7)
canvas.drawCentredString(defaultPageSize[0]/2, 40,_("Page %d") % doc.page)
canvas.setFont(self.fontName,5)
canvas.drawCentredString(defaultPageSize[0]/2, 20, (_("Document generated by Griffith v")+
version.pversion+" - Copyright (C) "+version.pyear+" "+
version.pauthor+" - " + _("Released Under the GNU/GPL License")).encode('utf-8'))
canvas.restoreState()
def onFirstPage(canvas: canvas.Canvas, doc):
canvas.saveState()
font, size = (options["toc"]["title"]["font"], options["toc"]["title"]["size"])
canvas.setFont(font, size)
canvas.drawCentredString(width / 2, height - (.02 * inch * size), options["toc"]["title"]["label"])
font, size = (options["toc"]["footer"]["font"], options["toc"]["footer"]["size"])
canvas.setFont(font, size)
canvas.drawCentredString(width / 2, (.02 * inch * size), options["toc"]["footer"]["label"])
canvas.restoreState()
def draw_title_header():
x = page_size[0] / 2
y = page_size[1] - page_margin
title1 = 'Gantt Chart for {}'.format(project.name)
title2 = '{} to {}'.format(chart.start.date(), chart.end.date())
canvas.setFont('Helvetica', 14)
canvas.drawCentredString(x, y - 10, title1)
canvas.setFont('Helvetica', 10)
canvas.drawCentredString(x, y - 25, title2)
def docPage(canvas,doc):
canvas.saveState()
canvas.setFont('Times-Bold', 10)
canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT - (.25 * inch), Title)
canvas.setFont('Times-Roman',9)
canvas.drawString(7 * inch, .75 * inch, "Page %d" % (doc.page,))
canvas.restoreState()
def __unicode__(self):
return u"Undefined Problem: %d" % self.file.id
def myFirstPage(canvas, doc):
PAGE_HEIGHT = defaultPageSize[1]
PAGE_WIDTH = defaultPageSize[0]
pageinfo = "DIAGNOSIS REPORT"
canvas.saveState()
canvas.setFont('Times-Bold', 16)
canvas.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 100, "DIAGNOSIS REPORT")
canvas.setFont('Times-Roman', 9)
canvas.drawString(inch, 0.75 * inch, "Page 1 / %s" % pageinfo)
canvas.restoreState()
def createPDF(file, title):
canvas = reportlab.pdfgen.canvas.Canvas(file)
canvas.setFont('Times-BoldItalic', 12)
canvas.drawString(inch, 10.5 * inch, title)
canvas.setFont('Times-Roman', 10)
canvas.drawCentredString(4.135 * inch, 0.75 * inch,
'Page %d' % canvas.getPageNumber())
canvas.showPage()
canvas.save()
def first_page(self,canvas,doc):
canvas.saveState()
canvas.setFont('Courier', 9)
canvas.drawString(inch, 0.75 * inch,"%s - %s" % (self.today.strftime('%d/%m/%Y'),
canvas.getPageNumber()))
canvas.drawString(490,0.75 * inch,"his Majesty")
canvas.setFont('Times-Bold',8)
canvas.drawCentredString(0.5 * A4[0],0.5 * inch,"%s" % self.app.GetAppName())
canvas.restoreState()
def setFirstPage(self,canvas,doc):
canvas.saveState()
canvas.setFont('Times-Bold', 25)
canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT - 100, 'Relatorio')
canvas.setFont('Times-Bold', 22)
canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT - 130, self.title)
canvas.setFont('Times-Roman',9)
canvas.drawString(inch, 0.75*inch, '1')
#canvas.setFont(self.fonts[0],self.sizes[0])
canvas.restoreState()
def _draw_front(self, canvas):
canvas.saveState()
# Draw red border
self._draw_single_border(canvas, 0, self.width, self.height)
# Parchment background
self._draw_single_background(
canvas,
0,
self.border_front,
self.width,
self.height,
self.front_orientation,
)
# Set card orientation
if self.front_orientation == Orientation.TURN90:
canvas.rotate(90)
canvas.translate(0, -self.width)
width = self.height
height = self.width
else:
width = self.width
height = self.height
# D&D logo
dnd_logo = svg2rlg(ASSET_DIR / "logo.svg")
if dnd_logo is not None:
factor = self.LOGO_WIDTH / dnd_logo.width
dnd_logo.width *= factor
dnd_logo.height *= factor
dnd_logo.scale(factor, factor)
logo_margin = (self.border_front[Border.TOP] - self.bleed -
dnd_logo.height) / 2
renderPDF.draw(
dnd_logo,
canvas,
(width - self.LOGO_WIDTH) / 2,
height - self.border_front[Border.TOP] + logo_margin,
)
self._draw_front_frame(canvas, width, height)
# Artist
if self.artist:
canvas.setFillColor("white")
artist_font_height = self.fonts.set_font(canvas, "artist")
canvas.drawCentredString(
width / 2,
self.border_front[Border.BOTTOM] - artist_font_height - 1 * mm,
"Artist: {}".format(self.artist),
)
canvas.restoreState()
def addPageNum(self, canvas, doc):
"""Page number util function for report builder."""
canvas.saveState()
canvas.setFont('Times-Roman', 10)
page_num_txt = "{}".format(doc.page)
canvas.drawCentredString(
0.75 * inch,
0.75 * inch,
page_num_txt,
)
canvas.restoreState()
def _draw_name(canvas, name):
yc = RESUME_PAGE_SIZE[1] - V_TOP_MARGIN
name_x = RESUME_PAGE_SIZE[0] / 2
name_y = yc - NAME_FONT_SIZE
name = name.upper()
canvas.setFont(NAME_FONT, NAME_FONT_SIZE)
canvas.drawCentredString(name_x, name_y, name)
return name_y - V_SEPARATOR
def framePage(canvas, title):
canvas.setFont('Times-BoldItalic',20)
canvas.drawString(inch, 10.5 * inch, title)
canvas.setFont('Times-Roman',10)
canvas.drawCentredString(4.135 * inch, 0.75 * inch,
'Page %d' % canvas.getPageNumber())
#reset carefully afterwards
canvas.setLineWidth(1)
canvas.setStrokeColorRGB(0,0,0)
def draw_survey_id(canvas, survey):
if 0:
assert isinstance(canvas, reportlab.pdfgen.canvas.Canvas)
pos = survey.defs.get_survey_id_pos()
canvas.saveState()
canvas.setFont(defs.codebox_text_font, defs.codebox_text_font_size)
canvas.drawCentredString(pos[3] * mm, pos[4] * mm, _(u'Survey-ID: %i') % survey.survey_id)
draw_codebox(canvas, pos[0] * mm, pos[2] * mm, survey.survey_id >> 16)
draw_codebox(canvas, pos[1] * mm, pos[2] * mm, survey.survey_id & ((1 << 16) - 1))
canvas.restoreState()
def draw_questionnaire_id(canvas, survey, questionnaire_id):
if 0:
assert isinstance(canvas, reportlab.pdfgen.canvas.Canvas)
pos = survey.defs.get_questionnaire_id_pos()
canvas.saveState()
canvas.setFont(defs.codebox_text_font, defs.codebox_text_font_size)
canvas.drawCentredString(pos[3] * mm, pos[4] * mm, _(u'Questionnaire-ID: %i') % questionnaire_id)
draw_codebox(canvas, pos[0] * mm, pos[2] * mm, questionnaire_id)
draw_codebox(canvas, pos[1] * mm, pos[2] * mm, questionnaire_id)
canvas.restoreState()
def myFirstPage(canvas, doc):
canvas.saveState()
canvas.setFont(font_choice,24)
canvas.drawCentredString(PAGE_WIDTH/2.0, top_position-0.2*inch, header_text)
canvas.setFont(font_choice, 14)
canvas.drawString(0.7*inch+logo_boxsize[0], top_position-0.6*inch, 'Observer: ' + observer_text)
canvas.drawString(0.7*inch+logo_boxsize[0], top_position-0.8*inch, 'Instrument: ' + instrument_text)
canvas.drawString(8.5*inch-(0.7*inch+logo_boxsize[0]), top_position-0.6*inch, 'Date: ' + date_text)
canvas.drawString(8.5*inch-(0.7*inch+logo_boxsize[0]), top_position-0.8*inch, 'Program: ' + program_text)
canvas.drawInlineImage(logoimage,0.3*inch,top_position - logo_boxsize[1],width=logo_boxsize[0],
height=logo_boxsize[1],preserveAspectRatio=True,anchor='nw')
canvas.restoreState()
def on_page(canvas,doc):
margin = DPI * 0.25
gap = DPI * 0.25
row = rows[doc.page-1]
canvas.saveState()
# canvas.rect(margin,margin,PAGE_WIDTH-margin*2,PAGE_HEIGHT-margin*2)
global SMALL
if TINY:
canvas.setFont("ComicBold",20)
elif SMALL:
canvas.setFont("ComicBold",20) # was 20
else:
canvas.setFont("ComicBold",25)
global teacher_grade
grade = teacher_grade
if TINY:
row['Project Title'] = row['First Name'] + ' ' + row['Last Name']
row['Project Type'] = grade
grade = ''
row['First Name'] = ''
row['Last Name'] = ''
project_title = row['Project Title'] or ''
project_type = row['Project Type'] or ''
if project_title == '':
project_title = project_type
project_type = ''
title = project_title.strip()
if not title:
title = '' #'Untitled'
canvas.drawCentredString(PAGE_WIDTH*0.5,PAGE_HEIGHT-margin*4,title)
canvas.setFont("ComicBold",18)
if SMALL or TINY:
canvas.setFont("ComicBold",16)
canvas.drawRightString(PAGE_WIDTH - DPI*0.5,gap*5,row['First Name'] + ' ' + row['Last Name'])
canvas.setFont("Comic",15)
if SMALL or TINY:
canvas.setFont("ComicBold",13)
canvas.drawRightString(PAGE_WIDTH - DPI*0.5,gap*4,grade)
canvas.drawRightString(PAGE_WIDTH - DPI*0.5,gap*3,project_type)
canvas.drawRightString(PAGE_WIDTH - DPI*0.5,gap*2,teacher_honorific+'. '+teacher_name+', Rm. '+str(teacher_room))
style = ParagraphStyle(
name='',
leading=20,
fontName='Comic',
fontSize=15,
)
width = PAGE_WIDTH - gap*8
height = PAGE_HEIGHT - gap*16
project_description = row['Project Description'] or ''
paragraph = Paragraph(project_description, style)
w, h = paragraph.wrap(width, height)
paragraph.drawOn(canvas,gap*4,PAGE_HEIGHT-gap*5-h)
canvas.restoreState()
def __add_page_header(self, canvas):
titulo = 'R E P O R T E D E P R O D U C T O S' +\
(' A G O T A D O S' if self.__agotados else '')
y = 520
canvas.drawCentredString(400, 570, titulo)
canvas.drawCentredString(400, 540, 'AL: ' +\
datetime.datetime.today().strftime('%Y/%m/%d %H:%M:%S'))
canvas.drawString(70, y, 'Id')
canvas.drawString(180, y, 'Nombre')
canvas.drawString(320, y, 'Proveedor')
canvas.drawString(490, y, 'P. Compra')
canvas.drawString(610, y, 'P. Venta')
canvas.drawString(710, y, 'Existencia')
def plantilla_turnos(canvas,doc):
canvas.saveState()
canvas.setFont('Times-Bold',10)
canvas.rect(50,80, PAGE_WIDTH-100, PAGE_HEIGHT-140)
canvas.rect(50,80, PAGE_WIDTH-100, PAGE_HEIGHT-200)
canvas.rect(50,30, PAGE_WIDTH-100,50)
#canvas.drawCentredString(PAGE_WIDTH/2.0 , PAGE_HEIGHT , TITULO)
canvas.drawCentredString(PAGE_WIDTH/2.0 , 35 , PIE_PAGINA)
#canvas.drawString(inch , 10.5 * inch,TITULO)
canvas.setFont('Times-Roman',9)
canvas.drawString(inch , 0.75 * inch,'Pagina %s '%doc.page)
canvas.restoreState()
