Python Canvas.drawRightString方法代码示例

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
 def test_06_fontsize(self):
     from reportlab.lib.pagesizes import A4
     from reportlab.pdfgen.canvas import Canvas
     from reportlab.lib.units import inch
     from reportlab.lib.colors import red, magenta
     c = Canvas('demo.pdf', pagesize=A4)
     c.translate(inch, inch)
     c.setFont("Times-Roman", 20)
     c.setFillColor(red)
     c.saveState()
     c.drawCentredString(2.75*inch, 2.5*inch,"Font size excmples")
     c.setFillColor(magenta)
     size = 7
     x = 2.3 * inch
     y = 1.3 * inch
     for line in range(7):
         c.setFont("Helvetica", size)
         c.drawRightString(x, y, "%s points" % size)
         c.drawString(x,y, "test")
         y = y-size*1.2
         size = size+1.5
     c.restoreState()
     c.drawString(0,0, "%s" % c.getAvailableFonts())
     c.showPage()
     c.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
 def generateOfficePDF(self,response):
     #Attach name.pdf file to responses content disposition
     response['Content-Disposition'] = 'attachment; filename=office.pdf'
     
     #Create empty pdf document, hook pdf with response
     pdf = Canvas(response) 
     
     #Get Todays Events
     brains = sorted(util.gatherTodaysEvents(self), key=attrgetter('location')) #so awesome, sorts on any attribute!
     brains = sorted(brains, key=attrgetter('start')) #even better a secondary sort.
     
     #Header: Title Information and Settings
     pdf.setFont("Helvetica-Bold", 12)
     pdf.setStrokeColorRGB(0, 0, 0) #sets Line/Rectangle Colors
     
     #Header Left Title
     if brains != None and len(brains) > 0:
         pdf.drawString(15, 810, DateTime(brains[0].start).strftime("%A, %B %d, %Y") + " Schedule")
     else:
         pdf.drawString(15, 810, "No Groups scheduled for " + datetime.datetime.now().strftime("%A, %B %d, %Y"))
         
     #Header Right Title
     pdf.drawRightString(575, 810, "GroupFinder")
     
     #Body: List of Groups and Settings
     index = 792 #Pixel Index, starting at the top of the pdf page
     page = 1 #Page Number
     
     for brain in brains:
         pdf.setFont("Helvetica", 12)
         pdf.setStrokeColorRGB(0, 0, 0) #sets Line/Rectangle Colors
         pdf.rect(10, index-20, 575, 30, stroke=1, fill=0) #Rectangle around each Group
         pdf.drawString(15, index-3, brain.Title) #Group Description
         
         l = self.locationLookup(brain.location)
         pdf.drawString(15, index-15, DateTime(brain.start).strftime("%I:%M %p") + 
                                      " - " + DateTime(brain.end).strftime("%I:%M %p") +
                                      " in " + l['Name']) 
         index -= 30 #Move Pixel Index downwards
         
         #Reach Bottom of page?  Creates New Page.
         if index < 30:
             pdf.drawString(15, 5, "Page " + str(page))#add page number pages
             pdf.drawCentredString(300, 5, "Created on " + datetime.datetime.now().strftime("%m/%d/%Y at %I:%M %p"))
             page+=1
             index = 792
             pdf.showPage() #next page
     
     #add page number pages
     pdf.drawString(15, 5, "Page " + str(page))
     
     #add date PDF was created
     pdf.drawCentredString(300, 5, "Created on " + datetime.datetime.now().strftime("%m/%d/%Y at %I:%M %p"))
                     
     pdf.showPage() #next page, finalize last page.
     
     pdf.save() #save the pdf content
     return response #return response with hooked pdf.

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
    def _on_other_page(self, canvas: Canvas, doc):
        canvas.saveState()
        canvas.setFont('OpenSans', 8)
        canvas.drawRightString(self.pagesize[0] - 20 * mm, 10 * mm, pgettext("invoice", "Page %d") % (doc.page,))

        for i, line in enumerate(self.invoice.footer_text.split('\n')[::-1]):
            canvas.drawCentredString(self.pagesize[0] / 2, 25 + (3.5 * i) * mm, line.strip())

        canvas.restoreState()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
