def build(self, printfile, style=1):
     template = SimpleDocTemplate(printfile, showBoundary=0)
     tFirst = PageTemplate(id='First', frames=self.getStyle(1, style), onPage=self.myPages, pagesize=defaultPageSize)
     tNext = PageTemplate(id='Later', frames=self.getStyle(2, style), onPage=self.myPages, pagesize=defaultPageSize)
     template.addPageTemplates([tFirst, tNext])
     template.allowSplitting = 1
     BaseDocTemplate.build(template, self.data)

def _create_application(application_buffer, application):
    every_page_frame = Frame(PAGE_MARGIN, PAGE_MARGIN, PAGE_WIDTH - 2 * PAGE_MARGIN, PAGE_HEIGHT - 2 * PAGE_MARGIN,
                             id='EveryPagesFrame')
    every_page_template = PageTemplate(id='EveryPages', frames=[every_page_frame])

    doc = BaseDocTemplate(application_buffer, pageTemplates=[every_page_template], pagesize=A4)

    elements = []

    elements.append(Paragraph(application.licence_type.name.encode('UTF-8'), styles['ApplicationTitle']))

    # cannot use licence get_title_with_variants because licence isn't saved yet so can't get variants
    if application.variants.exists():
        variants = '({})'.format(' / '.join(application.variants.all().values_list('name', flat=True)))
        elements.append(Paragraph(variants, styles['ApplicationVariantsTitle']))

    elements.append(Spacer(1, SECTION_BUFFER_HEIGHT))

    elements.append(_create_application_metadata(application))

    elements.append(Spacer(1, SECTION_BUFFER_HEIGHT))

    for field, datum in zip(application.licence_type.application_schema, application.data):
        _create_application_questionaire(field, datum, elements, 0)

    doc.build(elements)

    return application_buffer

 def __init__(self, filename, **kw):
     frame1 = Frame(2.5*cm, 2.5*cm, 16*cm, 25*cm, id='Frame1')
     self.allowSplitting = 0
     self.showBoundary = 1
     BaseDocTemplate.__init__(self, filename, **kw)
     template = PageTemplate('normal', [frame1], myMainPageFrame)
     self.addPageTemplates(template)

def create_pdf(togen, template_page, pos, dat):
    "Create the pdf, stream api"
    document = BaseDocTemplate(togen)
    page = MyPage(template_page, name='background') 
    document.addPageTemplates([page])
    elements = [NextPageTemplate('background')]
    # may add flowables to element here
    
    # add absolute content
    for posname in dat:
        if posname.startswith("_"): # ignore extra info
            continue
        if posname not in pos:
            raise Exception("%s does not have a position" % posname)
        tup = pos[posname]
        x, y = tup[0], tup[1]
        width = tup[2] if len(tup)>2 else PAGE_WIDTH
        style = tup[3] if len(tup)>3 else DEFAULT_STYLE
        data = dat[posname]
        if type(data) in (str, unicode):
            page.addAbsParagraph(data, x, y, width, style)
        else:
            page.addAbsPrimitive(data, x, y, width) # don't need no style
    # create page
    document.multiBuild(elements)

    def handle_flowable(self, flowables):
        f = flowables[0]
        BaseDocTemplate.handle_flowable(self, flowables)

        if hasattr(f, "link_object"):
            (obj, text) = f.link_object

            if type(obj).__name__ == "Club":
                if obj.departement != self.club_seen:
                    key = "Departement{}".format(obj.departement)
                    self.canv.bookmarkPage(key)
                    self.canv.addOutlineEntry("Département {}".format(obj.departement), key, level=0, closed=1)
                    self.club_seen = obj.departement
                level = 1

            elif type(obj).__name__ == "Competition":
                if not self.competition_seen:
                    key = "Competition"
                    self.canv.bookmarkPage(key)
                    self.canv.addOutlineEntry("Détail des compétitions", key, level=0, closed=1)
                    self.competition_seen = True
                level = 1

            else:
                level = 2

            key = obj.link()
            self.canv.bookmarkPage(key)
            self.canv.addOutlineEntry(text, key, level=level, closed=1)

    def build(self, flowables, onFirstPage=_doNothing, onLaterPages=_doNothing, canvasmaker=Canvas):
        #Override the build method
        self._calc()    #in case we changed margins sizes etc
        self.canvas = canvasmaker
        firstFrame = Frame(10,        # X
                       0,            # Y
                       A4[0]-20,     # width
                       A4[1]-106,     # height
                       id='normal')

        secondFrame = Frame(10,          # X
                       0,            # Y
                       A4[0]-20,     # width
                       A4[1]-46,     # height
                       #showBoundary=True,
                       id='normal')        
        
        self.addPageTemplates([PageTemplate(id='First',
                                            frames=[firstFrame],
                                            pagesize=self.pagesize,
                                            onPage=onFirstPage),
                                PageTemplate(id='Later',
                                            frames=[secondFrame],
                                            pagesize=self.pagesize,
                                            onPage=onLaterPages),
                                ]
        )
        if onFirstPage is _doNothing and hasattr(self,'onFirstPage'):
            self.pageTemplates[0].beforeDrawPage = self.onFirstPage
        if onLaterPages is _doNothing and hasattr(self,'onLaterPages'):
            self.pageTemplates[1].beforeDrawPage = self.onLaterPages
        BaseDocTemplate.build(self,flowables, canvasmaker=canvasmaker)        

