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

    def generator_file(self,D,d,m,b,bending_force,wear_force,velocity,Feff,FOS1,pdf_file_name):
        from reportlab.pdfgen import canvas
        from reportlab.lib.pagesizes import letter
        from reportlab.lib.pagesizes import portrait
        #from reportlab.platypus import image

        
        c=canvas.Canvas(pdf_file_name, pagesize=portrait(letter))
        c.setFont('Helvetica', 30 , leading=None)
        c.drawCentredString(320,750,'Final report generation')
        c.setFont('Helvetica', 25 , leading=None)
        c.drawString(10,700,"Unknown Parameters")
        c.drawString(500,700,"Values")
        c.setFont('Helvetica', 20 , leading=None)
        c.drawString(10,650,'Final Module =')
        c.drawString(500,650,str(m)+"mm")
        c.drawString(10,600,'Diameter of Gear=')
        c.drawString(500,600,str(D)+"mm")
        c.drawString(10,550,'Diameter of Pinion=')
        c.drawString(500,550,str(d)+"mm")
        c.drawString(10,500,'Deddendum=')
        c.drawString(500,500,str(m)+"mm")
        c.drawString(10,450,'Addendum=')
        c.drawString(500,450,str(1.25*m)+"mm")
        c.drawString(10,400,'Facewidth=')
        c.drawString(500,400,str(b)+"mm")
        c.drawString(10,350,'Permissible Bending force=')
        c.drawString(500,350,bending_force+"N")
        c.drawString(10,300,'Permissible Wear force=')
        c.drawString(500,300,wear_force+"N")
        c.drawString(10,250,'Velocity=')
        c.drawString(500,250,velocity+"m/s")
        c.drawString(10,200,'Available Factor of safty=')
        c.drawString(500,200,str(FOS1))
        c.drawString(10,150,'Maximum Effective force=')
        c.drawString(500,150,str(Feff))
        c.drawString(0,120,"------------------------------------------------------------------------------------------------")
        c.setFont('Helvetica', 30 , leading=None)
        c.drawString(200,75,"THANK YOU")
        self.count = self.count + 1

        c.showPage()
        c.save()

def receipt(response, people, amount_per_person, total):
  doc = p.SimpleDocTemplate(response)
  doc.pagesize = portrait(letter)

  elements = [p.Spacer(1, 2.5*inch)]

  # Create the main table of people.
  data = [['Activity', 'Rate/Unit', 'Count', 'Amount (USD)']]
  for person in people:
    data.append([person.name, '%.2f' % amount_per_person, 1, '%.2f' % amount_per_person])
  data.append(['','','',''])

  # Add in random accounting to make it look official.
  accounting_rows = 3
  data.append(['Sum Fees','','','%.2f' % (len(people) * amount_per_person)])
  if total != len(people) * amount_per_person:
    discount = len(people) * amount_per_person - total
    accounting_rows = 4
    data.append(['Discount','','','-%.2f' % (discount)])
  data.append(['Total','','','%.2f' % (total)])
  data.append(['Paid','','','-%.2f' % (total)])
  data.append(['Final Total','','','0.00'])

  # Draw some lines for style.
  style = p.TableStyle([
    ('LINEBELOW', (0, 0), (-1, 0), 2, colors.black),
    ('LINEBELOW', (0, -accounting_rows-2), (-1, -accounting_rows-2), 1, colors.black),
    ('LINEBELOW', (0, -2), (-1, -2), 2, colors.black),
    ('ALIGNMENT', (1, 0), (-1, -1), 'RIGHT'),
    ])
  elements.append(p.Table(data, colWidths=[3*inch, 1*inch, 0.75*inch, 1*inch], style=style))

  elements.append(p.Spacer(1, 1*inch))
  elements.append(p.Paragraph('Thank you for your patronage.',
                              style=ParagraphStyle('centered',alignment=1)))

  doc.build(elements, onFirstPage=drawHeading)

