Example #1
0
 def __init__(self, id, pageSize=defaultPageSize):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     colWidth = 0.5 * (self.pageWidth - 2.25 * inch)
     frame1 = Frame(inch, inch, colWidth, self.pageHeight - 2 * inch, id="leftCol")
     frame2 = Frame(0.5 * self.pageWidth + 0.125, inch, colWidth, self.pageHeight - 2 * inch, id="rightCol")
     PageTemplate.__init__(self, id, [frame1, frame2])  # note lack of onPage
Example #2
0
 def __init__(self, title, subtitle, background=None):
     self.title = title
     self.subtitle = subtitle
     self.background = background
     
     dummy = Frame(1, 1, 200, 200, id='dummy')
     #ReportLab uses old style classes, so super() doesn't work.
     PageTemplate.__init__(self, id='cover', frames=[dummy])
Example #3
0
 def __init__(self, id, pageSize=defaultPageSize):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     frame1 = Frame(inch,
                    3*inch,
                    self.pageWidth - 2*inch,
                    self.pageHeight - 518, id='cover')
     PageTemplate.__init__(self, id, [frame1])  # note lack of onPage
Example #4
0
    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)
Example #5
0
 def __init__(self, pageSize=pagesizes.A4):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     frame1 = Frame(0,
                    0,
                    self.pageWidth,
                    self.pageHeight,
                    id='normal')
     PageTemplate.__init__(self, frames=[frame1])
Example #6
0
    def build_pdf(self):
        """Using different internal page methods and given the data provided build the report
        """
        # doc options to abstract and set
        # doc.creator
        # doc.encrypt
        # doc.author
        # doc.subject
        # doc.title
        style = self.styles["Normal"]
        doc = BaseDocTemplate(self._filename)

        # Flowables to be added to document
        Story = []

        # could create different sized frames and set addPageTemplate frames to array frames=[frame1, frame2]
        standard_frame = Frame(doc.leftMargin, doc.bottomMargin, doc.width, doc.height, id='sframe')

        Story.append(NextPageTemplate('host'))
        # space for title page
        Story.append(PageBreak())
        
        # Host data
        Story.append(Paragraph('Scanned Hosts ---------------------', self.styles['Heading2']))
        for h in self._report['hosts']:
            if h.get_display_val():
                hname = f'Hostname: {h.get_display_name()}'
                ip = f'IP Address: {h.get_ip()}'
                mac = f'MAC Address: {h.get_mac_address()}'
                Story.append(Paragraph(hname, style))
                Story.append(Paragraph(ip, style))
                Story.append(Paragraph(mac, style))
                Story.append(Spacer(1, 0.2 * inch))

        # cpe data
        Story.append(Paragraph('CPEs ---------------------', self.styles['Heading2']))
        if self._report['cpes']:
            for c in self._report['cpes']:
                if self._report['cpes'][c][0]:
                    cpe = self._report['cpes'][c][0]
                    Story.append(Paragraph(cpe, style))
                    Story.append(Spacer(1, 0.2 * inch))
        else:
            Story.append(Paragraph('No CPEs found', style))

        # Vuln Data
        Story.append(Paragraph('Vulnerabilities ---------------------', self.styles['Heading2']))
        if self._report['vulns']:
            for v in self._report['vulns']:
                Story.append(Paragraph(v, style))
        else:
            Story.append(Paragraph('No vulnerabilities found.', style))

        doc.addPageTemplates([PageTemplate(id='title', frames=standard_frame, onPage=self.title_page),
                              PageTemplate(id='host', frames=standard_frame, onPage=self.host_page)])

        doc.build(Story)
Example #7
0
 def __init__(self, id, pageSize=A4):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     frame1 = Frame(2.54 * cm,
                    1.25 * cm,
                    self.pageWidth - 2 * 2.54 * cm,
                    self.pageHeight - 2.54 * cm - 1.25 * cm,
                    id='Cover')
     PageTemplate.__init__(self, id, [frame1])  # note lack of onPage
Example #8
0
 def __init__(self, id, pageSize=defaultPageSize):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     frame1 = Frame(inch,
                    inch,
                    self.pageWidth - 2 * inch,
                    self.pageHeight - 2 * inch,
                    id='normal')
     PageTemplate.__init__(self, id, [frame1])  # note lack of onPage
