def drawBounds(self, canvas):
"""Guidelines to help me draw - not needed in production"""
canvas.setStrokeColor(colors.red)
canvas.rect(-100, -70, 200, 140)
canvas.line(-100, 0, 100, 0)
canvas.line(0, 70, 0, -70)
canvas.setStrokeColor(colors.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 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 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 myLaterPages(self,canvas, doc):
canvas.saveState()
canvas.setFont('Times-Roman',9)
canvas.setStrokeColor('grey')
canvas.rect(0.5*inch,0.5*inch, 7.27*inch, 10.6*inch,stroke=1, fill=0)
canvas.drawString(PDF.PAGE_WIDTH*0.47, 0.8* inch, "Page %d " % (doc.page-1))
canvas.restoreState()
def draw_text_bottom(canvas, text, fontsize=60):
def get_center_x_coord(text, fontName, fontsize):
strwidth = stringWidth(text, fontName, fontsize)
x = (width - strwidth) / 2
return x
fontName = "Helvetica-Bold"
maxWidth = 0.8 * width
canvas.setFillColor(black)
canvas.setStrokeColor(black)
canvas.setFont(fontName, fontsize)
lines = simpleSplit(text, fontName, fontsize, maxWidth)
if (len(lines) > 1):
draw_text_bottom(canvas, text, fontsize * 0.9)
else:
y = 170
canvas.drawString(get_center_x_coord(text, fontName, fontsize), y,
text)
# Smaller text
fontName = "Helvetica"
fontsize = 20
canvas.setFont(fontName, fontsize)
text = "Asp-lunch Tisdag Lv1"
y = y - 30
canvas.drawString(get_center_x_coord(text, fontName, fontsize), y,
text)
text = "12:00 i FB"
y = y - fontsize - 5
canvas.drawString(get_center_x_coord(text, fontName, fontsize), y,
text)
text = "Tas ned den 11/12"
y = fontsize
canvas.drawString(get_center_x_coord(text, fontName, fontsize), y,
text)
def draw_guide(canvas, x, y, guide, working_dir, character_info):
if guide == Guide.CHARACTER:
prefill_character(working_dir, canvas, x + SQUARE_PADDING, \
y - SQUARE_PADDING, \
character_info.character + '0.png')
return
canvas.setDash(1, 2)
canvas.setStrokeColor(CMYKColor(0, 0, 0, 0.2))
if guide == Guide.STAR or guide == Guide.CROSS_STAR:
x1 = x
y1 = y
x2 = x1 + SQUARE_SIZE
y2 = y - SQUARE_SIZE
canvas.line(x1, y1, x2, y2)
canvas.line(x2, y1, x1, y2)
if guide == Guide.CROSS or guide == Guide.CROSS_STAR:
x1 = x
y1 = y - SQUARE_SIZE / 2
x2 = x1 + SQUARE_SIZE
y2 = y1
canvas.line(x1, y1, x2, y2)
x1 = x + SQUARE_SIZE / 2
y1 = y
x2 = x1
y2 = y1 - SQUARE_SIZE
canvas.line(x1, y1, x2, y2)
canvas.setDash()
canvas.setStrokeColor(CMYKColor(0, 0, 0, 1))
def draw_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 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 title(canvas, doc):
canvas.saveState()
lemma_img = 'L:/resources/code/models/accuracy_assessment/report/images/'
lemma_img += 'lemma_logo.gif'
# Page background
canvas.setStrokeColor(colors.black)
canvas.setLineWidth(1)
canvas.setFillColor('#e6ded5')
canvas.roundRect(0.5 * u.inch,
0.5 * u.inch,
7.5 * u.inch,
10.0 * u.inch,
0.15 * u.inch,
stroke=1,
fill=1)
# Page banner - image
canvas.drawImage(lemma_img,
0.5 * u.inch,
7.5 * u.inch,
width=7.5 * u.inch,
height=3 * u.inch,
mask='auto')
canvas.restoreState()
def draw_guide(canvas, x, y, guide):
canvas.setDash(1, 2)
canvas.setStrokeColor(CMYKColor(0, 0, 0, 0.2))
if guide == Guide.STAR:
x1 = x
y1 = y
x2 = x1 + SQUARE_SIZE
y2 = y - SQUARE_SIZE
canvas.line(x1, y1, x2, y2)
canvas.line(x2, y1, x1, y2)
elif guide == Guide.CROSS:
x1 = x
y1 = y - SQUARE_SIZE / 2
x2 = x1 + SQUARE_SIZE
y2 = y1
canvas.line(x1, y1, x2, y2)
x1 = x + SQUARE_SIZE / 2
y1 = y
x2 = x1
y2 = y1 - SQUARE_SIZE
canvas.line(x1, y1, x2, y2)
canvas.setDash()
canvas.setStrokeColor(CMYKColor(0, 0, 0, 1))
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 drawBounds(self, canvas):
"""Guidelines to help me draw - not needed in production"""
canvas.setStrokeColor(colors.red)
canvas.rect(-100,-70,200,140)
canvas.line(-100,0,100,0)
canvas.line(0,70,0,-70)
canvas.setStrokeColor(colors.black)
def piePagina(canvas, doc):
canvas.saveState()
canvas.setFillColor('#666666')
canvas.setFont('Helvetica', 8)
canvas.setStrokeColor('#ABAAAB')
canvas.line(A4[0] - 800, A4[1] - 818, A4[0] - 0, A4[1] - 818)
canvas.drawString(275, A4[1] - 835, "Pag. %d" % doc.page)
# canvas.drawString( 20, A4[1]-835, 'Codigo: '+form['data']['header']['code'])
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 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_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 _provider_rect(self, canvas, doc):
canvas.saveState()
top = 19.7 * cm
left = self.margins['left']
width = self.block_width
height = self.block_height
canvas.setStrokeColor(red)
canvas.setLineWidth(.5)
canvas.rect(left, top, width, height, stroke=1)
canvas.restoreState()
def _customer_rect(self, canvas, doc):
canvas.saveState()
top = 15.4 * cm
left = self.margins['left']
width = self.page_width - self.margins['left'] - self.margins['right']
height = self.block_height
canvas.setStrokeColor(red)
canvas.setLineWidth(.5)
canvas.rect(left, top, width, height, stroke=1)
canvas.restoreState()
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 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 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 _totals_rect(self, canvas, doc):
canvas.saveState()
top = 3.8 * cm
left = self.page_width - self.margins['right'] - self.block_width
width = self.block_width
height = self.block_height - 1 * cm
canvas.setStrokeColor(red)
canvas.setLineWidth(.5)
canvas.rect(left, top, width, height, stroke=1)
canvas.setFillColor(red)
canvas.rect(left, top, width - self.column_width * 2, height, fill=1)
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('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 firma_actasIntegrales(canvas, doc):
##########-------------------- Pie de Pagina del reporte ###########
canvas.saveState()
canvas.setStrokeColor(black)
canvas.setFont("Helvetica-BoldOblique",6.5)
canvas.drawString(2.7*inch, 2.37*cm, 'Firma y Sello Decanato')
canvas.drawString(4.35*inch, 2.37*cm, 'Firma y Sello Coordinación')
#canvas.drawString(9.3*cm, 2.37*cm, 'Profesor:')
#canvas.drawString(15*cm, 2.37*cm, u'Cédula:')
#canvas.drawString(11.3*cm, 1.0*cm, 'Firma')
#canvas.drawString(15*cm, 1.0*cm, 'Fecha')
canvas.grid([2.3*inch, 4.1*inch, 5.8*inch], [0.23*inch, 1.06*inch])
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 genSinglePageNameTag(canvas, data):
print 'new page!'
xcoords = [54, 306]
ycoords = [76, 236, 396, 556]
for x in xcoords:
for y in ycoords:
if data:
datum = data.pop(0)
genSingleNameTag(canvas, datum, x, y)
else:
break
canvas.setStrokeColor(black)
canvas.grid([54, 306, 558], [76, 236, 396, 556, 716])
def firma_actasIntegrales(canvas, doc):
##########-------------------- Pie de Pagina del reporte ###########
canvas.saveState()
canvas.setStrokeColor(black)
canvas.setFont("Helvetica-BoldOblique", 6.5)
canvas.drawString(2.7 * inch, 2.37 * cm, 'Firma y Sello Decanato')
canvas.drawString(4.35 * inch, 2.37 * cm, 'Firma y Sello Coordinación')
#canvas.drawString(9.3*cm, 2.37*cm, 'Profesor:')
#canvas.drawString(15*cm, 2.37*cm, u'Cédula:')
#canvas.drawString(11.3*cm, 1.0*cm, 'Firma')
#canvas.drawString(15*cm, 1.0*cm, 'Fecha')
canvas.grid([2.3 * inch, 4.1 * inch, 5.8 * inch],
[0.23 * inch, 1.06 * inch])
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 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 drawOn(self, canvas, x, y, _sW=0):
"Tell it to draw itself on the canvas. Do not override"
if _sW and hasattr(self,'hAlign'):
a = self.hAlign
if a in ['CENTER','CENTRE']:
x = x + 0.5*_sW
elif a == 'RIGHT':
x = x + _sW
elif a != 'LEFT':
raise ValueError, "Bad hAlign value "+str(a)
canvas.saveState()
canvas.translate(x, y)
self._drawOn(canvas)
if hasattr(self, '_showBoundary') and self._showBoundary:
#diagnostic tool support
canvas.setStrokeColor(gray)
canvas.rect(0,0,self.width, self.height)
canvas.restoreState()
def add(self, flowable, canvas, trySplit=0):
result = Frame.add(self, flowable, canvas, trySplit=trySplit)
if result == 0:
return result
# Slight hack: we're assuming that trySplit==0 iff this flowable
# is an already-split portion of another flowable. So we don't want
# to draw a line below it, since it's not the end of an entry.
# This assumes that this frame's parent doctemplate allowSplitting
# has not been changed from the default.
if trySplit == 0:
return result
canvas.saveState()
canvas.setStrokeColor(colors.gray)
fudge = flowable.getSpaceAfter() / 2.0
canvas.line(self._x, self._y + fudge, self._x + self.width, self._y + fudge)
canvas.restoreState()
return result
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 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 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()
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()
def draw(self):
canvas = self.canv
canvas.setLineWidth(0.1 * cm)
canvas.setFillColor(self.fillcolor)
canvas.setStrokeColor(self.strokecolor)
canvas.translate((1 - self.scale) * self.size / 2,
(1 - self.scale) * self.size / 2)
canvas.scale(self.scale, self.scale)
canvas.setFillColor(self.fillcolor)
canvas.setLineJoin(2)
ident = self.ident
shapes = [[(0, 0), (1, 0), (0.5, 1)], [(0, 0), (1, 0), (0, 1), (1, 1)],
[(0, 0), (1, 0), (1, 1), (0, 1)],
[(0, 0.5), (0.5, 1), (1, 0.5), (0.5, 0)],
[(0, 1), (1, 1), (0.5, 0)]]
if self.ident % 2 == 1:
canvas.setDash(3, 2)
p = canvas.beginPath()
ident = ident // 2
if self.ident % 2 == 0:
p.moveTo(0.5 * self.size, 0)
p.lineTo(0.5 * self.size, 1 * self.size)
ident = ident // 2
sndx = (ident) % (len(shapes) + 1)
if sndx < len(shapes):
d = shapes[sndx]
p.moveTo(d[0][0] * self.size, d[0][1] * self.size)
for ndx in range(len(d) - 1):
p.lineTo(d[ndx + 1][0] * self.size, d[ndx + 1][1] * self.size)
else:
p.ellipse(0, 0, 1 * self.size, 1 * self.size)
p.close()
canvas.drawPath(p)
def encabezado(canvas,nro,copia=False):
from reportlab.lib.colors import white, darkblue,black
x=740
canvas.setFillColor(darkblue)
canvas.rect(30,x,85,60,fill=True,stroke=False)
canvas.setFillColor(white)
canvas.setStrokeColor(white)
canvas.setFont("Helvetica-Bold", 35)
canvas.drawString(40, x+25, "MIS")
canvas.setFillColor(white)
canvas.setStrokeColor(white)
canvas.setFont("Helvetica-Bold", 12)
canvas.drawString(37,x+10, "PARAGUAY")
canvas.setFillColor(black)
canvas.setStrokeColor(black)
canvas.setFont("Helvetica-Bold", 11)
canvas.drawString(130, x+47, "MIS Implants Paraguay")
canvas.drawString(130, x+31, "América 192 c/ Mcal. López")
canvas.drawString(130, x+15, "Tel.: +59521 21 213193")
canvas.drawString(130, x+2, "www.misimplants.com.py")
canvas.setFont("Helvetica-Bold", 18)
canvas.drawString(350, x+17, "Nro. "+str(nro))
def render(self, pagemgr):
rendered = []
frame = None
canvas = None
if pagemgr is not None:
frame = pagemgr.getcurrentframe()
canvas = pagemgr.getcanvas()
rect = self._baseelement.getrect()
canvas_height = canvas._pagesize[1]
# We're looking for the object we're supposed to be positionned
# relative to, hopefully it exists and has been rendered already!
anchor_id, anchor_data = self._baseelement.getanchor()
rendered_anchor = findinstance(anchor_id)
if rendered_anchor is not None:
dest_rect = rendered_anchor.getrect()
dest_rect[1] = canvas_height - (dest_rect[1] + dest_rect[3])
rect = snapsrctodest(rect, dest_rect,
rlobject.snapto_dict[anchor_data[1].upper()],
rlobject.snapto_dict[anchor_data[2].upper()],
[0, 0])
rect[1] = canvas_height - (rect[1] + rect[3])
basestyle = self._baseelement.getstyle()
bckg_color = basestyle.getattribute('background-color', str)
border = basestyle.getattribute('border', float)
color = basestyle.getattribute('color', str)
canvas.saveState()
canvas.setStrokeColor(color)
canvas.setLineWidth(border)
dofill = 0
if bckg_color.lower() != 'none':
canvas.setFillColor(bckg_color)
dofill = 1
canvas.rect(rect[0], rect[1], rect[2], rect[3], stroke=1, fill=dofill)
canvas.restoreState()
register(self._baseelement.getid(),
RLFrame(rect[0], rect[1], rect[2], rect[3]))
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)
from_xy, to_xy = self._baseelement.getline()
canvas_height = canvas._pagesize[1]
from_y = canvas_height - from_xy[1]
to_y = canvas_height - to_xy[1]
canvas.saveState()
canvas.setStrokeColor(color)
canvas.setLineWidth(float(border))
canvas.line(from_xy[0], from_y, to_xy[0], to_y)
canvas.restoreState()
def contenido(canvas, rendicion):
from reportlab.lib.colors import darkblue, black
canvas.setFillColor(darkblue)
canvas.setFillColor(black)
canvas.setStrokeColor(black)
canvas.setFont("Helvetica-Bold", 13)
# DATOS DE LA RENDICION
canvas.setFont("Helvetica", 14)
canvas.drawString(30, 820, "Rendicion Nro. : %s" % force_text(rendicion.id or ''))
canvas.drawString(220, 820, "Fecha: %s" % force_text(rendicion.fecha.strftime('%d/%m/%Y') or ''))
canvas.drawString(30, 800, "Cobrador : %s" % force_text(rendicion.cobrador or ''))
# DETALLES
canvas.line(30, 785, 350, 785)
canvas.line(30, 765, 350, 765)
canvas.drawString(30, 770, "Recibo")
canvas.drawString(90, 770, u"Cliente")
canvas.drawString(290, 770, "Subtotal")
row = 765
canvas.setFont("Helvetica", 11)
detalles = DetallePresentacion.objects.filter(presentacion=rendicion)
total_rendicion = 0
for d in detalles:
row -= 15
canvas.drawString(40, row, force_text(d.cobro.numero))
canvas.drawString(90, row, force_text(Truncator(d.cobro.cliente).chars(30)))
canvas.drawString(280, row, force_text(separador_de_miles(d.subtotal)).rjust(13, ' '))
total_rendicion += d.subtotal
row -= 10
canvas.line(30, row, 350, row)
canvas.setFont("Helvetica-Bold", 13)
row -= 14
canvas.drawString(230, row, "Total: %s Gs." % separador_de_miles(total_rendicion))
def render(self, pagemgr):
rendered = []
frame = None
canvas = None
if pagemgr is not None:
frame = pagemgr.getcurrentframe()
canvas = pagemgr.getcanvas()
rect = self._baseelement.getrect()
canvas_height = canvas._pagesize[1]
# We're looking for the object we're supposed to be positionned
# relative to, hopefully it exists and has been rendered already!
anchor_id, anchor_data = self._baseelement.getanchor()
rendered_anchor = findinstance(anchor_id)
if rendered_anchor is not None:
dest_rect = rendered_anchor.getrect()
dest_rect[1] = canvas_height - (dest_rect[1]+dest_rect[3])
rect = snapsrctodest(rect,
dest_rect,
rlobject.snapto_dict[anchor_data[1].upper()],
rlobject.snapto_dict[anchor_data[2].upper()],
[0,0])
rect[1] = canvas_height - (rect[1]+rect[3])
basestyle = self._baseelement.getstyle()
bckg_color = basestyle.getattribute('background-color',str)
border = basestyle.getattribute('border',float)
color = basestyle.getattribute('color',str)
canvas.saveState()
canvas.setStrokeColor(color)
canvas.setLineWidth(border)
dofill = 0
if bckg_color.lower() != 'none':
canvas.setFillColor(bckg_color)
dofill = 1
canvas.rect(rect[0], rect[1], rect[2], rect[3], stroke=1, fill=dofill)
canvas.restoreState()
register(self._baseelement.getid(), RLFrame(rect[0], rect[1], rect[2], rect[3]))
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)
from_xy, to_xy = self._baseelement.getline()
canvas_height = canvas._pagesize[1]
from_y = canvas_height - from_xy[1]
to_y = canvas_height - to_xy[1]
canvas.saveState()
canvas.setStrokeColor(color)
canvas.setLineWidth(float(border))
canvas.line(from_xy[0], from_y, to_xy[0], to_y)
canvas.restoreState()
def _items_rect(self, canvas, doc):
canvas.saveState()
top = 6.6 * cm
left = self.margins['left']
width = self.page_width - self.margins['left'] - self.margins['right']
height = 8.5 * cm
canvas.setStrokeColor(red)
canvas.setFillColor(red)
canvas.setLineWidth(.5)
canvas.rect(left, top, width, height, stroke=1)
canvas.rect(left, top + 8 * cm, width, .5 * cm, stroke=1, fill=1)
left = left + self.column_width
canvas.line(left, top, left, top + height)
left = self.page_width - self.margins['right'] - self.column_width
canvas.line(left, top, left, top + height)
left = left - self.column_width
canvas.line(left, top, left, top + height)
left = left - self.column_width
canvas.line(left, top, left, top + height)
left = left - self.column_width
canvas.line(left, top, left, top + height)
canvas.setFillColor(white)
canvas.setFont(self.label_font, self.label_font_size)
text_top = top + height - .4 * cm
left = self.margins['left'] + self.column_width / 2.0
canvas.drawCentredString(left, text_top, _('REF.'))
left = left + (width - self.column_width * 5) / 2.0
canvas.drawCentredString(left, text_top, _('ITEMS'))
left = left + (width - self.column_width * 5) / 2.0 + self.column_width
canvas.drawCentredString(left, text_top, _('QTY.'))
left = left + self.column_width
canvas.drawCentredString(left, text_top, _('€/Unit'))
left = left + self.column_width
canvas.drawCentredString(left, text_top, _('DIS.'))
left = left + self.column_width
canvas.drawCentredString(left, text_top, _('TOTAL'))
canvas.restoreState()
def variousshapes(canvas):
from reportlab.lib.units import inch
inch = int(inch)
canvas.setStrokeGray(0.5)
canvas.grid(range(0,int(11*inch/2),int(inch/2)), range(0,int(7*inch/2),int(inch/2)))
rectangeHieght = .5
# % Favorable
favorableXposition = inch
favorableYposition = inch
favorableRectWidth = 1*inch
# Favorable Rect
canvas.setStrokeColor(green)
canvas.setFillColor(green)
canvas.rect(favorableXposition,favorableYposition,favorableRectWidth,rectangeHieght*favorableYposition, fill=1)
# % Favorable Text
canvas.setFillColor(black)
canvas.drawString(favorableXposition+(favorableXposition/2.5),favorableYposition+(favorableYposition/5), "11")
# % Neutral
neutralXposition = 2*inch
neutralYposition = 1*inch
neutralRectWidth = 1*inch
# Neutral Rect
canvas.setStrokeColor(yellow)
canvas.setFillColor(yellow)
canvas.rect(neutralXposition,neutralYposition,neutralRectWidth,rectangeHieght*inch, fill=1)
# % Neutral Text
canvas.setFillColor(black)
canvas.drawString(neutralXposition+(neutralXposition/2.5),neutralYposition+(neutralYposition/5), "22")
# % Unfavorable
unfavorableXposition = 3*inch
unfavorableYposition = 1*inch
unfavorableRectWidth = 1*inch
# Unfavorable Rect
canvas.setStrokeColor(red)
canvas.setFillColor(red)
canvas.rect(unfavorableXposition,unfavorableYposition,unfavorableRectWidth,rectangeHieght*inch, fill=1)
# Unfavorable Text
canvas.setFillColor(black)
canvas.drawString(unfavorableXposition+(unfavorableXposition/2.5),unfavorableYposition+(unfavorableYposition/5), "33")
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 setShade(canvas, c):
rlcolor = Color(c,c,c)
canvas.setFillColor(rlcolor)
canvas.setStrokeColor(rlcolor)
def colors2(canvas):
from reportlab.lib.units import inch
x = 0; dx = 0.4*inch
for i in range(4):
for color in (colors.pink, colors.green, colors.brown):
canvas.setFillColor(color)
canvas.rect(x,0,dx,3*inch,stroke=0,fill=1)
x = x+dx
canvas.setFillColor(colors.white)
canvas.setStrokeColor(colors.white)
canvas.setFont("Helvetica-Bold", 85)
canvas.drawCentredString(2.75*inch, 1.3*inch, "OPEN")
return
textobject = canvas.beginText()
textobject.setTextOrigin(inch, 2.5*inch)
textobject.setFont("Helvetica-Oblique", 14)
for line in lyrics:
textobject.textLine(line)
textobject.setFillGray(0.4)
textobject.textLines('''
With many apologies to the Beach Boys
and anyone else who finds this objectionable
''')
canvas.drawText(textobject)
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 cmyk in [(1,0,0,0), (0,1,0,0), (0,0,1,0), (0,0,0,1), (0,0,0,0)]:
c,m,y1,k = cmyk
canvas.setFillColorCMYK(c,m,y1,k)
canvas.rect(x+rdx, y+rdy, w, h, fill=1)
canvas.setFillColor(black)
canvas.drawCentredString(x+dx/2, y+texty, "c%s m%s y%s k%s"%cmyk)
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)
def render(canvas, bounding_box=False, pg=None):
assert canvas._pagesize == pagesizes.A4
# query setup
query = (
"SELECT othernames, surname, ticket_id, vip "
"FROM tickets "
"WHERE paid IS NOT NULL AND"
" printed IS NULL "
"ORDER BY user_id, surname, othernames"
)
cur = pg.cursor(True)
cur.execute(query)
# constants
start = (11.93 * units.mm, 24 * units.mm)
size = (41 * units.mm, 17.5 * units.mm)
delta = (48.35 * units.mm, 21.2 * units.mm)
count = (4, 12)
bar_height = size[1] / 4.0 - 1 * units.mm
bar_width = 0.71 * units.mm
coord_positions = [[start[n] + i * delta[n] for i in range(count[n])] for n in (0, 1)]
ticket_types = {
True: {"entry_time": "8:00pm", "type_string": "VIP"},
False: {"entry_time": "8:30pm", "type_string": "Standard"},
}
# position iterator stuff
positions = list(itertools.product(*coord_positions))
pos_enum = itertools.cycle(range(len(positions)))
# page counting
per_page = count[0] * count[1]
pages = cur.rowcount // per_page
if cur.rowcount % per_page:
pages += 1
page = 0
# util
def centred_text(canvas, x, y, row, what):
x_centre = x + size[0] / 2.0
canvas.saveState()
for font_size in range(12, 5, -1):
canvas.setFontSize(font_size)
if canvas.stringWidth(what) < size[0]:
break
else:
print("Warning: text", what, "too wide")
offset = row * size[1] / 4.0
canvas.drawCentredString(x_centre, y + offset, what)
canvas.restoreState()
# go
for pos_n, ticket in itertools.izip(pos_enum, cur):
if pos_n == 0:
if page != 0:
canvas.showPage()
page += 1
footer = "Barcodes page {0} of {1}".format(page, pages)
canvas.drawCentredString(pagesizes.A4[0] / 2.0, 20, footer)
ticket.update(ticket_types[ticket["vip"]])
name = "{othernames} {surname}".format(**ticket)
barcode_value = "{ticket_id:04d}".format(**ticket)
num_type = "{ticket_id:04d} {type_string}".format(**ticket)
entry_time = "Entry time: {entry_time}".format(**ticket)
x, y = positions[pos_n]
barcode = code128.Code128(barcode_value, barWidth=bar_width, barHeight=bar_height, quiet=False)
x_offset = (size[0] - barcode.width) / 2
if x_offset < 0:
raise ValueError("barcode too wide")
barcode.drawOn(canvas, x + x_offset, y + 2 * size[1] / 4.0)
centred_text(canvas, x, y, 3, name)
centred_text(canvas, x, y, 1, num_type)
centred_text(canvas, x, y, 0, entry_time)
if bounding_box:
canvas.setStrokeColor(colors.red)
canvas.rect(x, y, size[0], size[1], stroke=1, fill=0)
canvas.setStrokeColor(colors.black)
# last page
canvas.showPage()
# cleanup
cur.close()
def get_canvas(self, packet):
canvas = super(TaskPageMask, self).get_canvas(packet)
canvas.setStrokeColor(colors.black)
canvas.setFillColor(colors.white)
canvas.setLineWidth(0.2 * mm)
return canvas
def drawFirstPage(canvas, doc):
canvas.saveState()
# Title text
tobj = canvas.beginText()
tobj.setTextOrigin(doc.leftMargin, doc.pagesize[1]-doc.topMargin-24)
tobj.setFont('Helvetica-Bold', 32)
tobj.setLeading(22)
firstr = '/'.join(doc.firs)
tobj.textLine('NavPlot')
tobj.setFont('Helvetica', 16)
tobj.textLine('%s Navigation warnings for: %s' % (firstr, doc.dateStr))
canvas.drawText(tobj)
# Small print
canvas.setFont('Helvetica', 10)
canvas.drawString(doc.leftMargin, doc.bottomMargin,
"IMPORTANT: Do not rely on this map - check NOTAM's from an official "\
"source. Data "+UTF8_COPYRIGHT_SIGN+' '+doc.copyright_holder)
# Clipping rectangle for the map
path = canvas.beginPath()
path.rect(doc.leftMargin, doc.bottomMargin+doc.bottomOffset, doc.mapwidth,
doc.mapheight)
canvas.clipPath(path)
# Drawing style for the map
canvas.setLineWidth(0.5)
canvas.setFillColor(gray)
# Draw the other map stuff. Coordinate file must be in mapinfo format.
# Coast line from http://rimmer.ngdc.noaa.gov/mgg/coast/getcoast.html
moveFlag = True
path = canvas.beginPath()
map_data = doc.map_data
for lin in map_data.splitlines():
if lin[0] != '#':
lon, lat = map(float, lin.split('\t'))
x, y = doc.latlon2xy(lat, lon)
if moveFlag:
path.moveTo(x, y)
moveFlag = False
else:
path.lineTo(x, y)
else:
moveFlag = True
canvas.setStrokeColor(darkgray)
canvas.drawPath(path)
# Draw some gliding sites
canvas.setStrokeColor(gray)
delta = 2.5*mm
for gs in GLIDING_SITES:
x, y = doc.latlon2xy(*GLIDING_SITES[gs])
canvas.lines(((x, y+delta, x, y-delta), (x-delta, y, x+delta, y)))
canvas.drawString(x+mm, y+mm, gs)
# Draw NOTAM areas
canvas.setStrokeColor(blue)
canvas.setFillColor(black)
canvas.setLineWidth(0.5)
for n, notam in enumerate(doc.notams):
x, y = doc.latlon2xy(notam[0], notam[1])
radius = notam[2]/60.0*doc.scale
canvas.circle(x, y, radius)
if radius/mm < 3:
x1 = x + radius/1.41 + mm/2
y1 = y + radius/1.41 + mm/2
canvas.line(x, y, x1, y1)
canvas.drawString(x1, y1, str(n+1))
else:
canvas.drawCentredString(x, y-3, str(n+1))
canvas.restoreState()
