Python pagesizes.portrait函数代码示例

    def __init__(self, output):
        self.base_path = os.path.abspath(os.path.dirname(__file__))
        self.width, self.height = portrait(A4)
        self.y = self.height
        self.margin = 2.5
        self.x = self.margin
        self.pdf = output or tempfile.TemporaryFile()
        times_new_roman = os.path.join(self.base_path, "templates", "fonts", "times.ttf")
        times_new_roman_bold = os.path.join(self.base_path, "templates", "fonts", "timesbd.ttf")
        pdfmetrics.registerFont(TTFont('Times New Roman', times_new_roman))
        pdfmetrics.registerFont(TTFont('Times New Roman Bold', times_new_roman_bold))

        self.canvas = canvas.Canvas(self.pdf, pagesize=portrait(A4))

def PrintPdf(projectNo, probeInf, holelist, index=None):
    import os
    from config import basedir
    cptPath = os.path.join(basedir, 'app', 'static', 'download')

    if not os.path.exists(cptPath):
        os.makedirs(cptPath)
    doc = SimpleDocTemplate(cptPath,
                            pagesize=A4,
                            rightMargin=10,
                            leftMargin=20,
                            topMargin=30,
                            bottomMargin=20
                            )
    doc.pagesize = portrait(A4)
    filename = ''
    elements = []
    for i in range(len(holelist)):
        if index is not None:
            i = index
            filename = projectNo + '__' + holelist[i].holeName + '.pdf'
            # Attenion:where elments.extend must be used,but not elements.append
            elements.extend(Cpt2Pdf(holelist[i], probeInf))
            break;
        else:
            filename = projectNo + '__' + 'all.pdf'
            # Attenion:where elments.extend must be used,but not elements.append
            elements.extend(Cpt2Pdf(holelist[i], probeInf))
    doc.filename = os.path.join(cptPath, filename)
    print("dd" + doc.filename)
    doc.build(elements)
    # url='/'.join(['download',projectNo,filename])
    # os.path.join('download',projectNo,filename)将返回download\projectNo\filename，浏览器无法识别
    return doc.filename

def generate_pages(card_sizes,cards, filename="placecards.pdf", custom_font = None):
    pagesize = pagesizes.portrait( ( 8.5 * pagesizes.inch, 11 * pagesizes.inch))
    pdf = Canvas(filename, pagesize=pagesize,pdfVersion=(1,4))
    pdf.setAuthor('placecardboardgenerate.py')
    pdf.setSubject('wedding placecards')
    pdf.setTitle('Placecards for Wedding Reception')
    pdf.setKeywords(('wedding', 'placecards'))
    if custom_font is not None:
        pdf.setFont(custom_font,14)#FIXME don't hardcode font size
            
    adjusted_card_sizes = (card_sizes[0] * pagesizes.inch, card_sizes[1] * pagesizes.inch)
    card_printer = CardPrinter(pagesize,adjusted_card_sizes)

    (cardsPerRow,rowsPerPage) = (card_printer.cards_per_row, card_printer.cards_per_column)

    (page_width, page_height) = pagesize

    groupedCards = group_cards(cards, cardsPerRow, rowsPerPage)
    for (page_index,pageOfCards) in enumerate(groupedCards):
        if custom_font is not None:
            pdf.setFont(custom_font,14)#FIXME don't hardcode font size
        for (row_index,rowOfCards) in enumerate(pageOfCards):
            for (column_index,card) in enumerate(rowOfCards):
                card_printer.print_on_front_page(pdf,card,row_index, column_index)
        pdf.drawCentredString(page_width/2.0,20,"front of page %i" % (page_index + 1))
        pdf.showPage()
        if custom_font is not None:
            pdf.setFont(custom_font,14)#FIXME don't hardcode font size
        for (row_index,rowOfCards) in enumerate(pageOfCards):
            for (column_index,card) in enumerate(rowOfCards):
                card_printer.print_on_back_page(pdf,card,row_index, column_index)                
        pdf.drawCentredString(page_width/2.0,20,"back of page %i" % (page_index + 1))
        pdf.showPage()

    pdf.save()

    def print_pdf(pages, outfile, fontsize = 7, orientation='portrait',
                  blocks_per_page=1):

        if orientation == 'portrait':
            pagesize = portrait(letter)
        elif orientation == 'landscape':
            pagesize = landscape(letter)

        #precalculate some basics
        top_margin = pagesize[1] - .75*inch
        bottom_margin = 0.75*inch
        left_margin = 0.5*inch
        right_margin = pagesize[0] - 0.5*inch
        frame_width = right_margin - left_margin

        top_margin_offset = 0

        document_font = 'Courier'

        def drawPageFrame(canv):

            # pagecount = len(pages)
            pagecount = len(pageIter)
            pg = canv.getPageNumber()
            ofn = os.path.split(outfile)[-1]

            page_center = 0.5 * pagesize[0]

            canv.drawCentredString(page_center, top_margin + 0.3*inch,
                '%(ofn)s' % locals())

            lineycoord = top_margin + 0.25*inch
            canv.line(left_margin, lineycoord, right_margin, lineycoord)
    #       canv.setFont(document_font,fontsize)

            canv.drawCentredString(page_center, 0.5*inch,
                'Page %(pg)s of %(pagecount)s' % locals())

        canv = canvas.Canvas(outfile, invariant=1, pagesize=pagesize)
        canv.setPageCompression(1)

        pageIter = list(grouper(blocks_per_page, pages, pad=False))

        for pagegroup in pageIter:
            drawPageFrame(canv)
            canv.setFont(document_font, fontsize)
            tx = canv.beginText(left_margin, top_margin - top_margin_offset)

            for i, page in enumerate(pagegroup):
                for line in page:
                    tx.textLine(line)
                # separate blocks
                if blocks_per_page > 1 and i + 1 < blocks_per_page:
                    tx.textLine('')

            canv.drawText(tx)
            canv.showPage()

        canv.save()

