Python pagesizes.landscape函数代码示例

def drawCalendarPage(c, year, month):
    width = landscape(A4)[0] - 20*mm
    height = landscape(A4)[1] - 20*mm

    # leave 1cm margin on page
    drawable_h = height - titlesize - 5*mm
    c.translate(10*mm, 10*mm)
    
    # draw rounded background rect
    c.saveState()
    c.setStrokeColor(framefgcolor)
    c.setFillColor(framebgcolor)
    c.roundRect(0, 0, width, drawable_h, 5*mm, fill=1)
    c.restoreState()

    # place header 5mm from the left/right border sides
    c.saveState()
    c.translate(5*mm, height - titlesize) 
    drawHeader(c, year, month, width - 10*mm, titlesize)
    c.restoreState()

    # draw grid with a 5mm margin to the border
    c.saveState()
    c.translate(5*mm, 5*mm)
    drawGrid(c, year, month, width - 10*mm, drawable_h - 10*mm)
    c.restoreState()

    # show the page
    c.showPage()
    return

def print_cards():
    #LETTER = (8.5, 11)
    LETTER = (11, 8.5)
    DPI = 72
    # Set print margins
    MARGIN = 0.5
    x_offset = int(MARGIN * DPI)
    y_offset = int(MARGIN * DPI)
    CARDSIZE = (int(2.49 * DPI), int(3.48 * DPI))
    #scale = CARDSIZE[0] / 375.0  # Default cardsize in px
    cards = convert_to_cards(session['cardtext'])
    byte_io = BytesIO()
    from reportlab.pdfgen import canvas
    canvas = canvas.Canvas(byte_io, pagesize=landscape(letter))
    WIDTH, HEIGHT = landscape(letter)
    #draw = ImageDraw.Draw(sheet)
    for card in cards:
        image = create_card_img(card,session["do_google"])
        image_reader = ImageReader(image)
        canvas.drawImage(image_reader,
                         x_offset,
                         y_offset,
                         width=CARDSIZE[0],
                         height=CARDSIZE[1])
        x_offset += CARDSIZE[0] + 5  # 5 px border around cards
        if x_offset + CARDSIZE[0] > LETTER[0] * DPI:
            x_offset = int(MARGIN * DPI)
            y_offset += CARDSIZE[1] + 5
        if y_offset + CARDSIZE[1] > LETTER[1] * DPI:
            x_offset = int(MARGIN * DPI)
            y_offset = int(MARGIN * DPI)
            canvas.showPage()
    canvas.save()
    byte_io.seek(0)
    return send_file(byte_io, mimetype='application/pdf')

def conpdf(f_jpg):
    f_pdf = filename+'.pdf'
    (w, h) = landscape(A4)
    c = canvas.Canvas(f_pdf, pagesize = landscape(A4))
    c.drawImage(f, 0, 0, w, h)
    c.save()
    print "okkkkkkkk."

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

def bmp2pdf():
    """ bmp -> pdf
    """
    c = canvas.Canvas('bmp2pdf.pdf', pagesize=landscape(A4))
    (w, h) = landscape(A4)
    width, height = letter
    #c.drawImage(filename, inch, height - 2 * inch) # Who needs consistency?
    c.drawImage('bmp2pdf.bmp', 0, 0, w, h)
    c.showPage()
    c.save()

def drawCoverPage(c, filename):
    width = landscape(A4)[0] - 20*mm
    height = landscape(A4)[1] - 20*mm

    # leave 1cm margin on page
    drawable_h = height - titlesize - 5*mm

    # draw image
    c.drawImage(filename, 10*mm, 10*mm, width=width, height=height,
                preserveAspectRatio=True)

    # show the page
    c.showPage()

