Python Canvas.line方法代码示例

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
def generate_certificate(description_of_items,cost_of_items,amount,cost,qty,raise_for,request ):

    buffer = BytesIO()
    styleSheet = getSampleStyleSheet()
    style = styleSheet['Normal']
    canv = Canvas('my_pdf.pdf')
    canv.setFillColorRGB(0, 0, 255)
    canv.setFont('Helvetica-Bold', 44, leading=None)
    canv.drawCentredString(102, 800, "INVOICE")
    canv.setFont('Helvetica-Bold', 8, leading=None)
    #canv.drawCentredString(38, 824, "From:")
    b = Company_credentials.objects.get(user=request.user)
    canv.setFillColorRGB(0, 0, 255)
    canv.drawCentredString(480, 826, b.company_name)
    canv.drawCentredString(480, 813, b.email)
    canv.drawCentredString(480, 801, b.country + ',' + b.phone_number)
    #canv.drawCentredString(480, 790, b.email)
    canv.setFillColorRGB(0, 0, 0)

    canv.drawCentredString(480, 790, "Raised on:" + str(datetime.date.today()) )
    canv.line(0, 785, 800, 785)
    canv.setFont('Helvetica', 21, leading=None)
    canv.setFillColorRGB(0, 0, 255)
    canv.drawCentredString(68, 760, "Description:")
    canv.setFillColorRGB(0, 0, 0)
    canv.setFont('Helvetica-Bold', 14, leading=None)
    canv.drawCentredString(120, 730, "ITEMS")
    canv.drawCentredString(320, 730, "RATE")
    canv.drawCentredString(410, 730, "QTY")
    canv.drawCentredString(500, 730, "AMOUNT")
    canv.setFont('Helvetica', 8, leading=None)
    y_coordinate = 710
    chaska = 0
    length = len(description_of_items)
    for chaska in range(length):
        canv.drawCentredString(120, y_coordinate,description_of_items[chaska])
        canv.drawCentredString(320, y_coordinate, str(cost_of_items[chaska]))
        canv.drawCentredString(410, y_coordinate, str(qty[chaska]))
        canv.drawCentredString(500, y_coordinate, '$' + str(amount[chaska]))
        y_coordinate = y_coordinate - 15
    y_coordinate = y_coordinate - 25
    canv.line(310, y_coordinate, 580, y_coordinate)
    canv.setFont('Helvetica-Bold', 12, leading=None)
    canv.drawCentredString(410, y_coordinate-16, "Total")
    canv.drawCentredString(500, y_coordinate-16, '$' + str(cost))
    canv.setFillColorRGB(0,0,255)
    canv.setFont('Helvetica', 16, leading=None)
    canv.drawCentredString(55, y_coordinate-16, "Raised For:")
    canv.setFillColorRGB(0, 0, 0)
    P = Paragraph(raise_for, style)
    aW = 180
    aH = y_coordinate-46
    w, h = P.wrap(aW, aH)  # find required space
    if w <= aW and h <= aH:
        P.drawOn(canv, 12, aH)
        aH = aH - h  # reduce the available height
    canv.save()
    pdf = buffer.getvalue()
    buffer.close()
    return pdf

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
def draw(list):
    #声明Canvas类对象，传入的就是要生成的pdf文件名字
    for plot in list:


        can = Canvas('report.pdf')
        can.line(plot[0],plot[1],plot[2],plot[1])#最上面的横线
        can.line(plot[0],plot[3],plot[2],plot[3])#最下面的横线
        can.line(plot[0],plot[1],plot[0],plot[3])#最左面的横线
        can.line(plot[2],plot[1],plot[2],plot[3])#最右面的横线



        can.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
 def test_03_draw(self):
     from reportlab.lib.pagesizes import A4
     from reportlab.pdfgen.canvas import Canvas
     from reportlab.lib.units import inch
     c = Canvas('demo.pdf', pagesize=A4)
     c.translate(inch,inch)
     c.setFont("Helvetica", 14)
     c.setStrokeColorRGB(0.2,0.5,0.3)
     c.setFillColorRGB(1,0,1)
     c.line(0,0,0,1.7*inch)
     c.line(0,0,1*inch,0)
     c.rect(0.2*inch, 0.2*inch, 1*inch, 1.5*inch,fill=1)
     c.rotate(90)
     c.setFillColorRGB(0,0,0.77)
     c.drawString(0.3*inch, -inch, "Hello World")
     c.showPage()
     c.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
    def _build_omr_layer(marks):
        padding_x = 4.2 * mm
        padding_y = 8.5 * mm
        top_mark_x = 7 * mm
        top_mark_y = 220 * mm
        mark_y_spacing = 4 * mm

        mark_width = 6.5 * mm
        marks_height = (len(marks) - 1) * mark_y_spacing

        logger.info('Mailer DS-75i OMR Settings: 1={} 2={}'.format(
            (297 * mm - top_mark_y) / mm,
            (top_mark_x + mark_width / 2) / mm + 0.5
        ))

        omr_buffer = StringIO.StringIO()
        omr_canvas = Canvas(omr_buffer)
        omr_canvas.setLineWidth(0.2 * mm)

        # add a white background for the omr code
        omr_canvas.setFillColor(white)
        omr_canvas.rect(
            x=top_mark_x - padding_x,
            y=top_mark_y - marks_height - padding_y,
            width=mark_width + 2 * padding_x,
            height=marks_height + 2 * padding_y,
            fill=True,
            stroke=False
        )

        for offset, mark in enumerate(marks):
            mark_y = top_mark_y - offset * mark_y_spacing
            if mark:
                omr_canvas.line(top_mark_x, mark_y,
                                top_mark_x + mark_width, mark_y)

        # Close the PDF object cleanly.
        omr_canvas.showPage()
        omr_canvas.save()

        # move to the beginning of the StringIO buffer
        omr_buffer.seek(0)
        omr_pdf = PdfFileReader(omr_buffer)

        return omr_pdf.getPage(0)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
    def create_prod_labels(self):
        """
        These values should be measured from the printed page.
        In all the following calculations, the bottom left corner of
        the page is considered to be at the origin of the x-y plane.
        All the coordinates should be provided w.r.t. the this origin.
        """
        # page size
        page_H = 297*mm  # A4
        page_W = 210*mm   # A4
        # coordinates of lower left corner of single label w.r.t. origin
        box_X = 16.5*mm
        box_Y = 9.6*mm
        # distance between rows and columns of labels
        box_X_shift = 46.2*mm
        box_Y_shift = 36.0*mm

        pdfmetrics.registerFont(TTFont('Arial', 'ARIALN.TTF'))
        c = Canvas(self.outFile)
        c.setLineWidth(0.1)

        # horizontal lines
        for i in range(7):
            c.line(42*mm + i*box_Y_shift, 10*mm,
                   42*mm + i*box_Y_shift, page_W-10*mm)
        # vertical lines
        for i in range(3):
            c.line(2*mm, 58*mm + i*box_X_shift,
                   page_H-2*mm, 58*mm + i*box_X_shift)

        for i in range(4):
            dx = box_X + i*box_X_shift
            for j in range(8):
                dy = box_Y + j*box_Y_shift
                self.draw_single_label(dy, dx, c)

        c.setPageRotation(90)
        c.setPageSize((page_W, page_H))
        c.save()
        self.message.setText(
            "Creating " + self.outFile.replace(self.cdir, "Documents/"))

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
def grid_overlay(infile, outfile=sys.stdout, pagesize=letter, lpi=10):
    """Read PDF file 'infile'. Generates a new PDF file to 'outfile'
    containing the first page (only) of infile, with a 'lpi' grid
    overlaid.
    """

    c = Canvas(outfile, pagesize=pagesize)

    pdf = PdfReader(infile)
    xobj = pagexobj(pdf.pages[0])
    rlobj = makerl(c, xobj)

    c.doForm(rlobj)

    xmax = 9
    ymax = 12

    thickline = 0.5
    thinline = 0.1

    for x in range(0, xmax):
        c.setLineWidth(thickline)
        for xx in range(0, lpi):
            x0 = (x + (float(xx) / lpi)) * inch
            c.line(x0, 0, x0, ymax * inch)
            c.setLineWidth(thinline)

    for y in range(0, ymax):
        c.setLineWidth(thickline)
        for yy in range(0, lpi):
            y0 = (y + (float(yy) / lpi)) * inch
            c.line(0, y0, xmax * inch, y0)
            c.setLineWidth(thinline)

    c.showPage()
    c.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
    def drawboxes(self, outfilename, gluefunc=None, startpage=0,
                  pagecount=None, counters=None, metrics=None):
        """Create a copy of the parsed PDF file, but with the textboxes
        created by ``gluefunc`` clearly marked, and metrics shown on
        the page.

        .. note::

           This requires PyPDF2 and reportlab, which aren't installed
           by default. Reportlab (3.*) only works on py27+ and py33+

        """
        try:
            import PyPDF2
            from reportlab.pdfgen.canvas import Canvas
        except ImportError:
            raise ImportError("You need PyPDF2 and reportlab installed")
        styles = {}
        for k, v in metrics.items():
            if isinstance(v, dict):
                styles[(v['family'], v['size'])] = k
        packet = None
        output = PyPDF2.PdfFileWriter()
        fp = open(self.pdf.filename, "rb")
        existing_pdf = PyPDF2.PdfFileReader(fp)
        pageidx = 0
        tbidx = 0
        sf = 2 / 3.0  # scaling factor -- mapping between units produced by
        # pdftohtml and units used by reportlab
        dirty = False

        for tb in self.pdf.textboxes(gluefunc, pageobjects=True):
            if isinstance(tb, Page):
                if dirty:
                    canvas.save()
                    packet.seek(0)
                    new_pdf = PyPDF2.PdfFileReader(packet)
                    # print("Merging a new page into %s" % id(existing_page))

                    # this SHOULD place the new page (that only
                    # contains boxes and lines) on top of the existing
                    # page. Only problem is that the image (from the
                    # existing page) obscures those lines (contrary to
                    # documentation)
                    try:
                        new_page = new_pdf.getPage(0)
                        existing_page.mergePage(new_page)
                    except Exception as e:
                        self.log.error("Couldn't merge page %s: %s: %s" % (pageidx, type(e), e))
                    output.addPage(existing_page)

                    # alternate way: merge the existing page on top of
                    # the new. This doesn't seem to work any better,
                    # and creates issues with scaling.
                    #
                    # new_page = new_pdf.getPage(0)
                    # new_page.mergePage(existing_page)
                    # output.addPage(new_page)

                # print("Loading page %s" % pageidx)
                existing_page = existing_pdf.getPage(pageidx)
                pageidx += 1
                mb = existing_page.mediaBox
                horizontal_scale = float(mb.getHeight()) / tb.height
                vertical_scale = float(mb.getWidth()) / tb.width
                self.log.debug(
                    "Loaded page %s - Scaling %s, %s" %
                    (pageidx, horizontal_scale, vertical_scale))
                packet = BytesIO()
                canvas = Canvas(packet, pagesize=(tb.height, tb.width),
                                bottomup=False)
                # not sure how the vertical value 50 is derived...
                canvas.translate(0, 50)
                canvas.scale(horizontal_scale, vertical_scale)
                canvas.setStrokeColorRGB(0.2, 0.5, 0.3)

                # now draw margins on the page
                for k, v in metrics.items():
                    if isinstance(v, int):
                        if k in ('topmargin', 'bottommargin', 'pageheight'):
                            # horiz line
                            canvas.line(0, v, tb.width, v)
                            canvas.drawString(0, v, k)
                        else:
                            if ((k.endswith("_even") and (pageidx + 1) % 2 == 1) or
                                    (not k.endswith("_even") and (pageidx + 1) % 2 == 0) or
                                    (not self.twopage)):
                                # vert line
                                canvas.line(v, 0, v, tb.height)
                                canvas.drawString(v, tb.height - 2, k)
                # for k, v in counters:
                # for each area in header, footer, leftmarg[_even], rightmarg[_even]:
                #    select proper counter to draw in each area:
                #      (headercounter->left gutter,
                #       footercounter->right gutter,
                #       leftmargcounter->header,
                #       rightmargcounter->footer)
                #   find the most frequent value in the selected counter, normalize agaist the space in the area
                #   for each value of the counter draw single-width line at correct posiion
                tbidx = 0
