Python reportlab.lib.pagesizes 模块，A4 实例源码

def __init__(self, page_size=pagesizes.A4, shipping_labels_margin=(0, 0), posting_list_margin=(5 * mm, 5 * mm)):
        self.shipping_labels = []  # type: List[ShippingLabel]
        self._tracking_codes = set()

        self.page_size = page_size
        self.page_width = page_size[0]
        self.page_height = page_size[1]

        self.posting_list = None  # type: PostingList
        self.posting_list_margin = posting_list_margin

        self.shipping_labels_margin = shipping_labels_margin
        self.shipping_labels_width = self.page_width - (2 * shipping_labels_margin[0])
        self.shipping_labels_height = self.page_height - (2 * shipping_labels_margin[1])

        self.col_size = self.shipping_labels_width / 2
        self.row_size = self.shipping_labels_height / 2
        self._label_position = (
            (shipping_labels_margin[0], self.page_height / 2),
            (shipping_labels_margin[0] + self.col_size, self.page_height / 2),
            (shipping_labels_margin[0], shipping_labels_margin[1]),
            (shipping_labels_margin[0] + self.col_size, shipping_labels_margin[1]),
        )

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()

def test_05_coordinates(self):
        from reportlab.lib.pagesizes import A4
        from reportlab.pdfgen.canvas import Canvas
        from reportlab.lib.units import inch
        from reportlab.lib.colors import pink, black, red, blue, green
        c = Canvas('demo.pdf', pagesize=A4)
        c.translate(inch,inch)
        c.setStrokeColor(pink)
        c.grid([1*inch,2*inch,3*inch,4*inch],[0.5*inch, 1*inch, .5*inch, 2*inch, 2.5*inch])
        c.setFont("Times-Roman", 20)
        c.drawString(0,0, "(0,0) the Origin")
        c.drawString(2.5*inch, 1*inch, "(2.5,1) in inches")
        c.drawString(4*inch, 2.5*inch, "(4,2.5)")
        c.setFillColor(red)
        c.rect(0,2*inch,0.2*inch, 0.3*inch, fill=1)
        c.setFillColor(green)
        c.circle(4.5*inch, 0.4*inch, 0.2*inch, fill=1)
        c.showPage()
        c.save()

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()

def mainPageFrame(canvas, doc):
    "The page frame used for all PDF documents."

    canvas.saveState()

    pageNumber = canvas.getPageNumber()
    canvas.line(2*cm, A4[1]-2*cm, A4[0]-2*cm, A4[1]-2*cm)
    canvas.line(2*cm, 2*cm, A4[0]-2*cm, 2*cm)
    if pageNumber > 1:
        canvas.setFont('Times-Roman', 12)
        canvas.drawString(4 * inch, cm, "%d" % pageNumber)
        if hasattr(canvas, 'headerLine'): # hackish
            # HVB: Changed fr Hyphenation support
            # headerline = string.join(canvas.headerLine, ' \xc2\x8d ')
            headerline = string.join(canvas.headerLine, ' \xc2\x8d '.decode('utf8'))
            canvas.drawString(2*cm, A4[1]-1.75*cm, headerline)

    canvas.setFont('Times-Roman', 8)
    msg = "Generated with docpy. See http://www.reportlab.com!"
    canvas.drawString(2*cm, 1.65*cm, msg)

    canvas.restoreState()

def __init__(self, page_size=A4, font_face='Helvetica'):
        self.page_size = page_size
        self.font_face = font_face
        self.logo = None

def __init__(self, page_size=A4, font_face='Helvetica'):
        self.page_size = page_size
        self.font_face = font_face
        self.logo = None

def __init__(self, page_size=A4, font_face='Helvetica'):
        self.page_size = page_size
        self.font_face = font_face
        self.logo = None

def __init__(self, submission, styles, width):
        super().__init__()
        self.submission = submission
        self.styles = styles
        self.width = width
        self.height = min(2.5 * max(submission.get_duration(), 30) * mm, A4[1])