def convertImageToPDF(_fileName, _swfslides, isDocin):
    print "convecting files to pdf..."
    pdfCanvas = canvas.Canvas("%s.pdf" % _fileName, pagesize=portrait(A4))
    # pdfCanvas.drawString(150,700,"Welcome to flash slides downloader");
    # pdfCanvas.drawString(180,680,"contact: [email protected]");
    # pdfCanvas.showPage()
    numberOfSlides = 1
    for iswf in _swfslides:
        doc = gfx.open("swf", iswf)
        print iswf
        if doc:
            if isDocin == False:
                for pagenr in range(1, doc.pages + 1):
                    page1 = doc.getPage(pagenr)
                    print "Page", pagenr, "has dimensions", page1.width, "x", page1.height
                    pdfCanvas.setPageSize((page1.width * 2, page1.height * 2))
                    imageName = "image-%s-%s.png" % (numberOfSlides, pagenr)
                    imgRGBBuf = page1.asImage(page1.width * 2, page1.height * 2)
                    im = Image.fromstring(
                        "RGB", (page1.width * 2, page1.height * 2), imgRGBBuf
                    )  # convert to PIL Object
                    # img = gfx.ImageList()
                    # 				img.setparameter("antialise", "4") # turn on antialisin
                    # img.setparameter("zoom", "100")
                    # img.startpage(page1.width,page1.height)
                    # 				page1.render(img)
                    # 				img.endpage()
                    # pageNumOfThisSwf+=1"thumbnail%s.png" % pagenr
                    # img.save(imageName)
                    # pdfCanvas.drawImage(imageName,0,0,width= page1.width,height= page1.height,mask='auto')
                    pdfCanvas.drawImage(
                        ImageReader(im), 0, 0, width=page1.width * 2, height=page1.height * 2, mask="auto"
                    )
                    pdfCanvas.showPage()
                    # os.remove(imageName) # delete temp image
            else:
                # damn docins bad header.
                page1 = doc.getPage(1)
                print "Page %d" % numberOfSlides, "has dimensions", page1.width, "x", page1.height
                pdfCanvas.setPageSize((page1.width * 2, page1.height * 2))
                imageName = "image-%s-%s.png" % (numberOfSlides, 1)
                imgRGBBuf = page1.asImage(page1.width * 2, page1.height * 2)
                im = Image.fromstring("RGB", (page1.width * 2, page1.height * 2), imgRGBBuf)  # convert to PIL Object
                # img = gfx.ImageList()
                # img.setparameter("antialise", "4") # turn on antialisin
                # img.setparameter("zoom", "100")
                # img.startpage(page1.width,page1.height)
                # page1.render(img)
                # img.endpage()
                # pageNumOfThisSwf+=1"thumbnail%s.png" % pagenr
                # img.save(imageName)
                # pdfCanvas.drawImage(imageName,0,0,width= page1.width,height= page1.height,mask='auto')
                pdfCanvas.drawImage(ImageReader(im), 0, 0, width=page1.width * 2, height=page1.height * 2, mask="auto")
                pdfCanvas.showPage()
                # os.remove(imageName) # delete temp image
        numberOfSlides += 1
        os.remove(iswf)  # delete temp swf
    pdfCanvas.save()

