reportlab: comparison src/reportlab/platypus/paragraph.py

equal deleted inserted replaced

-:9f93d62b9f6e
+:61a7f0840d00
 __doc__='''The standard paragraph implementation'''
 from string import whitespace
 from operator import truth
 from unicodedata import category
 from reportlab.pdfbase.pdfmetrics import stringWidth, getFont, getAscentDescent
-from reportlab.platypus.paraparser import ParaParser, _PCT
+from reportlab.platypus.paraparser import ParaParser, _PCT, _num as _parser_num, _re_us_value
 from reportlab.platypus.flowables import Flowable
 from reportlab.lib.colors import Color
 from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY
 from reportlab.lib.geomutils import normalizeTRBL
 from reportlab.lib.textsplit import wordSplit, ALL_CANNOT_START
 from copy import deepcopy
 from reportlab.lib.abag import ABag
-from reportlab.rl_config import platypus_link_underline, decimalSymbol, _FUZZ, paraFontSizeHeightOffset
+from reportlab.rl_config import platypus_link_underline, decimalSymbol, _FUZZ, paraFontSizeHeightOffset, \
-from reportlab.lib.utils import _className, isBytes, unicodeT, bytesT, strTypes
+strikeGap, underlineGap
+from reportlab.lib.utils import _className, isBytes, unicodeT, bytesT, isStr
 from reportlab.lib.rl_accel import sameFrag
 from reportlab import xrange
 import re
 from types import MethodType
 u'\u3000',  # IDEOGRAPHIC SPACE
 ))
 _wsc_re_split=re.compile('[%s]+'% re.escape(_wsc)).split
 _wsc_end_search=re.compile('[%s]+$'% re.escape(_wsc)).search
+def _usConv(s, vMap, default=None):
+'''convert a strike/underline distance to a number'''
+if isStr(s):
+s = s.strip()
+if s:
+m = _re_us_value.match(s)
+if m:
+return float(m.group(1))*vMap[m.group(2)]
+else:
+return _parser_num(s,allowRelative=False)
+elif default:
+return default
+return s
 def split(text, delim=None):
 if isBytes(text): text = text.decode('utf8')
 if delim is not None and isBytes(delim): delim = delim.decode('utf8')
 return [uword for uword in (_wsc_re_split(text) if delim is None and u'\xa0' in text else text.split(delim))]
 else:
 return v
 def _getDotsInfo(style):
 dots = style.endDots
-if isinstance(dots,strTypes):
+if isStr(dots):
 text = dots
 fontName = style.fontName
 fontSize = style.fontSize
 textColor = style.textColor
 backColor = style.backColor
 tx._olb = cur_y - descent
 tx._oleading = leading
 ws = getattr(tx,'_wordSpace',0)
 nSpaces = 0
 words = line.words
+AL = []
+LL = []
+us_lines = xs.us_lines
+links = xs.links
 for i, f in enumerate(words):
 if hasattr(f,'cbDefn'):
 cbDefn = f.cbDefn
 kind = cbDefn.kind
 if kind=='img':
 tx.setFont(xs.style.fontName,xs.style.fontSize)
 tx._textOut('',1)
 else:
 cur_x_s = cur_x + nSpaces*ws
 end_x = cur_x_s
+fontSize = f.fontSize
+textColor = f.textColor
+rise = f.rise
 if i > 0:
 end_x = cur_x_s - _trailingSpaceLength(words[i-1].text, tx)
-if (tx._fontname,tx._fontsize)!=(f.fontName,f.fontSize):
+if (tx._fontname,tx._fontsize)!=(f.fontName,fontSize):
-tx._setFont(f.fontName, f.fontSize)
+tx._setFont(f.fontName, fontSize)
-if xs.textColor!=f.textColor:
+if xs.textColor!=textColor:
-xs.textColor = f.textColor
+xs.textColor = textColor
-tx.setFillColor(f.textColor)
+tx.setFillColor(textColor)
-if xs.rise!=f.rise:
+if xs.rise!=rise:
-xs.rise=f.rise
+xs.rise=rise
-tx.setRise(f.rise)
+tx.setRise(rise)
 text = f.text
 tx._textOut(text,f is words[-1])    # cheap textOut