def get(self, request, *args, **kwargs):
        with tempfile.NamedTemporaryFile(suffix=".pdf") as f:
            doc = BaseDocTemplate(
                f.name, pagesize=A4,
                leftMargin=0, rightMargin=0, topMargin=0, bottomMargin=0
            )
            doc.addPageTemplates([
                PageTemplate(
                    id='All',
                    frames=[
                        Frame(
                            0, 0, doc.width / 2, doc.height,
                            leftPadding=0, rightPadding=0, topPadding=0, bottomPadding=0,
                            id='left'
                        ),
                        Frame(
                            doc.width / 2, 0, doc.width / 2, doc.height,
                            leftPadding=0, rightPadding=0, topPadding=0, bottomPadding=0,
                            id='right'
                        )
                    ],
                    pagesize=A4
                )
            ])
            doc.build(self.get_story(doc))
            f.seek(0)
            r = HttpResponse(content_type='application/pdf')
            r.write(f.read())
            return r

def __init__(self, page_size=A4, font_face='Helvetica'):
        self.page_size = page_size
        self.font_face = font_face
        self.logo = None

def make_cards_file(path, cover, items, verbose=False):
    "Make cards with as many items as possible, shrinking too big ones."

    cardSize = (9.1 * cm, 5.9 * cm)
    cards = []
    for q, a in make_cards_platypus(cardSize, cover, items, verbose=verbose):
        cards += [q, a]

    outPath = os.path.splitext(path)[0] + ".pdf"
    pageSize = landscape(A4)
    layout(outPath, cards, pageSize, cardSize, frame=True, debug=False)

    if verbose:
        print("wrote %s" % outPath)

def __init__(self, *args, **kwargs):
        __version_info__ = ('1', '0', '0')
        self.__version__ = __version_info__
        self.games = kwargs.get('games', [])  # list of 'game' objects
        self.user = kwargs.get('user', '')
        self.time = kwargs.get('time', 'UK')
        self.filename = kwargs.get('filename')
        self.progress = kwargs.get('progress', False)
        self.family_names = kwargs.get('familys', [])
        self.font_names = kwargs.get('fonts', [])
        self.page_footer = kwargs.get(
            'page_footer', '')
        self.page_header = kwargs.get(
            'page_header', 'Board Game Geek Collection Printer (v0.1)')
        header = kwargs.get('header')
        body = kwargs.get('left')
        margin = kwargs.get('margin', 72)
        page_size = kwargs.get('page', 'A4')
        if page_size == 'A4':
            size = A4
        elif page_size == 'letter':
            size = Letter
        else:
            raise NotImplementedError('Page size "%" is not available' % page_size)
        self.set_doc(filename=self.filename, margin=margin, page=size)
        # fonts & styles
        for fname in self.family_names:
            self.ttf_register(fname, family=True)
        for fname in self.font_names:
            self.ttf_register(fname, family=False)
        self.styles = getSampleStyleSheet()
        self.set_styles(body, header)  # style sheets pre-made

def set_doc(self, filename, margin=72, page=A4):
        _filename = filename or 'games.pdf'
        self.doc = SimpleDocTemplate(
            _filename,
            rightMargin=margin,
            leftMargin=margin,
            topMargin=margin,
            bottomMargin=margin,
            pagesize=page)

def __init__(self, buffer, pagesize):
        self.main_answer = {}
        self.question={}
        self.data=[]
        self.buffer = buffer
        if pagesize == 'A4':
            self.pagesize = A4
        elif pagesize == 'Letter':
            self.pagesize = letter
        self.width, self.height = self.pagesize
        self.base_url = ''
        self.media_folder = ''
        self.project_name = ''
        self.project_logo = ''

def __init__(self, pagesize, orden_compra):
        self.orden_compra = orden_compra
        self.buffer = BytesIO()
        if pagesize == 'A4':
            self.pagesize = A4
        elif pagesize == 'Letter':
            self.pagesize = letter
        self.width, self.height = self.pagesize

def __init__(self, pagesize, requerimiento):
        self.requerimiento = requerimiento
        self.buffer = BytesIO()
        if pagesize == 'A4':
            self.pagesize = A4
        elif pagesize == 'Letter':
            self.pagesize = letter
        self.width, self.height = self.pagesize

def __init__(self, pagesize, movimiento):
        self.movimiento = movimiento
        self.buffer = BytesIO()
        if pagesize == 'A4':
            self.pagesize = A4
        elif pagesize == 'Letter':
            self.pagesize = letter
        self.width, self.height = self.pagesize

def __init__(self, pagesize, desde, hasta, almacen, grupos):
        self.desde = desde
        self.hasta = hasta
        self.almacen = almacen
        self.grupos = grupos
        self.total_paginas = 0
        self.buffer = BytesIO()
        if pagesize == 'A4':
            self.pagesize = landscape(A4)
        elif pagesize == 'Letter':
            self.pagesize = letter
        self.width, self.height = self.pagesize

