Python Canvas.setTitle方法代码示例

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

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
    def overlay_hocr_page(self, dpi, hocr_filename, img_filename):
        hocr_dir, hocr_basename = os.path.split(hocr_filename)
        img_dir, img_basename = os.path.split(img_filename)
        logging.debug("hocr_filename:%s, hocr_dir:%s, hocr_basename:%s" % (hocr_filename, hocr_dir, hocr_basename))
        assert(img_dir == hocr_dir)

        #basename = hocr_basename.split('.')[0]
        basename = os.path.splitext(hocr_basename)[0]
        pdf_filename = os.path.join("text_%s_ocr.pdf" % (basename))

        # Switch to the hocr directory to make this easier
        cwd = os.getcwd()
        if hocr_dir != "":
            os.chdir(hocr_dir)

        with open(pdf_filename, "wb") as f:
            logging.info("Overlaying hocr and creating text pdf %s" % pdf_filename)
            pdf = Canvas(f, pageCompression=1)
            pdf.setCreator('pypdfocr')
            pdf.setTitle(os.path.basename(hocr_filename))
            pdf.setPageCompression(1)

            width, height, dpi_jpg = self._get_img_dims(img_basename)
            pdf.setPageSize((width,height))
            logging.info("Page width=%f, height=%f" % (width, height))

            pg_num = 1

            logging.info("Adding text to page %s" % pdf_filename)
            self.add_text_layer(pdf,hocr_basename,pg_num,height,dpi)
            pdf.showPage()
            pdf.save()

        os.chdir(cwd)
        return os.path.join(hocr_dir, pdf_filename)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
