def spacer_ticker(canvas, feature, cLen, Y0, nudge, offset, side):
"""Draw separator indicators."""
# 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
# set Y axis coordinates
y0 = Y0-dop*3.5
if side == 'low':
yT1 = y0-h*4
else:
yT1 = y0+h*4
# draw
canvas.setLineWidth(2)
ttl = canvas.beginPath()
ttl.moveTo(xs,y0)
ttl.lineTo(xs,yT1)
ttl.lineTo(xe,yT1)
ttl.lineTo(xe,y0)
canvas.drawPath(ttl, stroke=1, fill=0)
ttl.close()
def draw(self, pmlOp, pageNr, canvas, pe):
canvas.setLineWidth(pe.mm2points(pmlOp.width))
path = canvas.beginPath()
path.arc( pe.x(pmlOp.x - pmlOp.radius), pe.y(pmlOp.y - pmlOp.radius),
pe.x(pmlOp.x + pmlOp.radius), pe.y(pmlOp.y + pmlOp.radius),
startAng=pmlOp.startAngle, extent=90)
canvas.drawPath(path)
def write_pdf(self, canvas):
canvas.setFont("Helvetica", 70)
if self.show_title:
canvas.drawString(70, 70, self.title)
canvas.setFont("Helvetica", SUDOKU_FONT_SIZE)
sudoku_offset = SUDOKU_PDF_OFFSET
xlist = [sudoku_offset[0] + j *
(2 * SUDOKU_XPAD + SUDOKU_FONT_SIZE) for j in range(0, 9 + 1)]
ylist = [sudoku_offset[1] + j *
(2 * SUDOKU_YPAD + SUDOKU_FONT_SIZE) for j in range(0, 9 + 1)]
canvas.grid(xlist, ylist)
for x in range(0, 9):
for y in range(0, 9):
if self.sudoku.mat[y][x] != UNKNOWN:
canvas.drawString(
sudoku_offset[0] +
(SUDOKU_FONT_SIZE + SUDOKU_XPAD) // 2 +
x * (2 * SUDOKU_XPAD + SUDOKU_FONT_SIZE) - 4,
sudoku_offset[1] + SUDOKU_FONT_SIZE +
y * (2 * SUDOKU_YPAD + SUDOKU_FONT_SIZE),
str(self.sudoku.mat[y][x])
)
if self.show_page_number:
canvas.setFont("Helvetica", 10)
canvas.drawString(280, 800, str(self.page_number))
# draw a cell
canvas.setLineWidth(3)
canvas.grid(xlist[::3], ylist[::3])
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 orf_eus(canvas, featL, coords, color_hex, shape):
"""Draw CDS and write count."""
xs, xe, xn, y0, yt, yb, ynt, ynb = coords
canvas.setLineWidth(1)
# initialize path
pORF = canvas.beginPath()
if shape == 'square':
pORF.moveTo(xs,ynt)
pORF.lineTo(xe,ynt)
pORF.lineTo(xe,ynb)
pORF.lineTo(xs,ynb)
pORF.lineTo(xs,ynt)
# draw triangle-shaped ORFS
elif featL <= minL:
pORF.moveTo(xs,yt)
pORF.lineTo(xe,y0)
pORF.lineTo(xs,yb)
pORF.lineTo(xs,yt)
# draw arrow-shaped ORFS
else:
pORF.moveTo(xs,ynt)
pORF.lineTo(xn,ynt)
pORF.lineTo(xn,yt)
pORF.lineTo(xe,y0)
pORF.lineTo(xn,yb)
pORF.lineTo(xn,ynb)
pORF.lineTo(xs,ynb)
pORF.lineTo(xs,ynt)
# evaluate function category and set fill color
canvas.setFillColor(color_hex)
# finalize object path
canvas.drawPath(pORF, stroke=1, fill=1)
pORF.close()
canvas.setFillColor(black)
def show(self, canvas, showframe=None): if self._border_width > 0.0: canvas.saveState() canvas.setStrokeColor(self._border_color) canvas.setLineWidth(self._border_width) if self._border_fill_color.lower() != 'none': canvas.setFillColor(self._border_fill_color) canvas.rect(self.x, self.y, self.width, self.height, stroke=self._border_type, fill=self._fill_border_rect) canvas.restoreState() if self.flowable is not None: self.flowable.width = self.width-(2.0*self._padding[0]) self.flowable.height = self.height-(2.0*self._padding[1]) self.flowable.drawOn(canvas, self.x+self._padding[0], self.y-self._padding[1]) if showframe is not None: canvas.saveState() canvas.setLineWidth(showframe[0]) canvas.rect(self.x, self.y, self.width, self.height, stroke=1, fill=showframe[1]) canvas.restoreState() return self
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 __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 contig_ticker(canvas, feature, cLen, Y0, offset, offset_mode):
"""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 offset coordinates
if offset_mode == 'loop':
offZs = offset_coord(Zs, cLen, offset)
offZe = offset_coord(Ze, cLen, offset)
elif offset_mode == 'nudge':
offZs = nudge_coord(Zs, offset)
offZe = nudge_coord(Ze, offset)
else:
offZs = Zs
offZe = Ze
xs, xe = offZs*u, offZe*u
# set Y axis coordinates
y0 = Y0-dop*3.5
# draw
canvas.setLineWidth(2)
ttl = canvas.beginPath()
ttl.moveTo(xs,y0)
ttl.lineTo(xs,y0-h*4)
ttl.lineTo(xs+dop,y0-h*4)
canvas.drawPath(ttl, stroke=1, fill=0)
canvas.setFont(bFont, NfSize)
canvas.drawString(xs+dop*2, y0-h*4.5, name)
canvas.setFont(rFont, SfSize)
canvas.drawString(xs+dop*2,y0-h*8,"".join(["[",str(Zs),"-",str(Ze),"]"]))
canvas.setFont(rFont, NfSize)
ttl.close()
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 confidential(self, canvas):
canvas.saveState()
canvas.translate(18.5*cm, 27.4*cm)
canvas.setLineWidth(3)
canvas.setFillColorRGB(1, 0, 0)
canvas.setStrokeGray(0.5)
p = canvas.beginPath()
p.moveTo(10, 0)
p.lineTo(20, 10)
p.lineTo(30, 0)
p.lineTo(40, 10)
p.lineTo(30, 20)
p.lineTo(40, 30)
p.lineTo(30, 40)
p.lineTo(20, 30)
p.lineTo(10, 40)
p.lineTo(0, 30)
p.lineTo(10, 20)
p.lineTo(0, 10)
canvas.drawPath(p, fill=1, stroke=0)
canvas.restoreState()
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 draw_half_star (self, inner_length=1*inch, outer_length=2*inch, points=5, origin=None):
canvas = self.canv
canvas.setLineWidth(0)
if not origin: canvas.translate(self.size*0.5,self.size*0.5)
else: canvas.translate(*origin)
canvas.setFillColor(self.fillcolor)
canvas.setStrokeColor(self.strokecolor)
p = canvas.beginPath()
inner = False # Start on top
is_origin = True
#print 'Drawing star with radius',outer_length,'(moving origin ',origin,')'
for theta in range(0,360,360/(points*2)):
if 0 < theta < 180: continue
if inner: r = inner_length
else: r = outer_length
x = (math.sin(math.radians(theta)) * r)
y = (math.cos(math.radians(theta)) * r)
#print 'POINT:',x,y
if is_origin:
p.moveTo(x,y)
is_origin = False
else:
p.lineTo(x,y)
inner = not inner
p.close()
canvas.drawPath(p,fill=1)
def beforeDrawPage(self, canvas, doc):
if self.background != None:
self.background.draw_on(canvas)
(width, height) = canvas._pagesize
canvas.setLineWidth(0.2 * cm)
canvas.line(cm, height - (2*cm), width - cm, height - (2*cm))
canvas.line(cm, (2*cm), width - cm, (2*cm))
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 draw_circle (self, x, y, r):
# Test...
canvas = self.canv
canvas.setLineWidth(0)
canvas.setStrokeColor(colors.grey)
canvas.setFillColor(colors.grey)
p = canvas.beginPath()
p.circle(x,y,r)
p.close()
canvas.drawPath(p,fill=1)
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('Times-Roman',12)
canvas.drawString(4 * inch, 0.75 * inch, "Page %d" % doc.page)
canvas.restoreState()
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 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('Times-Bold',24)
canvas.drawString(108, PAGE_HEIGHT-108, "TABLE OF CONTENTS DEMO")
canvas.setFont('Times-Roman',12)
canvas.drawString(4 * inch, 0.75 * inch, "First Page")
canvas.restoreState()
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 _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 draw(self):
canvas = self.canv
couleurDate = None
positionSeparation = 20
# Couleur de la case Date de la journée
if AFFICHER_VACANCES == True and self.dateDD in LISTE_VACANCES : couleurDate = COULEUR_VACANCES
if AFFICHER_WE == True and (self.dateDD.weekday() == 5 or self.dateDD.weekday() == 6) : couleurDate = COULEUR_WE
if AFFICHER_FERIES == True and self.dateDD in LISTE_FERIES : couleurDate = COULEUR_FERIES
if couleurDate != None :
r, g, b = ConvertCouleur(couleurDate)
canvas.setFillColorRGB(r, g, b)
canvas.rect(0, 0, positionSeparation, self.hauteurCase, fill=1, stroke=False)
# Texte date
canvas.setFillColorRGB(0, 0, 0)
canvas.setFont("Helvetica", 7)
canvas.drawRightString(positionSeparation-2, 2, self.labelDate)
# Trait séparation Date et Heures
canvas.setLineWidth(0.25)
canvas.line(positionSeparation, 0, positionSeparation, self.hauteurCase)
# Si aucune présence ce jour -là
if len(self.dictBarres) == 0 : return
# Récup du nbre total d'heure de la journée
totalJour = self.dictBarres["totalJour"]
# Transformation du nombre d'heures par catégorie en pourcentage
listeCategories = []
for IDcategorie, nbreHeures in self.dictBarres.items():
if IDcategorie != "totalJour" :
largeurBarre = nbreHeures * 1.0 * (self.largeurCase-positionSeparation-0.25) / totalJour
listeCategories.append( (largeurBarre, IDcategorie) )
listeCategories.sort()
# Création des graphes
if AFFICHER_COULEUR_CATEGORIES == True :
positionTemp = positionSeparation+0.25
for largeurBarre, IDcategorie in listeCategories :
r, g, b = ConvertCouleur(FormateCouleur(DICT_CATEGORIES[IDcategorie][2]))
canvas.setFillColorRGB(r, g, b)
canvas.rect(positionTemp, 0, largeurBarre, self.hauteurCase, fill=1, stroke=False)
positionTemp += largeurBarre
# Label Total Heure de la journée
if AFFICHER_HEURES == True :
canvas.setFillColorRGB(0, 0, 0)
canvas.setFont("Helvetica", 7)
canvas.drawRightString(self.largeurCase-2, 2, "%s" % minutesEnHeures(totalJour))
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 _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_later_header(self, canvas, doc):
header_string = f"{self.title} - {self.filename}".replace(
"<", "<").replace(">", ">")
canvas.setStrokeColorRGB(0, 0, 0)
canvas.setLineWidth(0.5)
canvas.setFont(_baseFontName, 10)
print(
f"Later Header Height: {self.bottomMargin + self.inner_height + 5}"
)
canvas.drawString(self.leftMargin + 5,
self.inner_height + self.bottomMargin + 5,
header_string)
def process(self):
kw = dict(self.getAttributeValues())
canvas = attr.getManager(self, interfaces.ICanvasManager).canvas
if 'width' in kw:
canvas.setLineWidth(kw['width'])
if 'join' in kw:
canvas.setLineJoin(kw['join'])
if 'cap' in kw:
canvas.setLineCap(kw['cap'])
if 'miterLimit' in kw:
canvas.setMiterLimit(kw['miterLimit'])
if 'dash' in kw:
canvas.setDash(kw['dash'])
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 framePage(canvas, doc):
# canvas.drawImage("snkanim.gif", 36, 36)
canvas.saveState()
canvas.setStrokeColorRGB(1, 0, 0)
canvas.setLineWidth(5)
canvas.line(66, 72, 66, PAGE_HEIGHT - 72)
canvas.setFont("Times-Italic", 12)
canvas.drawRightString(523, PAGE_HEIGHT - 56, "Platypus User Guide and Test Script")
canvas.setFont("Times-Roman", 12)
canvas.drawString(4 * inch, 0.75 * inch, "Page %d" % canvas.getPageNumber())
canvas.restoreState()
def process(self):
kw = dict(self.getAttributeValues())
canvas = attr.getManager(self, interfaces.ICanvasManager).canvas
if 'width' in kw:
canvas.setLineWidth(kw['width'])
if 'join' in kw:
canvas.setLineJoin(kw['join'])
if 'cap' in kw:
canvas.setLineCap(kw['cap'])
if 'miterLimit' in kw:
canvas.setMiterLimit(kw['miterLimit'])
if 'dash' in kw:
canvas.setDash(kw['dash'])
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 print_receipt(tot_price, trans_id, cashier_id, amount_paid, amount_rem):
#global last_trans, canvas, base, values, currentprinter, canvas
print str(tot_price)+' '+str(trans_id)+' '+str(cashier_id)+str(last_trans)
#raw_input("Press Enter to continue...")
canvas = canvas.Canvas("receipt.pdf", pagesize=letter)
canvas.setLineWidth(.3)
canvas.setFont('Helvetica', 12)
canvas.drawString(30,750,'CASHIER ID: '+str(cashier_id))
canvas.drawString(30,735,'TRANSACTION ID: '+str(trans_id))
canvas.drawString(500,750,time.strftime("%d/%m/%Y"))
canvas.line(480,747,580,747)
canvas.drawString(275,725,'TOTAL PRICE:')
canvas.drawString(500,725,"$"+str(tot_price))
canvas.line(378,723,580,723)
canvas.drawString(30,703,'PRODUCTS:')
canvas.drawString(120,703,'<Barcode>')
canvas.drawString(190,703,'<Quantity>')
canvas.drawString(260,703,'<Price>')
#items = ['10005058 2 24.00', '10005058 2 24.00']
base = 683
print last_trans
for check in last_trans:
values = check.split()
print values
#raw_input('print check')
left= 120
for value in values:
canvas.drawString(left,base,str(value))
left+=70
base=base-30
canvas.line(120,base,580,base)
base-=30
canvas.drawString(120,base,'AMOUNT PAID: $ %.2f'%amount_paid)
canvas.line(120,base-10,580,base-10)
base-=30
canvas.drawString(120,base,'CHANGE: $ %.2f'%amount_rem)
base-=30
canvas.line(120,base-10,580,base-10)
canvas.save()
currentprinter = win32print.GetDefaultPrinter()
if len(currentprinter):
win32print.SetDefaultPrinter(currentprinter)
win32api.ShellExecute(0, "print", 'receipt.pdf', None, ".", 0)
threading.Timer(15, lambda: os.remove('receipt.pdf') ).start()
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())
# draw a border
canvas.setStrokeColorRGB(1, 0, 0)
canvas.setLineWidth(5)
canvas.line(0.8 * inch, inch, 0.8 * inch, 10.75 * inch)
# reset carefully afterwards
canvas.setLineWidth(1)
canvas.setStrokeColorRGB(0, 0, 0)
def framePage(canvas,doc):
#canvas.drawImage("snkanim.gif", 36, 36)
canvas.saveState()
canvas.setStrokeColorRGB(1,0,0)
canvas.setLineWidth(5)
canvas.line(66,72,66,PAGE_HEIGHT-72)
canvas.setFont('Times-Italic',12)
canvas.drawRightString(523, PAGE_HEIGHT - 56, "Platypus User Guide and Test Script")
canvas.setFont('Times-Roman',12)
canvas.drawString(4 * inch, 0.75 * inch,
"Page %d" % canvas.getPageNumber())
canvas.restoreState()
def landscape(canvas, doc):
canvas.saveState()
# Page background
canvas.setStrokeColor(colors.black)
canvas.setLineWidth(1)
canvas.setFillColor('#e6ded5')
canvas.roundRect(0.5 * u.inch,
0.5 * u.inch,
10.0 * u.inch,
7.5 * u.inch,
0.15 * u.inch,
stroke=1,
fill=1)
canvas.restoreState()
def myFirstPage(self,canvas, doc):
canvas.saveState()
canvas.drawImage(STATICFILES_DIRS[0]+'escudo_transito.jpg',35, PAGE_HEIGHT-115)
canvas.setLineWidth(1)
canvas.line(10, 723, 600,723)
canvas.setFont('Times-Roman',8)
canvas.drawString(10,PAGE_HEIGHT-130, "MUNICIPIO DE LEON GUANAJUATO")
canvas.drawString(10,PAGE_HEIGHT-142, "SECRETARIA DE SEGURIDAD PUBLICA")
canvas.drawString(420,PAGE_HEIGHT-142, "INFORME DE CAPTURA DE INFRACCIONES")
canvas.setFillColorRGB(1,0,0)
canvas.setFontSize(18)
canvas.setFontSize(10)
canvas.setFillColorRGB(0,0,0)
canvas.drawString(10,PAGE_HEIGHT-154, "DIRECCION GENERAL DE TRANSITO MUNICIPAL")
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())
#draw a border
canvas.setStrokeColorRGB(1, 0, 0)
canvas.setLineWidth(5)
canvas.line(0.8 * inch, inch, 0.8 * inch, 10.75 * inch)
#reset carefully afterwards
canvas.setLineWidth(1)
canvas.setStrokeColorRGB(0, 0, 0)
def header(canvas, DOC, MAPHEADERTEXT):
"""Draws the page header"""
arcpy.AddMessage("Drawing Header...")
canvas.saveState()
header_top_padding = 1*cm
logo_image_height = 50
logo_header_gap = 0.75*cm
indent_right = 40
docy = PAGE_HEIGHT-60
style_header = getSampleStyleSheet()
style_header.add(ParagraphStyle(name='BodyT', alignment=TA_LEFT,
borderPadding=(5, 10, 10), fontName='Vera',
fontSize=14, spaceAfter=6,
backColor=Color(0, 0.2627450980392157,
0.42745098039215684, 1),
textColor=Color(1, 1, 1, 1)))
para = Paragraph(MAPHEADERTEXT, style_header["BodyT"])
logo_image_width, imageheight = ImageReader(IMAGE).getSize()
aspect_ratio = imageheight/(float(logo_image_width))
reduceby = 0.1
while logo_image_height <= imageheight:
logo_image_width = logo_image_width - reduceby
imageheight = logo_image_width*aspect_ratio
reduceby += 0.1
para_width_total, para_height = para.wrap(DOC.width + 0.70*inch
- logo_image_width
- logo_header_gap,
DOC.topMargin + 0.5 *inch)
logo_y = ((para_height + imageheight) / 2) + header_top_padding
canvas.drawImage(ImageReader(IMAGE), indent_right, PAGE_HEIGHT-logo_y,
logo_image_width, imageheight, mask='auto')
para_y = para_height + header_top_padding
para.drawOn(canvas,
(indent_right+ 0.1*cm + logo_image_width + logo_header_gap),
(PAGE_HEIGHT - para_y))
canvas.setLineWidth(1.0)
canvas.setStrokeColor(Color(0, 0.2627450980392157, 0.42745098039215684, 1))
canvas.line(indent_right, docy, (PAGE_WIDTH - indent_right), docy)
canvas.restoreState()
def __call__(self, canvas, doc):
canvas.saveState()
w, h = canvas._pagesize
# Gen hline coords
left_margin, right_margin, top_margin, linewidth = self._gen_line_coords(
)
line_start_x = left_margin
line_start_y = h - top_margin
line_end_x = w - right_margin
line_end_y = h - top_margin
# Set text fonts
font_name = ParagraphStyleGenerator._gen_font()
font_size = random_integer_from_list(self.config['text']['font_size'])
canvas.setFont(font_name, font_size)
# draw text
text_locations = self.config['text']['locations']
random_locations = np.random.choice(text_locations,
size=np.random.randint(
0,
len(text_locations) + 1),
replace=False)
for loc in random_locations:
if loc == 'left':
canvas.drawString(line_start_x, line_start_y + font_size // 3,
self._gen_text())
elif loc == 'right':
words = self._gen_text()
canvas.drawString(line_end_x - font_size * len(words),
line_start_y + font_size // 3, words)
elif loc == 'center':
canvas.drawCentredString(w / 2, line_start_y + font_size // 3,
self._gen_text())
else:
raise ValueError("Text location %s not identified !" % loc)
# draw hline
canvas.setLineWidth(linewidth)
canvas.line(line_start_x, line_start_y, line_end_x, line_end_y)
# add footer
line_y = random_integer_from_list([20, 40])
canvas.drawCentredString(w / 2, line_y, str(np.random.randint(100)))
canvas.restoreState()
def draw_footer(self, canvas, doc):
canvas.setStrokeColorRGB(0, 0, 0)
canvas.setLineWidth(0.5)
canvas.setFont('Times-Roman', 10)
username = getpass.getuser()
device = socket.gethostname()
creation_time = datetime.datetime.now().strftime("%H:%M:%S %d/%m/%Y")
footer_string = f"Generated from {self.full_filename} by {username}@{device} on {creation_time}"
# split_len = 100
split_len = self.inner_width / 4.6
print("Making Footer!")
generated_by_height = canvas.footer_height + (cm * 0.5)
if len(footer_string) > split_len:
wrap_text = textwrap.wrap(footer_string, width=split_len)[::-1]
for idx, line in enumerate(wrap_text):
canvas.drawString(doc.leftMargin,
generated_by_height + (idx * 0.5 * cm), line)
canvas.line(
x1=doc.leftMargin,
y1=generated_by_height + (len(wrap_text) * 0.5 * cm),
x2=doc.pagesize[0] - 50,
y2=generated_by_height + (len(wrap_text) * 0.5 * cm),
)
elif len(footer_string) < self.inner_width / 6:
canvas.drawString(doc.leftMargin, canvas.footer_height,
footer_string)
canvas.line(
x1=doc.leftMargin,
y1=canvas.footer_height + (0.5 * cm),
x2=doc.pagesize[0] - 50,
y2=canvas.footer_height + (0.5 * cm),
)
else:
canvas.drawString(doc.leftMargin, generated_by_height,
footer_string)
canvas.line(
x1=doc.leftMargin,
y1=generated_by_height + (0.5 * cm),
x2=doc.pagesize[0] - 50,
y2=generated_by_height + (0.5 * cm),
)
def full_background(canvas, document):
canvas.saveState()
# canvas.drawImage("background.jpg", 0,0, A4[0], A4[1])
canvas.drawImage(os.path.join(resource_dir, "letter_header.png"),
(A4[0] - 18.924 * cm) / 2, A4[1] - 3.294 * cm - 0.5 * cm,
18.924 * cm, 3.294 * cm)
canvas.drawImage(os.path.join(resource_dir, "letter_footer.png"),
(A4[0] - 18.911 * cm) / 2, 0.8 * cm, 18.911 * cm,
1.532 * cm)
# left_header_frame = platypus.Frame(A4[0] - 4*inch,A4[1] - 2*inch, 3*inch, 1*inch,showBoundary=True)
# header2_frame_right = platypus.Frame(12*cm,22*cm, 7.5*cm, 1*cm,showBoundary=True)
# body_frame = platypus.Frame(0.5*inch,3*inch, A4[0] - 1*inch, A4[1] - 5.6*inch,showBoundary=True)
# bottom_left_frame = platypus.Frame(0.5*inch, 1*inch, 3.3*inch, 1.9*inch,showBoundary=True)
# bottom_right_frame = platypus.Frame(A4[0] - 4.2*inch, 1*inch, 3.5*inch, 1.9*inch,showBoundary=True)
canvas.setLineWidth(0.1)
canvas.setFillColorRGB(0.8, 0.8, 0.8)
canvas.rect(1 * cm,
23 * cm,
A4[0] - 2 * cm,
1 * cm,
stroke=True,
fill=True)
canvas.rect(1 * cm,
8 * cm,
A4[0] - 2 * cm,
16 * cm,
stroke=True,
fill=False)
canvas.setFillColorRGB(1, 0, 0)
canvas.rect(1 * cm,
3 * cm, (A4[0] - 2 * cm) / 2,
5 * cm,
stroke=True,
fill=False)
canvas.rect(1 * cm + (A4[0] - 2 * cm) / 2,
3 * cm, (A4[0] - 2 * cm) / 2,
5 * cm,
stroke=True,
fill=False)
canvas.restoreState()
def draw(self, pmlOp, pageNr, canvas, pe):
# we need to adjust y position since PDF uses baseline of text as
# the y pos, but pml uses top of the text as y pos. The Adobe
# standard Courier family font metrics give 157 units in 1/1000
# point units as the Descender value, thus giving (1000 - 157) =
# 843 units from baseline to top of text.
# http://partners.adobe.com/asn/tech/type/ftechnotes.jsp contains
# the "Font Metrics for PDF Core 14 Fonts" document.
x = pe.x(pmlOp.x)
y = pe.y(pmlOp.y) - 0.843 * pmlOp.size
if pe.doc.tocs and pmlOp.toc:
key = "id%d" % id(pmlOp)
canvas.bookmarkPage(key,
fit="XYZ",
left=pe.x(pmlOp.x),
top=pe.y(pmlOp.y))
canvas.addOutlineEntry(pmlOp.toc.text, key)
newFont = (pe.getFontNr(pmlOp.flags), pmlOp.size)
if newFont != pe.currentFont:
canvas.setFont(*newFont)
pe.currentFont = newFont
if pmlOp.angle is None or pmlOp.angle == 0.0:
canvas.drawString(x, y, pmlOp.text)
else:
canvas.saveState()
canvas.translate(x, y)
canvas.rotate(pmlOp.angle)
canvas.drawString(0, 0, pmlOp.text)
canvas.restoreState()
if pmlOp.flags & pml.UNDERLINED:
undLen = fontinfo.getMetrics(pmlOp.flags).getTextWidth(
pmlOp.text, pmlOp.size)
# all standard PDF fonts have the underline line 100 units
# below baseline with a thickness of 50
undY = y - 0.1 * pmlOp.size
canvas.setLineWidth(0.05 * pmlOp.size)
canvas.line(x, undY, x + undLen, undY)
def baseliner(cLen, canvas, Y_map, nudge): # loop offset has no effect
"""Draw sequence baseline."""
canvas.setLineWidth(3)
y0 = Y_map
Zs = 0 # all sequences are initially aligned on the left
Ze = cLen
# calculate nudge offsets
offZs = nudge_coord(Zs, nudge)
offZe = nudge_coord(Ze, nudge)
# set zeroes
x0 = offZs*u
x1 = offZe*u
pBL = canvas.beginPath()
pBL.moveTo(x0,y0)
pBL.lineTo(x1,y0)
canvas.drawPath(pBL, stroke=1, fill=0)
pBL.close()
def rectInterna(canvas,
x0,
x1,
y0,
renglones,
altura_renglon,
linewidth=0.5,
title=0):
canvas.setLineWidth(linewidth)
# escalar x1 razon desconocida
x1 *= 1.355
# empezar en x0, y0+altura renglon
for i in range(1, renglones):
canvas.setLineWidth(
linewidth *
2.3) if (title == 1 and i == 1) else canvas.setLineWidth(linewidth)
# x0,y0,x1,y1
canvas.line(x0, y0 + altura_renglon * i, x1, y0 + altura_renglon * i)
def draw(self):
canvas = self.canv
# Texte label
canvas.setFillColorRGB(0, 0, 0)
canvas.setFont("Helvetica", 8)
if self.totalHeures == None :
canvas.drawString(15, 2, self.label)
else:
canvas.drawString(15, 2, "%s : %s" % (self.label, minutesEnHeures(self.totalHeures)))
# Carré de couleur
if self.couleur != None :
if type(self.couleur) == tuple :
r, g, b = ConvertCouleur(self.couleur)
else:
r, g, b = ConvertCouleur(FormateCouleur(self.couleur))
canvas.setLineWidth(0.25)
canvas.setFillColorRGB(r, g, b)
canvas.rect(0, 0, 10, 10, fill=1)
def draw(self, pmlOp, pageNr, canvas, pe):
if pmlOp.lw != -1:
canvas.setLineWidth(pe.mm2points(pmlOp.lw))
path = canvas.beginPath()
path.rect(pe.x(pmlOp.x),
pe.y(pmlOp.y) - pe.mm2points(pmlOp.height),
pe.mm2points(pmlOp.width), pe.mm2points(pmlOp.height))
if pmlOp.fillType == pml.STROKE:
canvas.drawPath(path)
elif pmlOp.fillType == pml.FILL:
canvas.drawPath(path, stroke=0, fill=1)
elif pmlOp.fillType == pml.STROKE_FILL:
canvas.drawPath(path, stroke=1, fill=1)
else:
print "Invalid fill type for RectOp"
def seq_scale(canvas, scX, scY, incrT, incrN, dip, dop) :
"""Draws the sequence scale bar."""
canvas.setLineWidth(1.2)
canvas.setFillColor(black)
incrCNT = 0 # initialize count of increments
psc = canvas.beginPath()
psc.moveTo(scX, scY+dip-dop) # start at beginning (duh!)
psc.lineTo(scX+incrT*incrN, scY+dip-dop) # draw the scale baseline
# draw ticks until the max number of increments is reached
while incrCNT <= incrN :
psc.moveTo(scX+incrT*incrCNT, scY+dip-dop)
psc.lineTo(scX+incrT*incrCNT, scY+dip)
incrCNT += 1
canvas.drawPath(psc, stroke=1, fill=0)
psc.close()
# write out scale extremities values (needs hand-fix if not using kbs)
canvas.setFont(rFont,NfSize)
canvas.drawRightString(scX, scY+dip+dop, '0')
canvas.drawString(scX+incrT*incrN, scY+dip+dop, str(incrN)+' kb')
def draw_page_size_A5(self, doc, canvas):
# Header
self.header.drawOn(canvas, doc.leftMargin + 40, doc.height + doc.topMargin + 20)
self.patient_name.drawOn(canvas, doc.leftMargin + 40, doc.height + doc.topMargin - 15)
# Footer
self.medic_name.drawOn(canvas, doc.leftMargin + 10, 64)
self.medic_specialty.drawOn(canvas, doc.leftMargin + 10, 52)
self.medic_crm.drawOn(canvas, doc.leftMargin + 10, 40)
self.footer.drawOn(canvas, doc.leftMargin + 10, 18)
# Draw Lines.
canvas.setLineWidth(0.5)
canvas.line(66, 78, A5[0] - 66, 78)
canvas.setLineWidth(.3)
canvas.line(30, 500, 390, 500)
if self.pattern.logo:
img = ImageReader(self.pattern.logo.path)
canvas.drawImage(img, 30, 510, 0.75 * inch, 0.75 * inch, mask='auto')
def draw_page_size_letter(self, doc, canvas):
# Header
self.header.drawOn(canvas, doc.leftMargin + 40, doc.height + doc.topMargin - self.h)
self.patient_name.drawOn(canvas, doc.leftMargin + 40, doc.height + doc.topMargin - 60)
# Footer
self.medic_name.drawOn(canvas, doc.leftMargin + 10, 60)
self.medic_specialty.drawOn(canvas, doc.leftMargin + 10, 48)
self.medic_crm.drawOn(canvas, doc.leftMargin + 10, 36)
self.footer.drawOn(canvas, doc.leftMargin + 10, 12)
# Draw Lines.
canvas.setLineWidth(0.5)
canvas.line(66, 78, letter[0] - 66, 78)
canvas.setLineWidth(.3)
canvas.line(30, 700, 580, 700)
if self.pattern.logo:
img = ImageReader(self.pattern.logo.path)
canvas.drawImage(img, 30, 710, 1 * inch, 1 * inch, mask='auto')
def _add_conference_details(self, canvas):
start_posn = self.start_posn
canvas.setFillColor(colors.blue)
canvas.setFont('Helvetica', 10)
canvas.drawString(0.5 * inch, start_posn,
'Section A - Conference Information')
canvas.setFillColor(colors.black)
canvas.setLineWidth(1)
canvas.rect(0.5 * inch, start_posn - 0.4 * inch, PAGE_WIDTH - inch,
0.3 * inch)
canvas.line(2.5 * inch, start_posn - 0.4 * inch, 2.5 * inch,
start_posn - 0.1 * inch)
canvas.setFillColor(colors.red)
canvas.drawString(0.7 * inch, start_posn - 0.3 * inch,
self.event.number)
canvas.setFillColor(colors.black)
canvas.drawString(2.7 * inch, start_posn - 0.3 * inch,
self.event.title)
self.start_posn = start_posn - 0.65 * inch
def contig_ticker(canvas, feature, cLen, Y0, nudge, offset, side):
"""Draw contig separators."""
# get contig name
try:
name = feature.qualifiers.get('locus_tag')[0]
except TypeError:
name = 'unnamed feature'
# 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
# set Y axis coordinates
if side == 'low':
y0 = Y0-dop*3.5
yT1 = y0-h*4
yT2 = y0-h*4.5
yT3 = y0-h*8
else:
y0 = Y0+dop*3.5
yT1 = y0+h*4
yT2 = y0+h*4.5
yT3 = y0+h*8
# draw
canvas.setLineWidth(2)
ttl = canvas.beginPath()
ttl.moveTo(xs,y0)
ttl.lineTo(xs,yT1)
ttl.lineTo(xs+dop,yT1)
canvas.drawPath(ttl, stroke=1, fill=0)
canvas.setFont(bFont, NfSize)
canvas.drawString(xs+dop*2, yT2, name)
canvas.setFont(rFont, SfSize)
canvas.drawString(xs+dop*2,yT3,"".join(["[",str(Zs),"-",str(Ze),"]"]))
canvas.setFont(rFont, NfSize)
ttl.close()
def _footer(canvas, doc):
splunkLayoutSettings = PAPERSIZES[doc.splunkPaperSize]
canvas.saveState()
canvas.setStrokeColorRGB(0.8, 0.8, 0.8)
canvas.setLineWidth(1) # hairline
canvas.line(inch, inch, doc.width + inch, inch)
canvas.setStrokeColorRGB(0.5, 0.5, 0.5)
canvas.setFillColorRGB(0.586, 0.586, 0.586)
canvas.drawRightString(doc.width + inch, 0.75 * inch - _TEXT_OFFSET,
"Page %d" % (doc.page))
# draw title centered and ellipsized
ellipsizedTitle = _ellipsize(doc.getTitle(),
splunkLayoutSettings['ellipsizedTitleCount'])
ellipsizedTitleWidth = doc.getFontManager().textWidth(
ellipsizedTitle, _TITLE_SIZE)
textObject = canvas.beginText(
inch + doc.width / 2 - ellipsizedTitleWidth / 2,
0.75 * inch - _TEXT_OFFSET)
doc.getFontManager().addTextAndFontToTextObject(textObject,
ellipsizedTitle,
_TITLE_SIZE)
canvas.drawText(textObject)
timestamp = doc.getTimestamp()
timestampWidth = doc.getFontManager().textWidth(timestamp, _DATE_SIZE)
textObject = canvas.beginText(inch + doc.width - timestampWidth,
inch - _TEXT_OFFSET)
doc.getFontManager().addTextAndFontToTextObject(textObject, timestamp,
_DATE_SIZE)
canvas.drawText(textObject)
canvas.restoreState()
canvas.saveState()
if doc.getLogoDrawing() != None:
logoDrawing = doc.getLogoDrawing()
renderPDF.draw(logoDrawing,
canvas,
inch,
inch - logoDrawing.height - _LOGO_OFFSET,
showBoundary=False)
canvas.restoreState()
def footer(canvas, DOC):
"""Draws the page footer"""
arcpy.AddMessage("Drawing Footer...")
canvas.saveState()
canvas.setFont("Vera", 7.5)
text = MAPHEADERTEXT
date_now = datetime.datetime.now()
date_formatted = (str(time.strftime("%b")) + " " + str(date_now.day) +
", " + str(date_now.year))
canvas.drawRightString(DOC.width - (DOC.rightMargin - 2.35 * inch),
0.5 * DOC.bottomMargin, date_formatted)
canvas.setFillGray(0.70)
canvas.drawString(DOC.leftMargin - 25, 0.5 * DOC.bottomMargin, text)
canvas.setLineWidth(2)
canvas.setStrokeColor(Color(0, 0.2627450980392157, 0.42745098039215684, 1))
pagex = 47.5
pagey = 0.75 * DOC.bottomMargin
canvas.line(pagex, pagey, (PAGE_WIDTH - pagex), pagey)
canvas.restoreState()
def markField(self, canvas, punktX, punktY, deltaX, deltaY, tekst=None):
"""En fullstendig giro har hjørneklammer rundt hvert tekstfelt.
PunktX og punktY setter øverste venstre hjørne i "boksen".
deltaX og deltaY angir relativ avstand til nederste høyre hjørne."""
# Oppe i venstre hjørne P(12,65)
canvas.setLineWidth(0.2*mm)
canvas.lines([(punktX, punktY, punktX+2*mm, punktY), (punktX, punktY-2*mm, punktX, punktY)])
# oppe i høyre hjørne P(98,65)
canvas.lines([(punktX+deltaX-2*mm, punktY, punktX+deltaX, punktY), (punktX+deltaX, punktY-2*mm, punktX+deltaX, punktY)])
# Nede i venstre hjørne P(12,43)
canvas.lines([(punktX, punktY+deltaY, punktX+2*mm, punktY+deltaY), (punktX, punktY+deltaY, punktX, punktY+deltaY+2*mm)])
# Nede i høyre hjørne P(98,43) # deltaX = 86, deltaY = -22
canvas.lines([(punktX+deltaX-2*mm, punktY+deltaY, punktX+deltaX, punktY+deltaY), (punktX+deltaX, punktY+deltaY, punktX+deltaX, punktY+deltaY+2*mm)])
if isinstance(tekst, basestring):
# skriv hjelpetekst til boksen
canvas.setFont("Helvetica-Bold", 6)
canvas.drawString(punktX+3*mm,punktY+1*mm, tekst)
def draw(self):
canvas = self.canv
# Texte label
canvas.setFillColorRGB(0, 0, 0)
canvas.setFont("Helvetica", 8)
if self.totalHeures == None:
canvas.drawString(15, 2, self.label)
else:
canvas.drawString(
15, 2,
"%s : %s" % (self.label, minutesEnHeures(self.totalHeures)))
# Carré de couleur
if self.couleur != None:
if type(self.couleur) == tuple:
r, g, b = ConvertCouleur(self.couleur)
else:
r, g, b = ConvertCouleur(FormateCouleur(self.couleur))
canvas.setLineWidth(0.25)
canvas.setFillColorRGB(r, g, b)
canvas.rect(0, 0, 10, 10, fill=1)
def baseliner(cLen, canvas, Y_map, offset, offset_mode):
"""Draw sequence baseline."""
canvas.setLineWidth(3)
y0 = Y_map
Zs = 0 # all sequences are initially aligned on the left
Ze = cLen
# calculate offsets
if offset_mode == 'nudge':
offZs = nudge_coord(Zs, offset)
offZe = nudge_coord(Ze, offset)
else:
offZs = Ze
offZe = Zs
x0 = offZs * u
x1 = offZe * u
pBL = canvas.beginPath()
pBL.moveTo(x0, y0)
pBL.lineTo(x1, y0)
canvas.drawPath(pBL, stroke=1, fill=0)
pBL.close()
def draw_ruler(self,
canvas,
x,
y,
length,
orientation=HORIZONTAL,
units=METRIC):
# Ruler attributes for METRIC and IMPERIAL
measurements = {
CalibrationPage.METRIC: {
'resolution': 0.1 * cm,
'tick_lengths': [(1, 0.1 * cm), (10, 0.2 * cm)]
},
CalibrationPage.IMPERIAL: {
'resolution':
0.03125 * inch,
'tick_lengths': [(1, 0.1 * cm), (4, 0.15 * cm), (8, 0.2 * cm),
(16, 0.25 * cm), (32, 0.3 * cm)]
}
}
canvas.saveState()
canvas.setLineWidth(0.2)
if orientation == CalibrationPage.VERTICAL:
canvas.rotate(90)
(x, y) = (y, -x)
canvas.line(x, y, x + length, y)
tick_placement = x
settings = measurements[units]
for tick in range(int(math.ceil(length / settings['resolution'])) + 1):
for division, size in settings['tick_lengths']:
if tick % division == 0:
tick_length = size
canvas.line(tick_placement, y, tick_placement, y - tick_length)
tick_placement += settings['resolution']
canvas.restoreState()
def draw_label(self, rect):
canvas.setFillColor(reportlab.lib.colors.black)
if args.grid:
canvas.setStrokeColor(reportlab.lib.colors.grey)
canvas.setLineWidth(1)
canvas.rect(rect.x * inch, rect.y * inch, rect.w * inch, rect.h * inch)
v = series[self.pos] * 10 ** self.decade
v_with_units = (v, '\u2126')
if (v >= 1000 and v < 10 ** 6):
v_with_units = (v/1000, "K" + v_with_units[1])
elif (v >= 10 ** 6):
v_with_units = (v/10 ** 6, "M" + v_with_units[1])
v_str = ("{:.5g} " + v_with_units[1]).format(v_with_units[0])
print(v_str)
canvas.setStrokeColor(reportlab.lib.colors.black)
canvas.setFont("Helvetica-Bold", 18)
y = (rect.y + 1/8)
canvas.drawString((rect.x + 1/8) * inch, y * inch, v_str)
stripes = list(stripes1and2[self.pos]) + [colors[self.decade]]
stripes.reverse()
stripeD = Dim(w = 1/8, h = 1/4)
x = rect.x + rect.w - 1/8 - stripeD.w
for s in stripes:
canvas.setFillColor(s)
canvas.setStrokeColor(reportlab.lib.colors.grey)
canvas.rect(x * inch, y * inch, stripeD.w * inch, stripeD.h * inch, stroke = 1, fill = 1)
x -= 1/16 + stripeD.w
self.pos += 1
if self.pos == len(series):
self.decade += 1
self.pos = 0
return (v != max_value)
def render(self, pagemgr):
rendered = []
frame = None
canvas = None
if pagemgr is not None:
frame = pagemgr.getcurrentframe()
canvas = pagemgr.getcanvas()
basestyle = self._baseelement.getstyle()
border = basestyle.getattribute('border', float)
color = basestyle.getattribute('color', str)
pos_xy, r_xy = self._baseelement.getellipse()
canvas_height = canvas._pagesize[1]
pos_y = canvas_height - pos_xy[1]
canvas.saveState()
canvas.setStrokeColor(color)
canvas.setLineWidth(float(border))
canvas.ellipse(pos_xy[0], pos_y, pos_xy[0] + r_xy[0], pos_y - r_xy[1])
canvas.restoreState()