class ReporteVertical(object):
	"""docstring for ReporteVertical"""
	def __init__(self, nombreReporteP, directorioArchivoP, operadorP):
		super(ReporteVertical, self).__init__()
		self.PAGE_HEIGHT = letter[1]
		self.PAGE_WIDTH = letter[0]
		self.story = []
		self.styles = getSampleStyleSheet()
		self.nombreReporte = str(nombreReporteP)
		self.dirArchivo = str(directorioArchivoP)
		self.tipoArchivo = ".pdf"
		global operador
		global imagenes
		operador = str(operadorP)
		imagenes = ['static/image/universidad.jpg', 'static/image/alcaldia.png']

	def inicializarReporte(self, nombreReporteP):
		self.doc = BaseDocTemplate(nombreReporteP, pagesize=letter)

	def contenidoFrame(self):
		self.contenidoFrame = Frame(self.doc.leftMargin, (self.doc.height - self.doc.topMargin), self.doc.width, self.doc.height / 6, showBoundary=1)

	def constructorPaginas(self):
		self.doc.addPageTemplates([PageTemplate(id='reporte', frames=self.contenidoFrame, onPage =encabezado, onPageEnd=piePagina)])

	def crearReporteVertical(self):
		try:
			self.inicializarReporte(os.path.join(self.dirArchivo, self.nombreReporte + self.tipoArchivo))
			self.contenidoFrame()
			self.constructorPaginas()
			self.story.append(Paragraph("El viaje del navegante. Blog de Python", self.styles['Normal']))
			self.doc.build(self.story)
			os.system(os.path.join(self.dirArchivo, self.nombreReporte + self.tipoArchivo))
		except Exception, e:
			print e

def build_pdf(filename):
    doc = BaseDocTemplate(filename)
    
    column_gap = 1 * cm
    
    doc.addPageTemplates(
        [
            PageTemplate(
                frames=[
                    Frame(
                        doc.leftMargin,
                        doc.bottomMargin,
                        doc.width / 2,
                        doc.height,
                        id='left',
                        rightPadding=column_gap / 2,
                        showBoundary=0  # set to 1 for debugging
                    ),
                    Frame(
                        doc.leftMargin + doc.width / 2,
                        doc.bottomMargin,
                        doc.width / 2,
                        doc.height,
                        id='right',
                        leftPadding=column_gap / 2,
                        showBoundary=0
                    ),
                ]
            ),
        ]
    )
    flowables = [
        Paragraph('word ' * 700, ParagraphStyle('default')),
    ]
    doc.build(flowables)

 def __init__(self,title, author, filename=None, size=(4,6), sb=0):
     (height,width,) = size
     if not filename:
         self.filename="%s-%sx%s.pdf" % (title,str(height),str(width))
     else:
         self.filename=filename
     pagesize = (width*inch,height*inch)
     F=Frame(0,0,width*inch,height*inch,
               leftPadding=0.5*inch,
               bottomPadding=0.50*inch,
               rightPadding=0.25*inch,
               topPadding=0.25*inch,
               showBoundary=sb)
     PT = PageTemplate(id="Notecard", frames=[F,])
     BaseDocTemplate.__init__(self, self.filename,
                              pageTemplates=[PT,], 
                              pagesize=pagesize,
                              showBoundary=sb,
                              leftMargin=0,
                              rightMargin=0,
                              topMargin=0,
                              bottomMargin=0,
                              allowSplitting=1,
                              title=title,
                              author=author)

    def fill(self, fname, pagesize, events, topspace, bottomspace, margins):
        tf = tempfile.NamedTemporaryFile(delete=False)
        pagesize = (pagesize[0] / 2 - 6, pagesize[1])
        doc = BaseDocTemplate(tf.name, pagesize=pagesize, leftMargin=margins, bottomMargin=bottomspace, rightMargin=margins, topMargin=topspace)
        column = Frame(doc.leftMargin+6, doc.bottomMargin+0.5*inch, doc.width-6, 3.3*inch)
        rsvp = Frame(doc.leftMargin+6, doc.bottomMargin, doc.width-6, 0.5*inch)
        doc.addPageTemplates(PageTemplate(frames=[rsvp, column]))

        # render one side
        story = []
        story.append(Paragraph("Please RSVP at map.berniesanders.com", styles["default"]))
        story.append(FrameBreak())
        for e in events:
            story.append(Event(e).render())
        doc.build(story)

        # now duplicate for 2-up
        src = PdfFileReader(open(tf.name, "rb"))
        out = PdfFileWriter()
        lhs = src.getPage(0)
        lhs.mergeTranslatedPage(lhs, lhs.mediaBox.getUpperRight_x(), 0, True)
        out.addPage(lhs)
        with open(fname.name, "wb") as outfile:
            out.write(outfile)
        os.remove(tf.name)

