python类Canvas()的实例源码

def get(self, request, *args, **kwargs):         
        codigo = kwargs['pk']
        orden = OrdenCompra.objects.get(pk=codigo)
        response = HttpResponse(content_type='application/pdf')
        #response['Content-Disposition'] = 'attachment; filename="orden_compra.pdf"'
        buffer = BytesIO()
        pdf = canvas.Canvas(buffer)  
        self.cabecera(pdf, orden)
        y=300
        self.detalle(pdf, y, orden)        
        self.otros(pdf, y, orden)
        self.cuadro_total(pdf, y, orden)
        self.cuadro_observaciones(pdf, y, orden)
        self.afectacion_presupuesta(pdf)
        pdf.setFont("Times-Roman", 8)
        pdf.drawString(115, y-250,"Elaborado por")
        pdf.drawString(430, y-250,"Autorizado por")
        pdf.line(70, y-240, 200, y-240)
        pdf.line(390, y-240, 520, y-240)
        pdf.drawCentredString(300, y-280, EMPRESA.direccion())
        pdf.showPage()    
        pdf.save()
        pdf = buffer.getvalue()
        buffer.close()
        response.write(pdf)
        return response

def get(self, request, *args, **kwargs):         
        codigo = kwargs['codigo']
        orden = OrdenServicios.objects.get(codigo=codigo)        
        response = HttpResponse(content_type='application/pdf')
        #response['Content-Disposition'] = 'attachment; filename="orden_compra.pdf"'
        buffer = BytesIO()
        pdf = canvas.Canvas(buffer)  
        self.cabecera(pdf, orden)
        y=300
        self.detalle(pdf, y, orden)        
        self.otros(pdf, y, orden)
        self.cuadro_total(pdf, y, orden)
        self.cuadro_observaciones(pdf, y, orden)
        self.afectacion_presupuesta(pdf)
        pdf.setFont("Times-Roman", 8)
        pdf.drawString(115, y-250,"Elaborado por")
        pdf.drawString(430, y-250,"Autorizado por")
        pdf.line(70, y-240, 200, y-240)
        pdf.line(390, y-240, 520, y-240)
        pdf.drawCentredString(300, y-280, EMPRESA.direccion())
        pdf.showPage()    
        pdf.save()
        pdf = buffer.getvalue()
        buffer.close()
        response.write(pdf)
        return response

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)

def BurnSudoOnPdf(path,numpage,diffarray):

    pdf = PdfFileWriter()

    # Using ReportLab Canvas to insert image into PDF
    imgTemp = BytesIO()
    imgDoc = canvas.Canvas(imgTemp, pagesize=A4)

    # Draw image on Canvas and save PDF in buffer
    pdfmetrics.registerFont(TTFont('VeraIt', 'VeraIt.ttf'))
    for i in range(len(path)):
        if ((i+1)%2==0):
            x=345
        else:
            x=55
        if (i<2):
            y=590
        elif (i<4):
            y=320
        else:
            y=50
        imgDoc.drawImage(path[i], x, y,200,200)
        imgDoc.setFont('VeraIt', 9)
        imgDoc.drawString(x+2,y+203,getStrDiff(diffarray[i]))

    pdfmetrics.registerFont(TTFont('Vera', 'Vera.ttf'))
    pdfmetrics.registerFont(TTFont('VeraBd', 'VeraBd.ttf'))
    pdfmetrics.registerFont(TTFont('VeraIt', 'VeraIt.ttf'))
    #pdfmetrics.registerFont(TTFont('VeraBI', 'VeraBI.ttf'))

    imgDoc.setFont('Vera', 13)
    imgDoc.drawString(30,820,"BurnYourPc Organization/")
    imgDoc.setFont('VeraBd', 9)
    imgDoc.drawString(197,820,"Sudoku Project")
    imgDoc.setFont('VeraIt', 8)
    imgDoc.drawString(430,20,"By PantelisPanka, nikfot, TolisChal")
    imgDoc.setFont('Vera', 8)
    imgDoc.drawString(550,820,str(numpage))

    imgDoc.save()

    # Use PyPDF to merge the image-PDF into the template
    pdf.addPage(PdfFileReader(BytesIO(imgTemp.getvalue())).getPage(0))

    pdf.write(open("output"+ str(numpage)+".pdf","wb"))