-if not xs.underline and f.underline:
+if LL != f.us_lines:
-xs.underline = 1
+S = set(LL)
-xs.underline_x = cur_x_s
+NS = set(f.us_lines)
-xs.underlineColor = f.textColor
+nL = NS - S #new lines
-elif xs.underline:
+eL = S - NS #ending lines
-if not f.underline:
+for l in eL:
-xs.underline = 0
+us_lines[l] = us_lines[l],end_x
-xs.underlines.append( (xs.underline_x, end_x, xs.underlineColor) )
+for l in nL:
-xs.underlineColor = None
+us_lines[l] = (l,fontSize,textColor,cur_x),fontSize
-elif xs.textColor!=xs.underlineColor:
+LL = f.us_lines
-xs.underlines.append( (xs.underline_x, end_x, xs.underlineColor) )
+if LL:
-xs.underlineColor = xs.textColor
+for l in LL:
-xs.underline_x = cur_x_s
+l0, fsmax = us_lines[l]
-if not xs.strike and f.strike:
+if fontSize>fsmax:
-xs.strike = 1
+us_lines[l] = l0, fontSize
-xs.strike_x = cur_x_s
-xs.strikeColor = f.textColor
+nlo = rise - 0.2*fontSize
-elif xs.strike:
+nhi = rise + fontSize
-if not f.strike:
+if AL != f.link:
-xs.strike = 0
+S = set(AL)
-xs.strikes.append( (xs.strike_x, end_x, xs.strikeColor) )
+NS = set(f.link)
-xs.strikeColor = None
+nL = NS - S #new linkis
-elif xs.textColor!=xs.strikeColor:
+eL = S - NS #ending links
-xs.strikes.append( (xs.strike_x, end_x, xs.strikeColor) )
+for l in eL:
-xs.strikeColor = xs.textColor
+links[l] = links[l],end_x
-xs.strike_x = cur_x_s
+for l in nL:
-if f.link and not xs.link:
+links[l] = (l,cur_x),nlo,nhi
-if not xs.link:
+AL = f.link
-xs.link = f.link
+if AL:
-xs.link_x = cur_x_s
+for l in AL:
-xs.linkColor = xs.textColor
+l0, lo, hi = links[l]
-elif xs.link:
+if nlo<lo or nhi>hi:
-if not f.link:
+links[l] = l0,min(nlo,lo),max(nhi,hi)
-xs.links.append( (xs.link_x, end_x, xs.link, xs.linkColor) )
-xs.link = None
-xs.linkColor = None
-elif f.link!=xs.link or xs.textColor!=xs.linkColor:
-xs.links.append( (xs.link_x, end_x, xs.link, xs.linkColor) )
-xs.link = f.link
-xs.link_x = cur_x_s
-xs.linkColor = xs.textColor
 bg = getattr(f,'backColor',None)
 if bg and not xs.backColor:
 xs.backColor = bg
 xs.backColor_x = cur_x_s
 elif xs.backColor:
 xs.backColor = bg
 xs.backColor_x = cur_x_s
 txtlen = tx._canvas.stringWidth(text, tx._fontname, tx._fontsize)
 cur_x += txtlen
 nSpaces += text.count(' ')+_nbspCount(text)
 cur_x_s = cur_x+(nSpaces-1)*ws
 if last and pKind!='right' and xs.style.endDots:
 _do_dots_frag(cur_x,cur_x_s,line.maxWidth,xs,tx)