def export(listino, luogoDiRiferimento):
    response = http.HttpResponse(content_type='application/pdf')
    width, height = portrait(A4)

    pageTemplates = [
        PageTemplate(id='Listino', onPage=onPageListino),
    ]

    doc = BaseDocTemplate(
        response,
        pagesize=(width, height),
        leftMargin=1 * cm,
        rightMargin=1 * cm,
        bottomMargin=1.5 * cm,
        topMargin=1 * cm,
        showBoundary=test,
        pageTemplates=pageTemplates,
    )

    doc.listino = listino  # arricchisco il doc

    righe_prezzo = listino.prezzolistino_set.all()

    story = []

    listinoEsclusivo = getTabellaListino(doc, righe_prezzo, 'T', luogoDiRiferimento)
    if listinoEsclusivo:
        title = Paragraph("SERVIZIO TAXI ESCLUSIVO", normalStyle)
        story.append(title)
        story.append(listinoEsclusivo)

    listinoCollettivo = getTabellaListino(doc, righe_prezzo, 'C', luogoDiRiferimento)
    if listinoEsclusivo and listinoCollettivo:
        story.append(Spacer(1, 1.5 * cm))
    if listinoCollettivo:
        title = Paragraph("SEVIZIO COLLETIVO MINIBUS", normalStyle)
        story.append(KeepTogether([title, listinoCollettivo]))

    if not listinoCollettivo and not listinoEsclusivo:
        story.append(
            Paragraph("Non abbiamo nessuna corsa specificata nel listino.", normal_style)
        )

    # footer
    footer_style = ParagraphStyle(name='Justify', alignment=TA_JUSTIFY, fontSize=8)
    # footer_height = 0
    if LISTINO_FOOTER:
        note_finali_lines = [LISTINO_FOOTER]
        story.append(Spacer(1, 1 * cm))
        note_finali = Paragraph("<br/>".join(note_finali_lines),
                                footer_style)
        # note_finali.wrap(width - doc.rightMargin - doc.leftMargin, 5 * cm)
        # note_finali.drawOn(canvas, doc.leftMargin, doc.bottomMargin)
        # footer_height = note_finali.height
        story.append(note_finali)

    doc.build(story, canvasmaker=NumberedCanvas)
    return response

def render( root, pdf, **kwargs ):

	debug = False
	mycanvas = None
	if kwargs is not None:
		try:
			fonts = kwargs['fonts']
			map(pdfmetrics.registerFont, fonts)
		except:
			pass
		
		try:
			debug = kwargs['showframes']
		except:
			pass
		try:
			mycanvas = kwargs['canvas']
		except:
			pass
	doc_pagesize = pagesizes.letter
	root_pagesize = root._style.getattribute('pagesize',str)
	root_pageorientation = root._style.getattribute('orientation',str)

	pagesize_tuple = root_pagesize.split(':')
	if len(pagesize_tuple) > 1:
		doc_pagesize = (float(pagesize_tuple[0]),float(pagesize_tuple[1]))

	if root_pageorientation == 'landscape':
		doc_pagesize = pagesizes.landscape(doc_pagesize)
	if root_pageorientation == 'portrait':
		doc_pagesize = pagesizes.portrait(doc_pagesize)        

	if mycanvas is None:
		pdf_canvas = NumberedCanvas(pdf, pagesize=doc_pagesize)        
	else:
		mycanvas.setPageSize(doc_pagesize)
		pdf_canvas = mycanvas                

	page_manager = pagemgr(pdf_canvas)        
	page_manager.showframes(debug)

	rlroot = rlobject(root)
	rlroot.render(page_manager)

	start = time.time()

	if mycanvas is None:
		pdf_canvas.save()

	end = time.time()
	delta = end - start
	adddeltatimer('canvas',delta)

	final_delta = 0

	return 0

 def set_canvas(self):
     """
     Il metodo si fa carico di impostare il formato di pagina conseguentemente all'orientamento
     specificato.
     """
     if self.oPageFormat.orientamento=="landscape":    
         x=landscape((self.oPageFormat.larghezza,self.oPageFormat.altezza))
     else:
         x=portrait((self.oPageFormat.larghezza,self.oPageFormat.altezza))
     return astraCanvas(self.oPageFormat.nomepdf,pagesize=x)

 def _calc(self):
     if self.defaultPage == "Landscape":
         self.pagesize = landscape(self.paper_size)
     else:
         self.pagesize = portrait(self.paper_size)
     BaseDocTemplate._calc(self)
     self.height = self.pagesize[PDF_HEIGHT]
     self.width = self.pagesize[PDF_WIDTH]
     self.printable_width = self.width - self.leftMargin - self.rightMargin - self.insideMargin
     self.printable_height = self.height - self.topMargin - self.bottomMargin