Example #9
0
def main(sFilename,invoice):
    pdf_file = sFilename
    t = get_table(invoice)
    Elements = []

    def pgHdr(c, doc):
      width,height = A4
      #c.saveState()
      #c.translate(.3 * inch, 0 * inch)

      # STUFF RELATED TO 2 INCH STTIC HEADER FOR FIRST PAGE
      #c.restoreState()
    def othPg(c,doc):
      width,height = A4


    styles = getSampleStyleSheet()
    Elements.append(Spacer(1,2*inch))
    style = styles["Normal"]

    for i in range(3):
        bogustext = ("This is Paragraph number %s.  " % i) * 2
        p = Paragraph(bogustext, style)
        Elements.append(p)
        Elements.append(Spacer(1,0.2*inch))

    doc = BaseDocTemplate(pdf_file,
                    pagesize=A4,
                    leftMargin=.3*inch,
                    rightMargin= .1 * inch,
                    topMargin= .1 * inch,
                    bottomMargin=.3 * inch,
                    showBoundary=0)
    #normal frame as for SimpleFlowDocument
    #frameT = Frame(doc.leftMargin + 2*inch, doc.bottomMargin, doc.width - 2.01*inch, doc.height - 4.1*inch, id='normal', showBoundary=0)
    #frameB = Frame(doc.leftMargin+2, doc.bottomMargin, 7.5*inch, 10*inch, id='small', showBoundary=0)

    frameT = Frame(doc.leftMargin , doc.bottomMargin + 1*inch, doc.width, doc.height, id='normal', showBoundary=0)
    frameB = Frame(doc.leftMargin , doc.bottomMargin + 1*inch, doc.width, doc.height, id='normal', showBoundary=0)

  



    doc.addPageTemplates([PageTemplate(id='First',frames=frameT,onPage=pgHdr),
                        PageTemplate(id='Later',frames=frameB,onPage=othPg)
                        ])
    Elements.append(NextPageTemplate('First'))
    Elements.append(NextPageTemplate('Later'))
    Elements.append(t)

    #doc.addPageTemplates([PageTemplate(id='First',onPage=pgHdr)])
    #Elements.append(BaseDocTemplate)
    #Elements.append(t)

    doc.build(Elements)
Example #10
0
 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)
Example #11
0
 def __init__(self, params, pageSize=pagesizes.landscape(pagesizes.A4)):
     self.params = params
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     frame1 = Frame(cm,
                    cm,
                    self.pageWidth - 2*cm,
                    self.pageHeight - 2.5*cm,
                    id='normal')
     PageTemplate.__init__(self, frames=[frame1])
Example #12
0
    def _make_pdf(self) -> bytes:
        """
		Crea el pdf a partir de story. Ademas inicializa el doc con los estilo de las hojas y el tamaño.

		return pdf
		"""
        # La clase io.BytesIO permite tratar un array de bytes como un fichero binario,
        # se utiliza como almacenamiento temporal dentro de python, para luego ser descargado todo el dato como pdf
        pdf_buffer = BytesIO()
        #c = canvas.Canvas(buffer)
        doc = BaseDocTemplate(
            pdf_buffer,
            pagesize=A4)  # Se pasa el pdf_buffer al BaseDocTemplate
        frame0 = Frame(doc.leftMargin,
                       doc.bottomMargin,
                       doc.width,
                       doc.height,
                       showBoundary=0,
                       id='normalBorde')  # Frames o marcos de la pagina
        # Plantillas de las hojas, cabecera, pie de pagina, marco de la pagina. Se
        # puede tener varias plantillas. Siempre partira de la primera plantilla
        doc.addPageTemplates([
            PageTemplate(id='primera_hoja',
                         frames=frame0,
                         onPage=self._cabecera_1,
                         onPageEnd=self._pie_pagina),
            PageTemplate(id='contenido',
                         frames=frame0,
                         onPage=self._cabecera_contenido,
                         onPageEnd=self._pie_pagina)
        ])
        # Creamos las hojas de Estilos
        estilo = getSampleStyleSheet()
        estilo.add(
            ParagraphStyle(name="titulo_tablas_graficas",
                           alignment=TA_CENTER,
                           fontSize=15,
                           fontName="Helvetica-Bold",
                           textColor=colors.Color(0.0390625, 0.4921875,
                                                  0.69140625)))
        estilo.add(
            ParagraphStyle(name="texto",
                           alignment=TA_LEFT,
                           fontSize=12,
                           fontName="Helvetica",
                           textColor=colors.Color(0, 0, 0)))
        kargs = self._make_table_graphics(
            estilo)  # Dicionario con las tablas y graficas para el story
        story = self._make_story(**kargs)
        doc.build(story)  # Se construye el pdf con el array story
        #Descargando todo el buffer
        pdf = pdf_buffer.getvalue()
        pdf_buffer.close()
        return pdf