def pdfout(parse, outfl, enableComments, font, page):
    if page.name == "A4":
        c = Canvas(outfl, pagesize=A4)
        width, height = A4
    else:
        c = Canvas(outfl, pagesize=letter)
        width, height = letter

    c.setFont('CourierPrime', 12)

    pgs = splitScriptText(parse, page, font, enableComments)

    if len(parse.titlePage) > 0:
        pdfTitlePage(c, parse, page, font)
        c.showPage()

    title = "UNTITLED"
    if "title" in parse.titlePage:
        title = " ".join(parse.titlePage["title"]).upper()

    for pgno in range(0, len(pgs)):
        c.setFont('CourierPrime', 12)
        if pgno > 0:
            c.drawRightString((page.width - page.marginRight) * inch, height - 0.5*inch, str(pgno+1)+".")
            c.drawString(page.marginLeft*inch, height - 0.5*inch, title)

        lineno = 0
        for e in pgs[pgno]:
            processPDFLine(c, e[0], e[1], lineno, page, font, width, height)
            lineno = lineno + 1

        c.showPage()



    c.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
class Reporter(object):
    def __init__(self,vapp):
        self.dataApp = vapp
        path = self.dataApp.repoPath + self.dataApp.rdataName + '.pdf'
        self.canvas = Canvas(path)
        self.page = 1

    def header(self):
        self.canvas.setFont("Helvetica", 10)  
        self.canvas.drawCentredString(4.135*inch, 10.74*inch, '[email protected] : ycroft.net')  
        self.canvas.setFont("Helvetica", 11.5)
        self.canvas.line(1*inch, 10.69*inch, 7.27*inch, 10.69*inch) 

    def footer(self):
        self.canvas.setFont("Helvetica", 11.5)
        self.canvas.line(1*inch, 1*inch, 7.27*inch, 1*inch)
        self.canvas.setFont("Helvetica", 10)  
        self.canvas.drawCentredString(4.135*inch, 0.83*inch, '- '+str(self.page)+' -')

    def cover(self,coverInfo):
        dataName = coverInfo.get('dataName','no name')
        author = coverInfo.get('author','no name')
        version = coverInfo.get('version','unknown')
        self.header()
        self.footer()
        self.canvas.setFont("Helvetica-Bold", 40)
        self.canvas.drawCentredString(4.135*inch, 7.5*inch, 'Analysis Report')
        self.canvas.setFont("Helvetica", 20)
        self.canvas.drawCentredString(4.135*inch, 6.8*inch, 'for data \'' + dataName + '\'')

        self.canvas.setFont("Helvetica", 15)
        self.canvas.drawRightString(3.935*inch, 4.4*inch, 'author:')
        self.canvas.drawRightString(3.935*inch, 3.9*inch, 'date:')
        self.canvas.drawRightString(3.935*inch, 3.4*inch, 'version:')
        self.canvas.drawString(4.335*inch, 4.4*inch, author)
        self.canvas.drawString(4.335*inch, 3.9*inch, str(datetime.now().strftime('%a, %b %d %H:%M')))
        self.canvas.drawString(4.335*inch, 3.4*inch, version)
        self.canvas.showPage()
        self.page += 1

    def body(self):
        self.header()
        self.footer()
        sdataName = self.dataApp.sdataName
        rdataName = self.dataApp.rdataName
        imgPath = './spec_data/img/'
        self.canvas.setFont("Helvetica-Bold", 15)
        self.canvas.drawString(1.25*inch, 10*inch, 'I. Modulation Factors ')
        self.canvas.setFont("Helvetica", 12)
        self.canvas.drawString(1.5*inch, 9.7*inch, 'These factors are derived from the file \''+sdataName+'\'')
        self.canvas.drawInlineImage(imgPath + sdataName + '_cs0.jpg',1.25*inch,5.3*inch,5.77*inch,4.33*inch)
        self.canvas.drawInlineImage(imgPath + sdataName + '_cs1.jpg',1.25*inch,1.2*inch,5.77*inch,4.33*inch)
        self.canvas.showPage()
        self.page += 1
        self.header()
        self.footer()
        self.canvas.drawInlineImage(imgPath + sdataName + '_cs2.jpg',1.25*inch,5.3*inch,5.77*inch,4.33*inch)
        self.canvas.drawInlineImage(imgPath + sdataName + '_cs3.jpg',1.25*inch,1.2*inch,5.77*inch,4.33*inch)
        self.canvas.showPage()
        self.page += 1
        self.header()
        self.footer()
        self.canvas.setFont("Helvetica-Bold", 15)
        self.canvas.drawString(1.25*inch, 10*inch, 'II. Measured Data & FFT ')
        self.canvas.setFont("Helvetica", 12)
        self.canvas.drawString(1.5*inch, 9.7*inch, 'The data is derived from the file \''+rdataName+'\', and each fft channel has been filtered.')
        self.canvas.drawInlineImage(imgPath + rdataName + '_rd.jpg',1.25*inch,5.3*inch,5.77*inch,4.33*inch)
        self.canvas.drawInlineImage(imgPath + rdataName + '_fft.jpg',1.25*inch,1.2*inch,5.77*inch,4.33*inch)
        self.canvas.showPage()
        self.page += 1
        self.header()
        self.footer()
        self.canvas.setFont("Helvetica-Bold", 15)
        self.canvas.drawString(1.25*inch, 10*inch, 'III. Modulation Signals ')
        self.canvas.setFont("Helvetica", 12)
        self.canvas.drawString(1.5*inch, 9.7*inch, 'These signals are derived by ifft on the corresponding channel.')
        self.canvas.drawInlineImage(imgPath + rdataName + '_fa0.jpg',1.25*inch,5.3*inch,5.77*inch,4.33*inch)
        self.canvas.drawInlineImage(imgPath + rdataName + '_fa1.jpg',1.25*inch,1.2*inch,5.77*inch,4.33*inch)
        self.canvas.showPage()
        self.page += 1
        self.header()
        self.footer()
        self.canvas.drawInlineImage(imgPath + rdataName + '_fa2.jpg',1.25*inch,5.3*inch,5.77*inch,4.33*inch)
        self.canvas.drawInlineImage(imgPath + rdataName + '_fa3.jpg',1.25*inch,1.2*inch,5.77*inch,4.33*inch)
        self.canvas.showPage()
        self.page += 1
        self.header()
        self.footer()
        self.canvas.setFont("Helvetica-Bold", 15)
        self.canvas.drawString(1.25*inch, 10*inch, 'IV. Stokes Vectors ')
        self.canvas.setFont("Helvetica", 12)
        self.canvas.drawString(1.5*inch, 9.7*inch, 'This can be figured out using modulation signals and modulation factors.')
        self.canvas.drawInlineImage(imgPath + rdataName + '_s0.jpg',1.25*inch,5.3*inch,5.77*inch,4.33*inch)
        self.canvas.drawInlineImage(imgPath + rdataName + '_s1.jpg',1.25*inch,1.2*inch,5.77*inch,4.33*inch)
        self.canvas.showPage()
        self.page += 1
        self.header()
        self.footer()
        self.canvas.drawInlineImage(imgPath + rdataName + '_s2.jpg',1.25*inch,5.3*inch,5.77*inch,4.33*inch)
        self.canvas.drawInlineImage(imgPath + rdataName + '_s3.jpg',1.25*inch,1.2*inch,5.77*inch,4.33*inch)
