def get_paragraph_styles():
        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
        from reportlab.lib.enums import TA_JUSTIFY, TA_RIGHT, TA_CENTER
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont

        pdfmetrics.registerFont(TTFont('Persian', 'Bahij-Nazanin-Regular.ttf'))
        pdfmetrics.registerFont(TTFont('Persian-Bold', 'Bahij-Nazanin-Bold.ttf'))
        styles = getSampleStyleSheet()
        styles.add(ParagraphStyle(name='Justify', alignment=TA_JUSTIFY, fontName='Persian', fontSize=10, wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Justify-Bold', alignment=TA_JUSTIFY, fontName='Persian-Bold', fontSize=10, wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Right-indented', alignment=TA_RIGHT, fontName='Persian', fontSize=10,
                                  rightIndent=10, wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Right', alignment=TA_RIGHT, fontName='Persian', fontSize=10,
                                  rightIndent=10, wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Right-with-space', alignment=TA_RIGHT, fontName='Persian', fontSize=10,
                                  rightIndent=10, wordWrap='CJK', spaceBefore=12, spaceAfter=12, bulletAnchor='end',
                                  bulletIndent=5))
        styles.add(ParagraphStyle(name='Right-Bold', alignment=TA_RIGHT, fontName='Persian-Bold', fontSize=10, wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Right-Bold-Titr', alignment=TA_RIGHT, fontName='Persian-Bold', fontSize=12,
                                  textColor=colors.cornflowerblue, wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Right-small', alignment=TA_RIGHT, fontName='Persian', fontSize=8,
                                  rightIndent=20,
                                  wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Centre', alignment=TA_CENTER, fontName='Persian', fontSize=10, wordWrap='CJK'))
        styles.add(ParagraphStyle(name='Centre-Bold', alignment=TA_CENTER, fontName='Persian-Bold', fontSize=10, wordWrap='CJK'))
        return styles

    def __init__(self, regFont='Anonymous Pro', pdfDir=gettempdir()):
        self.pdfDir = pdfDir
        for root, dirs, files in os.walk(os.getcwd()):  #to find Fonts directory regardless of how we're invoked
            if 'BPmono.ttf' in files:
                fontDir = root 
        
        self.regFont = regFont
        self.boldFont = regFont + ' Bold'

        self.fontSize = self.fontDict[regFont][2]
        fileNameReg = fontDir + os.sep + self.fontDict[regFont][0]
        fileNameBold = fontDir + os.sep + self.fontDict[regFont][1]
        pdfmetrics.registerFont(TTFont(self.regFont, fileNameReg))
        pdfmetrics.registerFont(TTFont(self.boldFont, fileNameBold))

        tmpCanv = canvas.Canvas('tmp.pdf')
        # cW - because 'charWidth' is too damn long
        self.cW = tmpCanv.stringWidth('W', fontName=regFont, fontSize=self.fontSize)
        del tmpCanv
        #---Table styles and widths
        self.styles = {}
        for tmpStyle in ['codes', 'clmHeader', 'clmLine', 'clmFooter1', 'clmFooter2', 'rptFooter']:
            self.styles[tmpStyle] = TableStyle([('VALIGN', (0,0), (-1,-1), 'TOP'),
                                                ('ALIGN', (0,0), (-1,-1), 'LEFT'),
                                                ('FONT', (0,0), (-1,-1), regFont, self.fontSize),
                                                ("BOTTOMPADDING",(0,0),(-1,-1),self.pad),
                                                ("TOPPADDING", (0,0),(-1,-1),self.pad),
                                                ("RIGHTPADDING", (0,0),(-1,-1),self.pad),
                                                ("LEFTPADDING", (0,0),(-1,-1),self.pad)])

    def docinit(self, els):
        from reportlab.lib.fonts import addMapping
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont

        for node in els:

            for font in node.findall('registerFont'):
                name = font.get('fontName').encode('ascii')
                fname = font.get('fontFile').encode('ascii')
                if name not in pdfmetrics._fonts:
                    pdfmetrics.registerFont(TTFont(name, fname))
                #by default, we map the fontName to each style (bold, italic, bold and italic), so that 
                #if there isn't any font defined for one of these style (via a font family), the system
                #will fallback on the normal font.
                addMapping(name, 0, 0, name)    #normal
                addMapping(name, 0, 1, name)    #italic
                addMapping(name, 1, 0, name)    #bold
                addMapping(name, 1, 1, name)    #italic and bold

            #if registerFontFamily is defined, we register the mapping of the fontName to use for each style.
            for font_family in node.findall('registerFontFamily'):
                family_name = font_family.get('normal').encode('ascii')
                if font_family.get('italic'):
                    addMapping(family_name, 0, 1, font_family.get('italic').encode('ascii'))
                if font_family.get('bold'):
                    addMapping(family_name, 1, 0, font_family.get('bold').encode('ascii'))
                if font_family.get('boldItalic'):
                    addMapping(family_name, 1, 1, font_family.get('boldItalic').encode('ascii'))

def print_rep(uid):
    registerFont(TTFont('DroidSans', 'DroidSans.ttf'))

    pdf = StringIO()

    doc = SimpleDocTemplate(pdf, pagesize=A4)
    elements = []
    style = getSampleStyleSheet()
    style.add(ParagraphStyle(name='Header', alignment=TA_LEFT,
                             fontName='DroidSans',
                             fontSize=14, leading=16))
    style.add(ParagraphStyle(name='Left', alignment=TA_LEFT,
                             fontName='DroidSans',
                             fontSize=12))
    style.add(ParagraphStyle(name='Right', alignment=TA_RIGHT,
                             fontName='DroidSans',
                             fontSize=12))
    if uid == 0:
        elements.append(Paragraph(u'<u>Users List</u>', style['Header']))
        u = User.query.all()     
        for i, o in enumerate(u):
            elements.append(Paragraph(u'%s. %s %s %s' % (i+1, o.name, o.email, o.progress), style['Left']))
    else:
        u = User.query.get(uid)
        elements.append(Paragraph(u'%s %s %s' % (u.name, u.email, u.progress), style['Header']))

    doc.build(elements)
    pdf_file = pdf.getvalue()
    pdf.close()
    response = make_response(pdf_file)

    response.headers['Content-Disposition'] = "attachment; filename='pdf_user.pdf"
    response.mimetype = 'application/pdf'
    return response

def pdftest(text=None):
    logging.info('pdftest')
    output = StringIO.StringIO()
   # pdfmetrics.registerTypeFace(pdfmetrics.EmbeddedType1Face(
   #         os.path.join(folderFonts, 'DarkGardenMK.afm'),
   #         os.path.join(folderFonts, 'DarkGardenMK.pfb')))
   # pdfmetrics.registerFont(pdfmetrics.Font(
   #         'DarkGardenMK', 'DarkGardenMK', 'WinAnsiEncoding'))

   # pdfmetrics.registerFont(TTFont('Vera', os.path.join(folderFonts,'Vera.ttf')))
    pdfmetrics.registerFont(TTFont('DejaVuSansMono', os.path.join(folderFonts,'DejaVuSansMono.ttf')))


    c = canvas.Canvas(output)    
    #c.setFont('DarkGardenMK', 16)
    c.setFont('DejaVuSansMono', 16)
    if text:
        c.drawString(100,100,text)
    else:
        c.drawString(100,100,'pdftest')

    c.showPage()
    c.save()
    logging.info('ok')    
    return output.getvalue() 

def add_font(fontname, path=None):
    fontname = fontname.upper()
    if fontname not in fontnames:
        if path is None:
            def addit(args, d, names):
                for fn in names:
                    FN = fn.upper()
                    if FN[:-4] == fontname and FN[-4:] == '.TTF':
                        pdfmetrics.registerFont(TTFont(FN[:-4], os.path.join(d, fn)))
                        fontnames.append(fontname)
                        if not os.path.exists(os.path.join('./fonts/', fn)):
                            source = open(os.path.join(d, fn), 'rb')
                            dest = open(os.path.join('./fonts/', fn), 'wb')
                            dest.write(source.read())
                            dest.close()
                        break
            for fontdir in fontpath:
                os.path.walk(fontdir, addit, ())
                if fontname in fontnames:
                    break
        else:
            path = '%s/%s.ttf' % (path, fontname)
            pdfmetrics.registerFont(TTFont(fontname, path))
            fontnames.append(fontname)
    return fontname in fontnames

def _setup():
    from reportlab.pdfbase import pdfmetrics, ttfonts
    pdfmetrics.registerFont(ttfonts.TTFont("Vera", "Vera.ttf"))
    pdfmetrics.registerFont(ttfonts.TTFont("VeraBd", "VeraBd.ttf"))
    pdfmetrics.registerFont(ttfonts.TTFont("VeraIt", "VeraIt.ttf"))
    pdfmetrics.registerFont(ttfonts.TTFont("VeraBI", "VeraBI.ttf"))
    F = ['Times-Roman','Courier','Helvetica','Vera', 'VeraBd', 'VeraIt', 'VeraBI']
    if sys.platform=='win32':
        for name, ttf in [
            ('Adventurer Light SF','Advlit.ttf'),('ArialMS','ARIAL.TTF'),
            ('Arial Unicode MS', 'ARIALUNI.TTF'),
            ('Book Antiqua','BKANT.TTF'),
            ('Century Gothic','GOTHIC.TTF'),
            ('Comic Sans MS', 'COMIC.TTF'),
            ('Elementary Heavy SF Bold','Vwagh.ttf'),
            ('Firenze SF','flot.ttf'),
            ('Garamond','GARA.TTF'),
            ('Jagger','Rols.ttf'),
            ('Monotype Corsiva','MTCORSVA.TTF'),
            ('Seabird SF','seag.ttf'),
            ('Tahoma','TAHOMA.TTF'),
            ('VerdanaMS','VERDANA.TTF'),
            ]:
            for D in ('c:\WINNT','c:\Windows'):
                fn = os.path.join(D,'Fonts',ttf)
                if os.path.isfile(fn):
                    try:
                        f = ttfonts.TTFont(name, fn)
                        pdfmetrics.registerFont(f)
                        F.append(name)
                    except:
                        pass
    return F

 def process(self):
     args = dict(self.getAttributeValues(attrMapping=self.attrMapping))
     if 'encoding' in args:
         font = cidfonts.CIDFont(**args)
     else:
         font = cidfonts.UnicodeCIDFont(**args)
     pdfmetrics.registerFont(font)

    def docinit(self, els):
        from reportlab.lib.fonts import addMapping
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.ttfonts import TTFont

        for node in els:
            for font in node.getElementsByTagName('registerFont'):
                name = font.getAttribute('fontName').encode('ascii')
                fname = font.getAttribute('fontFile').encode('ascii')
                pdfmetrics.registerFont(TTFont(name, fname))
                addMapping(name, 0, 0, name)    #normal
                addMapping(name, 0, 1, name)    #italic
                addMapping(name, 1, 0, name)    #bold
                addMapping(name, 1, 1, name)    #italic and bold
            for font in node.getElementsByTagName('registerTTFont'):
                name = font.getAttribute('faceName').encode('ascii')
                fname = font.getAttribute('fileName').encode('ascii')
                pdfmetrics.registerFont(TTFont(name, fname))	# , subfontIndex=subfontIndex
            for font in node.getElementsByTagName('registerFontFamily'):
                pdfmetrics.registerFontFamily(
                        font.getAttribute('normal').encode('ascii'),
                        normal = font.getAttribute('normal').encode('ascii'),
                        bold = font.getAttribute('bold').encode('ascii'),
                        italic = font.getAttribute('italic').encode('ascii'),
                        boldItalic = font.getAttribute('boldItalic').encode('ascii')
                )

    def ___test2_all(self):
        """Dumps out ALl GLYPHS in a CID font.

        Reach for your microscope :-)"""
        try:
            from reportlab.pdfbase.cidfonts import CIDFont, findCMapFile
            findCMapFile('90ms-RKSJ-H')
            findCMapFile('Identity-H')
        except:
            #don't have the font pack.  return silently
            return

        pdfmetrics.registerFont(CIDFont('HeiseiMin-W3','Identity-H'))

        c = Canvas('test_japanese_2.pdf')
        c.setFont('Helvetica', 30)
        c.drawString(100,800, 'All Glyphs in Adobe-Japan-1-2 collection!')

        # the two typefaces
        c.setFont('HeiseiMin-W3-Identity-H', 2)

        x0 = 50
        y0 = 700
        dx = 2
        dy = 2
        for row in range(256):
            for cell in range(256):
                s = chr(row) + chr(cell)
                x = x0 + cell*dx
                y = y0 - row*dy
                c.drawString(x,y,s)

        c.save()
        if VERBOSE:
            print('saved '+outputfile('test_multibyte_jpn.pdf'))

 def set_cyrillic_font(self):
     pdfmetrics.registerFont(TTFont('DejaVuSans', _self_path + u'/' 'DejaVuSans.ttf'))
     self.pdf.setFont('DejaVuSans', 10) # default font
     if self.debug:
         self.pdf.setFillColor(red)
     else:
         self.pdf.setFillColor(black)

    def docinit(self, els):
        from reportlab.lib.fonts import addMapping
        from reportlab.pdfbase import pdfmetrics
        from reportlab.pdfbase.cidfonts import UnicodeCIDFont
        from reportlab.pdfbase.ttfonts import TTFont

        for node in els:
            # register CID fonts
            for subnode in node.getElementsByTagName('registerCidFont'):
                params = dict(
                    faceName=subnode.getAttribute('faceName').encode('utf-8'))
                font = self.font_resolver('UnicodeCIDFont', params)
                if font:
                    pdfmetrics.registerFont(font)
            # register TrueType fonts
            for subnode in node.getElementsByTagName('registerTTFont'):
                faceName = subnode.getAttribute('faceName').encode('utf-8')
                fileName = subnode.getAttribute('fileName').encode('utf-8')
                subfontIndex = subnode.getAttribute('subfontIndex')
                if subfontIndex:
                    subfontIndex = int(subfontIndex)
                else:
                    subfontIndex = 0
                params = dict(faceName=faceName,
                              fileName=fileName,
                              subfontIndex=subfontIndex)
                # Resolvers are recommended to implement cache.
                font = self.font_resolver('TTFont', params)
                if font:
                    pdfmetrics.registerFont(font)

 def test_instanceStringWidth(self):
     from reportlab.pdfbase.pdfmetrics import registerFont, getFont, _fonts, unicode2T1
     from reportlab.pdfbase.ttfonts import TTFont
     ttfn = 'Vera'
     t1fn = 'Times-Roman'
     registerFont(TTFont(ttfn, "Vera.ttf"))
     ttf = getFont(ttfn)
     t1f = getFont(t1fn)
     testCp1252 = 'copyright %s trademark %s registered %s ReportLab! Ol%s!' % (chr(169), chr(153),chr(174), chr(0xe9))
     enc='cp1252'
     senc = 'utf8'
     ts = 'ABCDEF\xce\x91\xce\xb2G'
     utext = 'ABCDEF\xce\x91\xce\xb2G'.decode(senc)
     fontSize = 12
     defns="ttfn t1fn ttf t1f testCp1252 enc senc ts utext fontSize ttf.face ttf.face.charWidths ttf.face.defaultWidth t1f.widths t1f.encName t1f.substitutionFonts _fonts"
     rcv = getrc(defns)
     def tfunc(f,ts,fontSize,enc):
         w1 = f.stringWidth(ts,fontSize,enc)
         w2 = f._py_stringWidth(ts,fontSize,enc)
         assert abs(w1-w2)<1e-10,"f(%r).stringWidthU(%r,%s,%r)-->%r != f._py_stringWidth(...)-->%r" % (f,ts,fontSize,enc,w1,w2)
     tfunc(t1f,testCp1252,fontSize,enc)
     tfunc(t1f,ts,fontSize,senc)
     tfunc(t1f,utext,fontSize,senc)
     tfunc(ttf,ts,fontSize,senc)
     tfunc(ttf,testCp1252,fontSize,enc)
     tfunc(ttf,utext,fontSize,senc)
     rcc = checkrc(defns,rcv)
     assert not rcc, "rc diffs (%s)" % rcc

	def Text(self, o):

		print(C.CTFontCreateWithName)


		attrString = Q.CFAttributedStringCreate(Q.kCFAllocatorDefault, o.text, {})
		line = Q.CTLineCreateWithAttributedString(attrString)
		Q.CGContextSetTextPosition(self.context, self.X(o.x), self.Y(o.y))
		Q.CTLineDraw(line, self.context)

		
		return ['']

		from reportlab.pdfbase import pdfmetrics
		from reportlab.pdfbase.ttfonts import TTFont
		if not os.path.basename(o.font) in self.registeredFonts:
			pdfmetrics.registerFont(TTFont(os.path.basename(o.font), o.font))
			self.registeredFonts.append(os.path.basename(o.font))

		if o.fillcolor:
			self.setFillColor(o.fillcolor)
		if o.strokecolor:
			self.setStrokeColor(o.strokecolor)

		self.reportlabcanvas.setFont(os.path.basename(o.font), o.fontsize)
		if o.align == 'left':
			self.reportlabcanvas.drawString(self.X(o.x), self.Y(o.y) - o.fontsize + .17*o.fontsize, o.text)
		elif o.align == 'center':
			self.reportlabcanvas.drawCentredString(self.X(o.x), self.Y(o.y) - o.fontsize + .17*o.fontsize, o.text)
		elif o.align == 'right':
			self.reportlabcanvas.drawRightString(self.X(o.x), self.Y(o.y) - o.fontsize + .17*o.fontsize, o.text)


		return ['']

def make_cd_pdf(item_list):
    """Create CD label pdf"""

    # Filter non-CD items, copied items, split item bases, compilation items after the first for each CD
    cd_label_list = [each_item for each_item in item_list if \
        each_item.compilation_cd_item_counter <= 1 and 'cd' in each_item.format and \
        not (each_item.copies > 1 and not each_item.copy_counter) and \
        not (each_item.long and not each_item.side)]

    if not cd_label_list:
        logging.warning('No CD labels to print.')
        return
    logging.info('cd_label_list: ({0}): {1}'.format(len(cd_label_list), [item.name for item in cd_label_list]))

    # Draw CD labels
    c = canvas.Canvas(os.path.join(pdf_folder, 'cd-labels.pdf'), pagesize=(150 * mm, 320 * mm))
    width, height = (150 * mm, 320 * mm)
    pdfmetrics.registerFont(TTFont('Garamond', font_path))
    for item in cd_label_list:
        # Clipping
        path = c.beginPath()
        path.circle(81 * mm, 113 * mm, 60 * mm)
        path.circle(81 * mm, 113 * mm, 11 * mm)
        c.clipPath(path, stroke = 1, fill = 0)
        # Draw CD image
        if not item.counter_image_path:
            item.counter_image_path = make_cover_image(item)
        c.drawImage(item.counter_image_path, 20 * mm, 52 * mm, width=120 * mm, height=120 * mm)
        c.showPage()
    c.save()

def getAFont():
    '''register a font that supports most Unicode characters'''
    I = []
    font_name = 'DejaVuSans'
    I.append([(font_name, 0, 0, font_name),
                 (font_name, 1, 0, font_name + '-Bold'),
                 (font_name, 0, 1, font_name + '-Oblique'),
                 (font_name, 1, 1, font_name + '-BoldOblique'),
                 ])
    font_name = 'FreeSerif'
    I.append([(font_name, 0, 0, font_name),
                 (font_name, 1, 0, font_name + 'Bold'),
                 (font_name, 0, 1, font_name + 'Italic'),
                 (font_name, 1, 1, font_name + 'BoldItalic'),
                 ])
    for info in I:
        n = 0
        for font in info:
            fontName = font[3]
            try:
                pdfmetrics.registerFont(ttfonts.TTFont(fontName,fontName + '.ttf'))
                addMapping(*font)
                n += 1
            except:
                pass
        if n==4: return font[0]
    raise ValueError('could not find suitable font')

    def define(self, name, engine, enginefontname):
        """Define a new font.

        ``name`` is the name that will be used for this font in the
        presentation text.

        ``engine`` is the font engine.  MagicPoint supports several,
        but mgp2pdf supports only "xfont".

        ``enginefontname`` is the name of the font according to the
        font engine.  For ``xfont`` it can be "family", "family-weight"
        or "family-weight-slant".  Or it can be a fontconfig pattern.
        """
        if engine != "xfont":
            raise NotImplementedError("unsupported font engine %s" % engine)
        if '-' in enginefontname and ':' not in enginefontname:
            if enginefontname.count('-') == 1:
                # family-weight
                family, weight = enginefontname.split('-')
                weight = self.weights.get(weight, weight)
                enginefontname = '%s:weight=%s' % (family, weight)
            elif enginefontname.count('-') == 2:
                # family-weight-slant
                family, weight, slant = enginefontname.split('-')
                weight = self.weights.get(weight, weight)
                slant = {'i': 'italic', 'r': 'roman'}[slant]
                enginefontname = '%s:weight=%s:slant=%s' % (family, weight, slant)
        filename = subprocess.Popen(
            ['fc-match', enginefontname, '-f', '%{file}'],
            stdout=subprocess.PIPE).communicate()[0].strip()
        if not filename:
            sys.exit('Could not find the font file for %s' % enginefontname)
        log.debug("Font %s: %s -> %s" % (name, enginefontname, filename))
        pdfmetrics.registerFont(TTFont(name, filename))
        pdfmetrics.getFont(name)  # just see if raises

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 test_instanceStringWidth(self):
     from reportlab.pdfbase.pdfmetrics import registerFont, getFont, _fonts, unicode2T1
     from reportlab.pdfbase.ttfonts import TTFont
     ttfn = 'Vera'
     t1fn = 'Times-Roman'
     registerFont(TTFont(ttfn, "Vera.ttf"))
     ttf = getFont(ttfn)
     t1f = getFont(t1fn)
     testCp1252 = b'copyright \xa9 trademark \x99 registered \xae ReportLab! Ol\xe9!'
     enc='cp1252'
     senc = 'utf8'
     ts = b'ABCDEF\xce\x91\xce\xb2G'
     utext = b'ABCDEF\xce\x91\xce\xb2G'.decode(senc)
     fontSize = 12
     defns="ttfn t1fn ttf t1f testCp1252 enc senc ts utext fontSize ttf.face ttf.face.charWidths ttf.face.defaultWidth t1f.widths t1f.encName t1f.substitutionFonts _fonts"
     import sys
     F = []
     def tfunc(f,ts,fontSize,enc,funcs,i):
         w1 = funcs[i][0](f,ts,fontSize,enc)
         w2 = funcs[1][0](f,ts,fontSize,enc) #python version
         if abs(w1-w2)>=1e-10: F.append("stringWidth%s(%r,%r,%s,%r)-->%r != f._py_stringWidth(...)-->%r" % (fontType,f,ts,fontSize,enc,w1,w2))
     for font,fontType in ((t1f,'T1'),(ttf,'TTF')):
         funcs = getFuncs('instanceStringWidth'+fontType)
         for i,kind in enumerate(('c','py')):
             for j in (3,2,1,0): #we run several times to allow the refcounts to stabilize
                 if j: rcv = getrc(defns)
                 tfunc(font,testCp1252,fontSize,enc,funcs,i)
                 tfunc(font,ts,fontSize,senc,funcs,i)
                 tfunc(font,utext,fontSize,senc,funcs,i)
                 if not j:
                     rcc = checkrc(defns,rcv)
                     if rcc: F.append("%s %s refcount diffs (%s)" % (fontType,kind,rcc))
     assert not F,"instanceStringWidth failures\n\t%s" % '\n\t'.join(F)

def txt2PDF(path):

    pdfmetrics.registerFont(TTFont('song', 'SURSONG.TTF'))
    pdfmetrics.registerFont(TTFont('hei', 'SIMHEI.TTF'))
    fonts.addMapping('song', 0, 0, 'song')
    fonts.addMapping('song', 0, 1, 'song')
    fonts.addMapping('song', 1, 0, 'hei')
    fonts.addMapping('song', 1, 1, 'hei')

    f=file(path)
    content = f.read()
    contentList = content.split('\n')
    #print contentList

    stylesheet=getSampleStyleSheet()
    normalStyle = copy.deepcopy(stylesheet['Normal'])
    ###设置PDF中文字字体
    normalStyle.fontName ='hei' #字体为黑体
    normalStyle.fontSize = 14.5 #字体大小
    normalStyle.leading = 30    #行间距
    normalStyle.firstLineIndent = 32    #首行缩进
    story = []
    for text in contentList:
        #story.append(Paragraph(unicode(text, "utf-8" ), normalStyle))
        #story.append(Paragraph(text.decode('utf-8'), normalStyle))
        story.append(Paragraph(text.decode('gbk'), normalStyle))
    pdfPath = path.split('.')[0] + '.pdf'
    txtName = path.split('.')[0].split('/')[-1]
    doc = SimpleDocTemplate(pdfPath,
                            rightMargin=20,leftMargin=20,
                            topMargin=20,
                            bottomMargin=20)
    doc.build(story)