def RenderToIo(boards, write_target):
  """Renders the given boards to the passed output stream."""
  c = canvas.Canvas(write_target, pagesize=LETTER)
  for board in boards:
    _BoardRenderer(board, c).Render()
  c.save()

def _startBuild(self, filename=None, canvasmaker=canvas.Canvas):
        self._calc()

        #each distinct pass gets a sequencer
        self.seq = reportlab.lib.sequencer.Sequencer()

        self.canv = canvasmaker(filename or self.filename,
                                pagesize=self.pagesize,
                                invariant=self.invariant,
                                pageCompression=self.pageCompression,
                                enforceColorSpace=self.enforceColorSpace,
                                initialFontName = self.initialFontName,
                                initialFontSize = self.initialFontSize,
                                initialLeading = self.initialLeading,
                                cropBox = self.cropBox,
                                artBox = self.artBox,
                                trimBox = self.trimBox,
                                bleedBox = self.bleedBox,
                                )

        getattr(self.canv,'setEncrypt',lambda x: None)(self.encrypt)

        self.canv._cropMarks = self.cropMarks
        self.canv.setAuthor(self.author)
        self.canv.setTitle(self.title)
        self.canv.setSubject(self.subject)
        self.canv.setCreator(self.creator)
        self.canv.setKeywords(self.keywords)
        if self.displayDocTitle is not None:
            self.canv.setViewerPreference('DisplayDocTitle',['false','true'][self.displayDocTitle])
        if self.lang:
            self.canv.setCatalogEntry('Lang',self.lang)

        if self._onPage:
            self.canv.setPageCallBack(self._onPage)
        self.handle_documentBegin()

def test():
    from pprint import pprint
    #print test_program; return
    from reportlab.pdfgen import canvas
    from reportlab.lib.units import inch
    fn = "paratest0.pdf"
    c = canvas.Canvas(fn)
    test2(c,testparagraph)
    test2(c,testparagraph1)
    if 1:
        remainder = test_program + test_program + test_program
        laststate = {}
        while remainder:
            print("NEW PAGE")
            c.translate(inch, 8*inch)
            t = c.beginText()
            t.setTextOrigin(0,0)
            p = paragraphEngine()
            p.resetState(laststate)
            p.x = 0
            p.y = 0
            maxwidth = 7*inch
            maxheight = 500
            (formattedprogram, remainder, laststate, height) = p.format(maxwidth, maxheight, remainder)
            if debug:
                pprint( formattedprogram )#; return
            laststate = p.runOpCodes(formattedprogram, c, t)
            c.drawText(t)
            c.showPage()
            print("="*30, "x=", laststate["x"], "y=", laststate["y"])
    c.save()
    print(fn)

def rotate(self, theta):
        """Canvas.rotate(theta)

        Rotate the canvas by the angle theta (in degrees)."""
        c = cos(theta * pi / 180)
        s = sin(theta * pi / 180)
        self.transform(c, s, -s, c, 0, 0)

def encryptPdfInMemory(inputPDF,
                  userPassword, ownerPassword=None,
                  canPrint=1, canModify=1, canCopy=1, canAnnotate=1,
                       strength=40):
    """accepts a PDF file 'as a byte array in memory'; return encrypted one.

    This is a high level convenience and does not touch the hard disk in any way.
    If you are encrypting the same file over and over again, it's better to use
    pageCatcher and cache the results."""

    try:
        from rlextra.pageCatcher.pageCatcher import storeFormsInMemory, restoreFormsInMemory
    except ImportError:
        raise ImportError('''reportlab.lib.pdfencrypt.encryptPdfInMemory failed because rlextra cannot be imported.
See https://www.reportlab.com/downloads''')

    (bboxInfo, pickledForms) = storeFormsInMemory(inputPDF, all=1, BBoxes=1)
    names = list(bboxInfo.keys())

    firstPageSize = bboxInfo['PageForms0'][2:]

    #now make a new PDF document
    buf = getBytesIO()
    canv = Canvas(buf, pagesize=firstPageSize)

    # set a standard ID while debugging
    if CLOBBERID:
        canv._doc._ID = "[(xxxxxxxxxxxxxxxx)(xxxxxxxxxxxxxxxx)]"
    encryptCanvas(canv,
                  userPassword, ownerPassword,
                  canPrint, canModify, canCopy, canAnnotate,
                  strength=strength)

    formNames = restoreFormsInMemory(pickledForms, canv)
    for formName in formNames:
        canv.setPageSize(bboxInfo[formName][2:])
        canv.doForm(formName)
        canv.showPage()
    canv.save()
    return buf.getvalue()