#.........这里部分代码省略.........

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]

#.........这里部分代码省略.........

        self.canvas.setFillColor(black)
        self.canvas.setFont("Helvetica-Bold", self.big_title_height)
        self.canvas.drawCentredString((self.width-self.margin)/2, self.height/3, title)
        self.canvas.setFont("Helvetica-Bold", self.frag_title_height)
        self.canvas.drawString(offset, self.height - offset, enterprise)

    def __getstate__(self):
        d = self.__dict__.copy()
        del d['canvas']
        return d

    def __setstate__(self, d):
        self.__dict__ = d
        self.canvas = Canvas(self.buf, pagesize=A4)

    def build(self):
        self.canvas.showPage()
        self.canvas.save()
        return self.buf

    def addGraph(self, title, columns, table, render):
        frags = self.page_frags
        for row, cols in enumerate(self.page_rows):
            frags -= cols
            if frags < 0:
                break

        if frags >= 0:
            self.addPage(self.page_title, self.page_rows)
            col = 0
            row = 0
            cols = self.page_rows[0]
        else:
            col = - frags - 1

        # You can read that? Not me.
        x = self.margin + self.frame_margin + (col+1) * self.frag_margin + \
            col * (self.width - 2*self.margin - 2*self.frame_margin - (col+1)*self.frag_margin) / cols
        y = self.margin + self.frame_margin + (row+1) * self.frag_margin + \
            row * (self.height - 2*self.margin - 2*self.frame_margin - self.title_height - 2*self.frag_margin) / len(self.page_rows)
        width = (self.width - 2*self.margin - 2*self.frame_margin - 2*cols*self.frag_margin) / cols
        height = (self.height - 2*self.margin - 2*self.frame_margin - self.title_height - 2*len(self.page_rows)*self.frag_margin) / len(self.page_rows)

        self.canvas.setFillColor(colors.GREEN1)
        self.canvas.roundRect(x, y, width, height, 7, stroke=0, fill=1)
        self.canvas.setFillColor(white)
        x += 1
        y += 1
        width -= 2
        height -= 2

        self.canvas.roundRect(x, y, width, height - self.frag_title_height, 7, stroke=0, fill=1)

        self.canvas.setFillColor(white)
        self.canvas.setFont("Helvetica", 3*self.frag_title_height/4)
        self.canvas.drawCentredString(x + width/ 2, y + height - 3*self.frag_title_height/4, title)

        self.page_frags += 1

        if len(table) > 0:
            klass = self.render[render]
            obj = klass(width, height - self.frag_title_height - 2*self.frame_margin, columns, table)

            r = obj.render()
            if isinstance(r, Drawing):
                renderPDF.draw(obj.render(), self.canvas, x, y + self.frame_margin)
            elif isinstance(r, Flowable):
                r.drawOn(self.canvas, x, y + height - self.frag_title_height - obj.height - self.frame_margin)

        else:
            pass
            #self.append(Paragraph(title, h2))
            #self.append(Paragraph('No data', h2))

            #self.append(KeepTogether([Paragraph(title, h2),
            #                          Paragraph('No data', h2)]))

    def addPage(self, title, rows=[1]):
        self.canvas.showPage()
        self.canvas.saveState()
        self.canvas.setLineWidth(2)
        self.canvas.setStrokeColor(colors.RED)
        self.canvas.roundRect(self.margin, self.margin,
                              self.width - self.margin*2,
                              self.height - self.margin*2,
                              20, stroke=1, fill=0)
        self.canvas.restoreState()
        self.canvas.setFillColor(colors.GREEN1)
        self.canvas.setFont("Helvetica-Bold", self.title_height/3)
        self.canvas.drawString(self.margin*2, self.height - self.margin - 4*self.title_height/5, title)
        self.canvas.setFont("Helvetica-Bold", self.title_height/3)
        self.canvas.drawRightString(self.width - self.margin*2, self.height - self.margin - 4*self.title_height/5, self.interval)
        self.page_num += 1
        self.canvas.setFont("Helvetica-Bold", 12)
        self.canvas.drawCentredString(self.width/2, 0, "Page %d" % self.page_num)

        self.page_title = title
        self.page_rows = rows
        self.page_frags = 0

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
    def render(self, outfile, font_name, font_size):
        """
        Render the binary heat map as a PDF to the file-like object or filename
        ``outfile``.  All text will be typeset in the font named ``font_name``
        at size ``font_size``.
        """
        c = Canvas(outfile)
        c.setFont(font_name, font_size)
        leftlen = max(map(c.stringWidth, self.row_labels)) + LABEL_PAD * 2
        toplen  = max(map(c.stringWidth, self.column_labels)) + LABEL_PAD * 2
        miny = self.rows * font_size * 1.2
        maxx = self.columns * font_size * 1.2
        c.setPageSize((leftlen + maxx + PADDING*2, miny + toplen + PADDING*2))
        # Set coordinates so that LL corner has coord (-leftlen-PADDING,
        # -miny-PADDING) and the origin is at the point where the borders of the
        # row & column labels meet:
        c.translate(leftlen+PADDING, miny+PADDING)

        lineheight = font_size * 1.2
        radius = lineheight / 3

        c.setFillColorRGB(*COL_BG_COLOR)
        for i in range(0, self.columns, 2):
            c.rect(
                i * lineheight,
                -miny,
                lineheight,
                miny + toplen,
                stroke=0,
                fill=1,
            )

        c.setFillColorRGB(*ROW_BG_COLOR)
        for i in range(2, self.rows+1, 2):
            # Yes, it starts at 2, so that the positive rectangle height will
            # make it fill row 1.
            c.rect(
                -leftlen,
                -i * lineheight,
                leftlen + maxx,
                lineheight,
                stroke=0,
                fill=1,
            )

        c.setFillColorRGB(0, 0, 0)
        c.line(0, toplen, 0, -miny)
        c.line(-leftlen, 0, maxx, 0)

        for i, label in enumerate(self.row_labels):
            c.drawRightString(
                -LABEL_PAD,
                -(i+1) * lineheight + font_size / 3,
                label,
            )

        for i, label in enumerate(self.column_labels):
            c.saveState()
            c.translate((i+1) * lineheight, 0)
            c.rotate(90)
            c.drawString(LABEL_PAD, font_size / 3, label)
            c.restoreState()

        for row, col in self.get_indexed_pairs():
            c.circle(
                (col+0.5) * lineheight,
                -(row+0.5) * lineheight,
                radius,
                stroke=0,
                fill=1,
            )

        c.showPage()
        c.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
