Python pdfmetrics.registerTypeFace函数代码示例

def register_font(font_name, family=""):
    try:
        return _registered_font_names[font_name]
    except KeyError:
        pass

    found = ff.getFontsWithAttributes(name=font_name)
    if not found:
        # print '%(font_name)s not found, loading default for rl_config %(res)s' % locals()
        res = rl_config.defaultGraphicsFontName
    else:
        descr = found[0]
        if descr.typeCode == "ttf":
            font = TTFont(descr.name, descr.fileName)
        else:
            face = pdfmetrics.EmbeddedType1Face(descr.metricsFileName, descr.fileName)
            pdfmetrics.registerTypeFace(face)
            font = pdfmetrics.Font(font_name, font_name, rl_config.defaultEncoding)
        pdfmetrics.registerFont(font)
        res = font_name
    if 10:
        from reportlab.lib.fonts import addMapping

        bold = int("Bold" in font_name)
        italic = int("Italic" in font_name)
        addMapping(family or font_name, bold, italic, font_name)
    _registered_font_names[font_name] = res
    return res

    def __init__(self, path, margin_x=48, margin_y=60, file_name='Untitled.pdf',
                 file_name_S3='Untitled.pdf', is_landscape=False, author=None, title=None):
        self.path = path
        self.margin_x = self.origin_x = margin_x
        self.margin_y = self.origin_y = margin_y
        self.file_name = file_name
        self.is_landscape = is_landscape
        self.author = author
        self.title = title

        # embeds "Hand of Sean" font:
        afmFile = os.path.join(settings.FONT_ROOT, 'HandOfSean.afm')
        pfbFile = os.path.join(settings.FONT_ROOT, 'HandOfSean.pfb')
        ttfFile = os.path.join(settings.FONT_ROOT, 'handsean.ttf')
        justFace = pdfmetrics.EmbeddedType1Face(afmFile, pfbFile) #embeds font
        faceName = 'HandOfSean' # pulled from AFM file
        pdfmetrics.registerTypeFace(justFace)
        justFont = pdfmetrics.Font('HandSean', faceName, 'WinAnsiEncoding')
        pdfmetrics.registerFont(justFont)
        pdfmetrics.registerFont(TTFont('HandSean', ttfFile))

        response = HttpResponse(content_type='application/pdf')
        response['Content-Disposition'] = 'attachment; filename=' + self.file_name

        self.set_orientation(self.is_landscape)

        self.canvas = canvas.Canvas(self.path + '/' + self.file_name,
                               pagesize=(self.page_width, self.page_height))
        if self.author is not None:
            self.canvas.setAuthor(self.author)
        if self.title is not None:
            self.canvas.setTitle(self.title)

 def __makeParaStyles(self):
     psn = '_%s__paraStyles' % self.__class__.__name__
     if not hasattr(self.__class__,psn):
         from reportlab.pdfbase import pdfmetrics
         fontDir = self.getFontDir()
         if fontDir is None:
             fontName = 'Helvetica-Bold'
         else:
             face = pdfmetrics.EmbeddedType1Face(os.path.join(fontDir,'eurosbe2.afm'),os.path.join(fontDir,'eurosbe2.pfb'))
             pdfmetrics.registerTypeFace(face)
             fontName = "Eurostile-BoldExtendedTwo"
         from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT, TA_JUSTIFY
         from reportlab.lib.colors import white, PCMYKColor
         from reportlab.lib import colors
         colors.fidblue = fidblue = PCMYKColor(60,40,0,20,spotName='FidelityBlue',density=100)
         colors.fidlightblue = PCMYKColor(12.1568,8.2353,0,3.9216,spotName='FidelityLightBlue',density=100)
         S = []
         a = S.append
         normal = getSampleStyleSheet()['Normal']
         a(ParagraphStyle('ct0',normal, fontName=fontName, fontSize=12,leading=14.4, spaceAfter=6, spacebefore=6,textColor=fidblue))
         a(ParagraphStyle('ct1',normal, alignment=TA_CENTER, fontName="Helvetica-Bold", fontSize=7, textColor=white, leading=1.2*7))
         a(ParagraphStyle('ct2',normal, alignment=TA_CENTER, fontName="Helvetica", fontSize=6, leading=8))
         a(ParagraphStyle('ct3',normal, alignment=TA_JUSTIFY, fontName="Helvetica", fontSize=5.5, leading=6))
         a(ParagraphStyle('ct4',normal, fontName="Helvetica-Bold", fontSize=7, textColor=white,leading=7*1.2))
         a(ParagraphStyle('ct5',normal, alignment=TA_LEFT, fontName="Helvetica", fontSize=5, leading=5.5))
         a(ParagraphStyle('ct6',normal, alignment=TA_RIGHT, fontName="Helvetica", fontSize=5, leading=5.5))
         a(ParagraphStyle('ct7',normal, alignment=TA_CENTER, fontName="Helvetica", fontSize=5, leading=5.5))
         a(ParagraphStyle('ct8',normal, alignment=TA_JUSTIFY, fontName="Helvetica", fontSize=5.5, leading=6.0))
         a(ParagraphStyle('ct9',normal, alignment=TA_CENTER, fontName="Helvetica-Bold", fontSize=6, leading=1.2*6))
         setattr(self.__class__,psn,S)

 def _register_fonts(self):
     afmfile, pfbfile, fontname = self.TITLE_FONT
     registerTypeFace(EmbeddedType1Face(afmfile, pfbfile))
     registerFont(Font(fontname, fontname, 'WinAnsiEncoding'))
     
     for suffix in ['', '-Bold', '-Oblique', '-BoldOblique']:
         registerFont(TTFont(self.MONO_FONT[0].format(suffix), 
                             self.MONO_FONT[1].format(suffix)))
     registerFontFamily('Mono', normal='Mono', bold='Mono-Bold', 
                        italic='Mono-Oblique', boldItalic='Mono-BoldOblique')

 def embed_font(self, path, face_name):
     """
     Register a font face with ReportLab an (if used) embed in the target PDF.
     """
     ## Based on snippet from http://www.reportlab.org/devfaq.html
     afm = os.path.join(path, face_name + '.afm')
     pfb = os.path.join(path, face_name + '.pfb')
     face = pdfmetrics.EmbeddedType1Face(afm, pfb)         
     pdfmetrics.registerTypeFace(face)
     font = pdfmetrics.Font(face_name, face_name, 'WinAnsiEncoding')
     pdfmetrics.registerFont(font)

