def get_font_name(font_name, variant=NORMAL, require_exact=False):
'''Get name under which the font is registered in PDF metrics.
:param font_name: The basic name of the font (like 'Arial', ...)
:param variant: Variant of the file name (like 'normal', 'italic', ...)
:param require_exact: Use normal variant as fall-back.
Tries to find the font. If not found, it can either fallback to
normal variant or throw exception.
'''
key = _get_font_name(font_name, variant)
if not key in pdfmetrics.getRegisteredFontNames():
try_load_font_mpl(font_name)
if not key in pdfmetrics.getRegisteredFontNames():
if require_exact:
raise Exception("Font '%s', variant '%s' does not exist." % (font_name, variant))
else:
key = _get_font_name(font_name, variant=NORMAL)
if not key in pdfmetrics.getRegisteredFontNames():
raise Exception("Font '%s' does not exist." % (font_name))
else:
print("Font '%s', variant '%s' does not exist, using 'normal' instead." % (font_name, variant))
return key
def convert_font_family(value):
"""
Converts a font-family to a standard font name, or returns the value unmodified. PDFs are
expected to register their own font names, and the SVG must use this exact font name as well if it
is to be recognized later. Verifying these names is beyond the scope of this function.
> f("Arial") == "Arial"
> f("'Arial-Bold'") == "Arial-Bold"
> f("sans-serif") == "Helvetica" (unless overidden in settings)
> f("") == "Helvetica" (unless overidden in settings)
"""
# in svg-land, *Arial* is == 'Arial-Bold' (with the quotes)!
# <text fill="#000000" font-family="'Arial-Bold'" font-size="14">My Bold!</text>
if not value:
return ''
value = value.replace("'", "") # strip single quotes, e.g. 'Arial-Bold'
# todo: cache this mapping, rebuilding it each time rendering starts
if value in pdfmetrics.getRegisteredFontNames():
return value
# if this font name is already known to us, then just return it
if value in settings.FONT_ALIASES:
return settings.FONT_ALIASES[value]
if value in settings.FONT_ALIASES.values():
return value
# couldn't find it, so use the default font
return settings.DEFAULT_FONT
def __init__(self,
name: str,
char: str,
font_family: str,
font_fullname: str,
font_size: int,
color: str,
standalone: bool,
takes_lyric: bool,
lyric_offset: float,
keep_with_next: bool,
offset: [float, float] = (0.0, 0.0)):
self.name: str = name # The name in standard BNML
self.char: str = char # The character in a TTF
self.font_family: str = font_family # The font family name
self.font_fullname: str = font_fullname # The specific font file name
self.font_size: int = font_size
self.color: str = color
self.width: float = pdfmetrics.stringWidth(self.char,
self.font_fullname,
self.font_size)
ascent, descent = pdfmetrics.getAscentDescent(self.font_fullname,
self.font_size)
self.height: float = ascent - descent
self.standalone: bool = standalone
self.takes_lyric: bool = takes_lyric
self.lyric_offset: float = lyric_offset
self.keep_with_next: bool = keep_with_next
self.offset: [float, float] = offset
if self.font_fullname not in pdfmetrics.getRegisteredFontNames():
raise Exception("Neume font {} is not registered".format(
self.font_fullname))
def select_fontname(fontname, default_fontname):
if fontname not in pdfmetrics.getRegisteredFontNames()\
or fontname not in pdfmetrics.standardFonts:
# let reportlab attempt to find it
try:
pdfmetrics.getFont(fontname)
except Exception:
_logger.warning('Could not locate font %s, substituting default: %s',
fontname, default_fontname)
fontname = default_fontname
return fontname
def select_fontname(fontname, default_fontname):
if fontname not in pdfmetrics.getRegisteredFontNames()\
or fontname not in pdfmetrics.standardFonts:
# let reportlab attempt to find it
try:
pdfmetrics.getFont(fontname)
except Exception:
_logger.warning('Could not locate font %s, substituting default: %s',
fontname, default_fontname)
fontname = default_fontname
return fontname
def add_all_fonts():
global fontnames
fontnames = pdfmetrics.getRegisteredFontNames()
fontnames.append('Helvetica-Bold')
fontpaths = glob.glob('fonts/*.ttf')
for fp in fontpaths:
d, fn = os.path.split(fp)
fn = fn[:-4]
fontnames.append(fn)
pdfmetrics.registerFont(TTFont(fn, fp))
print 'added', fn, fontnames[-1]
def add_all_fonts():
global fontnames
fontnames = pdfmetrics.getRegisteredFontNames()
fontnames.append('Helvetica-Bold')
fontpaths = glob.glob('fonts/*.ttf')
for fp in fontpaths:
d, fn = os.path.split(fp)
fn = fn[:-4]
fontnames.append(fn)
pdfmetrics.registerFont(TTFont(fn, fp))
print 'added', fn, fontnames[-1]
def setFont(self, node):
fontname = node.get('name')
if fontname not in pdfmetrics.getRegisteredFontNames()\
or fontname not in pdfmetrics.standardFonts:
# let reportlab attempt to find it
try:
pdfmetrics.getFont(fontname)
except Exception:
_logger.debug('Could not locate font %s, substituting default: %s',
fontname,
self.canvas._fontname)
fontname = self.canvas._fontname
return self.canvas.setFont(fontname, utils.unit_get(node.get('size')))
def setFont(self, node):
fontname = node.get('name')
if fontname not in pdfmetrics.getRegisteredFontNames()\
or fontname not in pdfmetrics.standardFonts:
# let reportlab attempt to find it
try:
pdfmetrics.getFont(fontname)
except Exception:
_logger.debug('Could not locate font %s, substituting default: %s',
fontname,
self.canvas._fontname)
fontname = self.canvas._fontname
return self.canvas.setFont(fontname, utils.unit_get(node.get('size')))
def select_fontname(fontname, default_fontname):
if fontname not in pdfmetrics.getRegisteredFontNames()\
or fontname not in pdfmetrics.standardFonts:
# let reportlab attempt to find it
try:
pdfmetrics.getFont(fontname)
except Exception:
addition = ""
if " " in fontname:
addition = ". Your font contains spaces which is not valid in RML."
_logger.warning('Could not locate font %s, substituting default: %s%s',
fontname, default_fontname, addition)
fontname = default_fontname
return fontname
def select_fontname(fontname, default_fontname):
if fontname not in pdfmetrics.getRegisteredFontNames()\
or fontname not in pdfmetrics.standardFonts:
# let reportlab attempt to find it
try:
pdfmetrics.getFont(fontname)
except Exception:
addition = ""
if " " in fontname:
addition = ". Your font contains spaces which is not valid in RML."
_logger.warning('Could not locate font %s, substituting default: %s%s',
fontname, default_fontname, addition)
fontname = default_fontname
return fontname
def create_watermark(content='None',
angle=0,
pagesize=None,
font_file=None,
font_size=None,
color='black',
alpha=0.2,
out_dir='.'):
"""
create PDF watermark file
"""
if not isinstance(pagesize, float):
pagesize = (float(pagesize[0]), float(pagesize[1]))
uuid_str = uuid.uuid4().hex
wm_file = os.path.join(out_dir, 'watermark_%s.pdf' % uuid_str)
if font_file is None or not os.path.exists(font_file):
available_fonts = pdfmetrics.getRegisteredFontNames()
font_name = available_fonts[0]
else:
font_name = os.path.splitext(os.path.basename(font_file))[0]
pdfmetrics.registerFont(TTFont(font_name,
font_file)) # register custom font
c = canvas.Canvas(wm_file, pagesize=pagesize) # create an empty pdf file
# setting pdf parameters
w, h = pagesize
if font_size is None:
font_size = max(w, h) * DEFAULT_FONT_SIZE_SCALE
c.setFont(font_name, font_size)
c.setFillColor(eval('colors.%s' % color))
c.setFillAlpha(alpha)
c.saveState()
content_list = content.split('|')
# create 4 watermarks in page
for i, orgin in enumerate(ORGIN_LIST):
c.restoreState()
c.saveState()
c.translate(orgin[0] * w, orgin[1] * h)
c.rotate(angle)
y = 0
for c_item in content_list:
c.drawCentredString(0, 0 - y, c_item)
y += font_size
c.save()
return wm_file
def setFont(self, node):
fname = node.get('name')
if fname not in pdfmetrics.getRegisteredFontNames()\
or fname not in pdfmetrics.standardFonts:
# let reportlab attempt to find it
try:
pdfmetrics.getFont(fname)
except Exception:
logging.getLogger('report.fonts').\
warning('Could not locate font %s, substituting default: %s',
fname, self.canvas._fontname)
fname = self.canvas._fontname
try:
return self.canvas.setFont(fname, utils.unit_get(node.get('size')))
except KeyError:
logging.getLogger('report.fonts').error("setFont failed for %s", fname)
raise KeyError('Font "%s" cannot be used in the PDF engine' % fname)
def __init__(self,
char: str,
font_family: str,
font_size: int,
color: str,
offset_x: int = 0,
offset_y: int = 0):
self.char: str = char # The character in a TTF
if font_family not in pdfmetrics.getRegisteredFontNames():
raise Exception("Neume font is not registered")
self.font_family = font_family
self.font_size = font_size
self.color = color
self.offset_x = 0
self.offset_y = 0
self.width = pdfmetrics.stringWidth(self.char, self.font_family,
self.font_size)
ascent, descent = pdfmetrics.getAscentDescent(self.font_family,
self.font_size)
self.height = ascent - descent
def get_style(cls, base_style=NORMAL, alignment=LEFT_ALIGN, bold=False, font_size=None, font_name=None):
while True:
style_name = str(random.randint(1, 10**10))
if style_name not in cls._ADDED_STYLES:
cls._ADDED_STYLES.append(style_name)
break
kwargs = {
'name': style_name,
'parent': base_style,
'alignment': alignment,
}
if bold:
font_search_name = '{}-Bold'.format(base_style.fontName)
if font_search_name in pdfmetrics.getRegisteredFontNames():
kwargs['fontName'] = font_search_name
elif font_name:
kwargs['fontName'] = font_name
if font_size:
kwargs['fontSize'] = font_size
return ParagraphStyle(**kwargs)
def registerFonts():
rootDir = "fonts"
ftypes = ('/*.ttf', '/*.otf')
files_grabbed = []
# Get all font files in fonts directory
for ftype in ftypes:
temp = glob(rootDir + ftype)
files_grabbed.extend(temp)
# Try to register them
for fontLoc in files_grabbed:
fontName = ImageFont.truetype(fontLoc, 1)
try:
pdfmetrics.registerFont(TTFont(fontName.font.family,fontLoc))
except TTFError as e:
print "Error: {}".format(e)
raise SystemExit
# Check that default fonts are registered
registeredFonts = pdfmetrics.getRegisteredFontNames()
if not "EZ Psaltica" in registeredFonts or not "EZ Omega" in registeredFonts:
print "Warning: Default fonts 'EZ Psaltica' and 'EZ Omega' are missing from the fonts directory"
def registerFonts():
rootDir = "fonts"
ftypes = ('/*.ttf', '/*.otf')
files_grabbed = []
# Get all font files in fonts directory
for ftype in ftypes:
temp = glob(rootDir + ftype)
files_grabbed.extend(temp)
# Try to register them
for fontLoc in files_grabbed:
fontName = ImageFont.truetype(fontLoc, 1)
try:
pdfmetrics.registerFont(TTFont(fontName.font.family, fontLoc))
except TTFError as e:
print "Error: {}".format(e)
raise SystemExit
# Check that default fonts are registered
registeredFonts = pdfmetrics.getRegisteredFontNames()
if not "EZ Psaltica" in registeredFonts or not "EZ Omega" in registeredFonts:
print "Warning: Default fonts 'EZ Psaltica' and 'EZ Omega' are missing from the fonts directory"
import os
import sys
dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(dir_path)
import datetime
import pickle
# import subprocess
import datetime
from reportlab.pdfgen import canvas
from reportlab.lib.units import inch
from reportlab.pdfbase import pdfmetrics
print(pdfmetrics.getRegisteredFontNames()) # 'Symbol', 'ZapfDingbats'
from reportlab.pdfbase.ttfonts import TTFont
from utils.path_manage import PathManage
# 参考 https://blog.csdn.net/syshzbtt/article/details/73394580
def create_pdf(user):
'''字典生成pdf文件'''
with open(PathManage.db_path(f'{user}.db'), 'rb') as f:
data_list = pickle.load(f)
c = canvas.Canvas(PathManage.download_path(f'{user}.pdf'))
pdfmetrics.registerFont(TTFont('msyh', PathManage.db_path('msyh.ttf')))
# c.drawString(100, 300, u'雅黑雅黑')
c.setFont('msyh', 12)
textobject = c.beginText()
textobject.setTextOrigin(inch, 11 * inch)
now = datetime.datetime.today()
# 设定日期格式
def view_fonts():
print(pdfmetrics.getRegisteredFontNames())
def isRegisteredFont(fontName):
return fontName in pdfmetrics.getRegisteredFontNames()
def pdf(self, resource, list_fields=None):
"""
Export a resource as Adobe PDF (does not include components!)
@param resource: the resource
@param list_fields: fields to include in list views
@note: export does not include components!
@todo 2.3: fix error messages
@todo 2.3: do not redirect
@todo 2.3: PEP-8
@todo 2.3: test this!
@todo: implement audit
"""
db = self.db
table = resource.table
session = self.manager.session
request = self.manager.request
response = self.manager.response
xml = self.manager.xml
# Import ReportLab
try:
from reportlab.lib.units import cm
from reportlab.lib.pagesizes import A4
from reportlab.lib.enums import TA_CENTER, TA_RIGHT
from reportlab.pdfbase import pdfmetrics
except ImportError:
session.error = self.ERROR.REPORTLAB_ERROR
redirect(URL(r=request, extension=""))
# Import Geraldo
try:
from geraldo import Report, ReportBand, Label, ObjectValue, SystemField, landscape, BAND_WIDTH
from geraldo.generators import PDFGenerator
except ImportError:
session.error = self.ERROR.GERALDO_ERROR
redirect(URL(r=request, extension=""))
# Get records
query = resource.get_query()
records = db(query).select(table.ALL, orderby=table._id)
if not records:
session.warning = self.ERROR.NO_RECORDS
redirect(URL(r=request, extension=""))
# Create output stream
output = StringIO.StringIO()
# Find fields
fields = None
table = resource.table
if not list_fields:
fields = resource.readable_fields()
else:
fields = resource.readable_fields(subset=list_fields)
if not fields:
fields = [table.id]
if "SazanamiGothic" in pdfmetrics.getRegisteredFontNames():
font_name = "SazanamiGothic"
widget_style = {"fontName": "SazanamiGothic",
'wordWrap': True}
else:
font_name = "Helvetica-Bold"
widget_style = {}
# Export
_elements = [ SystemField(
expression = "%(report_title)s",
top = 0.1 * cm,
left = 0,
width = BAND_WIDTH,
style = {
"fontName": font_name,
"fontSize": 14,
"alignment": TA_CENTER
}
)]
detailElements = []
COLWIDTH = 2.5
LEFTMARGIN = 0.2
represent = self.manager.represent
#_represent = lambda field, value, table=table: \
# represent(table[field],
# value=value,
# strip_markup=True,
# xml_escape=True)
def _represent(field, value):
rep = represent(table[field],
value=value,
strip_markup=True,
xml_escape=True)
prog = re.compile(r"[^ -~]")
ret = ''
for part in rep.split():
if prog.search(part):
s = 7
else:
s = 14
if len(part) > s:
i = 0
while True:
ret += part[i:i+s] + "\n"
i += s
if i > len(part):
break
else:
ret += part + "\n"
return ret
for field in fields:
# Append label
label = Label(text = xml.xml_encode(str(field.label)).decode("utf-8")[:16],
top = 0.8 * cm,
left = LEFTMARGIN * cm,
style = widget_style
)
_elements.append(label)
# Append value
value = ObjectValue(attribute_name = field.name,
left = LEFTMARGIN * cm,
width = COLWIDTH * cm,
get_value = lambda instance, column = field.name: \
_represent(column, instance[column]),
style = widget_style
)
detailElements.append(value)
# Increase left margin
LEFTMARGIN += COLWIDTH
#mod, res = str(table).split("_", 1)
mod = resource.prefix
res = resource.name
try:
mod_nice = deployment_settings.modules[mod]["name_nice"]
except:
mod_nice = mod
_title = mod_nice + ": " + res.capitalize()
class MyReport(Report):
title = _title
page_size = landscape(A4)
class band_page_header(ReportBand):
height = 1.3*cm
auto_expand_height = True
elements = _elements
borders = {"bottom": True}
class band_page_footer(ReportBand):
height = 0.5*cm
elements = [
Label(text="%s" % request.utcnow.date(), top=0.1*cm, left=0),
SystemField(expression="Page # %(page_number)d of %(page_count)d", top=0.1*cm,
width=BAND_WIDTH, style={"alignment": TA_RIGHT}),
]
borders = {"top": True}
class band_detail(ReportBand):
height = 0.5*cm
auto_expand_height = True
elements = tuple(detailElements)
report = MyReport(queryset=records)
report.generate_by(PDFGenerator, filename=output)
# Set content type and disposition headers
if response:
filename = "%s_%s.pdf" % (request.env.server_name, str(table))
response.headers["Content-Type"] = contenttype(".pdf")
response.headers["Content-disposition"] = "attachment; filename=\"%s\"" % filename
# Return the stream
output.seek(0)
return output.read()
def is_registered_font(font_name):
return font_name in pdfmetrics.getRegisteredFontNames()
self.drawString(9 * cm, 2 * cm,
"Page %s of %s" % (self._pageNumber, page_count))
def firstpage(canvas, doc):
canvas.line(70, 800, 530, 800)
canvas.setFont('Helvetica', 22)
canvas.drawCentredString(9.5 * cm, 24 * cm, title)
canvas.line(70, 100, 530, 100)
def restpages(canvas, doc):
canvas.line(70, 790, 530, 790)
pdfmetrics.getRegisteredFontNames()
datas2 = []
datas2.append(['First', 'Second', 'Third'])
stylesoftable = TableStyle([('ALIGN', (0, 0), (2, -1), 'CENTRE'),
('FONT', (0, 0), (2, 0), 'Helvetica', 10),
('FONT', (0, 1), (-1, -1), 'Helvetica', 8),
('INNERGRID', (0, 0), (-1, -1), 0.25,
colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black)])
stylesoftable.add('BACKGROUND', (0, 0), (2, 0), colors.lightcoral)
for i in range(cellswithdata):
OBJ = Raw()
def get_loaded_fonts():
'''List all loaded fonts.
:rtype: list
'''
return pdfmetrics.getRegisteredFontNames()