def __init__(self, page_size=A4, font_face='Helvetica'):
        self.page_size = page_size
        self.font_face = font_face
        self.logo = None

def BurnSudoOnPdf(path,numpage,diffarray):

    pdf = PdfFileWriter()

    # Using ReportLab Canvas to insert image into PDF
    imgTemp = BytesIO()
    imgDoc = canvas.Canvas(imgTemp, pagesize=A4)

    # Draw image on Canvas and save PDF in buffer
    pdfmetrics.registerFont(TTFont('VeraIt', 'VeraIt.ttf'))
    for i in range(len(path)):
        if ((i+1)%2==0):
            x=345
        else:
            x=55
        if (i<2):
            y=590
        elif (i<4):
            y=320
        else:
            y=50
        imgDoc.drawImage(path[i], x, y,200,200)
        imgDoc.setFont('VeraIt', 9)
        imgDoc.drawString(x+2,y+203,getStrDiff(diffarray[i]))

    pdfmetrics.registerFont(TTFont('Vera', 'Vera.ttf'))
    pdfmetrics.registerFont(TTFont('VeraBd', 'VeraBd.ttf'))
    pdfmetrics.registerFont(TTFont('VeraIt', 'VeraIt.ttf'))
    #pdfmetrics.registerFont(TTFont('VeraBI', 'VeraBI.ttf'))

    imgDoc.setFont('Vera', 13)
    imgDoc.drawString(30,820,"BurnYourPc Organization/")
    imgDoc.setFont('VeraBd', 9)
    imgDoc.drawString(197,820,"Sudoku Project")
    imgDoc.setFont('VeraIt', 8)
    imgDoc.drawString(430,20,"By PantelisPanka, nikfot, TolisChal")
    imgDoc.setFont('Vera', 8)
    imgDoc.drawString(550,820,str(numpage))

    imgDoc.save()

    # Use PyPDF to merge the image-PDF into the template
    pdf.addPage(PdfFileReader(BytesIO(imgTemp.getvalue())).getPage(0))

    pdf.write(open("output"+ str(numpage)+".pdf","wb"))

def test() :
    """Test this."""
    from reportlab.pdfgen.canvas import Canvas
    from reportlab.lib import pagesizes

    canvas = Canvas("labels.pdf", pagesize=pagesizes.A4)
    canvas.setFont("Helvetica", 30)
    (width, height) = pagesizes.A4
    canvas.drawCentredString(width/2.0, height-4*cm, "Sample LTO labels")
    xpos = xorig = 2 * cm
    ypos = yorig = 2 * cm
    colwidth = 10 * cm
    lineheight = 3.9 * cm
    count = 1234
    BaseLTOLabel("RL", count, "3").drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    BaseLTOLabel("RL", count, "3",
                 border=0.0125).drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3").drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3",
                    border=0.0125).drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3",
                    colored=True).drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3",
                    border=0.0125, colored=True).drawOn(canvas, xpos, ypos)
    canvas.showPage()
    canvas.save()

def header(self, canvas, doc):
        canvas.saveState()
        canvas.setFont('Times-Roman', 9)
        canvas.drawString(inch, A4[1] - 50, TITLE_MSG)
        canvas.line(inch, A4[1] - 60, A4[0] - 65, A4[1] - 60)
        canvas.restoreState()

def test_02_pageSize(self):
        from reportlab.lib.pagesizes import A4
        from reportlab.pdfgen.canvas import Canvas
        myCanvas = Canvas('demo.pdf', pagesize=A4)
        width, height = A4
        print width, height
        myCanvas.drawString(width*1/3,height*2/3, "Hello World")
        myCanvas.showPage()
        myCanvas.save()