def make_report(infile, subdir='pdfs'):
    outdir = os.path.join(os.path.dirname(infile), subdir)
    try:
        os.makedirs(outdir)
    except OSError:
        pass

    basename = '.'.join(os.path.basename(infile).split('.')[:-1])
    outfile = os.path.join(outdir, basename + '.pdf')

    logger.info('Saving output to file ' + outfile)

    # Open the input FITS file and extract the HDUs.
    hdulist = pyfits.open(infile)
    kic_id = hdulist[0].header['kic_id']
    data_hdus = hdulist[1:-1]

    c = canvas.Canvas(outfile)
    page_width, page_height = portrait(letter)
    c.setPageSize((page_width,page_height))

    page_height /= inch
    page_width /= inch
    margin = 0.1
    bigmargin = 0.25
    fig_width = page_width - 2. * margin
    fig_height = 0.5 * page_height - 2. * margin
    color1 = 'CadetBlue'
    color2 = 'Chartreuse'
    alpha = 0.5
    edgecolor = 'black'
    markersize = 20

    count = len(data_hdus) / 2

    for i in xrange(0, len(data_hdus), 2):
        bls = data_hdus[i].data
        lc = data_hdus[i+1].data
        lchdr = data_hdus[i+1].header

        # Extract the light curve.
        time = lc['time']
        flux = lc['flux']
        yrng = np.ptp(flux)

        fig = plt.figure(figsize=(fig_width,fig_height), dpi=inch)

        try:
            period = lchdr['period']
            phase = lchdr['phase']
            duration = lchdr['duration']
            depth = lchdr['depth']

            pftime = np.mod(time, period)
            pftime2 = np.mod(time - phase + period / 2., period)
            signal_mask = ((pftime2 > 0.5 * period - 0.5 * duration) &
                (pftime2 < 0.5 * period + 0.5 * duration))

            plt.subplot(211)
            plt.scatter(time, flux, color=color1, edgecolor=edgecolor,
                alpha=alpha, s=markersize)
            plt.xlim(time[0], time[-1])
            plt.ylim(np.amin(flux) - 0.05 * yrng, np.amax(flux) + 0.05 * yrng)
            plt.xlabel(r'Time (BJD)')
            plt.ylabel(r'Flux')
            plt.title(r'KIC' + kic_id + r', pass #%d' % count)

            plt.subplot(212)
            plt.scatter(pftime[~signal_mask], flux[~signal_mask], color=color1,
                edgecolor=edgecolor, alpha=alpha, s=markersize)
            plt.scatter(pftime[signal_mask], flux[signal_mask],
                color=color2, edgecolor=edgecolor, alpha=alpha, s=markersize)
            plt.xlim(np.amin(pftime), np.amax(pftime))
            plt.ylim(np.amin(flux) - 0.05 * yrng, np.amax(flux) + 0.05 * yrng)
            plt.xlabel(r'Time (days)')
            plt.ylabel(r'Flux')
            plt.figtext(0.05, 0.02,
                r'P = %.4f, phi = %.2f, W = %.2f, delta = %.2g' % (period,
                phase / period, duration, depth))

            plt.tight_layout()
            plt.subplots_adjust(bottom=0.15)
        except KeyError:
            plt.subplot(111)
            plt.scatter(time, flux, color=color1, edgecolor=edgecolor,
                alpha=alpha, s=markersize)
            plt.xlim(time[0], time[-1])
            plt.ylim(np.amin(flux) - 0.05 * yrng, np.amax(flux) + 0.05 * yrng)
            plt.xlabel(r'Time (BJD)')
            plt.ylabel(r'Flux')
            plt.title(r'KIC' + kic_id + r', pass #%d' % count)

            plt.tight_layout()

        imgdata = cStringIO.StringIO()
        fig.savefig(imgdata, format='png')
        plt.close()
        imgdata.seek(0)
        img = ImageReader(imgdata)
        c.drawImage(img, margin * inch, 0.5 * page_height * inch,
#.........这里部分代码省略.........

elements =[]
styleS = getSampleStyleSheet()
styleS.add(ParagraphStyle(name='Left', alignment=TA_LEFT,fontName='Times-Bold',fontSize=14,spaceAfter=10))
elements.append(Paragraph(title, styleS["Left"]))

MakeTable()

if Layout == "Landscape8x11":
    PDF = scratch + r"\LandscapeMap.pdf"
    doc = SimpleDocTemplate(PDF, rightMargin = 72,bottomMargin=10, topMargin=10)
    doc.pagesize = landscape(A4)
elif Layout == "Portrait8x11":
    PDF = scratch + r"\PortraitMap.pdf"
    doc = SimpleDocTemplate(PDF, rightMargin = 72,bottomMargin=10, topMargin=10)
    doc.pagesize = portrait(A4)

doc.build(elements)


if WebMap == '#' or not WebMap:
    finalPdf = PDF
    # Set output file
    arcpy.SetParameterAsText(1, PDF)
    arcpy.AddMessage("  Finished")

else:
    if Layout == "Portrait8x11":
        LayoutFormat = "A4 Portrait"
        arcpy.ExportWebMap_server(WebMap, MapPDF,"PDF", "", LayoutFormat)
    else:

 def _create_pagesize(self,width,height):
     import reportlab.lib.pagesizes as ps
     return ps.portrait( (width * ps.inch, height * ps.inch))