Example #13
0
 def __init__(self, pdf_template_filename, name=None):
     frames = [
         Frame(0.85 * inch, 0.5 * inch, PAGE_WIDTH - 1.15 * inch,
               PAGE_HEIGHT - (1.5 * inch))
     ]
     PageTemplate.__init__(self, name, frames)
     # use first page as template
     page = PdfReader(pdf_template_filename).pages[0]
     self.page_template = pagexobj(page)
     # Scale it to fill the complete page
     self.page_xscale = PAGE_WIDTH / self.page_template.BBox[2]
     self.page_yscale = PAGE_HEIGHT / self.page_template.BBox[3]
Example #14
0
 def __init__(self, id, pageSize=A4):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     frame3 = Frame(2.54 * cm,
                    1.25 * cm,
                    self.pageWidth - 2 * 2.54 * cm,
                    self.pageHeight - 2.54 * cm - 1.25 * cm - 1.75 * cm -
                    (title_1_style.fontSize * 2) - logo_height,
                    id='Credits')
     PageTemplate.__init__(self, id, [frame3])  # note lack of onPage
Example #15
0
    def render(self, articles, outfile):
        """
        render list of articles as PDF into a byte file-like output.
        """
        story = []

        self.render_header(story)
        self.render_articles(articles, story)

        # build the pdf document
        # to show frame boundaries set showBoundary=1
        doc = BaseDocTemplate(outfile, title='', author='')

        # first page, has space for drawing header
        firstPageTemplate = PageTemplate(
            id='First',
            autoNextPageTemplate='Next',
            frames=[
                Frame(doc.leftMargin,
                      doc.bottomMargin + doc.height - self.header_height,
                      doc.width,
                      self.header_height,
                      id='header'),
                Frame(doc.leftMargin,
                      doc.bottomMargin,
                      doc.width / 2 - 6,
                      doc.height - self.header_height,
                      id='col1'),
                Frame(doc.leftMargin + doc.width / 2 + 6,
                      doc.bottomMargin,
                      doc.width / 2 - 6,
                      doc.height - self.header_height,
                      id='col2')
            ])

        laterPagesTemplate = PageTemplate(id='Next',
                                          frames=[
                                              Frame(doc.leftMargin,
                                                    doc.bottomMargin,
                                                    doc.width / 2 - 6,
                                                    doc.height,
                                                    id='col1'),
                                              Frame(doc.leftMargin +
                                                    doc.width / 2 + 6,
                                                    doc.bottomMargin,
                                                    doc.width / 2 - 6,
                                                    doc.height,
                                                    id='col2')
                                          ])

        doc.addPageTemplates([firstPageTemplate, laterPagesTemplate])

        doc.build(story)
Example #16
0
 def __init__(self, id, pageSize=A4):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     frame2 = Frame(2.54 * cm,
                    1.25 * cm,
                    self.pageWidth - 2 * 2.54 * cm,
                    self.pageHeight - 2.54 * cm - 1.25 * cm -
                    (title_1_style.fontSize * 2),
                    id='Normal')
     PageTemplate.__init__(self, id, [frame2])  # note lack of onPage
Example #17
0
 def init_templates(self, page_fn, page_fn_later=None):
     self.doc.addPageTemplates([
         PageTemplate(
             id='First',
             frames=[self.frame],
             onPage=page_fn),
         PageTemplate(
             id='Later',
             frames=[self.frame],
             onPage=page_fn_later or page_fn),
     ])
     self.story.append(NextPageTemplate('Later'))
