def __init__(self, canvas, maxWidth, maxHeight):
self.topBorderStr = u"\u00f9\u00fa\u00fa\u00fa\u00fa\u00fa\u00fa\u00fa\u00fa\u00fb"
# we draw the left border character (which includes the rank number),
# eight squares, and then the right border character
self.widthInChessChars = 1 + 8 + 1
# we draw the top border character, the 8 squares in a file,
# and the bottom border character (which includes the file name)
self.heightInChessChars = 1 + 8 + 1
self.maxWidth = maxWidth
self.maxHeight = maxHeight
self.canvas = canvas
# increase the font size until we surpass the limits, then decrement back
self.fontSymSize = 1
while 1:
canvas.setFont("ChessAlpha2", self.fontSymSize)
candidateWidth = canvas.stringWidth(self.topBorderStr)
if candidateWidth > maxWidth:
break
if self.fontSymSize * self.heightInChessChars > maxHeight:
break
self.fontSymSize += 1
self.fontSymSize -= 1
self.fontTextSize = self.fontSymSize - 8
# final calculations
canvas.setFont("ChessAlpha2", self.fontSymSize)
self.width = self.height = canvas.stringWidth(self.topBorderStr)
def myFirstPage(self, canvas, doc):
canvas.saveState()
canvas.setFont('Times-Roman',9)
canvas.drawString(inch, 0.75 * inch, "Page 1 / %s" % pageinfo)
self.headerTable.wrapOn(canvas, 540, height)
self.headerTable.drawOn(canvas, *coord(1.0, 1.5, cm))
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 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 _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 colorsRGB(canvas):
from reportlab.lib import colors
from reportlab.lib.units import inch
black = colors.black
y = x = 0; dy=inch*3/4.0; dx=inch*5.5/5; w=h=dy/2; rdx=(dx-w)/2
rdy=h/5.0; texty=h+2*rdy
canvas.setFont("Helvetica",10)
for [namedcolor, name] in (
[colors.lavenderblush, "lavenderblush"],
[colors.lawngreen, "lawngreen"],
[colors.lemonchiffon, "lemonchiffon"],
[colors.lightblue, "lightblue"],
[colors.lightcoral, "lightcoral"]):
canvas.setFillColor(namedcolor)
canvas.rect(x+rdx, y+rdy, w, h, fill=1)
canvas.setFillColor(black)
canvas.drawCentredString(x+dx/2, y+texty, name)
x = x+dx
y = y + dy; x = 0
for rgb in [(1,0,0), (0,1,0), (0,0,1), (0.5,0.3,0.1), (0.4,0.5,0.3)]:
r,g,b = rgb
canvas.setFillColorRGB(r,g,b)
canvas.rect(x+rdx, y+rdy, w, h, fill=1)
canvas.setFillColor(black)
canvas.drawCentredString(x+dx/2, y+texty, "r%s g%s b%s"%rgb)
x = x+dx
y = y + dy; x = 0
for gray in (0.0, 0.25, 0.50, 0.75, 1.0):
canvas.setFillGray(gray)
canvas.rect(x+rdx, y+rdy, w, h, fill=1)
canvas.setFillColor(black)
canvas.drawCentredString(x+dx/2, y+texty, "gray: %s"%gray)
x = x+dx
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 drawText(canvas, x, y, text, en = False, bold = False, size = 12):
wrkText = text
isArabic = False
isBidi = False
for c in wrkText:
cat = unicodedata.bidirectional(c)
if cat == "AL" or cat == "AN" or cat == "FA":
isArabic = True
isBidi = True
break
elif cat == "R" or cat == "RLE" or cat == "RLO":
isBidi = True
if isArabic:
wrkText = a_forms.fuse(wrkText)
wrkText = a_process.shape(wrkText)
if isBidi:
wrkText = get_display(wrkText)
if bold:
canvas.setFont('BNazanin', size)
else:
canvas.setFont('Nazanin', size)
canvas.drawRightString(x, canvas._pagesize[1] - y, wrkText)
def __init__(self, pt_ID, amount):
self.amount = amount
self.pt_ID = pt_ID
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
lt = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (settings.LINUXPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
at = "%s/EMR_outputs/%s/Other/rcpt-%s.pdf" % (settings.APPLEPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
wt = "%s\EMR_outputs\%s\Other\rcpt-%s.pdf" % (settings.WINPATH, self.pt_ID, EMR_utilities.dateToday('file format'))
filename = EMR_utilities.platformText(lt, at, wt)
canvas = canvas.Canvas(filename, pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750,'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
canvas.drawString(30,735,'RENDERED AT BARRON FAMILY MEDICINE')
canvas.drawString(500,750,"%s" % EMR_utilities.dateToday())
canvas.line(480,747,580,747)
canvas.drawString(275,725,'AMOUNT PAID:')
canvas.drawString(500,725,"$%s" % self.amount)
canvas.line(378,723,580,723)
canvas.drawString(30,703,'RECEIVED BY:')
canvas.line(120,700,580,700)
canvas.drawString(120,703, settings.NAME)
canvas.save()
def printColors(canvas):
canvas.setFont("Helvetica",10)
y = x = 0; dy=inch*1/2.0; dx=1*inch; w=h=dy/2
rdx=(dx-w)/2; rdy=h/5.0
available_paper = 10*inch
for name, color in colors.getAllNamedColors().iteritems():
# for [namedcolor, name] in (
# 'darkseagreen', 'darkslateblue',
# [colors.darkblue, 'darkblue'],
# [colors.darkcyan, 'darkcyan'],
# [colors.darkolivegreen, 'darkolivegreen'],
# [colors.cornflower, 'cornflower'],
# [colors.orchid, 'orchid'],
# [colors.lavenderblush, "lavenderblush"],
# [colors.lawngreen, "lawngreen"],
# [colors.lemonchiffon, "lemonchiffon"],
# [colors.lightblue, "lightblue"],
# [colors.lightcoral, "lightcoral"]):
canvas.setFillColor(color)
canvas.rect(x+rdx, y+rdy, w, h, fill=1)
canvas.setFillColor(colors.black)
canvas.drawString(x+dx/4 + 1*inch, y+rdy, name)
rdy += .2*inch
available_paper -= (y+rdy)
if available_paper < 1*inch:
c.showPage()
y = x = 0; dy=inch*1/2.0; dx=1*inch; w=h=dy/2
rdx=(dx-w)/2; rdy=h/5.0
available_paper = 10*inch
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 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 draw_debug_outline(self, config ):
"""draw an outline around the box"""
canvas = self.canvas
# don't muck up the external state
canvas.saveState()
# discreet - but visible
canvas.setStrokeColorRGB( 0.9, 0.7, 0.7 )
canvas.setFillColorRGB( 0.6, 0.6, 0.6 )
canvas.setFont( 'Helvetica', 8 )
# draw a box to show the extent
canvas.rect(
config['x'], config['y'], config['w'], config['h'],
stroke=1, fill=0,
)
# put in some debug info
canvas.drawRightString(
config['x'] + config['w'],
config['y'] + 4,
', '.join(config['content'])
)
# restore state
canvas.restoreState()
def __init__(self, pt_ID, amount):
self.amount = amount
self.pt_ID = pt_ID
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
canvas = canvas.Canvas("/home/mb/Desktop/GECKO/EMR_outputs/%s/Other/rcpt-%s.pdf" % \
(self.pt_ID, EMR_utilities.dateToday()), pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750,'PAYMENT FOR MEDICAL SERVICES FOR %s' % self.name_find())
canvas.drawString(30,735,'RENDERED AT BARRON FAMILY MEDICINE')
canvas.drawString(500,750,"%s" % EMR_utilities.dateToday())
canvas.line(480,747,580,747)
canvas.drawString(275,725,'AMOUNT PAID:')
canvas.drawString(500,725,"$%s" % self.amount)
canvas.line(378,723,580,723)
canvas.drawString(30,703,'RECEIVED BY:')
canvas.line(120,700,580,700)
canvas.drawString(120,703,"MICHAEL BARRON MD")
canvas.save()
def create_report():
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
width, height = letter
canvas = canvas.Canvas("form.pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 10)
canvas.drawString(30, 750, 'OFFICIAL COMMUNIQUE')
canvas.drawString(30, 735, 'OF ACME INDUSTRIES')
canvas.drawString(500, 750, "12/12/2010")
canvas.line(480, 747, 580, 747)
canvas.drawString(275, 725, 'AMOUNT OWED:')
canvas.drawString(500, 725, "$1,000.00")
canvas.line(378, 723, 580, 723)
canvas.drawString(30, 703, 'RECEIVED BY:')
canvas.line(110, 700, 580, 700)
canvas.drawString(110, 703, "JOHN DOE")
canvas.save()
def draw(self):
canvas = self.canv
if type(self.labelLigne) != six.text_type :
self.labelLigne = self.labelLigne.decode("iso-8859-15")
canvas.setFont("Helvetica", 9)
# Dessin du label de la ligne
xRightLabel = COORD_LIGNE[0] - 10
yBasLabel = 0
if MODE_TEXTE == 2 : yBasLabel = yBasLabel + 6
canvas.drawRightString(xRightLabel, yBasLabel + 3, self.labelLigne)
# Dessin test de la ligne totale
## canvas.rect(COORD_LIGNE[0], 0, COORD_LIGNE[1]-COORD_LIGNE[0], 10)
tailleVirtuelleLigne = COORD_LIGNE[1]-COORD_LIGNE[0]
largeurMargesFeuille = 75
posXGaucheLigne = COORD_LIGNE[0]
taillePapierLigne = LARGEUR_PAGE- (largeurMargesFeuille*2) - posXGaucheLigne
facteurAgrandissement = (taillePapierLigne *1.0) / tailleVirtuelleLigne
# Dessine la ligne
## canvas.setFillColorRGB(0.9, 0.9, 0.5)
## canvas.rect(COORD_LIGNE[0], 0, taillePapierLigne, HAUTEUR_BARRE, fill=0)
# Dessin de toutes les barres de la ligne
for barre in self.listeBarresLigne :
IDpresence, IDpersonne, date, heureDebut, heureFin, IDcategorie, intitule, posG, posD, posYhaut, posYbas = barre
x = posG
y = 0
largeur = posD - posG
hauteur = HAUTEUR_BARRE - 3
label = intitule
self.Barre(canvas, x, y, largeur, hauteur, label, heureDebut, heureFin, IDcategorie, facteurAgrandissement)
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 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 header(canvas, signup, entry, metadata):
year = int(signup.get('year'))
# Prints Show info
canvas.setFont("Helvetica-Bold", 20)
canvas.drawString(inch, 10 * inch, "That Takes the Cake! " + str(year))
canvas.setFont("Helvetica", 14)
canvas.drawString(inch, 9.75 * inch, "Cake & Sugar Art Show & Competition")
canvas.drawString(inch, 9.50 * inch, "Capital Confectioners, Austin, TX")
canvas.drawString(inch, 9.25 * inch, get_show_start_date(year) + " & " + get_show_end_date(year))
# Print entry number, division & category
canvas.setFont("Helvetica-Bold", 20)
canvas.drawRightString(7.75 * inch, 10 * inch, "Entry #" + str(entry.get('id')))
canvas.setFont("Helvetica", 12)
if (entry.get('category').startswith('Showcakes')):
canvas.drawRightString(7.75 * inch, 9.75 * inch, entry.get('category'))
elif _is_tasting(metadata, entry):
canvas.drawRightString(7.75 * inch, 9.75 * inch, entry.get('category'))
else:
className = signup.get('class', '')
canvas.drawRightString(7.75 * inch, 9.75 * inch, className)
if (className):
if ((className.find('Child') < 0) and (className.find('Junior') < 0)):
canvas.drawRightString(7.75 * inch, 9.50 * inch, entry.get('category'))
canvas.setFont("Helvetica", 14)
def get_canvas(self, packet):
canvas = super(AnswerSheetMask, self).get_canvas(packet)
canvas.setStrokeColor(colors.black)
canvas.setFillColor(colors.white)
canvas.setLineWidth(0.2 * mm)
canvas.setFont('Helvetica', 8)
return canvas
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 laterPages(canvas, doc):
canvas.saveState()
canvas.setFont('Helvetica', 12)
canvas.drawString(35, 750, "SuperBar")
canvas.drawString(450, 750, titulo)
actual = datetime.now()
canvas.drawString(470, 735, actual.strftime('%Y-%m-%d'))
canvas.restoreState()
def myfirstpage(canvas, doc):
canvas.saveState()
canvas.line(0 * inch, 0.01 * inch, 11.69 * inch, 0.01 * inch)
canvas.line(0 * inch, 0 * inch, 0 * inch, 8.24 * inch)
canvas.line(11.69 * inch, 0 * inch, 11.69 * inch, 8.24 * inch)
canvas.line(0 * inch, 8.23 * inch, 11.69 * inch, 8.23 * inch)
canvas.setFont('Times-Bold', 16)
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 addFooter(canvas, doc):
canvas.setFont('Arial',12)
page_num = canvas.getPageNumber()
text = "Page %s" % page_num
canvas.drawRightString(200*mm, 10*mm, text)
canvas.drawRightString(200*mm, 20*mm, "Signature_________________ Date:_______________")
canvas.drawRightString(110*mm, 10*mm, "REPORT Model XXXX Generated on:" + datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
canvas.drawRightString(50*mm, 20*mm, "Proprietary Document")
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_address(canvas):
""" Draws the business address """
canvas.setFont('Helvetica', 9)
textobject = canvas.beginText(13 * cm, -2.5 * cm)
for line in business_details:
textobject.textLine(line)
canvas.drawText(textobject)
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 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 myLaterPages(canvas, doc):
from reportlab.lib.colors import red
PAGE_HEIGHT = canvas._pagesize[1]
canvas.saveState()
canvas.setStrokeColor(red)
canvas.setLineWidth(5)
canvas.line(66, 72, 66, PAGE_HEIGHT - 72)
canvas.setFont(_baseFontName, 12)
canvas.drawString(4 * inch, 0.75 * inch, "Page %d" % doc.page)
canvas.restoreState()
def drawBackground(self, canvas):
underkant = 5.0/6.0 * inch
# a4 format spec:
# http://www.cl.cam.ac.uk/~mgk25/iso-paper.html
# 210 x 297
# faktura spek:
# Norsk Standard Skjema F60-1
# url: http://code.google.com/p/finfaktura/issues/detail?id=38
canvas.saveState()
canvas.setFillColor(yellow)
# Yellow bits; skipping the receipt area.
# Lag de gule feltene
#canvas.rect(0*mm, 101*mm, 210*mm, 21*mm, stroke=0, fill=1)
canvas.rect(0*mm, 33*mm, 210*mm, 9*mm, stroke=0, fill=1)
canvas.rect(0*mm, 14*mm, 210*mm, 2*mm, stroke=0, fill=1)
canvas.setFillColor(white)
# Legg de hvite feltene oppå for "gjennomsiktighet"
canvas.rect(80*mm, 103*mm, 36*mm, 9*mm, stroke=0, fill=1) # beløp
canvas.rect(126*mm, 103*mm, 40*mm, 9*mm, stroke=0, fill=1) # betalerens kontonummer
canvas.rect(170*mm, 103*mm, 31*mm, 9*mm, stroke=0, fill=1) # blankettnummer
canvas.restoreState()
# skillelinjer for KID
canvas.lines([(9*mm, 16*mm, 9*mm, 30*mm), (80*mm, 16*mm, 80*mm, 30*mm)])
# blankettnummer
#canvas.setFont("Courier", 10)
#blankettnr = "xxxxxxx"
#canvas.drawString(173*mm, 105*mm, blankettnr)
#canvas.drawString(173*mm, underkant, blankettnr)
# Lag klammer for kontrollsiffer til sum.
canvas.drawString(115*mm, underkant, "<")
canvas.drawString(125*mm, underkant, ">")
# Lag tekst som beskriver feltene.
canvas.setFont("Helvetica-Bold", 6)
canvas.drawString(15*mm, 98*mm, "Betalingsinformasjon")
canvas.drawString(10*mm,30*mm,"Kundeidentifikasjon (KID)")
canvas.drawString(82*mm,30*mm,"Kroner")
canvas.drawString(107*mm,30*mm,"Øre")
canvas.drawString(133*mm,30*mm,"Til konto")
canvas.drawString(172*mm,30*mm,"Blankettnummer")
canvas.drawString(150*mm,98*mm,"Betalings-")
canvas.drawString(150*mm,95*mm,"frist")
# Lag hjørneklammer rundt alle tekstfelt
self.markField(canvas, 12*mm,64*mm, 86*mm, -21*mm, "Betalt av")
self.markField(canvas, 110*mm,64*mm, 86*mm, -21*mm, "Betalt til")
self.markField(canvas, 110*mm,89*mm, 86*mm, -19*mm, "Underskrift ved girering")
self.markField(canvas, 166*mm,99*mm, 30*mm, -6*mm) # Betalingsfrist.
# Add the all-important "GIRO" text. It seems to do wonders for the recognition.
canvas.setFont('Helvetica-Bold', 14)
canvas.drawString(110*mm, 98*mm, "GIRO")
def first_page(self, canvas, doc):
canvas.setFont("Times-Roman", 10)
canvas.drawString(65,720,"Finance report for : %s %s" %(datetime.date.today().strftime("%B"), datetime.date.today().strftime("%Y")))
canvas.drawString(65,705,'Report generated on : %s' %str("{:%d.%m.%Y}".format(datetime.datetime.now())))
canvas.setLineWidth(.2)
canvas.line(50,695,540,695)
page_num = canvas.getPageNumber()
text = "Page #%s" % page_num
canvas.drawRightString(200*mm, 20*mm, text)
def fonts(canvas):
from reportlab.lib.units import inch
text = "Now is the time for all good men to..."
x = 1.8 * inch
y = 2.7 * inch
for font in canvas.getAvailableFonts():
canvas.setFont(font, 10)
canvas.drawString(x, y, text)
canvas.setFont("Helvetica", 10)
canvas.drawRightString(x - 10, y, font + ":")
y = y - 13
def later_pages(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 draw_footer(canvas, font_size, y):
text1 = 'Created with ' + PROGRAM_FULLNAME
text2 = PROGRAM_WEBSITE
text2_w = stringWidth(text2, FONT_NAME, FOOTER_FONT_SIZE)
text2_x = PAGE_SIZE[0] - GRID_OFFSET - text2_w
canvas.setFont(FONT_NAME, font_size)
canvas.drawString(GRID_OFFSET, y, text1)
canvas.drawString(text2_x, y, text2)
y -= 0.2 * FONT_SIZE
canvas.linkURL('www.' + text2, (text2_x, y, \
text2_x + text2_w, y + 0.8*FONT_SIZE))
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 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 _add_registration_details(self, canvas):
start_posn = self.start_posn
reg_detail_dict = {t[0]: t[1] for t in REG_STATUS_OPTIONS}
canvas.setFillColor(colors.blue)
canvas.setFont('Helvetica', 10)
canvas.drawString(0.5 * inch, start_posn,
'Section D: Registration Details')
canvas.setLineWidth(1)
canvas.setFillColor(colors.black)
canvas.rect(0.5 * inch, start_posn - 1.3 * inch, PAGE_WIDTH - inch,
1.2 * inch)
canvas.line(2.5 * inch, start_posn - 1.3 * inch, 2.5 * inch,
start_posn - 0.1 * inch)
canvas.drawString(0.7 * inch, start_posn - 0.3 * inch,
'Registration Status:')
canvas.drawString(2.7 * inch, start_posn - 0.3 * inch,
reg_detail_dict[self.details['registration_status']])
canvas.line(0.5 * inch, start_posn - 0.4 * inch,
PAGE_WIDTH - 0.5 * inch, start_posn - 0.4 * inch)
canvas.drawString(0.7 * inch, start_posn - 0.6 * inch,
'Pre-Tax Price:')
try:
price = float(self.details['pre_tax_price'])
gst, hst, qst, inv_total = self._calculate_tax_total(price)
price = '${:0,.2f}'.format(price)
except ValueError:
if self.details['pre_tax_price'] == '':
price = gst = hst = qst = inv_total = '$0.00'
else:
price = 'ERROR: Price Entered Incorrectly'
gst = hst = qst = inv_total = '?????'
canvas.drawString(2.7 * inch, start_posn - 0.6 * inch, price)
canvas.line(0.5 * inch, start_posn - 0.7 * inch,
PAGE_WIDTH - 0.5 * inch, start_posn - 0.7 * inch)
canvas.drawString(0.7 * inch, start_posn - 0.9 * inch, 'Taxes:')
tax_info = ''
if self.event.gst_charged:
tax_info += 'GST: ' + gst + ' / '
if self.event.hst_charged:
tax_info += 'HST: ' + hst + ' / '
if self.event.qst_charged:
tax_info += 'QST: ' + qst + ' / '
if len(tax_info) > 0:
tax_info = tax_info[:-3]
else:
tax_info = 'No tax charged'
canvas.drawString(2.7 * inch, start_posn - 0.9 * inch, tax_info)
canvas.line(0.5 * inch, start_posn - 1.0 * inch,
PAGE_WIDTH - 0.5 * inch, start_posn - 1.0 * inch)
canvas.setFont('Helvetica-Bold', 10)
canvas.drawString(0.7 * inch, start_posn - 1.2 * inch,
'Total Invoice:')
canvas.drawString(2.7 * inch, start_posn - 1.2 * inch, inv_total)
self.start_posn = start_posn - 1.55 * inch
def encabezado(canvas, doc):
canvas.saveState()
#canvas.drawImage(app_home + 'logo1.png', 15, 800, width=140, height=29, mask='auto')
# canvas.drawImage(current_app.config["APP_PATH"] + '/src/etc/img/' + 'logo2.png', 430, 800, width=140, height=25, mask='auto')
canvas.setStrokeColor('#ABAAAB')
canvas.line(A4[0] - 700, A4[1] - 53, A4[0] - 0, A4[1] - 53)
canvas.setFillColor('#666666')
canvas.setFont('Helvetica', 20)
# canvas.drawString(10, A4[1] - 77, form['data']['header']['name'])
canvas.line(A4[0] - 700, A4[1] - 90, A4[0] - 0, A4[1] - 90)
canvas.restoreState()
def __encabezado(self, canvas, doc):
canvas.saveState()
canvas.setFont('Helvetica', 10)
canvas.drawCentredString(6 * cm, 13.5 * cm,
'EMPRESA MINERA COMUNITARIA')
canvas.drawCentredString(6 * cm, 13 * cm, '"INCA SAYAÑA" S.A.')
canvas.setFont('Helvetica-Bold', 16)
canvas.drawCentredString(12 * cm, 12 * cm,
'COMPROBANTE DE CAJA - EGRESOS')
canvas.line(6.8 * cm, 11.9 * cm, 17.2 * cm, 11.9 * cm)
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 labeller(cName, cLen, canvas, Y_map) :
"""Label baselines with genome/contig name and size."""
canvas.setFillColor(black)
y0 = Y_map
x0 = -pNsize # retreat into the left margin to write out name and size
y1 = y0 + ck_vsp/10 # bump name up a bit from BL level
y2 = y0 - ck_vsp # bump size down a bit from BL level
pLenStr = str(float(cLen)/1000) # converts number to suitable form
canvas.setFont(bFont,LfSize)
canvas.drawString(x0,y1,cName)
canvas.setFont(rFont,NfSize)
canvas.drawString(x0,y2,pLenStr+' kb')
def draw(self):
canvas = self.canv
# Texte label
canvas.setFillColorRGB(0, 0, 0)
canvas.setFont("Helvetica", 9)
canvas.drawString(
15, 1, "%s : %s" % (self.label, minutesEnHeures(self.totalHeures)))
# Carré de couleur
if self.couleur != None:
r, g, b = ConvertCouleur(FormateCouleur(self.couleur))
canvas.setFillColorRGB(r, g, b)
canvas.rect(0, 0, 10, 10, fill=1)
def get_stamp_pdf(PROJ_NAME, PAGE_NO):
from reportlab.pdfgen import canvas
out_path = tempfile.mktemp(suffix=".pdf")
canvas = canvas.Canvas(out_path, pagesize=A4)
canvas.setLineWidth(.3)
canvas.setFont('Segoe UI', 8)
canvas.setStrokeColorRGB(0, 0, 0)
canvas.setFillColorRGB(0, 0, 0)
canvas.drawString(30, 10, "Feedback Report for {0}".format(PROJ_NAME))
canvas.drawString(540, 10, "Page {0}".format(PAGE_NO))
canvas.save()
return out_path
def generate(self):
canvas = self.canvas
canvas.setLineWidth(0.3)
canvas.setFont("Helvetica", 12)
self.__add_header()
for i in range(len(self.questions)):
question = self.questions[i]
answers = self.answers[i]
self.__add_block(question, answers, i)
canvas.save()
def draw_header(canvas):
""" Draws the invoice header """
canvas.setStrokeColorRGB(176 / 255., 196 / 255., 222 / 255.)
# canvas.setStrokeColorRGB(0.9, 0.5, 0.2)
canvas.setFillColorRGB(0.2, 0.2, 0.2)
canvas.setFont('Helvetica', 16)
canvas.drawString(18 * cm, -1 * cm, 'Invoice')
if consultant_logo_filename:
canvas.drawInlineImage(consultant_logo_filename, 1 * cm, -1 * cm, 250,
16)
canvas.setLineWidth(4)
canvas.line(0, -1.25 * cm, 21.7 * cm, -1.25 * cm)
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 drawStrings(canvas, x, y, *lines):
step = 0.5*cm
for line in lines:
if isinstance(line, int):
if line < 0:
canvas.setFont('Helvetica-Bold', abs(line))
else:
canvas.setFont('Helvetica', abs(line))
step = abs(line) / 24.0 * cm
continue
canvas.drawString(x, y, line)
y -= step
def first_pages(canvas, document):
canvas.saveState()
canvas.setFont("PTAstraSerifReg", 9)
# вывести интерактивную форму "текст"
form = canvas.acroForm
# canvas.drawString(25, 780, '')
form.textfield(name='comment',
tooltip='comment',
fontName='Times-Roman',
fontSize=10,
x=57,
y=750,
borderStyle='underlined',
borderColor=black,
fillColor=white,
width=515,
height=13,
textColor=black,
forceBorder=False)
# Вывести на первой странице код-номер договора
barcode128.drawOn(canvas, 120 * mm, 283 * mm)
#вывести внизу QR-code (ФИО, (номера направлений))
qr_code = qr.QrCodeWidget(qr_value)
qr_code.barWidth = 70
qr_code.barHeight = 70
qr_code.qrVersion = 1
bounds = qr_code.getBounds()
width = bounds[2] - bounds[0]
height = bounds[3] - bounds[1]
d = Drawing()
d.add(qr_code)
renderPDF.draw(d, canvas, 90 * mm, 7)
#вывести атрибуты для подписей
canvas.setFont('PTAstraSerifReg', 10)
canvas.drawString(40 * mm, 10 * mm, '____________________________')
canvas.drawString(115 * mm, 10 * mm,
'/{}/____________________________'.format(npf))
canvas.setFont('Symbola', 18)
canvas.drawString(195 * mm, 10 * mm, '\u2713')
canvas.setFont('PTAstraSerifReg', 8)
canvas.drawString(50 * mm, 7 * mm, '(подпись сотрудника)')
canvas.drawString(160 * mm, 7 * mm, '(подпись плательщика)')
#вывестии защитны вертикальный мелкий текст
canvas.rotate(90)
canvas.setFillColor(HexColor(0x4f4b4b))
canvas.setFont('PTAstraSerifReg', 5.2)
canvas.drawString(10 * mm, -12 * mm, '{}'.format(6 * left_size_str))
canvas.restoreState()
def draw_address(canvas, text=None):
""" Draws the business address """
canvas.setFont('Helvetica', 9)
textobject = canvas.beginText(13 * cm, -2.5 * cm)
if text is None:
text = business_details
for line in text:
textobject.textLine(line)
canvas.drawText(textobject)
def myFirstPage(canvas, doc):
from reportlab.lib.colors import red
PAGE_HEIGHT = canvas._pagesize[1]
canvas.saveState()
canvas.setStrokeColor(red)
canvas.setLineWidth(5)
canvas.line(66,72,66,PAGE_HEIGHT-72)
canvas.setFont(_baseFontNameB,24)
canvas.drawString(108, PAGE_HEIGHT-108, "TABLE OF CONTENTS DEMO")
canvas.setFont(_baseFontName,12)
canvas.drawString(4 * inch, 0.75 * inch, "First Page")
canvas.restoreState()
def addPageNumber(canvas, doc):
"""
Add the page numbers to the document
"""
width, height = A4 # this is useful when defining where to plot something on the page
page_num = canvas.getPageNumber()
text = "%s" % page_num
header = "TIC {}".format(tic)
canvas.setFont('Helvetica', 8)
canvas.drawString(width * 0.85, height * 0.95, header)
canvas.drawRightString(200 * mm, 10 * mm, text)
def drawCode(canvas, code):
"""Draws a block of text at current point, indented and in Courier"""
canvas.addLiteral('36 0 Td')
canvas.setFillColor(colors.blue)
canvas.setFont('Courier', 10)
t = canvas.beginText()
t.textLines(code)
c.drawText(t)
canvas.setFillColor(colors.black)
canvas.addLiteral('-36 0 Td')
canvas.setFont('Times-Roman', 10)
def onMyFirstPage(self, canvas, doc):
# If the left_footer attribute is not None, then add it to the page
canvas.saveState()
if self.left_footer is not None:
# canvas.setFont('Helvetica', 8)
# canvas.drawString(1 * cm, 1 * cm, self.left_footer)
canvas.setFont("Times-Roman", 150)
canvas.setStrokeColorRGB(0.74, 0.74, 0.74)
canvas.setFillColorRGB(0.74, 0.74, 0.74)
canvas.translate(A4[0] / 2, A4[1] / 2)
canvas.rotate(45)
canvas.drawCentredString(20, 0, self.left_footer)
canvas.restoreState()
def _headerfooter(self, canvas, doc):
canvas.setLineWidth(1)
canvas.saveState()
canvas.setFont('Helvetica', 9)
canvas.drawString(4, 410, "%s" % self.title)
canvas.line(2, 407, 295, 407)
canvas.setFont('Helvetica', 6)
canvas.line(2, 10, 295, 10)
canvas.drawString(
4, 4,
"PyAeromanger 14/2015 by zerodine GmbH - Thomas Spycher @tspycher")
canvas.restoreState()
def draw_main_doc_header(canvas, pdf):
""" Draws the invoice header """
canvas.saveState()
canvas.translate(0, 29.7 * cm)
canvas.setFont('Helvetica', 10)
canvas.setStrokeColorRGB(0.9, 0.5, 0.2)
canvas.setFillColorRGB(0.2, 0.2, 0.2)
canvas.setFont('Helvetica', 16)
canvas.drawString(18 * cm, -1 * cm, 'Invoice')
canvas.drawInlineImage(INV_LOGO, 1 * cm, -1 * cm, 25, 25)
canvas.setLineWidth(4)
canvas.line(0, -1.25 * cm, 21.7 * cm, -1.25 * cm)
canvas.restoreState()
def printBandOutline(self, canvas, text):
""" Draw a dotted rectangle around the entire band, and type a small faded
caption at the origin of the band.
"""
canvas.saveState()
canvas.setLineWidth(0.1)
canvas.setStrokeColorRGB(0.8, 0.5, 0.7)
canvas.setDash(1, 2)
canvas.rect(self.x, self.y, self.width, self.height)
canvas.setFont("Helvetica", 8)
canvas.setFillColor((0.6, 0.8, 0.7))
canvas.drawString(self.x, self.y, text)
canvas.restoreState()
def _general_data_rect(self, canvas, doc):
canvas.saveState()
top = 19.7 * cm
left = self.page_width - self.margins['right'] - self.block_width
width = self.block_width
height = self.block_height
canvas.setStrokeColor(red)
canvas.setLineWidth(.5)
canvas.rect(left, top, width, height, stroke=1)
canvas.setFillColorRGB(.7, .7, .7)
canvas.setFont(self.label_font, 25)
canvas.drawCentredString(15.5 * cm, 22.4 * cm, _('INVOICE'))
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()