can.setFillColorCMYK(.7,0,.5,0)                 # couleur de remplissage (CMJN)
can.ellipse(3*cm, 4*cm, 19*cm, 10*cm, fill=1)   # ellipse (! axes = 16 x 6 cm)
can.setLineWidth(1)                             # nouvelle épaisseur des lignes
can.ellipse(centreX -.5*cm, centreY -.5*cm,     # petit cercle indiquant la
            centreX +.5*cm, centreY +.5*cm)     # position du centre de la page

# Quelques textes, avec polices, orientation et alignement divers :
can.setFillColor("navy")                        # couleur des textes
texteC ="Petite pluie abat grand vent."         # texte à centrer
can.setFont("Times-Bold", 18)
can.drawCentredString(centreX, centreY, texteC)
texteG ="Qui ne risque rien, n'a rien."         # texte à aligner à gauche
can.setFont("Helvetica", 18)
can.drawString(centreX, centreY -1*cm, texteG)
texteD ="La nuit porte conseil."                # texte à aligner à droite
can.setFont("Courier", 18)
can.drawRightString(centreX, centreY -2*cm, texteD)
texteV ="L'espoir fait  vivre."                 # texte à disposer verticalement
can.rotate(90)
can.setFont("Times-Italic", 18)
can.drawString(centreY +1*cm, -centreX, texteV) # ! inversion des coordonnées !
texteE ="L'exception confirme la règle"         # texte à afficher en blanc
can.rotate(-90)                                 # retour à l'orientation horiz.
can.setFont("Times-BoldItalic", 28)
can.setFillColor("white")                       # nouvelle couleur des textes
can.drawCentredString(centreX, 7*cm, texteE)