def StringIO2pdf():
    """ bmp -> StringIO -> ImageReader -> pdf
    """
    with open('bmp2pdf.bmp', 'rb') as f:
        buf = StringIO.StringIO(f.read())
        ir = ImageReader(buf)
        c = canvas.Canvas('StringIO2pdf.pdf', pagesize=landscape(A4))
        (w, h) = landscape(A4)
        width, height = letter
        #c.drawImage(filename, inch, height - 2 * inch) # Who needs consistency?
        c.drawImage(ir, 0, 0, w, h)
        c.showPage()
        c.save()

 def get_frame(self, debug, side='Left'): # or Right
     x1 = 0
     if side == 'Right':
         x1 = landscape(letter)[0]/2
     return Frame(x1=x1,
                  y1=0,
                  width=landscape(letter)[0]/2,
                  height=landscape(letter)[1],
                  leftPadding=self.left_padding,
                  bottomPadding=DEFAULT_PADDING,
                  rightPadding=self.right_padding,
                  topPadding=DEFAULT_PADDING,
                  showBoundary=debug)

def createPDF(pdf, texts):
    page = pagesizes.landscape(pagesizes.A4)
    pdf.setFillColorRGB(0.0, 0.0, 0.0)
    pdf.setPageSize(page)
    for text in texts:
        centerString(pdf, page, text)
        pdf.showPage()

 def render(self):
     elements = []
     
     self.styles['Title'].alignment = TA_LEFT
     self.styles['Title'].fontName = self.styles['Heading2'].fontName = "Helvetica"
     self.styles["Normal"].fontName = "Helvetica"
     self.styles["Normal"].fontSize = 10
     self.styles["Normal"].fontWeight = "BOLD"
         
     filename = self.filename + datetime.now().strftime("%Y%m%d%H%M%S") + ".pdf"
     doc = SimpleDocTemplate(filename)
     
     elements.append(Paragraph(self.title, self.styles['Title']))
     
     clinics = Provider.objects.values('clinic').distinct()
     
     for data in self.data:
         elements.append(data)
     
     #elements.append(Paragraph("Created: %s" % datetime.now().strftime("%d/%m/%Y"), styles["Normal"]))        
     if self.landscape is True:
         doc.pagesize = landscape(A4)
     
     doc.build(elements, onFirstPage=self.myFirstPage, onLaterPages=self.myLaterPages)
     
     response = HttpResponse(mimetype='application/pdf')
     response['Cache-Control'] = ""
     response['Content-Disposition'] = "attachment; filename=%s" % filename
     response.write(open(filename).read())
     os.remove(filename)
     return response

def generate_sertificate(first_name, last_name, employment, pdf_file_name):
    attendee_name = first_name + ' ' + last_name
    c = canvas.Canvas(pdf_file_name, pagesize=landscape(letter))

    # header text
    c.setFont('Helvetica', 48, leading=None)
    c.drawCentredString(415, 500, 'Employee Certificate')
    c.setFont('Helvetica', 24, leading=None)
    c.drawCentredString(415, 450, 'This certificate is presented to:')
    # attendee name
    c.setFont('Helvetica-Bold', 34, leading=None)
    c.drawCentredString(415, 395, attendee_name)
    # for completing the...
    c.setFont('Helvetica', 24, leading=None)
    c.drawCentredString(415, 350, 'who holds the position in the IT company of:')
    # employment
    c.setFont('Helvetica', 20, leading=None)
    c.drawCentredString(415, 310, employment)
    # image of seal
    seal = 'certificate.ico'
    c.drawImage(seal, 350, 150, width=100, height=100)

    c.showPage()

    c.save()

    def write_string_to_pdf(self, participants_name):
        outputfiletemp = 'output/testoutput.pdf'
        pdf1File = open('templates/participants.pdf', 'rb')
        pdf1Reader = PyPDF2.PdfFileReader(pdf1File)
        pdfWriter = PyPDF2.PdfFileWriter()

        packet = StringIO.StringIO()

        cv=canvas.Canvas(packet, pagesize=letter)
        cv.setPageSize(landscape(letter))
        #create a string
        cv.drawString(350, 300, participants_name)
        #save to string
        cv.save()
        #write to a file
        with open(outputfiletemp,'wb') as fp:
            fp.write(packet.getvalue())

        certFirstPage = pdf1Reader.getPage(0)
        pdfWatermarkReader = PyPDF2.PdfFileReader(open(outputfiletemp, 'rb'))
        certFirstPage.mergePage(pdfWatermarkReader.getPage(0))
        pdfWriter.addPage(certFirstPage)

        pdfOutputFile = open('output/pyconph2015_certificate_' + participants_name + '.pdf', 'wb')
        pdfWriter.write(pdfOutputFile)
        pdfOutputFile.close()
        pdf1File.close()