#.........这里部分代码省略.........

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
def formboleto(response,sacado,endereco,endereco1,valor,vencimento_date,nossonumero,observacao2):
    #temporarios
    #nossonumero = '99999998'
    #valor = '1,00'
    vencimento = vencimento_date.strftime('%d/%m/%Y')
    v = valor.replace(',','')
    fator = diff_date(vencimento_date)
    linhadigitavel = mount_line(banco,'9',carteira,agencia,nossonumero,fator,v)
    nossonumero += '-'+str(calc_our_number(ag+conta+carteira+nossonumero))
    boleto=Canvas(response)
    
    # Logomarca da empresa
    boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/empresa.jpg', x=7*mm, y=280*mm, width=30*mm, height=11*mm)
    
    boleto.setStrokeColor(colors.black)
    boleto.setLineWidth(0.1)
    boleto.setFont('Helvetica-Bold',14)
    global localpagamento, usobanco
  
  
    if banco=='237':
# bradesco
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancobradesco.jpg',x=160*mm, y=280*mm, width=25*mm, height=8*mm)
        
        # imagem do recido do sacado
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancobradesco.jpg',x=7*mm, y=229*mm, width=25*mm, height=8*mm)
        
        # imagem do banco na ficha de compensação
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancobradesco.jpg',x=7*mm, y=112*mm, width=25*mm, height=8*mm)
        
        # codigo do banco
        boleto.drawString(43*mm, 229*mm, '237-9')
        boleto.drawString(43*mm, 112*mm, '237-9')
        
        localpagamento+='Banco BRADESCO S/A'
        
        usobanco='269'
        #LINHADIGITAVEL='2379.264712 90600.000336 23007.514005 5 33070000011402'
        #CODIGOBARRA='23795330700000114022647190600000332300751400'
  
    elif banco=='422':
        # safra
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancosafra.jpg',x=160*mm, y=275*mm, width=32*mm, height=7*mm)
        
        # imagem do recido do sacado
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancosafra.jpg',x=7*mm, y=229*mm, width=30*mm, height=6*mm)
        
        # imagem do banco na ficha de compensação
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancosafra.jpg',x=7*mm, y=112*mm, width=30*mm, height=6*mm)
        
        # codigo do banco
        boleto.drawString(43*mm, 229*mm, '422-7')
        boleto.drawString(43*mm, 112*mm, '422-7')
          
        localpagamento+='Banco SAFRA'

    elif banco=='341':
        # itau
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancoitau.jpg',x=160*mm, y=275*mm, width=32*mm, height=7*mm)
        
        # imagem do recido do sacado
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancoitau.jpg',x=7*mm, y=229*mm, width=30*mm, height=6*mm)
        
        # imagem do banco na ficha de compensação
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancoitau.jpg',x=7*mm, y=112*mm, width=30*mm, height=6*mm)
        
        # codigo do banco
        boleto.drawString(43*mm, 229*mm, '341-7')
        boleto.drawString(43*mm, 112*mm, '341-7')
        
        #localpagamento+='Banco ITAU'
      
    else:
        # banco do brasil para default
        # imagem do canhoto
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancodobrasil.jpg',x=160*mm, y=280*mm, width=30*mm, height=5*mm)
        
        # imagem do recido do sacado
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancodobrasil.jpg',x=7*mm, y=229*mm, width=30*mm, height=5*mm)
        
        # imagem do banco na ficha de compensação
        boleto.drawImage(image=MEDIA_URL+'/alagoasdigital/logos/bancodobrasil.jpg',x=7*mm, y=112*mm, width=30*mm, height=5*mm)
        
        # codigo do banco
        boleto.drawString(43*mm, 229*mm, '001-9')
        boleto.drawString(43*mm, 112*mm, '001-9')
        localpagamento+='Banco do BRASIL S/A'
        
        
        # telefone da empresa
        boleto.setFont('Helvetica-Bold', 12)
        boleto.drawString(7*mm, 275*mm, telefone_empresa)
    
    
    ###############
    #RETICULAS DO VENCIMENTO E DO VALOR 
    #           (NÃO RETIRAR DAQUI SENÃO SOBREPORÁ O VALOR E O VENCIMENTO)
    
    # Recibo do sacado
    # retícula com cinza (Vencimento)