def create_pdf(data):
	report_header='./static/images/report-header.jpg'
	other_header='./static/images/report-header2.jpg'
	today=data[0]
	pname=data[1]
	orgname=data[2]
	mission=data[3]
	product=data[4]
	puser=data[5]
	inputs=data[6]
	outputs=data[7]
	controls=data[8]
	plots=data[9]
	regs=data[10]
	reporttext = []
	#File Name
	pdfname="hello"+pname+"_"+today
	doc=BaseDocTemplate(pdfname,pagesize=letter)
	frame=Frame(doc.leftMargin,doc.bottomMargin,doc.width,doc.height,id='normal')
	template=PageTemplate(id='test',frames=frame,onPage=footer)
	doc.addPageTemplates([template])
	styles = getSampleStyleSheet()
	methods="In keeping with the ReadyMade tenet to keep the analysis simple, we look for one key outcome variable that is highly correlated with the other available outcome variables "
	reporttext.append(Paragraph(methods,styles['Normal']))
	doc.build(metext)
	return pdfname

def makeForm():
    ''' Make PDF of MyPidge app form. '''
    posts = []
    pageWidth, pageHeight = A4
    formPages = (
    FormFront(None),
    FormFront(None),
    FormFront(None),
    FormFront(None),
    FormBack(None),
    FormBack(None),
    FormBack(None),
    FormBack(None),
    )
    for (offset, frame) in enumerate(formPages):
        posts.append(frame.makeFrame())
        if len(formPages)==(offset+1):
            # Break page at end of a PocketPidge
            # But need to do this twice if on an odd page
            posts.append(PageBreak())
        else:
            posts.append(FrameBreak())
        
    # Build File
    document = BaseDocTemplate("form.pdf", pagesize=A4)
    template = PageTemplate(frames=createFrames(pageWidth, pageHeight, 2, 2))
    document.addPageTemplates(template)
    document.build(posts)

    def build(self,
              header_flowable,
              body_flowable,
              footer_flowable,
              canvasmaker=canvas.Canvas):
        """
            Build the document using the flowables.

            Set up the page templates that the document can use

        """
        self.header_flowable = header_flowable
        self.body_flowable = body_flowable
        self.footer_flowable = footer_flowable
        self.calc_body_size(header_flowable,
                            footer_flowable,
                           )
        showBoundary = 0 # for debugging set to 1, otherwise 0

        body_frame = Frame(self.leftMargin,
                           self.bottomMargin + self.footer_height,
                           self.printable_width,
                           self.body_height,
                           leftPadding = 0,
                           bottomPadding = 0,
                           rightPadding = 0,
                           topPadding = 0,
                           id = "body",
                           showBoundary = showBoundary
                          )

        self.body_frame = body_frame
        self.normalPage = PageTemplate (id = 'Normal',
                                        frames = [body_frame,],
                                        onPage = self.add_page_decorators,
                                        pagesize = self.pagesize
                                       )
        # @todo set these page templates up