-if xs.underline:
-xs.underlines.append( (xs.underline_x, cur_x_s, xs.underlineColor) )
+if LL:
-if xs.strike:
+for l in LL:
-xs.strikes.append( (xs.strike_x, cur_x_s, xs.strikeColor) )
+us_lines[l] = us_lines[l], cur_x_s
-if xs.link:
-xs.links.append( (xs.link_x, cur_x_s, xs.link,xs.linkColor) )
+if AL:
+for l in AL:
+links[l] = links[l], cur_x_s
 if xs.backColor:
 xs.backColors.append( (xs.backColor_x, cur_x_s, xs.backColor) )
 if tx._x0!=x0:
 setXPos(tx,x0-tx._x0)
 def _drawBullet(canvas, offset, cur_y, bulletText, style, rtl):
 '''draw a bullet text could be a simple string or a frag list'''
 bulletAnchor = style.bulletAnchor
 if rtl or style.bulletAnchor!='start':
 numeric = bulletAnchor=='numeric'
-if isinstance(bulletText,strTypes):
+if isStr(bulletText):
 t =  bulletText
 q = numeric and decimalSymbol in t
 if q: t = t[:t.index(decimalSymbol)]
 bulletWidth = stringWidth(t, style.bulletFontName, style.bulletFontSize)
 if q: bulletWidth += 0.5 * stringWidth(decimalSymbol, style.bulletFontName, style.bulletFontSize)
 width = rtl[0]
 bulletStart = width+style.rightIndent-(style.bulletIndent+bulletWidth)
 tx2 = canvas.beginText(bulletStart, cur_y)
 tx2.setFont(style.bulletFontName, style.bulletFontSize)
 tx2.setFillColor(getattr(style,'bulletColor',style.textColor))
-if isinstance(bulletText,strTypes):
+if isStr(bulletText):
 tx2.textOut(bulletText)
 else:
 for f in bulletText:
 tx2.setFont(f.fontName, f.fontSize)
 tx2.setFillColor(f.textColor)
 def _handleBulletWidth(bulletText,style,maxWidths):
 '''work out bullet width and adjust maxWidths[0] if neccessary
 '''
 if bulletText:
-if isinstance(bulletText,strTypes):
+if isStr(bulletText):
 bulletWidth = stringWidth( bulletText, style.bulletFontName, style.bulletFontSize)
 else:
 #it's a list of fragments
 bulletWidth = 0
 for f in bulletText:
 g = (f,start,j)
 line.append(g)
 if j==lim:
 i += 1
-def _old_do_line(tx, x1, y1, x2, y2):
+def _do_line(tx, x1, y1, x2, y2, nlw, nsc):
-tx._canvas.line(x1, y1, x2, y2)
+canv = tx._canvas
+olw = canv._lineWidth
-def _do_line(tx, x1, y1, x2, y2):
-olw = tx._canvas._lineWidth
-nlw = tx._underlineProportion*tx._fontsize
 if nlw!=olw:
-tx._canvas.setLineWidth(nlw)
+canv.setLineWidth(nlw)
-tx._canvas.line(x1, y1, x2, y2)
+osc = canv._strokeColorObj
-tx._canvas.setLineWidth(olw)
+if nsc!=osc:
-else:
+canv.setStrokeColor(nsc)
-tx._canvas.line(x1, y1, x2, y2)
+canv.line(x1, y1, x2, y2)
-def _do_under_line(i, t_off, ws, tx, lm=-0.125):
+def _do_under_line(i, x1, ws, tx, us_lines):
-y = tx.XtraState.cur_y - i*tx.XtraState.style.leading + lm*tx.XtraState.f.fontSize
+xs = tx.XtraState
-textlen = tx._canvas.stringWidth(' '.join(tx.XtraState.lines[i][1]), tx._fontname, tx._fontsize)
+style = xs.style
-tx._do_line(t_off, y, t_off+textlen, y)
+y0 = xs.cur_y - i*style.leading
+f = xs.f
+fs = f.fontSize
+tc = f.textColor
+values = dict(L=fs,F=fs,f=fs)
+dw = tx._defaultLineWidth
+x2 = x1 + tx._canvas.stringWidth(' '.join(tx.XtraState.lines[i][1]), tx._fontname, fs)
+for n,k,c,w,o,r,m,g in us_lines:
+underline = k=='underline'
+lw = _usConv(w,values,default=tx._defaultLineWidth)
+lg = _usConv(g,values,default=1)
+dy = lg+lw
+if not underline: dy = -dy
+y = y0 + r + _usConv(('-0.125*L' if underline else '0.25*L') if o=='' else o,values)
+if not c: c = tc
+while m>0:
+tx._do_line(x1, y, x2, y, lw, c)
+y -= dy
+m -= 1
 _scheme_re = re.compile('^[a-zA-Z][-+a-zA-Z0-9]+$')
 def _doLink(tx,link,rect):
 parts = link.split(':',1)
 scheme = len(parts)==2 and parts[0].lower() or ''
 if _scheme_re.match(scheme) and scheme!='document':
 kind=scheme.lower()=='pdf' and 'GoToR' or 'URI'
 if kind=='GoToR': link = parts[1]
 tx._canvas.linkURL(link, rect, relative=1, kind=kind)
 else:
+if not link: return
 if link[0]=='#':
 link = link[1:]
 scheme=''
 tx._canvas.linkRect("", scheme!='document' and link or parts[1], rect, relative=1)
 xs = tx.XtraState
 leading = xs.style.leading
 y = xs.cur_y - i*leading - xs.f.fontSize/8.0 # 8.0 factor copied from para.py
 text = ' '.join(xs.lines[i][1])
 textlen = tx._canvas.stringWidth(text, tx._fontname, tx._fontsize)
-_doLink(tx, xs.link, (t_off, y, t_off+textlen, y+leading))
+for n, link in xs.link:
+_doLink(tx, link, (t_off, y, t_off+textlen, y+leading))
 def _do_post_text(tx):
 xs = tx.XtraState
+y0 = xs.cur_y
+f = xs.f
 leading = xs.style.leading
 autoLeading = xs.autoLeading
-y0 = xs.cur_y
+fontSize = f.fontSize
-f = xs.f
-ff = 0.125*f.fontSize
-yl = y0 + f.fontSize
 if autoLeading=='max':
-leading = max(leading,1.2*f.fontSize)
+leading = max(leading,1.2*fontSize)
 elif autoLeading=='min':
-leading = 1.2*f.fontSize
+leading = 1.2*fontSize
-ydesc = yl - leading
+if xs.backColors:
-for x1,x2,c in xs.backColors:
+yl = y0 + fontSize
-tx._canvas.setFillColor(c)
+ydesc = yl - leading
-tx._canvas.rect(x1,ydesc,x2-x1,leading,stroke=0,fill=1)
-xs.backColors=[]
+for x1,x2,c in xs.backColors:
-xs.backColor=None
+tx._canvas.setFillColor(c)
+tx._canvas.rect(x1,ydesc,x2-x1,leading,stroke=0,fill=1)
-y = y0 - ff
+xs.backColors=[]
-csc = None
+xs.backColor=None
-for x1,x2,c in xs.underlines:
-if c!=csc:
+for (((n,link),x1),lo,hi),x2 in sorted(xs.links.values()):
-tx._canvas.setStrokeColor(c)
+_doLink(tx, link, (x1, y0+lo, x2, y0+hi))
-csc = c
+xs.links = {}
-tx._do_line(x1, y, x2, y)
-xs.underlines = []
+if xs.us_lines:
-xs.underline=0
+#print 'lines'
-xs.underlineColor=None
+dw = tx._defaultLineWidth
+values = dict(L=fontSize)
-ys = y0 + 2*ff
+for (((n,k,c,w,o,r,m,g),fs,tc,x1),fsmax),x2 in sorted(xs.us_lines.values()):
-for x1,x2,c in xs.strikes:
+underline = k=='underline'
-if c!=csc:
+values['f'] = fs
-tx._canvas.setStrokeColor(c)
+values['F'] = fsmax
-csc = c
+lw = _usConv(w,values,default=tx._defaultLineWidth)
-tx._do_line(x1, ys, x2, ys)
+lg = _usConv(g,values,default=1)
-xs.strikes = []
+dy = lg+lw
-xs.strike=0
+if not underline: dy = -dy
-xs.strikeColor=None
+y = y0 + r + _usConv(o if o!='' else ('-0.125*L' if underline else '0.25*L'),values)
+#print 'n=%s k=%s x1=%s x2=%s r=%s c=%s w=%r o=%r fs=%r tc=%s y=%s lW=%r offs=%r' % (n,k,x1,x2,r,(c.hexval() if c else ''),w,o,fs,tc.hexval(),y,lW,y-y0-r)
-for x1,x2,link,c in xs.links:
+if not c: c = tc
-if platypus_link_underline:
+while m>0:
-if c!=csc:
+tx._do_line(x1, y, x2, y, lw, c)
-tx._canvas.setStrokeColor(c)
+y -= dy
-csc = c
+m -= 1
-tx._do_line(x1, y, x2, y)
+xs.us_lines = {}
-_doLink(tx, link, (x1, ydesc, x2, yl))
-xs.links = []
-xs.link=None
-xs.linkColor=None
 xs.cur_y -= leading
 def textTransformFrags(frags,style):
 tt = style.textTransform
 This class is a flowable that can format a block of text
 into a paragraph with a given style.
 The paragraph Text can contain XML-like markup including the tags:
 <b> ... </b> - bold