def test_04_canvasMethods(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.setAuthor("JY.zenist.song")
        c.setTitle("Hello ReportLib")
        c.drawString(3*inch, 3*inch, "Hello World")
        c.showPage()
        c.save()

def __init__(self, page_size=A4, font_face='Helvetica'):
        self.page_size = page_size
        self.font_face = font_face
        self.logo = None

def __init__(self,mypagesize=A4):


        styleSheet = getSampleStyleSheet()

        self.doc = SimpleDocTemplate("/tmp/Promotion_List.pdf", pagesize=mypagesize,title="PromotionList Report",topMargin=.4*inch,bottomMargin=.3*inch,author="Asif Kodur")

def __init__(self, input_path, output_path, fontname, fontpath,
                 is_landscape=False, padding=20):
        if is_landscape:
            self.canvas = canvas.Canvas(output_path, pagesize=landscape(A4))
            self.page_height, self.page_width = A4
        else:
            self.canvas = canvas.Canvas(output_path)
            self.page_width, self.page_height = A4

        self.padding = padding

        self.page = 0
        self.story_count = 0

        self.black = 0.3
        self.gray = 0.5
        self.lite_gray = 0.95
        self.white = 1

        if fontname and fontpath:
            pdfmetrics.registerFont(TTFont(fontname, fontpath))
            self.fontname = fontname
        else:
            self.fontname = 'Helvetica'

        self.load_backlog(input_path)

def __init__(self, page_size=A4, font_face='Helvetica'):
        self.page_size = page_size
        self.font_face = font_face
        self.logo = None

def main():
    context = {
        'instructor': INSTRUCTOR,
        'course': COURSE,
        'student': STUDENT,
        'hours': HOURS,
    }
    styles = getSampleStyleSheet()
    styles.add(
        ParagraphStyle(
            name='Justify', alignment=TA_JUSTIFY, fontSize=16, leading=22
        )
    )
    elements = []
    certificate_txt = render(TEXT_PATH, context)
    paragraphs = certificate_txt.split(os.linesep)
    elements.append(Spacer(1, 50))
    for p in paragraphs:
        elements.append(Paragraph(p, styles['Justify']))
        elements.append(Spacer(1, 16))

    certificate = tempfile.NamedTemporaryFile()
    doc = SimpleDocTemplate(certificate, topMargin=3 * cm, bottomMargin=0)
    doc.pagesize = landscape(A4)
    doc.build(elements)

    output = PdfFileWriter()
    template_file = open('template.pdf', 'rb')
    input1 = PdfFileReader(template_file)
    page1 = input1.getPage(0)
    content = PdfFileReader(certificate)
    page1.mergePage(content.getPage(0))
    output.addPage(page1)
    save_file = open(SAVE_AS, 'wb')
    output.write(save_file)
    print('Certificado gerado com sucesso em %s' % SAVE_AS)

def generateReport(self, results):

        #Pintamos la tabla con sus contenidos
        doc = IOCDocTemplate(DEFAULT_REPORT_NAME, pagesize=A4, results=results)

        doc.addPageTemplates(
            [
                PageTemplate(id='summary',
                             frames=[Frame(doc.leftMargin, doc.bottomMargin, doc.width, 425)],
                             onPage=doc.summary, onPageEnd=doc.footer),

                PageTemplate(id='content',
                             frames=[Frame(doc.leftMargin, doc.bottomMargin, doc.width, doc.height)],
                             onPage=doc.header, onPageEnd=doc.footer),

            ]
        )

        estiloHoja = getSampleStyleSheet()

        # Estilos de la tabla para cabeceras y datos
        thead = estiloHoja["BodyText"]
        thead.fontSize = 7

        table_data = [ ['INDICADOR DE COMPROMISO', 'FORMATO', 'TIPO DE EVIDENCIA', 'VALOR', 'PRUEBA'] ]
        for incident in results.incidents:
            for evidence in incident.evidences:
                table_data.append([Paragraph(self.__prettyPrint__(incident.indicator.id),thead),
                                   Paragraph(self.__prettyPrint__(incident.indicator.format.value),thead),
                                   Paragraph(self.__prettyPrint__(evidence.context),thead),
                                   Paragraph(self.__prettyPrint__(evidence.value),thead),
                                   Paragraph(self.__prettyPrint__(evidence.proof),thead)])

        table_report=[]
        table_report.append(NextPageTemplate('summary'))
        table_report.append(NextPageTemplate('content'))
        table_report.append(Table(table_data, colWidths=[120, 50, 75, 120, 180],
                              style=TableStyle([
                                  ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
                                  ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
                                  ('SIZE', (0, 0), (-1, -1), 7),
                                  ('GRID', (0, 0), (-1, -1), 0.5, colors.black),
                                  ('BOX', (0, 0), (-1, -1), 1, colors.black),
                                  ('BACKGROUND', (0, 0), (-1, 0), colors.lavender),
                              ])
                              )
                            )

        doc.build(table_report)