Initial commit: IT Site Survey AI v2 with all features
This commit is contained in:
BeawIT Admin
@@ -0,0 +1,751 @@
|
||||
#Copyright ReportLab Europe Ltd. 2000-2017
|
||||
#see license.txt for license details
|
||||
#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/pdfgen/textobject.py
|
||||
__version__='3.3.0'
|
||||
__doc__="""
|
||||
PDFTextObject is an efficient way to add text to a Canvas. Do not
|
||||
instantiate directly, obtain one from the Canvas instead.
|
||||
|
||||
Progress Reports:
|
||||
8.83, 2000-01-13, gmcm: created from pdfgen.py
|
||||
"""
|
||||
from reportlab.lib.colors import Color, CMYKColor, CMYKColorSep, toColor
|
||||
from reportlab.lib.utils import isBytes, isStr, asUnicode
|
||||
from reportlab.lib.rl_accel import fp_str
|
||||
from reportlab.pdfbase.pdfmetrics import getFont as pdfmetrics_getFont, stringWidth as pdfmetrics_stringWidth, unicode2T1 as pdfmetrics_unicode2T1
|
||||
from reportlab.pdfbase.ttfonts import ShapedStr, ShapeData, _sdGuardL, shapeStr
|
||||
from itertools import groupby
|
||||
from operator import itemgetter
|
||||
|
||||
#this is to handle the optionality of rlbidi
|
||||
try:
|
||||
import rlbidi
|
||||
log2vis = rlbidi.log2vis
|
||||
class BidiStr(str):
|
||||
'''A str with indices visual __bidiV__, logical __bidiL__'''
|
||||
def __new__(cls, s, bidiV=-1, bidiL=-1):
|
||||
self = super().__new__(cls,s)
|
||||
self.__bidiV__ = bidiV
|
||||
self.__bidiL__ = bidiL
|
||||
return self
|
||||
isBidiStr = lambda _: isinstance(_,BidiStr)
|
||||
class BidiList(list):
|
||||
'''A list with indices visual __bidiV__, logical __bidiL__'''
|
||||
def __init__(self, L, bidiV=-1, bidiL=-1):
|
||||
super().__init__(L)
|
||||
self.__bidiV__ = bidiV
|
||||
self.__bidiL__ = bidiL
|
||||
def __repr__(self):
|
||||
return f'{self.__class__.__name__}({super().__repr__()},{self.__bidiV__},{self.__bidiL__})'
|
||||
isBidiList = lambda _: isinstance(_,BidiList)
|
||||
def bidiText(text,direction):
|
||||
if direction: direction = direction.upper()
|
||||
return log2vis(text, direction,clean=True) if direction in ('LTR','RTL') else text
|
||||
from reportlab.lib.utils import KlassStore
|
||||
from copy import deepcopy
|
||||
_bidiKS = KlassStore()
|
||||
def innerBidiStrWrap(s, bidiV=-1, bidiL=-1):
|
||||
if isinstance(s,BidiStr): return s
|
||||
if type(s) is str:
|
||||
klass = BidiStr
|
||||
else:
|
||||
sklassName = s.__class__.__name__
|
||||
klassName = f'BidiIndexed{sklassName}'
|
||||
if klassName not in _bidiKS:
|
||||
NS=dict(BidiStr=BidiStr,klassName=klassName,klass=s.__class__,deepcopy=deepcopy)
|
||||
exec( f'''class {klassName}(klass,BidiStr):\n'''
|
||||
'''\tdef __new__(cls,s,bidiV=-1,bidiL=-1):\n'''
|
||||
'''\t\tself = super(cls,cls).__new__(cls,s)\n'''
|
||||
'''\t\tif hasattr(s,'__dict__'): self.__dict__=deepcopy(s.__dict__)\n'''
|
||||
'''\t\tself.__bidiV__ = bidiV\n'''
|
||||
'''\t\tself.__bidiL__ = bidiL\n'''
|
||||
'''\t\treturn self\n''',
|
||||
NS)
|
||||
_bidiKS.add(klassName,NS[klassName])
|
||||
klass = _bidiKS[klassName]
|
||||
return klass(s,bidiV=bidiV,bidiL=bidiL)
|
||||
def bidiStrWrap(s, orig):
|
||||
if not isinstance(orig,BidiStr): return s
|
||||
return innerBidiStrWrap(s,orig.__bidiV__,orig.__bidiL__)
|
||||
def bidiListWrap(L, orig):
|
||||
if not isinstance(orig,(BidiList,BidiIndex)) or isinstance(L,BidiList): return L
|
||||
if type(L) is list:
|
||||
klass = BidiList
|
||||
else:
|
||||
lklassName = L.__class__.__name__
|
||||
klassName = f'BidiIndexed{lklassName}'
|
||||
if klassName not in _bidiKS:
|
||||
NS=dict(BidiList=BidiList,klassName=klassName,klass=L.__class__,deepcopy=deepcopy)
|
||||
exec( f'''class {klassName}(klass,BidiList):\n'''
|
||||
'''\tdef __init__(self,L,bidiV=-1,bidiL=-1):\n'''
|
||||
'''\t\tklass.__init__(self,L)\n'''
|
||||
'''\t\tif hasattr(L,'__dict__'): self.__dict__=deepcopy(L.__dict__)\n'''
|
||||
'''\t\tself.__bidiV__ = bidiV\n'''
|
||||
'''\t\tself.__bidiL__ = bidiL\n''',
|
||||
NS)
|
||||
_bidiKS.add(klassName,NS[klassName])
|
||||
klass = _bidiKS[klassName]
|
||||
return klass(L,orig.__bidiV__,orig.__bidiL__)
|
||||
#return _bidiKS[klassName](L,orig.__bidiV__,orig.__bidiL__)
|
||||
class BidiIndex:
|
||||
def __init__(self,bidiV=-1,bidiL=-1):
|
||||
self.__bidiV__ = bidiV
|
||||
self.__bidiL__ = bidiL
|
||||
import re
|
||||
wordpat = re.compile(r'[^ ]+',re.M)
|
||||
del re
|
||||
def bidiWordList(words,direction='RTL', clean=True, wx=False):
|
||||
'''takes words (list of strings) returns bidi associated lists
|
||||
if wx is True then the V2L index only is returned
|
||||
'''
|
||||
if direction: direction = direction.upper()
|
||||
if direction not in ('LTR','RTL'): return words
|
||||
if not isinstance(words,(list,tuple)):
|
||||
raise ValueError('bidiWordList argument words should be a list or tuple of strings')
|
||||
raw = ' '.join(words)
|
||||
V2L = []
|
||||
bidi = log2vis(raw, base_direction=direction, clean=clean, positions_V_to_L=V2L)
|
||||
|
||||
VMAP = {}
|
||||
for i, m in enumerate(wordpat.finditer(bidi)):
|
||||
t = (m.group(0), i)
|
||||
start, end = m.span()
|
||||
for j in range(start,end):
|
||||
VMAP[V2L[j]] = t
|
||||
|
||||
res = [].append
|
||||
#create result by assigning a V word to a raw one
|
||||
for w, m in enumerate(wordpat.finditer(raw)):
|
||||
for j in range(*m.span()):
|
||||
if j in VMAP:
|
||||
s, i = VMAP[j]
|
||||
res(i if wx else BidiStr(s,i,w))
|
||||
break
|
||||
else:
|
||||
#we seem to have a raw word that doesn't appear in bidi
|
||||
pass
|
||||
return res.__self__
|
||||
def bidiShapedText(text, direction='RTL', clean=True, fontName='Helvetica', fontSize=10, shaping=False):
|
||||
'''return shaped/bidi text and width; assumes text is aways in logical order'''
|
||||
text = asUnicode(text)
|
||||
if shaping:
|
||||
font = pdfmetrics_getFont(fontName)
|
||||
if not font.shapable: shaping = False
|
||||
if direction: direction = direction.upper()
|
||||
if direction in ('RTL','LTR'):
|
||||
if shaping:
|
||||
w = text.lstrip()
|
||||
bL = len(text) - len(w)
|
||||
text = w.rstrip()
|
||||
bR = len(w) - len(text)
|
||||
LW = [text[slice(*m.span())] for m in wordpat.finditer(text)] #logical words
|
||||
VX = bidiWordList(LW,direction=direction,wx=True) #visual order
|
||||
SW = [shapeStr(LW[i],fontName,fontSize) for i in VX] #shaped words in visual order
|
||||
if len(VX)>1 and VX[0]>VX[-1]:
|
||||
bL, bR = bR, bL
|
||||
text = shapeStr(bL*' ',fontName,fontSize, force=True)
|
||||
for w in SW:
|
||||
if not hasattr(w,'__shapeData__'): w = shapeStr(w,fontName,fontSize,force=True)
|
||||
if w is not SW[0]: text += shapeStr(' ',fontName,fontSize, force=True)
|
||||
text += w
|
||||
if bR:
|
||||
text += shapeStr(bR*' ',fontName,fontSize)
|
||||
else:
|
||||
text = log2vis(text,base_direction=direction,clean=clean)
|
||||
else:
|
||||
if shaping:
|
||||
text = shapeStr(text, fontName, fontSize)
|
||||
width = (sum((_.x_advance for _ in text.__shapeData__))*fontSize/1000 if isinstance(text,ShapedStr)
|
||||
else pdfmetrics_stringWidth(text, fontName, fontSize))
|
||||
return text, width
|
||||
def bidiFragWord(w,direction=None,bidiV=-1,bidiL=-1, clean=True):
|
||||
if direction not in ('RTL','LTR'): return w
|
||||
text = ''
|
||||
cbd = [].append
|
||||
fL = [].append
|
||||
for i, (f, s) in enumerate(w[1:]):
|
||||
if hasattr(f,'cbDefn'):
|
||||
cbd(i)
|
||||
else:
|
||||
for u in s:
|
||||
fL(i)
|
||||
text += u
|
||||
if len(text)<=1: return w #nothing to bidi
|
||||
fL = fL.__self__
|
||||
V2L = []
|
||||
bidi = log2vis(text, base_direction=direction, clean=clean, positions_V_to_L=V2L)
|
||||
fsL = [(w[1+k][0],''.join((ks[1] for ks in g))) for k, g in groupby(((fL[V2L[i]],v) for i,v in enumerate(bidi)),key=itemgetter(0))]
|
||||
bfw = [sum((pdfmetrics_stringWidth(s,f.fontName,f.fontSize) for f,s in fsL))] + fsL
|
||||
cbd = cbd.__self__
|
||||
if cbd:
|
||||
if V2L[0]>V2L[-1]:
|
||||
#reversed
|
||||
for i in sorted(cbd):
|
||||
fs = w[i+1]
|
||||
bfw.insert(len(w)-i,fs)
|
||||
bfw[0] += getattr(fs,'width',0)
|
||||
else:
|
||||
for i in reversed(sorted(cbd)):
|
||||
fs = w[i+1]
|
||||
bfw.insert(i+1,fs)
|
||||
bfw[0] += getattr(fs,'width',0)
|
||||
bfw = w.__class__(bfw)
|
||||
return bidiListWrap(bfw, BidiIndex(bidiV,bidiL))
|
||||
rtlSupport = True
|
||||
except:
|
||||
import warnings
|
||||
_rlbidiMsg = 'rlbidi is not installed - RTL/LTR not supported'
|
||||
def log2vis(*args,**kwds):
|
||||
raise ValueError(_rlbidiMsg)
|
||||
isBidiStr = isBidiList = lambda _: False
|
||||
BidiStr = str
|
||||
BidiList = list
|
||||
def bidiText(*args,**kwds):
|
||||
direction = kwds.pop('direction',None)
|
||||
if direction: direction = direction.upper()
|
||||
if direction in ('LTR','RTL'):
|
||||
warnings.warn(_rlbidiMsg,stacklevel=0)
|
||||
return args[0]
|
||||
def bidiShapedText(text, direction='RTL', clean=True, fontName='Helvetica', fontSize=10, shaping=False):
|
||||
return bidiText(text,direction), pdfmetrics_stringWidth(text,fontName,fontSize)
|
||||
bidiWordList = bidiStrWrap = bidiListWrap = bidiFragWord = innerBidiStrWrap = BidiIndex = bidiText
|
||||
rtlSupport = False
|
||||
|
||||
class _PDFColorSetter:
|
||||
'''Abstracts the color setting operations; used in Canvas and Textobject
|
||||
asseumes we have a _code object'''
|
||||
def _checkSeparation(self,cmyk):
|
||||
if isinstance(cmyk,CMYKColorSep):
|
||||
name,sname = self._doc.addColor(cmyk)
|
||||
if name not in self._colorsUsed:
|
||||
self._colorsUsed[name] = sname
|
||||
return name
|
||||
|
||||
#if this is set to a callable(color) --> color it can be used to check color setting
|
||||
#see eg _enforceCMYK/_enforceRGB
|
||||
_enforceColorSpace = None
|
||||
|
||||
def setFillColorCMYK(self, c, m, y, k, alpha=None):
|
||||
"""set the fill color useing negative color values
|
||||
(cyan, magenta, yellow and darkness value).
|
||||
Takes 4 arguments between 0.0 and 1.0"""
|
||||
self.setFillColor((c,m,y,k),alpha=alpha)
|
||||
|
||||
def setStrokeColorCMYK(self, c, m, y, k, alpha=None):
|
||||
"""set the stroke color useing negative color values
|
||||
(cyan, magenta, yellow and darkness value).
|
||||
Takes 4 arguments between 0.0 and 1.0"""
|
||||
self.setStrokeColor((c,m,y,k),alpha=alpha)
|
||||
|
||||
def setFillColorRGB(self, r, g, b, alpha=None):
|
||||
"""Set the fill color using positive color description
|
||||
(Red,Green,Blue). Takes 3 arguments between 0.0 and 1.0"""
|
||||
self.setFillColor((r,g,b),alpha=alpha)
|
||||
|
||||
def setStrokeColorRGB(self, r, g, b, alpha=None):
|
||||
"""Set the stroke color using positive color description
|
||||
(Red,Green,Blue). Takes 3 arguments between 0.0 and 1.0"""
|
||||
self.setStrokeColor((r,g,b),alpha=alpha)
|
||||
|
||||
def setFillColor(self, aColor, alpha=None):
|
||||
"""Takes a color object, allowing colors to be referred to by name"""
|
||||
if self._enforceColorSpace:
|
||||
aColor = self._enforceColorSpace(aColor)
|
||||
if isinstance(aColor, CMYKColor):
|
||||
d = aColor.density
|
||||
c,m,y,k = (d*aColor.cyan, d*aColor.magenta, d*aColor.yellow, d*aColor.black)
|
||||
self._fillColorObj = aColor
|
||||
name = self._checkSeparation(aColor)
|
||||
if name:
|
||||
self._code.append('/%s cs %s scn' % (name,fp_str(d)))
|
||||
else:
|
||||
self._code.append('%s k' % fp_str(c, m, y, k))
|
||||
elif isinstance(aColor, Color):
|
||||
rgb = (aColor.red, aColor.green, aColor.blue)
|
||||
self._fillColorObj = aColor
|
||||
self._code.append('%s rg' % fp_str(rgb) )
|
||||
elif isinstance(aColor,(tuple,list)):
|
||||
l = len(aColor)
|
||||
if l==3:
|
||||
self._fillColorObj = aColor
|
||||
self._code.append('%s rg' % fp_str(aColor) )
|
||||
elif l==4:
|
||||
self._fillColorObj = aColor
|
||||
self._code.append('%s k' % fp_str(aColor))
|
||||
else:
|
||||
raise ValueError('Unknown color %r' % aColor)
|
||||
elif isStr(aColor):
|
||||
self.setFillColor(toColor(aColor))
|
||||
else:
|
||||
raise ValueError('Unknown color %r' % aColor)
|
||||
if alpha is not None:
|
||||
self.setFillAlpha(alpha)
|
||||
elif getattr(aColor, 'alpha', None) is not None:
|
||||
self.setFillAlpha(aColor.alpha)
|
||||
|
||||
def setStrokeColor(self, aColor, alpha=None):
|
||||
"""Takes a color object, allowing colors to be referred to by name"""
|
||||
if self._enforceColorSpace:
|
||||
aColor = self._enforceColorSpace(aColor)
|
||||
if isinstance(aColor, CMYKColor):
|
||||
d = aColor.density
|
||||
c,m,y,k = (d*aColor.cyan, d*aColor.magenta, d*aColor.yellow, d*aColor.black)
|
||||
self._strokeColorObj = aColor
|
||||
name = self._checkSeparation(aColor)
|
||||
if name:
|
||||
self._code.append('/%s CS %s SCN' % (name,fp_str(d)))
|
||||
else:
|
||||
self._code.append('%s K' % fp_str(c, m, y, k))
|
||||
elif isinstance(aColor, Color):
|
||||
rgb = (aColor.red, aColor.green, aColor.blue)
|
||||
self._strokeColorObj = aColor
|
||||
self._code.append('%s RG' % fp_str(rgb) )
|
||||
elif isinstance(aColor,(tuple,list)):
|
||||
l = len(aColor)
|
||||
if l==3:
|
||||
self._strokeColorObj = aColor
|
||||
self._code.append('%s RG' % fp_str(aColor) )
|
||||
elif l==4:
|
||||
self._strokeColorObj = aColor
|
||||
self._code.append('%s K' % fp_str(aColor))
|
||||
else:
|
||||
raise ValueError('Unknown color %r' % aColor)
|
||||
elif isStr(aColor):
|
||||
self.setStrokeColor(toColor(aColor))
|
||||
else:
|
||||
raise ValueError('Unknown color %r' % aColor)
|
||||
if alpha is not None:
|
||||
self.setStrokeAlpha(alpha)
|
||||
elif getattr(aColor, 'alpha', None) is not None:
|
||||
self.setStrokeAlpha(aColor.alpha)
|
||||
|
||||
def setFillGray(self, gray, alpha=None):
|
||||
"""Sets the gray level; 0.0=black, 1.0=white"""
|
||||
self._fillColorObj = (gray, gray, gray)
|
||||
self._code.append('%s g' % fp_str(gray))
|
||||
if alpha is not None:
|
||||
self.setFillAlpha(alpha)
|
||||
|
||||
def setStrokeGray(self, gray, alpha=None):
|
||||
"""Sets the gray level; 0.0=black, 1.0=white"""
|
||||
self._strokeColorObj = (gray, gray, gray)
|
||||
self._code.append('%s G' % fp_str(gray))
|
||||
if alpha is not None:
|
||||
self.setFillAlpha(alpha)
|
||||
|
||||
def setStrokeAlpha(self,a):
|
||||
if not (isinstance(a,(float,int)) and 0<=a<=1):
|
||||
raise ValueError('setStrokeAlpha invalid value %r' % a)
|
||||
getattr(self,'_setStrokeAlpha',lambda x: None)(a)
|
||||
|
||||
def setFillAlpha(self,a):
|
||||
if not (isinstance(a,(float,int)) and 0<=a<=1):
|
||||
raise ValueError('setFillAlpha invalid value %r' % a)
|
||||
getattr(self,'_setFillAlpha',lambda x: None)(a)
|
||||
|
||||
def setStrokeOverprint(self,a):
|
||||
getattr(self,'_setStrokeOverprint',lambda x: None)(a)
|
||||
|
||||
def setFillOverprint(self,a):
|
||||
getattr(self,'_setFillOverprint',lambda x: None)(a)
|
||||
|
||||
def setOverprintMask(self,a):
|
||||
getattr(self,'_setOverprintMask',lambda x: None)(a)
|
||||
|
||||
class PDFTextObject(_PDFColorSetter):
|
||||
"""PDF logically separates text and graphics drawing; text
|
||||
operations need to be bracketed between BT (Begin text) and
|
||||
ET operators. This class ensures text operations are
|
||||
properly encapusalted. Ask the canvas for a text object
|
||||
with beginText(x, y). Do not construct one directly.
|
||||
Do not use multiple text objects in parallel; PDF is
|
||||
not multi-threaded!
|
||||
|
||||
It keeps track of x and y coordinates relative to its origin."""
|
||||
|
||||
def __init__(self, canvas, x=0,y=0, direction=None):
|
||||
self._code = ['BT'] #no point in [] then append RGB
|
||||
self._canvas = canvas #canvas sets this so it has access to size info
|
||||
self._fontname = self._canvas._fontname
|
||||
self._fontsize = self._canvas._fontsize
|
||||
self._leading = self._canvas._leading
|
||||
self._doc = self._canvas._doc
|
||||
self._colorsUsed = self._canvas._colorsUsed
|
||||
self._enforceColorSpace = getattr(canvas,'_enforceColorSpace',None)
|
||||
font = pdfmetrics_getFont(self._fontname)
|
||||
self._curSubset = -1
|
||||
self.direction = direction
|
||||
self.setTextOrigin(x, y)
|
||||
self._textRenderMode = 0
|
||||
self._clipping = 0
|
||||
self._rise = 0
|
||||
|
||||
def getCode(self):
|
||||
"pack onto one line; used internally"
|
||||
self._code.append('ET')
|
||||
if self._clipping:
|
||||
self._code.append('%d Tr' % (self._textRenderMode^4))
|
||||
return ' '.join(self._code)
|
||||
|
||||
def setTextOrigin(self, x, y):
|
||||
if self._canvas.bottomup:
|
||||
self._code.append('1 0 0 1 %s Tm' % fp_str(x, y)) #bottom up
|
||||
else:
|
||||
self._code.append('1 0 0 -1 %s Tm' % fp_str(x, y)) #top down
|
||||
|
||||
# The current cursor position is at the text origin
|
||||
self._x0 = self._x = x
|
||||
self._y0 = self._y = y
|
||||
|
||||
def setTextTransform(self, a, b, c, d, e, f):
|
||||
"Like setTextOrigin, but does rotation, scaling etc."
|
||||
if not self._canvas.bottomup:
|
||||
c = -c #reverse bottom row of the 2D Transform
|
||||
d = -d
|
||||
self._code.append('%s Tm' % fp_str(a, b, c, d, e, f))
|
||||
|
||||
# The current cursor position is at the text origin Note that
|
||||
# we aren't keeping track of all the transform on these
|
||||
# coordinates: they are relative to the rotations/sheers
|
||||
# defined in the matrix.
|
||||
self._x0 = self._x = e
|
||||
self._y0 = self._y = f
|
||||
|
||||
def moveCursor(self, dx, dy):
|
||||
"""Starts a new line at an offset dx,dy from the start of the
|
||||
current line. This does not move the cursor relative to the
|
||||
current position, and it changes the current offset of every
|
||||
future line drawn (i.e. if you next do a textLine() call, it
|
||||
will move the cursor to a position one line lower than the
|
||||
position specificied in this call. """
|
||||
|
||||
# Check if we have a previous move cursor call, and combine
|
||||
# them if possible.
|
||||
if self._code and self._code[-1].endswith(' Td'):
|
||||
L = self._code[-1].split()
|
||||
if len(L)==3:
|
||||
del self._code[-1]
|
||||
else:
|
||||
self._code[-1] = ''.join(L[:-4])
|
||||
|
||||
# Work out the last movement
|
||||
lastDx = float(L[-3])
|
||||
lastDy = float(L[-2])
|
||||
|
||||
# Combine the two movement
|
||||
dx += lastDx
|
||||
dy -= lastDy
|
||||
|
||||
# We will soon add the movement to the line origin, so if
|
||||
# we've already done this for lastDx, lastDy, remove it
|
||||
# first (so it will be right when added back again).
|
||||
self._x0 -= lastDx
|
||||
self._y0 -= lastDy
|
||||
|
||||
# Output the move text cursor call.
|
||||
self._code.append('%s Td' % fp_str(dx, -dy))
|
||||
|
||||
# Keep track of the new line offsets and the cursor position
|
||||
self._x0 += dx
|
||||
self._y0 += dy
|
||||
self._x = self._x0
|
||||
self._y = self._y0
|
||||
|
||||
def setXPos(self, dx):
|
||||
"""Starts a new line dx away from the start of the
|
||||
current line - NOT from the current point! So if
|
||||
you call it in mid-sentence, watch out."""
|
||||
self.moveCursor(dx,0)
|
||||
|
||||
def getCursor(self):
|
||||
"""Returns current text position relative to the last origin."""
|
||||
return (self._x, self._y)
|
||||
|
||||
def getStartOfLine(self):
|
||||
"""Returns a tuple giving the text position of the start of the
|
||||
current line."""
|
||||
return (self._x0, self._y0)
|
||||
|
||||
def getX(self):
|
||||
"""Returns current x position relative to the last origin."""
|
||||
return self._x
|
||||
|
||||
def getY(self):
|
||||
"""Returns current y position relative to the last origin."""
|
||||
return self._y
|
||||
|
||||
def _setFont(self, psfontname, size):
|
||||
"""Sets the font and fontSize
|
||||
Raises a readable exception if an illegal font
|
||||
is supplied. Font names are case-sensitive! Keeps track
|
||||
of font anme and size for metrics."""
|
||||
self._fontname = psfontname
|
||||
self._fontsize = size
|
||||
font = pdfmetrics_getFont(self._fontname)
|
||||
|
||||
if font._dynamicFont:
|
||||
self._curSubset = -1
|
||||
else:
|
||||
pdffontname = self._canvas._doc.getInternalFontName(psfontname)
|
||||
self._code.append('%s %s Tf' % (pdffontname, fp_str(size)))
|
||||
|
||||
def setFont(self, psfontname, size, leading = None):
|
||||
"""Sets the font. If leading not specified, defaults to 1.2 x
|
||||
font size. Raises a readable exception if an illegal font
|
||||
is supplied. Font names are case-sensitive! Keeps track
|
||||
of font anme and size for metrics."""
|
||||
self._fontname = psfontname
|
||||
self._fontsize = size
|
||||
if leading is None:
|
||||
leading = size * 1.2
|
||||
self._leading = leading
|
||||
font = pdfmetrics_getFont(self._fontname)
|
||||
if font._dynamicFont:
|
||||
self._curSubset = -1
|
||||
else:
|
||||
pdffontname = self._canvas._doc.getInternalFontName(psfontname)
|
||||
self._code.append('%s %s Tf %s TL' % (pdffontname, fp_str(size), fp_str(leading)))
|
||||
|
||||
def setCharSpace(self, charSpace):
|
||||
"""Adjusts inter-character spacing"""
|
||||
self._charSpace = charSpace
|
||||
self._code.append('%s Tc' % fp_str(charSpace))
|
||||
|
||||
def setWordSpace(self, wordSpace):
|
||||
"""Adjust inter-word spacing. This can be used
|
||||
to flush-justify text - you get the width of the
|
||||
words, and add some space between them."""
|
||||
self._wordSpace = wordSpace
|
||||
self._code.append('%s Tw' % fp_str(wordSpace))
|
||||
|
||||
def setHorizScale(self, horizScale):
|
||||
"Stretches text out horizontally"
|
||||
self._horizScale = 100 + horizScale
|
||||
self._code.append('%s Tz' % fp_str(horizScale))
|
||||
|
||||
def setLeading(self, leading):
|
||||
"How far to move down at the end of a line."
|
||||
self._leading = leading
|
||||
self._code.append('%s TL' % fp_str(leading))
|
||||
|
||||
def setTextRenderMode(self, mode):
|
||||
"""Set the text rendering mode.
|
||||
|
||||
0 = Fill text
|
||||
1 = Stroke text
|
||||
2 = Fill then stroke
|
||||
3 = Invisible
|
||||
4 = Fill text and add to clipping path
|
||||
5 = Stroke text and add to clipping path
|
||||
6 = Fill then stroke and add to clipping path
|
||||
7 = Add to clipping path
|
||||
|
||||
after we start clipping we mustn't change the mode back until after the ET
|
||||
"""
|
||||
|
||||
assert mode in (0,1,2,3,4,5,6,7), "mode must be in (0,1,2,3,4,5,6,7)"
|
||||
if (mode & 4)!=self._clipping:
|
||||
mode |= 4
|
||||
self._clipping = mode & 4
|
||||
if self._textRenderMode!=mode:
|
||||
self._textRenderMode = mode
|
||||
self._code.append('%d Tr' % mode)
|
||||
|
||||
def setRise(self, rise):
|
||||
"Move text baseline up or down to allow superscript/subscripts"
|
||||
v = f'{fp_str(rise)} Ts'
|
||||
if self._code[-1].endswith(' Ts'): #optimize out r0 Ts r1 Ts
|
||||
#reverse previous changes
|
||||
self._y += self._rise
|
||||
self._code[-1] = v
|
||||
else:
|
||||
self._rise = rise
|
||||
self._y -= rise
|
||||
self._code.append(v)
|
||||
|
||||
def _formatText(self, text):
|
||||
"Generates PDF text output operator(s)"
|
||||
#if log2vis and self.direction in ('LTR','RTL'):
|
||||
# # Use pyfribidi to write the text in the correct visual order.
|
||||
# text = log2vis(text, self.direction)
|
||||
canv = self._canvas
|
||||
font = pdfmetrics_getFont(self._fontname)
|
||||
state = (self._code, self._x, self._y)
|
||||
try:
|
||||
self._code = []
|
||||
R = self._code.append
|
||||
if font._dynamicFont:
|
||||
canv_escape = canv._escape
|
||||
tmpl = None
|
||||
r0 = self._rise
|
||||
#it's a truetype font
|
||||
if font.shapable and isinstance(text,ShapedStr):
|
||||
sd0 = 0
|
||||
r0 = self._rise
|
||||
shapeData = text.__shapeData__
|
||||
fontsize = self._fontsize
|
||||
for subset, t in font.splitString(text, canv._doc):
|
||||
cluster = None
|
||||
if subset!=self._curSubset:
|
||||
if not tmpl:
|
||||
tmpl = f'{fp_str(fontsize)} Tf {fp_str(self._leading)} TL'
|
||||
R(f'{font.getSubsetInternalName(subset, canv._doc)} {tmpl}')
|
||||
self._curSubset = subset
|
||||
sd1 = sd0 + len(t)
|
||||
SD = shapeData[sd0:sd1] + _sdGuardL
|
||||
sd0 = sd1
|
||||
for i, sd in enumerate(SD):
|
||||
r = r0 + fontsize*sd.y_offset/1000
|
||||
if cluster is None or sd.cluster<0 or r!=self._rise:
|
||||
if cluster is not None:
|
||||
#end current cluster
|
||||
A = [v for v in ((('(%s)' % canv_escape(b''.join(g))) if k else fp_str(sum(g)))
|
||||
for k, g in groupby(filter(None,A.__self__),lambda x: isinstance(x,bytes))) if v!='0']
|
||||
if len(A)==1 and A[0].startswith('('):
|
||||
R(f'{A[0]} Tj')
|
||||
else:
|
||||
R(f'[{" ".join(A)}] TJ')
|
||||
|
||||
if self._rise!=r0: self.setRise(r0)
|
||||
if sd.cluster<0: break
|
||||
|
||||
#begin new cluster
|
||||
if r!=self._rise: self.setRise(r)
|
||||
cluster = sd.cluster
|
||||
A = [].append
|
||||
|
||||
#we assume that both harfbuzz and pdf positions are correct
|
||||
A(-sd.x_offset) #adjust using harfbuzz offset
|
||||
A(bytes(chr(t[i]).encode('latin1')))
|
||||
#A(sd.x_offset) #remove the harfbuzz adjustment
|
||||
#we assume the harfbuzz position is correct, but we will have
|
||||
# 1<----O------|
|
||||
# 1-----O ---->|--------------A--------->2
|
||||
#
|
||||
# 1<----O------|<....(W-O).....><...x...>2
|
||||
# 1--------------------W------->
|
||||
#
|
||||
# W - O + x = A ==> x = A-W+O
|
||||
A(sd.width - sd.x_advance + sd.x_offset)
|
||||
if self._rise!=r0: self.setRise(r0)
|
||||
else:
|
||||
for subset, t in font.splitString(text, canv._doc):
|
||||
if subset!=self._curSubset:
|
||||
if not tmpl:
|
||||
tmpl = f'{fp_str(self._fontsize)} Tf {fp_str(self._leading)} TL'
|
||||
R(f'{font.getSubsetInternalName(subset, canv._doc)} {tmpl}')
|
||||
self._curSubset = subset
|
||||
R(f'({canv_escape(t)}) Tj')
|
||||
elif font._multiByte:
|
||||
#all the fonts should really work like this - let them know more about PDF...
|
||||
R("%s %s Tf %s TL" % (
|
||||
canv._doc.getInternalFontName(font.fontName),
|
||||
fp_str(self._fontsize),
|
||||
fp_str(self._leading)
|
||||
))
|
||||
R("(%s) Tj" % font.formatForPdf(text))
|
||||
else:
|
||||
#convert to T1 coding
|
||||
fc = font
|
||||
if isBytes(text):
|
||||
try:
|
||||
text = text.decode('utf8')
|
||||
except UnicodeDecodeError as e:
|
||||
i,j = e.args[2:4]
|
||||
raise UnicodeDecodeError(*(e.args[:4]+('%s\n%s-->%s<--%s' % (e.args[4],text[max(i-10,0):i],text[i:j],text[j:j+10]),)))
|
||||
|
||||
canv_escape = canv._escape
|
||||
for f, t in pdfmetrics_unicode2T1(text,[font]+font.substitutionFonts):
|
||||
if f!=fc:
|
||||
R("%s %s Tf %s TL" % (canv._doc.getInternalFontName(f.fontName), fp_str(self._fontsize), fp_str(self._leading)))
|
||||
fc = f
|
||||
R(f'({canv_escape(t)}) Tj')
|
||||
if font!=fc:
|
||||
R("%s %s Tf %s TL" % (canv._doc.getInternalFontName(self._fontname), fp_str(self._fontsize), fp_str(self._leading)))
|
||||
finally:
|
||||
self._code, self._x, self._y = state
|
||||
return ' '.join(R.__self__)
|
||||
|
||||
def _shapedTextOut(self, text, dx, dy):
|
||||
add = self._code.append
|
||||
canv = self._canvas
|
||||
font = pdfmetrics_getFont(self._fontname)
|
||||
canv_escape = canv._escape
|
||||
for subset, t in font.splitString(text, canv._doc):
|
||||
if subset!=self._curSubset:
|
||||
pdffontname = font.getSubsetInternalName(subset, canv._doc)
|
||||
R.append("%s %s Tf %s TL" % (pdffontname, fp_str(self._fontsize), fp_str(self._leading)))
|
||||
self._curSubset = subset
|
||||
if dy:
|
||||
print(f'{dy} -->',end='')
|
||||
dy = (dy / font.face.unitsPerEm) * self._fontsize
|
||||
print(f'{dy}')
|
||||
add(f'{fp_str(dy)} Ts')
|
||||
if dx:
|
||||
add(f'[{fp_str(font.pdfScale(dx))} ({canv_escape(t)})] TJ')
|
||||
if dy:
|
||||
add(f'{fp_str(-dy)} Ts')
|
||||
|
||||
|
||||
def _textOut(self, text, TStar=0):
|
||||
"prints string at current point, ignores text cursor"
|
||||
self._code.append('%s%s' % (self._formatText(text), (TStar and ' T*' or '')))
|
||||
|
||||
def textOut(self, text):
|
||||
"""prints string at current point, text cursor moves across."""
|
||||
self._x = self._x + self._canvas.stringWidth(text, self._fontname, self._fontsize)
|
||||
self._code.append(self._formatText(text))
|
||||
|
||||
def textLine(self, text=''):
|
||||
"""prints string at current point, text cursor moves down.
|
||||
Can work with no argument to simply move the cursor down."""
|
||||
# Update the coordinates of the cursor
|
||||
self._x = self._x0
|
||||
if self._canvas.bottomup:
|
||||
self._y = self._y - self._leading
|
||||
else:
|
||||
self._y = self._y + self._leading
|
||||
|
||||
# Update the location of the start of the line
|
||||
# self._x0 is unchanged
|
||||
self._y0 = self._y
|
||||
|
||||
# Output the text followed by a PDF newline command
|
||||
self._code.append('%s T*' % self._formatText(text))
|
||||
|
||||
def textLines(self, stuff, trim=1):
|
||||
"""prints multi-line or newlined strings, moving down. One
|
||||
comon use is to quote a multi-line block in your Python code;
|
||||
since this may be indented, by default it trims whitespace
|
||||
off each line and from the beginning; set trim=0 to preserve
|
||||
whitespace."""
|
||||
if isStr(stuff):
|
||||
lines = asUnicode(stuff).strip().split(u'\n')
|
||||
if trim==1:
|
||||
lines = [s.strip() for s in lines]
|
||||
elif isinstance(stuff,(tuple,list)):
|
||||
lines = stuff
|
||||
else:
|
||||
assert 1==0, "argument to textlines must be string,, list or tuple"
|
||||
|
||||
# Output each line one at a time. This used to be a long-hand
|
||||
# copy of the textLine code, now called as a method.
|
||||
for line in lines:
|
||||
self.textLine(line)
|
||||
|
||||
def __nonzero__(self):
|
||||
'PDFTextObject is true if it has something done after the init'
|
||||
return self._code != ['BT']
|
||||
|
||||
def _setFillAlpha(self,v):
|
||||
self._canvas._doc.ensureMinPdfVersion('transparency')
|
||||
self._canvas._extgstate.set(self,'ca',v)
|
||||
|
||||
def _setStrokeOverprint(self,v):
|
||||
self._canvas._extgstate.set(self,'OP',v)
|
||||
|
||||
def _setFillOverprint(self,v):
|
||||
self._canvas._extgstate.set(self,'op',v)
|
||||
|
||||
def _setOverprintMask(self,v):
|
||||
self._canvas._extgstate.set(self,'OPM',v and 1 or 0)
|
||||
Reference in New Issue
Block a user