#        self.evenPage = PageTemplate (id='even',
#                                      frames=frame_list,
#                                      onPage=self.onEvenPage,
#                                      pagesize=self.pagesize
#                                     )
#        self.oddPage = PageTemplate (id='odd',
#                                     frames=frame_list,
#                                     onPage=self.onOddPage,
#                                     pagesize=self.pagesize
#                                    )
        self.landscapePage = PageTemplate (id='Landscape',
                                           frames = [body_frame,],
                                           onPage=self.add_page_decorators,
                                           pagesize=landscape(self.pagesize)
                                          )
        if self.defaultPage == "Landscape":
            self.addPageTemplates(self.landscapePage)
        else:
            self.addPageTemplates(self.normalPage)

        BaseDocTemplate.build(self, self.body_flowable, canvasmaker=canvasmaker)

 def __init__(self, name, teacher):
     self.PAGE_WIDTH = A4[0]
     self.PAGE_HEIGHT = A4[1]
     self.CENTRE_WIDTH = self.PAGE_WIDTH/2.0
     self.CENTRE_HEIGHT = self.PAGE_HEIGHT/2.0
     BaseDocTemplate.__init__(self,name, pagesize=A4, topMargin=0.5*cm)
     self.fileName = name
     self.teacher = teacher

 def handle_frameBegin(self, resume=0):
     BaseDocTemplate.handle_frameBegin(self, resume=resume)
     self.frame.add(Paragraph(self.__headerLeft, header_left_style), self.canv)
     self.frame.add(Paragraph(self.__headerRight, header_right_style), self.canv)
     self.frame.add(Paragraph(" ".join(list(self.__section)), header_style), self.canv)
     self.frame.add(Rule(lineWidth=0.5, spaceBefore=2, spaceAfter=1), self.canv)
     if self.__entryTitle:
         self.frame.add(self.__entryTitle, self.canv)

    def handle_pageBreak(self, slow=None):
	self._breaks += 1
	if self._breaks > 1 and self.page > 1 :
	    frame = self.frame
	    while (frame._y > 60) :
		para = Paragraph (u'\u3000.'.encode('utf8'), self.hiddenStyle) 
		frame.add(para, self.canv, trySplit=0)
	BaseDocTemplate.handle_pageBreak(self, slow)

  def __init__(self, *args, **kwargs):
    from reportlab.lib.units import cm

    if not kwargs.has_key('leftMargin'): kwargs['leftMargin'] = 1.5 * cm
    if not kwargs.has_key('rightMargin'): kwargs['rightMargin'] = 1.5 * cm
    if not kwargs.has_key('bottomMargin'): kwargs['bottomMargin'] = 1.5 * cm

    BaseDocTemplate.__init__(self, *args, **kwargs)

    def build(self, style=1):
        template = SimpleDocTemplate(config.get("paths.tempdir", "") + "print.pdf", showBoundary=0)
        tFirst = PageTemplate(id='First', frames=self.getStyle(1, style), onPage=self.myPages, pagesize=defaultPageSize)
        tNext = PageTemplate(id='Later', frames=self.getStyle(2, style), onPage=self.myPages, pagesize=defaultPageSize)

        template.addPageTemplates([tFirst, tNext])
        template.allowSplitting = 1
        BaseDocTemplate.build(template, self.data)
        return template.canv._doc.GetPDFData(template.canv)

 def build(self,flowables,onFirstPage=_doNothing, onLaterPages=_doNothing, canvasmaker=canvas.Canvas):
     self._calc()    #in case we changed margins sizes etc
     frameT = Frame(self.leftMargin, self.bottomMargin, self.width, self.height, id='normal')
     self.addPageTemplates([PageTemplate(id='First',frames=frameT, onPage=onFirstPage,pagesize=self.pagesize),
                     PageTemplate(id='Later',frames=frameT, onPage=onLaterPages,pagesize=self.pagesize)])
     if onFirstPage is _doNothing and hasattr(self,'onFirstPage'):
         self.pageTemplates[0].beforeDrawPage = self.onFirstPage
     if onLaterPages is _doNothing and hasattr(self,'onLaterPages'):
         self.pageTemplates[1].beforeDrawPage = self.onLaterPages
     BaseDocTemplate.build(self,flowables, canvasmaker=canvasmaker)

    def __init__(self, *args, **kwargs):
        BaseDocTemplate.__init__(self, *args, **kwargs)
        self.numPages = 0
        self._lastNumPages = 0
        self.setProgressCallBack(self._onProgress_cb)

        # For batch reports with several PDFs concatenated
        self.restartDoc = False
        self.restartDocIndex = 0
        self.restartDocPageNumbers = []