can.save()                                      # Sauvegarde du résultat

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
    c.translate(0, -leading)
    c.drawString(0, 0, text.next())

c.translate(0, -20*mm)
c.drawString(-100*mm, 0, "Canvas.drawCentredString")
c.translate(0, -leading)
for i in range(2):
    c.translate(0, -leading)
    c.drawCentredString(0, 0, text.next())

c.translate(0, -20*mm)
c.drawString(-100*mm, 0, "Canvas.drawRightString")
c.translate(0, -leading)
for i in range(2):
    c.translate(0, -leading)
    c.drawRightString(0, 0, text.next())

c.translate(0, -20*mm)
c.drawString(-100*mm, 0, "Canvas.beginText (Text object)")
c.translate(0, -leading*2)

# Text objects are more efficient for anything more than simple labels
textobject = c.beginText()
textobject.setTextOrigin(0, 0)
textobject.setFont("Times-Italic", 10)

# supply text one line at a time:
for i in range(6):
    textobject.textLine(text.next())
textobject.textLine()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
def impr_recibo(request, pk):
    mitad = 14.8 * cm
    mita = 14.8
    # Inicializo todos los comprobantes y valores
    recibo = Recibo.objects.get(pk=pk)
    a_cuenta = recibo.a_cuenta
    # Datos de comprobantes
    comprobantes = recibo.detalle_cobro_set.all()
    # a_cuenta = recibo.cobranza_a_cuenta_set.all()
    # credito_anterior = recibo.cobranza_credito_anterior_set.all()
    # Datos de valores
    valores = recibo.dinero_set.all()
    # transferencia = recibo.transferenciabancariaentrante_set.all()
    # efectivo = recibo.dinero_set.all()
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = 'filename="somefilename.pdf"'
    p = Canvas(response, pagesize=A4)
    # Numero de recibo
    p.setFont('Helvetica-Bold', 16)
    p.drawString(15.7 * cm, 13 * cm, recibo.numero_full)
    # Fecha
    p.setFont('Helvetica', 13)
    p.drawString(17 * cm, 12 * cm, str(recibo.fecha.day))
    p.drawString(18 * cm, 12 * cm, str(recibo.fecha.month))
    p.drawString(19 * cm, 12 * cm, str(recibo.fecha.year))
    # Datos del cliente
    p.setFont('Helvetica', 13)
    p.drawString(12 * cm, 11 * cm, recibo.cliente.razon_social)
    p.drawString(12 * cm, 10.3 * cm, recibo.cliente.get_cond_iva_display())
    p.drawString(12 * cm, 9.8 * cm, "CUIT: %s" % recibo.cliente.cuit)
    p.drawString(12 * cm, 9.3 * cm, recibo.cliente.direccion)
    p.drawString(12 * cm, 8.8 * cm, "%s - %s" % (recibo.cliente.localidad, recibo.cliente.get_provincia_display()))
    inicio_y = 6.2
    alto_item = 0.4
    i = 0
    p.setFont('Helvetica', 7)
    if a_cuenta and a_cuenta > 0:
        p.drawString(3.4 * cm, (inicio_y - i * alto_item) * cm, "A cuenta")
        p.drawRightString(7.4 * cm, (inicio_y - i * alto_item) * cm, "%.2f" % a_cuenta)
        i += 1
    if recibo.credito_anterior and recibo.credito_anterior > 0:
        p.drawString(3.4 * cm, (inicio_y - i * alto_item) * cm, "Credito anterior")
        p.drawRightString(7.4 * cm, (inicio_y - i * alto_item) * cm, "-%.2f" % recibo.credito_anterior)
        i += 1
    for item in comprobantes:
        p.drawString(2 * cm, (inicio_y - i * alto_item) * cm, item.venta.tipo)
        p.drawString(3.4 * cm, (inicio_y - i * alto_item) * cm, item.venta.num_comp_full())
        p.drawString(5.1 * cm, (inicio_y - i * alto_item) * cm, item.venta.fecha_dd_mm_aaaa())
        p.drawRightString(7.4 * cm, (inicio_y - i * alto_item) * cm, item.monto_2d())
        i += 1
    # Cheques
    i = 0
    for item in valores:
        try:
            p.drawString(10 * cm, (inicio_y - i * alto_item) * cm, item.chequetercero.numero)
            p.drawString(11.7 * cm, (inicio_y - i * alto_item) * cm, item.chequetercero.cuit_titular)
            p.drawString(13.8 * cm, (inicio_y - i * alto_item) * cm, item.chequetercero.fecha_dd_mm_aaaa())
            p.drawString(15.4 * cm, (inicio_y - i * alto_item) * cm, item.chequetercero.banco.nombre[:20])
            p.drawRightString(20 * cm, (inicio_y - i * alto_item) * cm, "%.2f" % item.monto)
        except Dinero.DoesNotExist:
            try:
                item.transferenciabancariaentrante
                p.drawString(10 * cm, (inicio_y - i * alto_item) * cm, "Transferencia Bancaria")
                p.drawRightString(20 * cm, (inicio_y - i * alto_item) * cm, "%.2f" % item.monto)
            except Dinero.DoesNotExist:
                p.drawString(10 * cm, (inicio_y - i * alto_item) * cm,
                             "Efectivo" if item.monto >= 0 else "Efectivo - SU VUELTO")
                p.drawRightString(20 * cm, (inicio_y - i * alto_item) * cm, "%.2f" % item.monto)
        finally:
            i += 1
    # for item in transferencia:
    #    p.drawString(10*cm, (inicio_y-i*alto_item)*cm, "Transferencia Bancaria")
    #    p.drawRightString(20*cm, (inicio_y-i*alto_item)*cm, "%.2f" %item.monto)
    #    i+=1
    # for item in efectivo:
    #    p.drawString(10*cm, (inicio_y-i*alto_item)*cm, "Efectivo")
    #    p.drawRightString(20*cm, (inicio_y-i*alto_item)*cm, "%.2f" %item.monto)
    #    i+=1
    p.setFont('Helvetica-Bold', 12)
    p.drawString(7.5 * cm, 2.3 * cm, recibo.total_str)
    p.drawString(18 * cm, 2.3 * cm, recibo.total_str)
    try:
        letra = (to_word(int(recibo.total_str.split('.')[0].strip())) + "con " + to_word(
            int(recibo.total_str.split('.')[1].strip())) + "centavos").lower()
    except IndexError:
        letra = (to_word(int(recibo.total_str.split('.')[0].strip()))).lower()
    p.setFont('Helvetica', 9)
    p.drawString(2 * cm, 7.5 * cm, letra)
    ######################################################
    ##############RECIBO DUPLICADO########################
    ######################################################
    # Numero de recibo
    p.setFont('Helvetica-Bold', 16)
    p.drawString(15.7 * cm, mitad + 13 * cm, recibo.numero_full)
    # Fecha
    p.setFont('Helvetica', 13)
    p.drawString(17 * cm, mitad + 12 * cm, str(recibo.fecha.day))
    p.drawString(18 * cm, mitad + 12 * cm, str(recibo.fecha.month))
    p.drawString(19 * cm, mitad + 12 * cm, str(recibo.fecha.year))
    # Datos del cliente