#.........这里部分代码省略.........

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [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 line [as 别名]
class InvoiceTemplate(object):

    def __init__(self, filename, logo_filename=LOGO_FILENAME,
                 from_address=Address(**settings.INVOICE_FROM_ADDRESS),
                 to_address=None, project_name='',
                 invoice_date=None, invoice_number='',
                 terms=settings.INVOICE_TERMS,
                 due_date=None, date_start=None, date_end=None,
                 bank_name=settings.BANK_NAME,
                 bank_address=Address(**settings.BANK_ADDRESS),
                 account_number=settings.BANK_ACCOUNT_NUMBER,
                 routing_number_ach=settings.BANK_ROUTING_NUMBER_ACH,
                 routing_number_wire=settings.BANK_ROUTING_NUMBER_WIRE,
                 swift_code=settings.BANK_SWIFT_CODE,
                 applied_credit=None,
                 subtotal=None, tax_rate=None, applied_tax=None, total=None,
                 is_wire=False, is_prepayment=False):
        self.canvas = Canvas(filename)
        self.canvas.setFontSize(DEFAULT_FONT_SIZE)
        self.logo_filename = os.path.join(os.getcwd(), logo_filename)
        self.from_address = from_address
        self.to_address = to_address
        self.project_name = project_name
        self.invoice_date = invoice_date
        self.invoice_number = invoice_number
        self.terms = terms
        self.due_date = due_date
        self.date_start = date_start
        self.date_end = date_end
        self.bank_name = bank_name
        self.bank_address = bank_address
        self.account_number = account_number
        self.routing_number_ach = routing_number_ach
        self.routing_number_wire = routing_number_wire
        self.swift_code = swift_code
        self.applied_credit = applied_credit
        self.subtotal = subtotal
        self.tax_rate = tax_rate
        self.applied_tax = applied_tax
        self.total = total
        self.is_wire = is_wire
        self.is_prepayment = is_prepayment

        self.items = []

    def add_item(self, description, quantity, unit_cost, subtotal, credits, total):
        self.items.append(PdfLineItem(description, quantity, unit_cost,
                                      subtotal, credits, total))

    def get_pdf(self):
        self.draw_logo()
        self.draw_from_address()
        self.draw_to_address()
        self.draw_project_name()
        if not self.is_prepayment:
            self.draw_statement_period()
        self.draw_invoice_label()
        self.draw_details()
        if not self.is_wire or self.is_prepayment:
            self.draw_table()
        self.draw_footer()

        self.canvas.showPage()
        self.canvas.save()

    def draw_logo(self):
        self.canvas.drawImage(self.logo_filename, inches(0.5), inches(2.5),
                              width=inches(1.5), preserveAspectRatio=True)

    def draw_text(self, string, x, y):
        text = self.canvas.beginText()
        text.setTextOrigin(x, y)
        for line in string.split('\n'):
            text.textLine(line)
        self.canvas.drawText(text)

    def draw_from_address(self):
        if self.from_address is not None:
            self.draw_text(unicode(self.from_address), inches(3), inches(11))

    def draw_to_address(self):
        origin_x = inches(1)
        origin_y = inches(9.2)
        self.canvas.translate(origin_x, origin_y)

        left = inches(0)
        right = inches(4.5)
        top = inches(0.3)
        middle_horizational = inches(0)
        bottom = inches(-1.7)
        self.canvas.rect(left, bottom, right - left, top - bottom)

        self.canvas.setFillColorRGB(*LIGHT_GRAY)
        self.canvas.rect(left, middle_horizational, right - left,
                         top - middle_horizational, fill=1)

        self.canvas.setFillColorRGB(*BLACK)
        self.draw_text("Bill To", left + inches(0.2),
                       middle_horizational + inches(0.1))

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

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
c = Canvas("04_03_low_level_pdf_operations_II.pdf", pagesize=(210*mm, 297*mm))
text_file = open("04_02_The_Raven.txt")
text = (l.strip() for l in text_file if l.strip())

c.setFontSize(10)
leading = 14 # line spacing.

c.saveState()

# translate halfway across page
c.translate(105*mm, 0) 

# draw a light grey vertical line 
c.setStrokeColorRGB(255, 0, 0)
c.line(0, 0, 0, 297*mm)

# move up the page
c.translate(0, 260*mm)

c.drawString(-100*mm, 0, "Canvas.drawString")
c.translate(0, -leading)
for i in range(2):
    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)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        response = HttpResponse(content_type='application/pdf')
        response['Content-Disposition'] = 'attachment; filename="{0}-{1}.pdf"'.format(self.object.registru.serie, self.object.numar_inregistrare)

        pdf = Canvas(response, pagesize = A4)

        import os
        from reportlab.lib.styles import getSampleStyleSheet
        from reportlab.platypus import Paragraph

        pdfmetrics.registerFont(TTFont("DejaVuSans-Bold", "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans-Bold.ttf"))
        pdfmetrics.registerFont(TTFont("DejaVuSans", "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf"))

        if self.object.registru.centru_local.antet:
            antet_path = os.path.join(settings.MEDIA_ROOT, "%s" % self.object.registru.centru_local.antet)
            pdf.drawInlineImage(antet_path, 2.5 * cm, 10.8 * cm, width=16. * cm, height=2.66 * cm)
            pdf.drawInlineImage(antet_path, 2.5 * cm, 24.5 * cm, width=16. * cm, height=2.66 * cm)
        pdf.setStrokeColorRGB(0, 0, 0)
        pdf.rect(2. * cm, 2. * cm, 17. * cm, 12. * cm)
        pdf.rect(2. * cm, 15.7 * cm, 17. * cm, 12 * cm)

        pdf.setStrokeColorRGB(0.5, 0.5, 0.5)
        pdf.setDash(1, 2)
        pdf.line(0 * cm, 14.85 * cm, 21. * cm, 14.85 * cm)

        pdf.setFont("DejaVuSans-Bold", 0.5 * cm, leading=None)
        pdf.drawCentredString(10.5 * cm, 9.5 * cm, u"Chitanță")
        pdf.drawCentredString(10.5 * cm, 23.2 * cm, u"Chitanță")

        text_serie = u"seria {0}, nr. {1} / {2}".format(self.object.registru.serie, self.object.numar_inregistrare,
                                                       self.object.data_inregistrare.strftime("%d.%m.%Y"))

        pdf.setFont("DejaVuSans-Bold", 4. * cm, leading=None)
        pdf.setFillColorRGB(0.95, 0.95, 0.95)
        pdf.rotate(15)
        pdf.drawString(4.5 * cm, 2. * cm, u"COPIE")
        pdf.rotate(-15)

        pdf.setFillColorRGB(0, 0, 0)
        pdf.setFont("DejaVuSans", 0.35 * cm, leading=None)
        pdf.drawCentredString(10.5 * cm, 8.9 * cm, text_serie)
        pdf.drawCentredString(10.5 * cm, 22.6 * cm, text_serie)

        reprezinta = self.object.descriere
        if hasattr(self.object, "chitantacotizatie"):
            reprezinta = []
            for p in self.object.chitantacotizatie.platacotizatietrimestru_set.all().order_by("index"):
                date_reprezinta = (p.trimestru.__unicode__(), p.suma, u"- parțial" if p.partial else "")
                reprezinta.append("{0} ({1} RON{2})".format(*date_reprezinta))
            reprezinta = ", ".join(reprezinta)
            reprezinta = u"cotizație membru pentru {0}".format(reprezinta)
        date_chitanta = (self.object.platitor().__unicode__(), self.object.suma, suma2text(self.object.suma).strip(), reprezinta)
        text_chitanta = u"Am primit de la <strong>{0}</strong> suma de {1} lei, adică {2}, reprezentând {3}.".format(*date_chitanta)

        style_sheet = getSampleStyleSheet()
        style = style_sheet['Normal']
        style.alignment = TA_JUSTIFY
        style.fontName = "DejaVuSans"
        style.leading = 0.85 * cm

        paragraph = Paragraph(text_chitanta, style)
        w, h  = paragraph.wrap(15. * cm, 5. * cm)
        # print w, h

        paragraph.drawOn(pdf, 3. * cm, 5.5 * cm)
        paragraph.drawOn(pdf, 3. * cm, 19.2 * cm)

        pdf.drawString(12.5 * cm, 4.5 * cm, u"Casier,")
        pdf.drawString(12.5 * cm, 18.2 * cm, u"Casier, ")

        trezorier = self.object.registru.centru_local.ocupant_functie(u"Trezorier Centru Local")
        pdf.drawString(12.5 * cm, 3.8 * cm, trezorier.__unicode__())
        pdf.drawString(12.5 * cm, 17.5 * cm, trezorier.__unicode__())


        pdf.showPage()
        pdf.save()

        return response

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