def drawToFile(d, fn, msg="", showBoundary=rl_config._unset_, autoSize=1):
    """Makes a one-page PDF with just the drawing.

    If autoSize=1, the PDF will be the same size as
    the drawing; if 0, it will place the drawing on
    an A4 page with a title above it - possibly overflowing
    if too big."""
    d = renderScaledDrawing(d)
    c = Canvas(fn)
    if msg:
        c.setFont(rl_config.defaultGraphicsFontName, 36)
        c.drawString(80, 750, msg)
    c.setTitle(msg)

    if autoSize:
        c.setPageSize((d.width, d.height))
        draw(d, c, 0, 0, showBoundary=showBoundary)
    else:
        #show with a title
        c.setFont(rl_config.defaultGraphicsFontName, 12)
        y = 740
        i = 1
        y = y - d.height
        draw(d, c, 80, y, showBoundary=showBoundary)

    c.showPage()
    c.save()
    if sys.platform=='mac' and not hasattr(fn, "write"):
        try:
            import macfs, macostools
            macfs.FSSpec(fn).SetCreatorType("CARO", "PDF ")
            macostools.touched(fn)
        except:
            pass

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
def create_new_pdf(playground, width, height):
  import reportlab.rl_config
  from reportlab.pdfgen.canvas import Canvas
  pdf = Canvas(os.path.join(playground, "book.pdf"),
               pagesize=(width, height), pageCompression=1)
  pdf.setCreator('cheesegrater')
  pdf.setTitle(os.path.basename(playground))
  load_font()
  return pdf

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
    def overlay_hocr(self, dpi, hocr_filename):
        hocr_dir, hocr_basename = os.path.split(hocr_filename)
        logging.debug("hocr_filename:%s, hocr_dir:%s, hocr_basename:%s" % (hocr_filename, hocr_dir, hocr_basename))
        basename = hocr_basename.split('.')[0]
        pdf_filename = os.path.join("%s_ocr.pdf" % (basename))
        # Switch to the hocr directory to make this easier

        cwd = os.getcwd()
        if hocr_dir != "":
            os.chdir(hocr_dir)

        with open(pdf_filename, "wb") as f:
            logging.info("Overlaying hocr and creating final %s" % pdf_filename)
            pdf = Canvas(f, pageCompression=1)
            pdf.setCreator('pyocr')
            pdf.setTitle(os.path.basename(hocr_filename))
            logging.info("Analyzing OCR and applying text to PDF...")

            pdf.setPageCompression(1)
            logging.info("Searching for %s" % ("%s*.jpg" % basename))

            for jpg_file in glob.glob("%s*.jpg" % basename):

                jpg = Image.open(jpg_file)
                w,h = jpg.size
                dpi_jpg = jpg.info['dpi']
                width = w*72.0/dpi_jpg[0]
                height = h*72.0/dpi_jpg[1]
                del jpg

                pdf.setPageSize((width,height))
                logging.info("Adding page image %s" % jpg_file)
                logging.info("Page width=%f, height=%f" % (width, height))
                pdf.drawImage(jpg_file,0,0, width=width, height=height)
                # Get the page number
                pg_num = int(jpg_file.split(basename)[1].split('.')[0])
                logging.info("Adding text to page %d" % pg_num)
                self.add_text_layer(pdf, hocr_basename,pg_num,height,dpi)
                pdf.showPage()
                os.remove(jpg_file)

            pdf.save()
        logging.info("Created OCR'ed pdf as %s" % (pdf_filename))

	# Now we have to fix up stuff on windows because of reportlab
	# adding \r\r\n on each line (instead of \r\n)
	f = open(pdf_filename, "rb")
	s = str(f.read())
	f.close()
	#s = s.replace('\r\r\n', '\r\n')
	#s = re.sub("\r\r\n", "\r\n", s)
	#f = open(pdf_filename, "wb")
	#f.write(s)
	#f.close()
        os.chdir(cwd)
        return os.path.join(hocr_dir,pdf_filename)

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
 def makePDF(self, outfile):
     canvas = Canvas(outfile, self.pageSize)
     if self.title:
         canvas.setTitle(self.title)
     # canvas.setAuthor(...)
     # canvas.setSubject(...)
     for n, s in enumerate(self.slides):
         s.drawOn(canvas, self.pageSize)
         canvas.showPage()
     canvas.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
 def render(self, path):
     canvas = Canvas(path, pagesize=A4, pageCompression=1)
     canvas.setTitle(self.title)
     canvas.setSubject(self.subject)
     canvas.setAuthor(self.author)
     canvas.setCreator(self.creator)
     canvas._doc.info.producer = self.creator
     self.canvas = canvas
     self.render_pages()
     self.canvas.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
 def _save_pdf(self):
     """
     Output the current document to a PDF file using ReportLab.
     """
     save_model = self.application.get_save_model()
     save_view = self.application.get_save_view()
     document_model = self.application.get_document_model()
     
     # TODO: seperate saving code into its own thread?
     
     # Setup output pdf
     pdf = PdfCanvas(save_model.filename)
     pdf.setTitle(save_model.title)
     pdf.setAuthor(save_model.author)
     pdf.setKeywords(save_model.keywords)
         
     # Generate pages
     page_iter = document_model.get_iter_first()
     while page_iter:
         current_page = document_model.get_value(page_iter, 0)
         
         # Write transformed image
         temp_file_path = ''.join([tempfile.mktemp(), '.bmp'])
         current_page.pil_image.save(temp_file_path)
     
         assert os.path.exists(temp_file_path), \
             'Temporary bitmap file was not created by PIL.'
         
         size = constants.PAGESIZES_INCHES[current_page.page_size]
         pdf_width = size[0] * points_per_inch 
         pdf_height = size[1] * points_per_inch
         
         # Swizzle width and height if the page has been rotated on its side
         if abs(current_page.rotation) % 180 == 90:
             pdf_width, pdf_height = pdf_height, pdf_width
             
         pdf.setPageSize((pdf_width, pdf_height))
         pdf.drawImage(
             temp_file_path, 
             0, 0, width=pdf_width, height=pdf_height, 
             preserveAspectRatio=True)
         pdf.showPage()
         
         os.remove(temp_file_path)
         
         page_iter = document_model.iter_next(page_iter)
         
     # Save complete PDF
     pdf.save()
         
     assert os.path.exists(save_model.filename), \
         'Final PDF file was not created by ReportLab.'
         
     document_model.clear()

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

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
    def makePDF(self, outfile):
        """Render the presentation into a PDF.

        ``outfile`` can be a filename or a file-like object.
        """
        canvas = Canvas(outfile, self.pageSize)
        if self.title:
            canvas.setTitle(self.title)
        # canvas.setAuthor(...)
        # canvas.setSubject(...)
        for n, s in enumerate(self.slides):
            s.drawOn(canvas, self.pageSize)
            canvas.showPage()
        canvas.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
    def draw(self, invoice, stream):
        """ Draws the invoice """
        # embed unicode font
        pdfmetrics.registerFont(
            TTFont('FreeSans', join(STATIC_DIR, 'FreeSans.ttf'))
        )
        addMapping('FreeSans', 0, 0, 'FreeSans')

        self.baseline = -2*cm

        canvas = Canvas(stream, pagesize=A4)
        canvas.setCreator("django-invoice")
        canvas.setAuthor(smart_text(invoice.contractor))
        canvas.setTitle(smart_text(invoice))

        canvas.translate(0, 29.7*cm)
        canvas.setFont(self.FONT_NAME, 10)

        canvas.saveState()
        self.draw_header(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_subscriber(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_contractor(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_info(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_items(invoice, canvas)
        canvas.restoreState()

        canvas.saveState()
        self.draw_footer(invoice, canvas)
        canvas.restoreState()

        canvas.showPage()
        canvas.save()
        canvas = None
        self.baseline = 0

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
def start_pdf(filename, author=None, keywords=None, subject=None, title=None):
    """ Starts a new pdf document
    @param filename the name of the PDF generated in output.
    @param author the author name.
    @param subject the subject of the document.
    @param title the title of the document.
    """
    canvas = Canvas(filename)

    if author:
        canvas.setAuthor(author)
    if keywords:
        canvas.setKeywords(keywords)
    if title:
        canvas.setTitle(title)
    if subject:
        canvas.setSubject(subject)
    canvas.setPageCompression(1)
    return canvas

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
    def generateCollage(self,session):
        file_name =  'collage.pdf' #TODO image should be created in a temp directory
        pdf = Canvas(file_name,pagesize=self._pagesize)
        # add metadata
        pdf.setAuthor('photobooth') #TODO add app version to author
        pdf.setSubject('wedding photos')
        pdf.setTitle('pictures for session %s' % session.get_name())
        pdf.setKeywords(('wedding', 'pictures','photobooth'))

        # add pictures
        #TODO add padding
        (total_width, total_height) = self._pagesize
        (image_width, image_height) = (total_width, total_height / len(session.get_photos()))        
        for (i,photo) in enumerate(session.get_photos()):
            pdf.drawInlineImage(photo,0,i * image_height, image_width, image_height, preserveAspectRatio=True, anchor='n')
        
        pdf.showPage()
        pdf.save()
        return file_name

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
def generate_key(verticalCardsCount,horizontalCardsCount,cards, filename="key.pdf", page_margins = 4 * (0.5 * pagesizes.inch, )):
    (page_margin_top, page_margin_left, page_margin_bottom, page_margin_right) = page_margins
    padding = 0.0625 * pagesizes.inch

    spaces = (verticalCardsCount * horizontalCardsCount) * [None,]
    for card in cards:
        spaces[card.position] = card

    pagesize = pagesizes.landscape( ( 8.5 * pagesizes.inch, 11 * pagesizes.inch))
    pdf = Canvas(filename, pagesize=pagesize, pdfVersion=(1,4))
    pdf.setAuthor('placecardboardgenerate.py')
    pdf.setSubject('wedding placecards key')
    pdf.setTitle('Key for Placecards for Wedding Reception')
    pdf.setKeywords(('wedding', 'placecards'))

    (page_width, page_height) = pagesize

    pdf.drawCentredString(page_width/2.0,20,"key of place cards")

    thumbnail_width = ((page_width - page_margin_left - page_margin_right) - (padding * (horizontalCardsCount - 1))) / horizontalCardsCount
    thumbnail_height = ((page_height - page_margin_top - page_margin_bottom) - (padding * (verticalCardsCount - 1))) / verticalCardsCount


    x_margin = page_margin_left
    x_offset = thumbnail_width + padding
    y_margin = page_margin_top
    y_offset = thumbnail_height + padding


    for row_index in range(verticalCardsCount):
        for column_index in range(horizontalCardsCount):
            position = (row_index * horizontalCardsCount) +  column_index
            card = spaces[position]
            (card_x, card_y) = \
                 (x_margin + (x_offset * column_index),\
                  (page_height - thumbnail_height) - (y_margin + (y_offset * row_index)))
            
            if card is not None:
                pdf.drawImage(card.image, card_x, card_y, width = thumbnail_width, height = thumbnail_height)
                pdf.drawCentredString(card_x + thumbnail_width/2.0,card_y + thumbnail_height/2.0, str(card.position))
    
    pdf.showPage()
    pdf.save()

# 需要导入模块: from reportlab.pdfgen.canvas import Canvas [as 别名]
# 或者: from reportlab.pdfgen.canvas.Canvas import setTitle [as 别名]
 def run(self):
     try:
         filename = self.filename + '.pdf'
         if os.path.exists(filename):
             raise Exception('File already exists')
         canvas = Canvas(filename, pageCompression=1)
         canvas.setCreator('Scanvark')
         canvas.setTitle('Scanned document')
         i = 0
         count = len(self.pages)
         for i, page in enumerate(self.pages):
             self._progress_callback(self, i, count)
             w, h = [a * 72 / page.resolution for a in page.size]
             canvas.setPageSize((w, h))
             reader = ImageReader(page.open_jpeg())
             canvas.drawImage(reader, 0, 0, width=w, height=h)
             canvas.showPage()
         self._progress_callback(self, i, count)
         canvas.save()
     except Exception, e:
         self._error_callback(self, str(e))