def test():
    c = Canvas('codecharts.pdf')
    c.setFont('Helvetica-Bold', 24)
    c.drawString(72, 750, 'Testing code page charts')
    cc1 = SingleByteEncodingChart()
    cc1.drawOn(c, 72, 500)

    cc2 = SingleByteEncodingChart(charsPerRow=32)
    cc2.drawOn(c, 72, 300)

    cc3 = SingleByteEncodingChart(charsPerRow=25, hex=0)
    cc3.drawOn(c, 72, 100)

##    c.showPage()
##
##    c.setFont('Helvetica-Bold', 24)
##    c.drawString(72, 750, 'Multi-byte Kuten code chart examples')
##    KutenRowCodeChart(1, 'HeiseiMin-W3','EUC-H').drawOn(c, 72, 600)
##    KutenRowCodeChart(16, 'HeiseiMin-W3','EUC-H').drawOn(c, 72, 450)
##    KutenRowCodeChart(84, 'HeiseiMin-W3','EUC-H').drawOn(c, 72, 300)
##
##    c.showPage()
##    c.setFont('Helvetica-Bold', 24)
##    c.drawString(72, 750, 'Big5 Code Chart Examples')
##    #Big5CodeChart(0xA1, 'MSungStd-Light-Acro','ETenms-B5-H').drawOn(c, 72, 500)

    c.save()
    print('saved codecharts.pdf')

def test() :
    """Test this."""
    from reportlab.pdfgen.canvas import Canvas
    from reportlab.lib import pagesizes

    canvas = Canvas("labels.pdf", pagesize=pagesizes.A4)
    canvas.setFont("Helvetica", 30)
    (width, height) = pagesizes.A4
    canvas.drawCentredString(width/2.0, height-4*cm, "Sample LTO labels")
    xpos = xorig = 2 * cm
    ypos = yorig = 2 * cm
    colwidth = 10 * cm
    lineheight = 3.9 * cm
    count = 1234
    BaseLTOLabel("RL", count, "3").drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    BaseLTOLabel("RL", count, "3",
                 border=0.0125).drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3").drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3",
                    border=0.0125).drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3",
                    colored=True).drawOn(canvas, xpos, ypos)
    ypos += lineheight
    count += 1
    VerticalLTOLabel("RL", count, "3",
                    border=0.0125, colored=True).drawOn(canvas, xpos, ypos)
    canvas.showPage()
    canvas.save()

def writePDF(drawings):
    "Create and save a PDF file containing some drawings."

    pdfPath = os.path.splitext(sys.argv[0])[0] + '.pdf'
    c = Canvas(pdfPath)
    c.setFont(_FONTS[0], 32)
    c.drawString(80, 750, 'ReportLab Graphics-Shapes Test')

    # Print drawings in a loop, with their doc strings.
    c.setFont(_FONTS[0], 12)
    y = 740
    i = 1
    for (drawing, docstring, funcname) in drawings:
        if y < 300:  # Allows 5-6 lines of text.
            c.showPage()
            y = 740
        # Draw a title.
        y = y - 30
        c.setFont(_FONTS[2],12)
        c.drawString(80, y, '%s (#%d)' % (funcname, i))
        c.setFont(_FONTS[0],12)
        y = y - 14
        textObj = c.beginText(80, y)
        textObj.textLines(docstring)
        c.drawText(textObj)
        y = textObj.getY()
        y = y - drawing.height
        drawing.drawOn(c, 80, y)
        i = i + 1

    c.save()
    print('wrote %s ' % pdfPath)