Example #18
0
    def __init__(self, aDocInfo, aStyleSheet):
        self.docInfo = aDocInfo
        self.style = aStyleSheet

        if "pageOrientation" in self.docInfo:
            self.orientation = self.docInfo["pageOrientation"]
        else:
            self.orientation = "portrait"

        if "pageSize" in self.docInfo:
            self.pageSize = A3 if self.docInfo["pageSize"] == "A3" else A4
        else:
            self.pageSize = A4

        if isinstance(self.pageSize, list):
            if len(self.pageSize) > 1:
                self.pageRect = [self.pageSize[0], self.pageSize[1]]
        else:
            self.pageRect = \
                landscape(self.pageSize) \
                if self.orientation == "landscape" \
                else portrait(self.pageSize)

        self.doc = DocTemplateWithToc('',
                                      outputfilepagesize=self.pageRect,
                                      leftMargin=self.style["marginL"], rightMargin=self.style["marginR"],
                                      topMargin=self.style["marginT"], bottomMargin=self.style["marginB"])

        portraitTempl = PageTemplate(id="portrait",
                                     frames=Frame(0, 0, self.pageRect[0], self.pageRect[1],
                                                  leftPadding=self.style["marginL"],
                                                  bottomPadding=self.style["marginB"],
                                                  rightPadding=self.style["marginR"],
                                                  topPadding=self.style["marginT"]),
                                     onPageEnd=self.drawDecoration,
                                     pagesize=self.pageRect)
        self.doc.addPageTemplates(portraitTempl)

        landscapeTempl = PageTemplate(id="landscape",
                                      frames=Frame(0, 0, self.pageRect[0], self.pageRect[1],
                                                   leftPadding=self.style["marginL"],
                                                   bottomPadding=self.style["marginB"],
                                                   rightPadding=self.style["marginR"],
                                                   topPadding=self.style["marginT"]),
                                      onPageEnd=self.drawDecoration,
                                      pagesize=self.pageRect)
        self.doc.addPageTemplates(landscapeTempl)

        self.doc.setDefaultTemplate(self.orientation)

        self.enabledDecorations = []
        self.availableDecorations = []
Example #19
0
 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)
Example #20
0
 def __init__(self,
              id,
              pageSize=defaultPageSize,
              top=1,
              bottom=1,
              left=1,
              right=1):
     self.pagesize, (self.pageWidth, self.pageHeight) = pageSize, pageSize
     self.nTop, self.nBottom, self.nLeft, self.nRight = top * inch, bottom * inch, left * inch, right * inch
     frameList = self.CreateTemplateFrames(
     )  # overload this virtual function in all derived classes
     PageTemplate.__init__(self, id, frameList,
                           pagesize=pageSize)  # note lack of onPage
Example #21
0
 def __init__(self, student):
     self.student = student
     filename = slugify('{0}_{1}'.format(
         self.student.last_name, self.student.first_name)) + '_Expert.pdf'
     super().__init__(filename)
     self.addPageTemplates([
         PageTemplate(id='FirstPage',
                      frames=[self.page_frame],
                      onPage=self.header),
         PageTemplate(id='ISOPage',
                      frames=[self.page_frame],
                      onPage=self.header_iso),
     ])
Example #22
0
 def __init__(self, pdf_template_filename, name=None):
     frames = [Frame(
         PAD,
         PAD,
         PAGE_WIDTH - 2 * PAD,
         PAGE_HEIGHT - 2 * PAD,
         )]
     PageTemplate.__init__(self, name, frames)
     # use first page as template
     page = PdfReader(pdf_template_filename, decompress=False).pages[0]
     self.page_template = pagexobj(page)
     # Scale it to fill the complete page
     self.page_xscale = PAGE_WIDTH/self.page_template.BBox[2]
     self.page_yscale = PAGE_HEIGHT/self.page_template.BBox[3]
Example #23
0
 def __init__(self, pdf_template_filename, name=None):
     frames = [Frame(
         0.85 * inch,
         0.5 * inch,
         PAGE_WIDTH - 1.15 * inch,
         PAGE_HEIGHT - (1.5 * inch)
         )]
     PageTemplate.__init__(self, name, frames)
     # use first page as template
     page = PdfReader(pdf_template_filename).pages[0]
     self.page_template = pagexobj(page)
     # Scale it to fill the complete page
     self.page_xscale = PAGE_WIDTH/self.page_template.BBox[2]
     self.page_yscale = PAGE_HEIGHT/self.page_template.BBox[3]