def main(infile, outfile, color, font, font_size, portrait, scale, no_times,
         no_weekends, start_monday):
    """
    Weekly schedule typesetter

    Visit <https://github.com/jwodder/schedule> for more information.
    """
    if font in available_fonts():
        font_name = font
    else:
        # Assume we've been given a path to a .ttf file
        font_name = 'CustomFont'
        ### TODO: Use the basename of the filename as the font name?  (Could
        ### that ever cause problems?)
        pdfmetrics.registerFont(TTFont(font_name, font))
    if portrait:
        page_width, page_height = pagesizes.portrait(pagesizes.letter)
    else:
        page_width, page_height = pagesizes.landscape(pagesizes.letter)
    colors = COLORS if color else [GREY]
    if no_weekends:
        week = WEEKDAYS_EN
    elif start_monday:
        week = FULL_WEEK_MON_EN
    else:
        week = FULL_WEEK_EN
    sched = Schedule(week)
    for ev in read_events(infile, colors=colors):
        sched.add_event(ev)
    if outfile is None:
        if infile is sys.stdin:
            outfile_name = '-'
        else:
            outfile_name = str(Path(infile.name).with_suffix('.pdf'))
        outfile = click.open_file(outfile_name, 'wb')
    c = Canvas(outfile, (page_width, page_height))
    c.setFont(font_name, font_size)
    if scale is not None:
        factor = 1 / scale
        c.translate(
            (1-factor) * page_width / 2,
            (1-factor) * page_height / 2,
        )
        c.scale(factor, factor)
    sched.render(
        c,
        x          = inch,
        y          = page_height - inch,
        width      = page_width - 2*inch,
        height     = page_height - 2*inch,
        font_size  = font_size,
        show_times = not no_times,
    )
    c.showPage()
    c.save()

 def write(self):
     """Assembles the final PDF and writes to disk."""
     pdf_writer = pyPdf.PdfFileWriter()
     if self.front_matter is not None:
         front_matter = pyPdf.PdfFileReader(file(self.front_matter, "rb"))
         for page in range(front_matter.getNumPages()):
             pdf_writer.addPage(front_matter.getPage(page))
     working_file = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False)
     doc = SimpleDocTemplate(working_file)
     doc.pagesize = portrait(letter)
     story = []
     styles = getSampleStyleSheet()
     for section in self.sections:
         heading_text = section.heading
         story.append(Paragraph(heading_text, styles["Heading1"]))
         for content in section.contents:
             if "figure" in content:
                 figure = content["figure"]
                 if os.path.exists(figure):
                     im = utils.ImageReader(figure)
                     img_width, img_height = im.getSize()
                     aspect = img_height / float(img_width)
                     story.append(Image(figure, width=img_width, height=(img_width * aspect)))
                 if content.get("caption", None) is not None:
                     caption_text = "<font size=10>{0}</font>".format(content["caption"].strip())
                     story.append(Paragraph(caption_text, styles["Italic"]))
                     story.append(Spacer(1, 10))
             if "table" in content:
                 _t = self.build_table(content["table"])
                 story.append(_t)
                 if content.get("caption", None) is not None:
                     caption_text = "<font size=10>{0}</font>".format(content["caption"].strip())
                     story.append(Paragraph(caption_text, styles["Italic"]))
                     story.append(Spacer(1, 10))
             if "text" in content:
                 for para in content["text"]:
                     story.append(Paragraph(para, styles["Normal"]))
                     story.append(Spacer(1, 12))
     doc.build(story)
     body_matter = pyPdf.PdfFileReader(working_file)
     for page in range(body_matter.getNumPages()):
         pdf_writer.addPage(body_matter.getPage(page))
     try:
         os.remove(working_file.name)
     except OSError:  # Windows reports file in use, other OS errors, etc.
         pass
     if self.end_matter is not None:
         end_matter = pyPdf.PdfFileReader(file(self.end_matter, "rb"))
         for page in range(end_matter.getNumPages()):
             pdf_writer.addPage(end_matter.getPage(page))
     output_stream = file(self.output_filename, "wb")
     pdf_writer.write(output_stream)