+< u [color="red"] [width="pts"] [offset="pts"]> < /u > - underline
+width and offset can be empty meaning use existing canvas line width
+or with an f/F suffix regarded as a fraction of the font size
+< strike > < /strike > - strike through has the same parameters as underline
 <i> ... </i> - italics
 <u> ... </u> - underline
 <strike> ... </strike> - strike through
 <super> ... </super> - superscript
 <sub> ... </sub> - subscript
 <font name=fontfamily/fontname color=colorname size=float>
 <span name=fontfamily/fontname color=colorname backcolor=colorname size=float style=stylename>
 <onDraw name=callable label="a label"/>
 <index [name="callablecanvasattribute"] label="a label"/>
 <link>link text</link>
 attributes of links
-size/fontSize=num
+size/fontSize/uwidth/uoffset=num
 name/face/fontName=name
-fg/textColor/color=color
+fg/textColor/color/ucolor=color
 backcolor/backColor/bgcolor=color
 dest/destination/target/href/link=target
+underline=bool turn on underline
 <a>anchor text</a>
 attributes of anchors
-fontSize=num
+size/fontSize/uwidth/uoffset=num
 fontName=name
-fg/textColor/color=color
+fg/textColor/color/ucolor=color
 backcolor/backColor/bgcolor=color
 href=href
+underline="yes|no"
 <a name="anchorpoint"/>
 <unichar name="unicode character name"/>
 <unichar value="unicode code point"/>
 <img src="path" width="1in" height="1in" valign="bottom"/>
 width="w%" --> fontSize*w/100   idea from Roberto Alsina
 #set up the font etc.
 canvas.setFillColor(f.textColor)
 tx = self.beginText(cur_x, cur_y)
-if style.underlineProportion:
-tx._underlineProportion = style.underlineProportion
-tx._do_line = _do_line
-else:
-tx._do_line = _old_do_line
-tx._do_line = MethodType(tx._do_line,tx)
 if autoLeading=='max':
 leading = max(leading,blPara.ascent-blPara.descent)
 elif autoLeading=='min':
 leading = blPara.ascent-blPara.descent
 words = lines[0][1]
 lastLine = noJustifyLast and nLines==1
 if lastLine and jllwc and len(words)>jllwc:
 lastLine=False
 t_off = dpl( tx, offset, ws, words, lastLine)