Example #24
0
 def multiBuild(self,
                story,
                filename=None,
                canvasMaker=Canvas,
                maxPasses=10,
                onFirstPage=_doNothing,
                onLaterPages=_doNothing):
     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='Later',
                      frames=frameT,
                      onPageEnd=onLaterPages,
                      pagesize=self.pagesize)
     ])
     if onLaterPages is _doNothing and hasattr(self, 'onLaterPages'):
         self.pageTemplates[0].beforeDrawPage = self.onLaterPages
     SimpleDocTemplate.multiBuild(self,
                                  story,
                                  maxPasses,
                                  canvasmaker=canvasMaker)
     self._prepareTOC()
     contentFile = self.filename
     self.filename = FileDummy()
     self.pageTemplates = []
     self.addPageTemplates([
         PageTemplate(id='First',
                      frames=frameT,
                      onPage=onFirstPage,
                      pagesize=self.pagesize)
     ])
     if onFirstPage is _doNothing and hasattr(self, 'onFirstPage'):
         self.pageTemplates[0].beforeDrawPage = self.onFirstPage
     self.addPageTemplates([
         PageTemplate(id='Later',
                      frames=frameT,
                      onPageEnd=self.laterPages,
                      pagesize=self.pagesize)
     ])
     if onLaterPages is _doNothing and hasattr(self, 'onLaterPages'):
         self.pageTemplates[1].beforeDrawPage = self.onLaterPages
     SimpleDocTemplate.multiBuild(self,
                                  self._tocStory,
                                  maxPasses,
                                  canvasmaker=canvasMaker)
     self.mergePDFs(self.filename, contentFile)
Example #25
0
 def afterInit(self):
     """Set up the page templates"""
     frameT = Frame(self.leftMargin,
                    self.bottomMargin,
                    self.width,
                    self.height,
                    id='normal')
     self.addPageTemplates([
         PageTemplate(id='Front', frames=frameT),
         PageTemplate(id='Body', frames=frameT)
     ])
     # just need a unique key generator for outline entries;
     # easiest is to count all flowables in afterFlowable
     # and set up a counter variable here
     self._uniqueKey = 0
Example #26
0
 def __init__(self, id, pageSize=defaultPageSize):
     self.pageWidth = pageSize[0]
     self.pageHeight = pageSize[1]
     colWidth = 0.5 * (self.pageWidth - 2.25*inch)
     frame1 = Frame(inch,
                    inch,
                    colWidth,
                    self.pageHeight - 2*inch,
                    id='leftCol')
     frame2 = Frame(0.5 * self.pageWidth + 0.125,
                    inch,
                    colWidth,
                    self.pageHeight - 2*inch,
                    id='rightCol')
     PageTemplate.__init__(self, id, [frame1, frame2])  # note lack of onPage
Example #27
0
 def __init__(self, bg_page, name=None):
     frames = [Frame(
         22.0*mm,
         13.0*mm,
         PAGE_WIDTH-30.0*mm,
         PAGE_HEIGHT-30.0*mm,
         )]
     PageTemplate.__init__(self, name, frames)
     self.page_template = pagexobj(bg_page)
     # scale to fill the complete page
     self.page_xscale = PAGE_WIDTH/self.page_template.BBox[2]
     self.page_yscale = PAGE_HEIGHT/self.page_template.BBox[3]
     # store content and absolute position of paragraphs/primitives
     self.abspars = []
     self.absprims = []
Example #28
0
    def __init__(self,
                 empfaenger: Mitglied,
                 abrechnung: Abrechnung,
                 buffer=BytesIO()):
        self._abrechnung = abrechnung
        self._empfaenger = empfaenger
        self._buffer = buffer

        first_page_tpl = PageTemplate(id='first_page_tpl',
                                      onPage=self._first_page_static,
                                      frames=[
                                          Frame(
                                              x1=10 * mm,
                                              y1=15 * mm,
                                              width=PAGE_WIDTH - 20 * mm,
                                              height=PAGE_HEIGHT - 105 * mm,
                                              showBoundary=DEBUG,
                                              id='mainFrame',
                                          ),
                                      ])
        next_page_tpl = PageTemplate(id='next_page_tpl',
                                     onPage=self._next_page_static,
                                     frames=[
                                         Frame(x1=10 * mm,
                                               y1=15 * mm,
                                               width=PAGE_WIDTH - 20 * mm,
                                               height=PAGE_HEIGHT - 25 * mm,
                                               showBoundary=DEBUG,
                                               id='mainFrame'),
                                     ])

        self.doc = BaseDocTemplate(
            self._buffer,
            pagesize=A4,
            pageTemplates=[first_page_tpl, next_page_tpl],
            showBoundary=DEBUG,
            title=f'Abrechnung für {self.filename}',
            author=PDF_AUTHOR,
            # Die folgenden sind nur für nicht-flowables interessant:
            # (falls überhaupt)
            leftMargin=10 * mm,
            rightMargin=10 * mm,
            topMargin=10 * mm,
            bottomMargin=10 * mm,
            #
        )

        self._elements = [NextPageTemplate('next_page_tpl')]