def pdf(files, outfile, useportrait=True):
    print("Creating PDF...")
    pdf = Canvas(outfile)
    pagesize = portrait(A4) if useportrait else landscape(A4)
    for i in files:
        print("Creating PDF page for %s..." % i)
        pdf.setPageSize(pagesize)
        pdf.drawImage(i, 0, 0, *pagesize)
        pdf.showPage()
        print("Done!")
    print("Saving PDF...")
    pdf.save()
    print("Done!")

 def __init__(self, title='', pretext='', two_column=False):
     self.story = ['', '']
     self.pagesize = portrait(letter)
     self.styles = getSampleStyleSheet()
     if title: 
         self.title = PDF.Item('TITLE', title)
     else: 
         self.title = PDF.Item('TITLE', timestamp())   
     self.pretext = PDF.Item('PRETEXT', pretext)
     self.set_title(self.title.value)
     self.set_pretext(self.pretext.value)
     self.two_column = two_column
     self.savedir = '%s\\Documents'%os.path.expanduser('~') 

 def __init__(self, oIreport, pdfFileName):
     self.oPageFormat=page_Format(oIreport.get_ReportStru(), pdfFileName)
     if self.oPageFormat.orientamento=="Landscape":    
         x=landscape((self.oPageFormat.larghezza,self.oPageFormat.altezza))
     else:
         x=portrait((self.oPageFormat.larghezza,self.oPageFormat.altezza))
         
     self.set_row(self.oPageFormat.altezza-self.oPageFormat.topMargin)
     canvas.Canvas.__init__(self, self.oPageFormat.nomepdf,
                            pagesize=x,
                            bottomup =1,
                            pageCompression=0,
                            #encoding=rl_config.defaultEncoding,
                            verbosity=0)
     self.pageNumber=0

def informesPdf(periode,grup):
    response = HttpResponse(mimetype='application/pdf')
    response['Content-Disposition'] = 'attachment; filename=informe.pdf'

    elements = []
    styles = getSampleStyleSheet()
    styles['Normal'].fontsize=8
    doc = SimpleDocTemplate(response, leftMargin=25, rightMargin=25, topMargin=25, bottomMargin=25)
    doc.pagesize = portrait(A4)

    today = datetime.date.today().strftime('%d/%m/%Y')
    periode = Periode.objects.get(id=periode)
    amonList = Amonestacio.objects.filter(dataHora__gt=periode.dt1).filter(dataHora__lt=periode.dt2)
    if grup != "-1":
        grup = Grup.objects.get(id=grup)
        amonList = amonList.filter(alumne__grup=grup)

    alumnes = set( [ a.alumne for a in amonList ] )

    for al in sorted(alumnes, key = lambda a: unicode(a)):
        par = Paragraph(u"<b>Es Liceu</b>. Carrer Cabana, 31. 07141, Pont d'Inca, Marratxí<br/>Telèfon: 971 60 09 86. E-MAIL: [email protected]<br/><br/>",
            styles['Normal'])
        elements.append(par)
        elements.append(Paragraph(unicode(periode.descripcio), styles['Normal']))
        elements.append(Paragraph(unicode(al), styles['Heading1']))

        elements.append(Paragraph("Data: " + today, styles['Normal']))
        elements.append(Paragraph("Curs: " + unicode(al.grup), styles['Normal']))
        elements.append(Paragraph("Tutor/a: " + unicode(al.grup.tutor) + "<br/>", styles['Normal']))

        elements.append(Paragraph(u"Informe d'incidències", styles['Heading2']))

        for a in amonList.filter(alumne=al).order_by('dataHora'):
            elements.append(Paragraph(u"<b>Data:</b> " + a.dataHora.strftime('%d/%m/%Y') + u'<br/>', styles['Normal']))
            elements.append(Paragraph(u"<b>Professor:</b> " + unicode(a.professor) + u'<br/>', styles['Normal']))
            elements.append(Paragraph(u"<b>Tipus d'incidència:</b> " + unicode(a.gravetat) + u'<br/>', styles['Normal']))
            elements.append(Paragraph(u"<b>Descripció:</b> " + a.descripcio + u'<br/><br/>', styles['Normal']))

        totalpunts = puntsAlumnePeriode(al,periode)
        elements.append(Paragraph(u"Total punts restants: " + unicode(totalpunts) + u'<br/><br/>', styles['Heading3']))
        elements.append(PageBreak())

    doc.build(elements)
    return response