-if f.underline or f.link or f.strike or style.endDots:
+if f.us_lines or f.link or style.endDots:
-xs = tx.XtraState = ABag()
+tx._do_line = MethodType(_do_line,tx)
+tx.xs = xs = tx.XtraState = ABag()
+tx._defaultLineWidth = canvas._lineWidth
 xs.cur_y = cur_y
 xs.f = f
 xs.style = style
 xs.lines = lines
-xs.underlines=[]
-xs.underlineColor=None
-xs.strikes=[]
-xs.strikeColor=None
-xs.links=[]
 xs.link=f.link
 xs.textColor = f.textColor
 xs.backColors = []
-canvas.setStrokeColor(f.textColor)
 dx = t_off+leftIndent
 if dpl!=_justifyDrawParaLine: ws = 0
-underline = f.underline or (f.link and platypus_link_underline)
+if f.us_lines:
-strike = f.strike
+_do_under_line(0, t_off, ws, tx, f.us_lines)
-link = f.link
+if f.link: _do_link_line(0, dx, ws, tx)
-if underline: _do_under_line(0, dx, ws, tx)
-if strike: _do_under_line(0, dx, ws, tx, lm=0.125)
-if link: _do_link_line(0, dx, ws, tx)
 if lastLine and style.endDots and dpl!=_rightDrawParaLine: _do_dots(0, dx, ws, xs, tx, dpl)
 #now the middle of the paragraph, aligned with the left margin which is our origin.
 for i in xrange(1, nLines):
 ws = lines[i][0]
 if lastLine and jllwc and len(words)>jllwc:
 lastLine=False
 t_off = dpl( tx, _offsets[i], ws, words, lastLine)
 dx = t_off+leftIndent
 if dpl!=_justifyDrawParaLine: ws = 0
-if underline: _do_under_line(i, dx, ws, tx)
+if f.us_lines:
-if strike: _do_under_line(i, dx, ws, tx, lm=0.125)
+_do_under_line(i, t_off, ws, tx, f.us_lines)
-if link: _do_link_line(i, dx, ws, tx)
+if f.link: _do_link_line(i, dx, ws, tx)
 if lastLine and style.endDots and dpl!=_rightDrawParaLine: _do_dots(i, dx, ws, xs, tx, dpl)
 else:
 for i in xrange(1, nLines):
 words = lines[i][1]
 lastLine = noJustifyLast and i==lim
 else:
 raise ValueError("bad align %s" % repr(alignment))
 #set up the font etc.
 tx = self.beginText(cur_x, cur_y)
-if style.underlineProportion:
+tx._defaultLineWidth = canvas._lineWidth
-tx._underlineProportion = style.underlineProportion
+tx._underlineWidth = getattr(style,'underlineWidth','')
-tx._do_line = _do_line
+tx._underlineOffset = getattr(style,'underlineOffset','') or '-0.125f'
-else:
+tx._strikeWidth = getattr(style,'strikeWidth','')
-tx._do_line = _old_do_line
+tx._strikeOffset = getattr(style,'strikeOffset','') or '0.25f'
-tx._do_line = MethodType(tx._do_line,tx)
+tx._do_line = MethodType(_do_line,tx)
 # set the paragraph direction
 tx.direction = self.style.wordWrap
 xs = tx.XtraState=ABag()
 xs.textColor=None
 xs.backColor=None
 xs.rise=0
-xs.underline=0
-xs.underlines=[]
-xs.underlineColor=None
-xs.strike=0
-xs.strikes=[]
-xs.strikeColor=None
 xs.backColors=[]
-xs.links=[]
+xs.us_lines = {}
-xs.link=None
+xs.links = {}
+xs.link={}
 xs.leading = style.leading
 xs.leftIndent = leftIndent
 tx._leading = None
 tx._olb = None
 xs.cur_y = cur_y

changeset 4389	61a7f0840d00
parent 4387	c9accf85d669
child 4409	e1546608f841