#.........这里部分代码省略.........
            self.pdf.setFont("Helvetica-Bold", 9)
            self.pdf.drawString(1*inch, self.location*inch,
                                developer.kerb_name)
            self.__drawLineDataWithPer(data[developer], args[1])
        self.location -= 0.5

    def __doubleLayer(self, title, data):
        self.__sectionHead(title)
        for project in data:
            branchData = data[project]
            self.location -= 0.15
            self.__checkBottom(title)
            self.pdf.setFont("Helvetica", 9)
            self.pdf.drawString(1*inch, self.location*inch, project.name)
            self.location -= 0.15
            for branchItem in branchData:
                self.__checkBottom(title)
                for branch in branchItem:
                    self.pdf.setFont("Helvetica-Bold", 9)
                    self.pdf.drawString(1.3*inch, self.location*inch,
                                        branch.name)
                    self.__drawLineData(branchItem[branch])
                self.location -= 0.15
        self.location -= 0.5

    def __tribleLayer(self, title, data):
        self.__sectionHead(title)
        for developer in data:
            projectData = data[developer]
            self.__checkBottom(title)
            self.pdf.setFont("Helvetica", 9)
            self.location -= 0.15
            self.pdf.drawString(1*inch, self.location*inch,
                                developer.kerb_name)
            for project in projectData:
                branchData = projectData[project]
                self.location -= 0.15
                self.__checkBottom(title)
                self.pdf.setFont("Helvetica-Bold", 9)
                self.pdf.drawString(1.3*inch, self.location*inch, project.name)
                for branchItem in branchData:
                    self.__checkBottom(title)
                    self.pdf.setFont("Helvetica-Bold", 9)
                    self.location -= 0.15
                    for branch in branchItem:
                        self.pdf.drawString(1.5*inch, self.location*inch,
                                            branch.name)
                        self.__drawLineData(branchItem[branch])
            self.location -= 0.1
            self.pdf.line(1*inch, self.location*inch,
                          7.5*inch, self.location*inch)
        self.location -= 0.5

    def __drawLineData(self, lineData):
        x_value = 3.8
        self.pdf.drawString(x_value*inch, self.location*inch,
                            str(lineData.commit))
        self.pdf.drawString((x_value+1)*inch, self.location*inch,
                            str(lineData.line))
        self.pdf.drawString((x_value+2)*inch, self.location*inch,
                            str(lineData.added))
        self.pdf.drawString((x_value+3)*inch, self.location*inch,
                            str(lineData.deleted))

    def __drawLineDataWithPer(self, lineData, commitCount):
        x_value = 3.8
        self.pdf.drawString(x_value*inch, self.location*inch,
                            str(lineData.commit))
        self.pdf.drawString(
            (x_value+0.35)*inch,
            self.location*inch,
            "(%.0f%%)" % (float(lineData.commit)/float(commitCount)*100)
        )
        self.pdf.drawString((x_value+1)*inch, self.location*inch,
                            str(lineData.line))
        self.pdf.drawString((x_value+2)*inch, self.location*inch,
                            str(lineData.added))
        self.pdf.drawString((x_value+3)*inch, self.location*inch,
                            str(lineData.deleted))

    def __sectionHead(self, title):
        self.__checkBottom(title)
        self.pdf.setFont("Helvetica-Bold", 11.5)
        self.pdf.drawString(1*inch, self.location*inch, title)
        self.location -= 0.1
        self.pdf.line(1*inch, self.location*inch, 7.5*inch, self.location*inch)
        self.location -= 0.15
        self.pdf.drawString(1*inch, self.location*inch, "Name")
        self.pdf.drawString(3.8*inch, self.location*inch, "Commits")
        self.pdf.drawString(4.8*inch, self.location*inch, "Lines")
        self.pdf.drawString(5.8*inch, self.location*inch, "Added(+)")
        self.pdf.drawString(6.8*inch, self.location*inch, "Deleted(-)")
        self.location -= 0.25
        self.__checkBottom(title)

    def __checkBottom(self, title):
        if self.location <= 1.5:
            self.pdf.showPage()
            self.location = self.startLocation
            self.__sectionHead(title)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