def reporte_proveedores(request):
    print ("Genero el PDF");
    response = HttpResponse(content_type='application/pdf')
    pdf_name = "proveedores.pdf"  # llamado clientes
    # la linea 26 es por si deseas descargar el pdf a tu computadora
    # response['Content-Disposition'] = 'attachment; filename=%s' % pdf_name
    buff = BytesIO()
    doc = SimpleDocTemplate(buff,
                            pagesize=landscape(legal),
                            rightMargin=40,
                            leftMargin=40,
                            topMargin=60,
                            bottomMargin=18,
                            )
    proveedores = []
    styles = getSampleStyleSheet()
    header = Paragraph("Listado de Proveedores", styles['Heading1'])
    proveedores.append(header)
    headings = ('No. Proveedor','Nombre','RFC','Giro','Direccion','Ciudad','Estado','Pais','Telefono','Correo','Comentario')
    allproveedores = [(p.num_proveedor, p.nombre, p.RFC ,p.giro ,p.direccion ,p.ciudad ,p.estado ,p.pais ,p.telefono ,p.correo ,p.comentario) for p in Proveedor.objects.all()]
    print (allproveedores);

    t = Table([headings] + allproveedores)
    t.setStyle(TableStyle(
        [
            ('GRID', (0, 0), (12, -1), 1, colors.dodgerblue),
            ('LINEBELOW', (0, 0), (-1, 0), 2, colors.darkblue),
            ('BACKGROUND', (0, 0), (-1, 0), colors.dodgerblue)
        ]
    ))
    proveedores.append(t)
    doc.build(proveedores)
    response.write(buff.getvalue())
    buff.close()
    return response

    def __init__(self, filename, title_left, title_right, portrait=True):
        if portrait is True:
            page_size = A4
            column_width = 8*cm
        else:
            page_size = landscape(A4)
            column_width = 13*cm
        SimpleDocTemplate.__init__(self, filename, pagesize=page_size,
                                   topMargin=0*cm,
                                   leftMargin=2 * cm,
                                   rightMargin=2 * cm,
                                   bottomMargin=0.5 * cm,
                                   )
        self.fileName = filename
        im1 = Image(settings.MEDIA_ROOT + 'logo_EPC.png', width=170, height=80, hAlign=TA_LEFT)
        data = list()
        data.append([im1, ''])
        data.append([Spacer(0, 0.5*cm)])

        data.append([title_left, title_right])
        t = Table(data, colWidths=[column_width]*2, hAlign=TA_LEFT)
        t.setStyle(
            TableStyle(
                [
                    ('SIZE', (0, 0), (-1, -1), 9),
                    ('FONT', (0, 0), (-1, 0), 'Helvetica-Bold'),
                    ('ALIGN', (0, 0), (0, 0), 'LEFT'),
                    ('ALIGN', (1, 0), (-1, -1), 'RIGHT'),
                    ('LINEABOVE', (0, 0), (-1, -1), 0.5, colors.black),
                    ('LINEBELOW', (0, -1), (-1, -1), 0.5, colors.black),
                ]
            )
        )
        self.flowable.append(t)

 def __init__(self,filename):
     self.filename = r"%s" % filename
     self.myold = oldpdf(self.filename)
     self.canvas_obj = canvas.Canvas(self.filename,pagesize=pagesizes.landscape(letter))
     self.canvas_obj.grid(self.make_listx(),self.make_listy())
     self.canvas_obj.setFont("Times-Roman", self.fontsize_to_fit)
     self.label_axes()