def reg_font_afm(head,root):
    afmFile = os.path.join(head,root+".afm")
    pfbFile = os.path.join(head,root+".pfb")

    (topLevel, glyphData) = pdfmetrics.parseAFMFile(afmFile)
    faceName=topLevel['FontName']

    justFace = pdfmetrics.EmbeddedType1Face(afmFile, pfbFile)
    pdfmetrics.registerTypeFace(justFace)
    justFont = pdfmetrics.Font(faceName, faceName, 'WinAnsiEncoding')
    pdfmetrics.registerFont(justFont)
    return

    def font_start(self, name, ttf=None, afm=None, pfb=None):

        # True Type Fonts
        if ttf:
            font_path = os.path.join(self.font_dir, ttf)
            pdfmetrics.registerFont(TTFont(name, font_path))
            return

        # Type 1
        face = pdfmetrics.EmbeddedType1Face(afm, pfb)
        pdfmetrics.registerTypeFace(face) 
        font = pdfmetrics.Font(name, name, 'WinAnsiEncoding')
        pdfmetrics.registerFont(font) 

def registerFont0(sourceFile, name, path):
    "Register Type-1 font for future use, simple version."

    rl_config.warnOnMissingFontGlyphs = 0

    p = os.path.join(os.path.dirname(sourceFile), path)
    afmFiles = glob.glob(p + ".[aA][fF][mM]")
    pfbFiles = glob.glob(p + ".[pP][fF][bB]")
    assert len(afmFiles) == len(pfbFiles) == 1, FontFilesNotFoundError

    T1face = pdfmetrics.EmbeddedType1Face(afmFiles[0], pfbFiles[0])
    T1faceName = name
    pdfmetrics.registerTypeFace(T1face)
    T1font = pdfmetrics.Font(name, T1faceName, "WinAnsiEncoding")
    pdfmetrics.registerFont(T1font)

    def import_pdf_font(self, base_name, face_name):
        if self.fonts.get(face_name, None) is None:
            afm = find(base_name + '.afm')
            pfb = find(base_name + '.pfb')

            try:
                face = pdfmetrics.EmbeddedType1Face(afm, pfb)

                pdfmetrics.registerTypeFace(face)
                font = pdfmetrics.Font(face_name, face_name, 'WinAnsiEncoding')
                pdfmetrics.registerFont(font)
            except:
                pass
        else:
            self.fonts[face_name] = True

 def import_pdf_font(self, base_name, face_name):
     import os
     import reportlab
     from reportlab.pdfbase import pdfmetrics
     
     if self.fonts.get(face_name, None) is None:
         afm = os.path.join(settings.MEDIA_ROOT, base_name + '.afm')
         pfb = os.path.join(settings.MEDIA_ROOT, base_name + '.pfb')
     
         try:
             face = pdfmetrics.EmbeddedType1Face(afm, pfb)
     
             pdfmetrics.registerTypeFace(face)
             font = pdfmetrics.Font(face_name, face_name, 'WinAnsiEncoding')
             pdfmetrics.registerFont(font)
         except:
             pass
     else:
         self.fonts[face_name] = True

   def get(self):
      text = self.request.get('t')
      if text:
         pdfmetrics.registerTypeFace(pdfmetrics.EmbeddedType1Face(
            os.path.join(folderFonts, 'DarkGardenMK.afm'),
            os.path.join(folderFonts, 'DarkGardenMK.pfb')))
         pdfmetrics.registerFont(pdfmetrics.Font(
            'DarkGardenMK', 'DarkGardenMK', 'WinAnsiEncoding'))

         p = canvas.Canvas(self.response.out)
         p.drawImage('dog.jpg', 150, 400)
         p.drawString(50, 700, 'The text you entered: ' + text)
         p.setFont('DarkGardenMK', 16)
         p.drawString(50, 600, 'DarkGarden font loaded from reportlab.zip')
         p.showPage()

         self.response.headers['Content-Type'] = 'application/pdf'
         self.response.headers['Content-Disposition'] = 'filename=testpdf.pdf'

         p.save()
      else:
         self.response.out.write(template.render('testpdf.html', {}))

    def _setup_font(self, fontname, locale):
        registerTypeFace(TypeFace('Times-Roman'))

        if fontname != '(auto)':
            if fontname not in self._stdfonts \
                    and fontname not in self._cidfonts:
                fontname = '(auto)'

        if fontname == '(auto)':
            lang = None
            if locale:
                lang = str(locale).split('_', 1)[0]
            fontname = {'ja': 'HeiseiKakuGo-W5',
                        'ko': 'HYGothic-Medium',
                        'zh': 'STSong-Light'}.get(lang, 'Helvetica')

        if fontname in self._stdfonts:
            font = TypeFace(fontname)
            registerTypeFace(font)
        elif fontname in self._cidfonts:
            font = UnicodeCIDFont(fontname)
            registerFont(font)

        return fontname

    def loadFont(self, names, src, encoding="WinAnsiEncoding", bold=0, italic=0):
        
        # XXX Just works for local filenames!        
        if names and src: # and src.local:
            
            file = src
            src = file.uri
            
            log.debug("Load font %r", src)
            
            if type(names) is types.ListType:
                fontAlias = names
            else:
                fontAlias = [x.lower().strip() for x in names.split(",") if x]
            
            # XXX Problems with unicode here 
            fontAlias = [str(x) for x in fontAlias]            
            
            fontName = fontAlias[0]
            parts = src.split(".")                
            baseName, suffix = ".".join(parts[: - 1]), parts[ - 1]
            suffix = suffix.lower()
                        
            try:
                
                if suffix == "ttf":

                    # determine full font name according to weight and style
                    fullFontName = "%s_%d%d" % (fontName, bold, italic)                    

                    # check if font has already been registered
                    if fullFontName in self.fontList:
                        log.warn(self.warning("Repeated font embed for %s, skip new embed ", fullFontName))
                    else:
                                                
                        # Register TTF font and special name 
                        filename = file.getNamedFile()
                        pdfmetrics.registerFont(TTFont(fullFontName, filename))
                        
                        # Add or replace missing styles
                        for bold in (0, 1):
                            for italic in (0, 1):                                                                
                                if ("%s_%d%d" % (fontName, bold, italic)) not in self.fontList:
                                    addMapping(fontName, bold, italic, fullFontName)

                        # Register "normal" name and the place holder for style                                                
                        self.registerFont(fontName, fontAlias + [fullFontName])
                                         
                elif suffix in ("afm", "pfb"):
                    
                    if suffix == "afm":
                        afm = file.getNamedFile()
                        tfile = pisaFileObject(baseName + ".pfb")
                        pfb = tfile.getNamedFile()
                    else:
                        pfb  = file.getNamedFile()
                        tfile = pisaFileObject(baseName + ".afm")
                        afm = tfile.getNamedFile()
                        
                    #afm = baseName + ".afm"
                    #pfb = baseName + ".pfb"

                    # determine full font name according to weight and style
                    fullFontName = "%s_%d%d" % (fontName, bold, italic)   
                        
                    #fontNameOriginal = ""
                    #for line in open(afm).readlines()[:-1]:
                    #    if line[:16] == 'StartCharMetrics':
                    #        self.error("Font name not found")
                    #    if line[:8] == 'FontName':
                    #        fontNameOriginal = line[9:].strip()
                    #        break
                                   
                    # check if font has already been registered
                    if fullFontName in self.fontList:
                        log.warn(self.warning("Repeated font embed for %s, skip new embed", fontName))
                    else:                                              
                        
                        # Include font                 
                        face = pdfmetrics.EmbeddedType1Face(afm, pfb)                        
                        fontNameOriginal = face.name
                        pdfmetrics.registerTypeFace(face)
                        # print fontName, fontNameOriginal, fullFontName
                        justFont = pdfmetrics.Font(fullFontName, fontNameOriginal, encoding)
                        pdfmetrics.registerFont(justFont)
                        
                        # Add or replace missing styles
                        for bold in (0, 1):
                            for italic in (0, 1):                                                                
                                if ("%s_%d%d" % (fontName, bold, italic)) not in self.fontList:
                                    addMapping(fontName, bold, italic, fontNameOriginal)
                        
                        # Register "normal" name and the place holder for style                                                
                        self.registerFont(fontName, fontAlias + [fullFontName, fontNameOriginal])
    
                        #import pprint
                        #pprint.pprint(self.fontList)
    
                else:
                    log.warning(self.warning("wrong attributes for <pdf:font>"))