# Compose new pdf
canvas = Canvas(output_file)

for page_num, page in enumerate(pages, start=1):

    # Add page
    canvas.setPageSize((page.BBox[2], page.BBox[3]))
    canvas.doForm(makerl(canvas, page))

    # Draw footer
    footer_text = "Page %s of %s" % (page_num, len(pages))
    x = 128
    canvas.saveState()
    canvas.setStrokeColorRGB(0, 0, 0)
    canvas.setLineWidth(0.5)

    canvas.line(66, 53, page.BBox[2] - 66, 53)
    canvas.setFont("Times-Roman", 10)
    canvas.drawString(page.BBox[2] - x, 40, footer_text)

    canvas.restoreState()

    canvas.showPage()

canvas.save()
os.remove(input_file)
os.rename(fname + ".txt", fname.rstrip("d") + ".txt")

print("Done.")

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import line [as 别名]
from __future__ import division                 # division "réelle"
# -------------------------------------------------------------------------

# Importation de quelques éléments de la bibliothèque ReportLab :
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.units import cm
from reportlab.lib.pagesizes import A4

fichier ="document_2.pdf"
can = Canvas("%s" % (fichier), pagesize=A4)
# Installation d'éléments divers dans le canevas :
largeurP, hauteurP = A4                         # largeur et hauteur de la page
centreX, centreY = largeurP/2, hauteurP/2       # coordonnées du centre page
can.setStrokeColor("red")                       # couleur des lignes
# Rappel : la position verticale sur la page est comptée à partir du bas.
can.line(1*cm, 1*cm, 1*cm, 28*cm)               # ligne verticale à gauche
can.line(1*cm, 1*cm, 20*cm, 1*cm)               # ligne horizontale en bas
can.line(1*cm, 28*cm, 20*cm, 1*cm)              # ligne oblique (descendante)
can.setLineWidth(3)                             # nouvelle épaisseur des lignes
can.setFillColorRGB(1,1,.5)                     # couleur de remplissage (RVB)
can.rect(2*cm, 2*cm, 18*cm, 20*cm, fill=1)      # rectangle de 18 x 20 cm

# Dessin d'un bitmap (aligné par son coin inférieur gauche). La méthode
# drawImage renvoie les dimensions du bitmap (en pixels) dans un tuple :
dX, dY =can.drawImage("cocci3.gif", 1*cm, 23*cm, mask="auto")
ratio =dY/dX                                    # rapport haut./larg. de l'image
can.drawImage("cocci3.gif", 1*cm, 14*cm,
              width=3*cm, height=3*cm*ratio, mask="auto")
can.drawImage("cocci3.gif", 1*cm, 7*cm, width=12*cm, height=5*cm, mask="auto")

can.setFillColorCMYK(.7,0,.5,0)                 # couleur de remplissage (CMJN)