def __init__(self, page_size):
        self._file = BytesIO()
        self.canvas = Canvas(self._file, pagesize=page_size)
        self._saved = False

def producePrintoutsForLayer(base_name, layer, canv):


    ctmp = canvas.Canvas(base_name + "_assy.pdf")
    ext = renderGerber(base_name, layer, ctmp);

    scale1 = (gerberPageSize[0]-2*gerberMargin)/((ext[2]-ext[0]))
    scale2 = (gerberPageSize[1]-2*gerberMargin)/((ext[3]-ext[1]))
    scale = min(scale1, scale2)
    gerberScale = (scale,scale)
#    print("PS" , gerberPageSize[0], gerberMargin, gerberScale)
    gerberOffset = (-ext[0]*scale + gerberMargin, -ext[1]*scale + gerberMargin)
#    print "Offset (in.): (%4.2f, %4.2f)" % (gerberOffset[0]/inch,gerberOffset[1]/inch)
#    print "Scale (in.):  (%4.2f, %4.2f)" % gerberScale



    pf = PickAndPlaceFileKicad(base_name+".CSV")
    ngrp =  pf.num_groups(layer)

    for page in range(0, (ngrp+5)/6):
        n_comps = min(6, ngrp - page*6)

        canv.saveState()
        canv.translate( gerberOffset[0], gerberOffset[1] )
        if(layer == "Bottom"):
            canv.scale( gerberScale[0], gerberScale[1] )
#            canv.scale( -1, 1 )
#            canv.translate(-0.5*gerberPageSize[0],0)
        else:
            canv.scale( gerberScale[0], gerberScale[1] )

        renderGerber(base_name, layer, canv);

        pf.draw(layer, page*6, n_comps, canv);

        canv.restoreState()
        pf.gen_table(layer, page*6, n_comps, canv);
        canv.showPage()

def __init__(self, fileName, canv=None):
        from reportlab.pdfgen import canvas
        if(canv == None):
            self.canv = canvas.Canvas(fileName, pagesize=gerberPageSize, pageCompression = 1 )
        else:
            self.canv = canv

        self.Initialize()

    # }}}
    # {{{ Initialize

def test_01_start(self):
        from reportlab.pdfgen import canvas
        c = canvas.Canvas("demo.pdf")
        c.drawString(100,100, "Hello World")
        c.showPage()
        c.save()

def test_02_pageSize(self):
        from reportlab.lib.pagesizes import A4
        from reportlab.pdfgen.canvas import Canvas
        myCanvas = Canvas('demo.pdf', pagesize=A4)
        width, height = A4
        print width, height
        myCanvas.drawString(width*1/3,height*2/3, "Hello World")
        myCanvas.showPage()
        myCanvas.save()

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()

def test_07_registerFont(self):
        from reportlab.lib.pagesizes import A4
        from reportlab.pdfgen.canvas import Canvas
        from reportlab.lib.units import inch
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont

        pdfmetrics.registerFont(TTFont('chsFont', 'STHeiti Light.ttc'))
        c = Canvas('demo.pdf', pagesize=A4)
        c.translate(inch, inch)
        c.setFont('chsFont', 32)
        c.drawString(0,0,"??????????")
        c.showPage()
        c.save()

def process_pdf(self, image_data, hocr_data, pdf_filename):
        """Utility function if you'd rather get the PDF data back instead of save it automatically."""
        pdf = Canvas(pdf_filename, pageCompression=1)
        pdf.setCreator('hocr-tools')
        pdf.setPageSize((self.width, self.height))
        pdf.drawImage(image_data, 0, 0, width=self.width, height=self.height)
        pdf = self.add_text_layer(pdf, hocr_data)
        pdf_data = pdf.getpdfdata()
        return pdf_data