Example #29
0
    def __init__(self, filename, **kw):
        m = 2 * cm
        cw, ch = (PAGESIZE[0] - 2 * m) / 2., (PAGESIZE[1] - 2 * m)

        # if we replace the value 4.9 with 5.0, everything works as expected
        f1 = Frame(m,
                   m + 0.5 * cm,
                   cw + 4.9 * cm,
                   ch - 1 * cm,
                   id='F1',
                   leftPadding=0,
                   topPadding=0,
                   rightPadding=0,
                   bottomPadding=0,
                   showBoundary=True)
        f2 = Frame(cw + 7 * cm,
                   m + 0.5 * cm,
                   cw - 5 * cm,
                   ch - 1 * cm,
                   id='F2',
                   leftPadding=0,
                   topPadding=0,
                   rightPadding=0,
                   bottomPadding=0,
                   showBoundary=True)
        BaseDocTemplate.__init__(self, filename, **kw)
        template = PageTemplate('template', [f1, f2])
        self.addPageTemplates(template)
Example #30
0
    def run(self):
        """
        Run the report
        """
        def make_landscape(canvas, doc):
            canvas.setPageSize(landscape(A4))

        # file initialization in buffer
        self.doc = BaseDocTemplate(
            self.buffer,
            showBoundary=1,  # margines
            pagesize=landscape(A4))

        # create the frames. Here you can adjust the margins
        frame = Frame(self.doc.leftMargin - 65,
                      self.doc.bottomMargin - 50,
                      self.doc.width + 125,
                      self.doc.height + 110,
                      id='first_frame')

        # add the PageTempaltes to the BaseDocTemplate.
        # You can also modify those to adjust the margin
        # if you need more control over the Frames.
        self.doc.addPageTemplates(
            PageTemplate(id='first_page', frames=frame, onPage=make_landscape))
        self.create_text()
        self.create_table()
        self.create_footer()
        self.doc.build(self.story)
Example #31
0
    def __init__(self,
                 doc_or_path,
                 coverpage=None,
                 pagesize=None,
                 stylesheet=None,
                 showBoundary=0):
        self.path = None
        if isinstance(doc_or_path, str):
            self.path = doc_or_path
            doc = self.build_doc(doc_or_path,
                                 pagesize=pagesize,
                                 showBoundary=showBoundary)

        self.doc = doc
        self.pagesize = doc.pagesize
        self.width, self.height = self.pagesize
        self.inc_cover = inc_coverpage = coverpage is not None
        self.template_defs = {}
        self.story = []
        self.active_template_id = None
        self.stylesheet = stylesheet or getSampleStyleSheet()
        if inc_coverpage:
            # Allow user to override the cover page template
            if not self.get_page_template('cover', err=0):
                f = Frame(0, 0, self.width, self.height)
                pt = PageTemplate(id='cover',
                                  frames=[f],
                                  onPage=coverpage.onPage)
                self.add_page_template(pt)
Example #32
0
 def as_page_template(self, builder):
     rheight = builder.height / self.nrows
     cwidth = builder.width / self.ncols
     frames = []
     for alias, (gframe, fargs) in list(self.gframes.items()):
         rs, re, cs, ce = gframe.y0, gframe.y1, gframe.x0, gframe.x1
         # Flip since y-axis starting at bottom
         rs, re = abs(self.nrows - rs), abs(self.nrows - re)
         x = cs * cwidth
         y = re * rheight
         h = (rs - re) * rheight
         w = (ce - cs) * cwidth
         frames.append(Frame(x, y, w, h, id=alias, **fargs))
     pt = PageTemplate(frames=frames)
     pt.id = self.template_id
     return pt
    def __init__(self, path):

        self.path = path

        styles = getSampleStyleSheet()
        styles2 = getSampleStyleSheet()
        self._styleN = styles["Normal"]
        self._styleH1 = styles["Heading1"]
        self._styleH2 = styles["Heading2"]
        self._styleRightAlignment = styles2["Normal"]  # to make sure we don't overwrite the normal styles (IS HACK)
        self._styleRightAlignment.alignment = 2
        self._header = ""
        self._footer = ""
        self._pagenr = 0

        self.doc = BaseDocTemplate(self.path, pagesize=A4)
        self.doc.leftMargin = 1 * cm
        self.doc.rightMargin = 1 * cm
        self.doc.bottomMargin = 1.5 * cm
        self.doc.topMargin = 1.5 * cm
        frame = Frame(self.doc.leftMargin, self.doc.bottomMargin, self.doc.width, self.doc.height - 2 * cm, id="normal")
        template = PageTemplate(id="legal_doc", frames=frame, onPage=self._header_footer)
        self.doc.addPageTemplates([template])

        self.parts = []