#.........这里部分代码省略.........

                 fontSize=36))

    d.add(String(150, 160, 'Hello World',
                 fontName='DarkGardenMK',
                 fontSize=36))
"""
)

from reportlab.pdfbase import pdfmetrics
from reportlab import rl_config

rl_config.warnOnMissingFontGlyphs = 0
afmFile, pfbFile = getJustFontPaths()
T1face = pdfmetrics.EmbeddedType1Face(afmFile, pfbFile)
T1faceName = "DarkGardenMK"
pdfmetrics.registerTypeFace(T1face)
T1font = pdfmetrics.Font(T1faceName, T1faceName, "WinAnsiEncoding")
pdfmetrics.registerFont(T1font)

d = Drawing(400, 200)
for size in range(12, 36, 4):
    d.add(String(10 + size * 2, 10 + size * 2, "Hello World", fontName="Times-Roman", fontSize=size))

d.add(String(130, 120, "Hello World", fontName="Courier", fontSize=36))

d.add(String(150, 160, "Hello World", fontName="DarkGardenMK", fontSize=36))

draw(d, "fancy font example")


heading3("""Paths""")

    def test0(self):
        """Make documents with embedded fonts.

        Just vam Rossum has kindly donated a font which we may use
        for testing purposes.  You need to contact him at [email protected]
        if you want to use it for real."""

        #LettError fonts should always be there.  The others are voluntary.

        ok = 1

        c = Canvas(outputfile('test_pdfbase_fontembed.pdf'))
        c.setPageCompression(0)
        c.setFont('Helvetica', 12)
        c.drawString(100, 700, 'This is Helvetica.  The text below should be different fonts...')

        if os.path.isfile('GDB_____.AFM') and os.path.isfile('GDB_____.PFB'):
            # a normal text font
            garaFace = pdfmetrics.EmbeddedType1Face('GDB_____.AFM','GDB_____.PFB')
            faceName = 'AGaramond-Bold'  # pulled from AFM file
            pdfmetrics.registerTypeFace(garaFace)

            garaFont = pdfmetrics.Font('MyGaramondBold', faceName, 'WinAnsiEncoding')
            pdfmetrics.registerFont(garaFont)

            c.setFont('AGaramond-Bold', 12)
            c.drawString(100, 650, 'This should be in AGaramond-Bold')

        if os.path.isfile('CR______.AFM') and os.path.isfile('CR______.PFB'):

            # one with a custom encoding
            cartaFace = pdfmetrics.EmbeddedType1Face('CR______.AFM','CR______.PFB')
            faceName = 'Carta'  # pulled from AFM file
            pdfmetrics.registerTypeFace(cartaFace)

            cartaFont = pdfmetrics.Font('Carta', 'Carta', 'CartaEncoding')
            pdfmetrics.registerFont(cartaFont)

            text = 'This should be in Carta, a map symbol font:'
            c.setFont('Helvetica', 12)
            c.drawString(100, 600, text)
            w = c.stringWidth(text, 'Helvetica', 12)

            c.setFont('Carta', 12)
            c.drawString(100+w, 600, ' Hello World')

        # LettError sample - creates on demand, we hope
        y = 550
##        justFace = pdfmetrics.EmbeddedType1Face('LeERC___.AFM','LeERC___.PFB')
##
##        faceName = 'LettErrorRobot-Chrome'  # pulled from AFM file
##        pdfmetrics.registerTypeFace(justFace)
##
##        justFont = pdfmetrics.Font('LettErrorRobot-Chrome', faceName, 'WinAnsiEncoding')
##        pdfmetrics.registerFont(justFont)

        c.setFont('LettErrorRobot-Chrome', 12)
        c.drawString(100, y, 'This should be in LettErrorRobot-Chrome')

        def testNamedFont(canv, fontName):
            canv.showPage()
            makeWidthTestForAllGlyphs(canv, fontName, outlining=0)

        testNamedFont(c, 'LettErrorRobot-Chrome')

        c.save()