#.........这里部分代码省略.........

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import drawRightString [as 别名]
    def _on_first_page(self, canvas: Canvas, doc):
        canvas.setCreator('pretix.eu')
        canvas.setTitle(pgettext('invoice', 'Invoice {num}').format(num=self.invoice.number))

        canvas.saveState()
        canvas.setFont('OpenSans', 8)
        canvas.drawRightString(self.pagesize[0] - 20 * mm, 10 * mm, pgettext("invoice", "Page %d") % (doc.page,))

        for i, line in enumerate(self.invoice.footer_text.split('\n')[::-1]):
            canvas.drawCentredString(self.pagesize[0] / 2, 25 + (3.5 * i) * mm, line.strip())

        textobject = canvas.beginText(25 * mm, (297 - 15) * mm)
        textobject.setFont('OpenSansBd', 8)
        textobject.textLine(pgettext('invoice', 'Invoice from').upper())
        canvas.drawText(textobject)

        self._draw_invoice_from(canvas)

        textobject = canvas.beginText(25 * mm, (297 - 50) * mm)
        textobject.setFont('OpenSansBd', 8)
        textobject.textLine(pgettext('invoice', 'Invoice to').upper())
        canvas.drawText(textobject)

        self._draw_invoice_to(canvas)

        textobject = canvas.beginText(125 * mm, (297 - 38) * mm)
        textobject.setFont('OpenSansBd', 8)
        textobject.textLine(pgettext('invoice', 'Order code').upper())
        textobject.moveCursor(0, 5)
        textobject.setFont('OpenSans', 10)
        textobject.textLine(self.invoice.order.full_code)
        canvas.drawText(textobject)

        textobject = canvas.beginText(125 * mm, (297 - 50) * mm)
        textobject.setFont('OpenSansBd', 8)
        if self.invoice.is_cancellation:
            textobject.textLine(pgettext('invoice', 'Cancellation number').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(self.invoice.number)
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Original invoice').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(self.invoice.refers.number)
        else:
            textobject.textLine(pgettext('invoice', 'Invoice number').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(self.invoice.number)
        textobject.moveCursor(0, 5)

        if self.invoice.is_cancellation:
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Cancellation date').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(date_format(self.invoice.date, "DATE_FORMAT"))
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Original invoice date').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(date_format(self.invoice.refers.date, "DATE_FORMAT"))
            textobject.moveCursor(0, 5)
        else:
            textobject.setFont('OpenSansBd', 8)
            textobject.textLine(pgettext('invoice', 'Invoice date').upper())
            textobject.moveCursor(0, 5)
            textobject.setFont('OpenSans', 10)
            textobject.textLine(date_format(self.invoice.date, "DATE_FORMAT"))
            textobject.moveCursor(0, 5)

        canvas.drawText(textobject)

        if self.invoice.event.settings.invoice_logo_image:
            logo_file = self.invoice.event.settings.get('invoice_logo_image', binary_file=True)
            ir = ThumbnailingImageReader(logo_file)
            try:
                ir.resize(25 * mm, 25 * mm, 300)
            except:
                logger.exception("Can not resize image")
                pass
            canvas.drawImage(ir,
                             95 * mm, (297 - 38) * mm,
                             width=25 * mm, height=25 * mm,
                             preserveAspectRatio=True, anchor='n',
                             mask='auto')

        def shorten(txt):
            txt = str(txt)
            p = Paragraph(txt.strip().replace('\n', '<br />\n'), style=self.stylesheet['Normal'])
            p_size = p.wrap(65 * mm, 50 * mm)

            while p_size[1] > 2 * self.stylesheet['Normal'].leading:
                txt = ' '.join(txt.replace('…', '').split()[:-1]) + '…'
                p = Paragraph(txt.strip().replace('\n', '<br />\n'), style=self.stylesheet['Normal'])
                p_size = p.wrap(65 * mm, 50 * mm)
            return txt
#.........这里部分代码省略.........