def go():
    #create the basic page and frames
    doc = BaseDocTemplate("phello.pdf",
                          leftMargin=10,
                          rightMargin=0,
                          topMargin=0,
                          bottomMargin=0)
    doc.pagesize = landscape(A4)

    frameCount = 2
    frameWidth = doc.height / frameCount
    frameHeight = doc.width - .05 * inch
    frames = []
    #construct a frame for each column
    for frame in range(frameCount):
        leftMargin = doc.leftMargin + frame * frameWidth
        column = Frame(leftMargin, doc.bottomMargin, frameWidth, frameHeight)
        print leftMargin, doc.bottomMargin, frameWidth, frameHeight

        frames.append(column)
    template = PageTemplate(frames=frames)
    doc.addPageTemplates(template)

    #	doc = SimpleDocTemplate("phello.pdf", id='TwoColumns')
    #	doc.pagesize = landscape(A4) ## TODO: make configurable

    Story = []
    style = styles["Normal"]
    style.fontName = 'Courier'
    style.fontSize = 6
    for monkey in monkeys:
        p = Preformatted(get_ttview(monkey[0], monkey[1], 15), style)
        Story.append(KeepTogether(p))
        Story.append(Spacer(1, 0.05 * inch))
    doc.build(Story)
 def _create_document(self, buff):
     page_t = PageTemplate(
         "normal",
         [
             Frame(
                 self.page_margin[0],
                 self.page_margin[1],
                 self.page_size[0] - self.page_margin[0] -
                 self.page_margin[2],
                 self.page_size[1] - self.page_margin[1] -
                 self.page_margin[3],
                 leftPadding=self.page_padding[0],
                 bottomPadding=self.page_padding[3],
                 rightPadding=self.page_padding[2],
                 topPadding=self.page_padding[1],
             )
         ],
     )
     doc_t = self.doc_template_type(
         buff,
         pagesize=letter,
         title=self.title,
         author=self.author,
         subject=self.subject,
         creator=self.creator,
         leftMargin=self.page_margin[0],
         rightMargin=self.page_margin[2],
         topMargin=self.page_margin[1],
         bottomMargin=self.page_margin[3],
     )
     doc_t.addPageTemplates(page_t)
     return doc_t
Example #36
0
def _create_bulk_licence_renewal(licences, site_url, buf=None):
    bulk_licence_renewal_frame = Frame(LETTER_PAGE_MARGIN,
                                       LETTER_PAGE_MARGIN,
                                       PAGE_WIDTH - 2 * LETTER_PAGE_MARGIN,
                                       PAGE_HEIGHT - 160,
                                       id='BulkLicenceRenewalFrame')
    bulk_licence_renewal_template = PageTemplate(
        id='BulkLicenceRenewalFrame',
        frames=bulk_licence_renewal_frame,
        onPage=_create_letter_header_footer)

    if buf is None:
        buf = BytesIO()
    doc = BaseDocTemplate(buf,
                          pageTemplates=[bulk_licence_renewal_template],
                          pagesize=A4)

    # this is the only way to get data into the onPage callback function
    doc.site_url = site_url
    all_elements = []
    for licence in licences:
        all_elements += _create_letter_address(licence) + [Spacer(1, LETTER_ADDRESS_BUFFER_HEIGHT)] + \
            _create_licence_renewal_elements(licence) + _create_letter_signature()
        all_elements.append(PageBreak())
    doc.build(all_elements)
    return doc
Example #37
0
 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)
Example #38
0
 def __init__(self, filename, **kw):
     m = 2 * cm
     cw, ch = (PAGESIZE[0] - 2 * m) / 2., (PAGESIZE[1] - 2 * m)
     ch -= 14 * cm
     f1 = Frame(m,
                m + 0.5 * cm,
                cw - 0.75 * cm,
                ch - 1.9 * cm,
                id='F1',
                leftPadding=0,
                topPadding=0,
                rightPadding=0,
                bottomPadding=0,
                showBoundary=True)
     f2 = Frame(cw + 2.7 * cm,
                m + 0.5 * cm,
                cw - 0.75 * cm,
                ch - 1 * cm,
                id='F2',
                leftPadding=0,
                topPadding=0,
                rightPadding=0,
                bottomPadding=0,
                showBoundary=True)
     BaseDocTemplate.__init__(self, filename, **kw)
     template = PageTemplate('template', [f1, f2])
     self.addPageTemplates(template)
Example #39
0
 def as_page_template(self, builder):
     rheight = builder.height / self.nrows
     cwidth = builder.width / self.ncols
     frames = []
     for alias, (gframe, fargs) in self.gframes.iteritems():
         rs, re, cs, ce = gframe.y0, gframe.y1, gframe.x0, gframe.x1
         # Flip since y-axis starting at bottom
         rs, re = abs(self.nrows - rs), abs(self.nrows - re)
         x = cs * cwidth
         y = re * rheight
         h = (rs - re) * rheight
         w = (ce - cs) * cwidth
         frames.append(Frame(x, y, w, h, id=alias, **fargs))
     pt = PageTemplate(frames=frames)
     pt.id = self.template_id
     return pt
Example #40
0
    def __init__(self, id='basic', columns=1, pagesize=A4, leftMargin=(2*cm), bottomMargin=(2.1*cm), colmargin=(0.5*cm), background=None):
        (right, top) = pagesize
        right -= leftMargin
        top -= bottomMargin

        height = top - bottomMargin
        width = (right - leftMargin)
        # Subtract out blank space between columns
        colwidth = (width - ((columns - 1) * colmargin)) / columns

        frames = []
        for col in range(columns):
            left = leftMargin + (col * (colwidth + colmargin))
            frames.append(Frame(left, bottomMargin, colwidth, height))

        self.background = background
        PageTemplate.__init__(self, id=id, frames=frames, pagesize=pagesize)
Example #41
0
    def __init__(self, id, pageSize=defaultPageSize):
        self.pageWidth = pageSize[0]
        self.pageHeight = pageSize[1]
        border = 0.3*cm

        miniwidth = (self.pageWidth / 2) - 2*border
        miniheight = (self.pageHeight / 2) - 2*border

        #self.f4 = Frame(border, border, miniwidth, miniheight, id='p4')
        #self.f1 = Frame(self.pageWidth/2 + border, border, miniwidth, miniheight, id='p1')
        #self.f2 = Frame(self.pageWidth/2 + border, self.pageHeight/2 + border, miniwidth, miniheight, id='p2')
        #self.f3 = Frame(border, self.pageHeight/2 + border, miniwidth, miniheight, id='p3')
        self.f4 = Frame(0, 0, miniwidth, miniheight, id='p4')
        self.f1 = Frame(miniwidth, 0, miniwidth, miniheight, id='p1')
        self.f2 = Frame(miniwidth, miniheight, miniwidth, miniheight, id='p2')
        self.f3 = Frame(0, miniheight, miniwidth, miniheight, id='p3')

        PageTemplate.__init__(self, id, [self.f1, self.f2, self.f3, self.f4])
Example #42
0
    def __init__(self, id, pageSize=defaultPageSize):
        self.pageWidth = pageSize[0]
        self.pageHeight = pageSize[1]
        border = 1.0*cm

        miniwidth = (self.pageWidth / 2) - 2*border
        miniheight = (self.pageHeight / 2) - 2*border

        # with border, in booklet order (but not rotated)
        #self.f4 = Frame(border, border, miniwidth, miniheight, id='p4')
        #self.f1 = Frame(self.pageWidth/2 + border, border, miniwidth, miniheight, id='p1')
        #self.f2 = Frame(self.pageWidth/2 + border, self.pageHeight/2 + border, miniwidth, miniheight, id='p2')
        #self.f3 = Frame(border, self.pageHeight/2 + border, miniwidth, miniheight, id='p3')

        self.bl = Frame(border, border, miniwidth, miniheight, id='BL')
        self.br = Frame(self.pageWidth/2 + border, border, miniwidth, miniheight, id='BR')
        self.ur = Frame(self.pageWidth/2 + border, self.pageHeight/2 + border, miniwidth, miniheight, id='UR')
        self.ul = Frame(border, self.pageHeight/2 + border, miniwidth, miniheight, id='UL')

        PageTemplate.__init__(self, id, [self.ul, self.ur, self.bl, self.br])
Example #43
0
 def __init__(self, order=None):
     frames = [Frame(MARGIN, MARGIN,
         PAGE_WIDTH - (2 * MARGIN),
         PAGE_HEIGHT - (2 * MARGIN) - (8.5 * cm))]
     self.order = order
     PageTemplate.__init__(self, id='first', frames=frames)