#Copyright ReportLab Europe Ltd. 2000-2012

#see license.txt for license details

#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/platypus/paraparser.py

__version__=''' $Id$ '''

__doc__='''The parser used to process markup within paragraphs'''

import string

import re

import sys

import os

import copy

import base64

try:

    import pickle as pickle

except:

    import pickle

import unicodedata

import reportlab.lib.sequencer

from reportlab.lib.abag import ABag

from reportlab.lib.colors import toColor, white, black, red, Color

from reportlab.lib.fonts import tt2ps, ps2tt

from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY

from reportlab.lib.units import inch,mm,cm,pica

_re_para = re.compile(r'^\s*<\s*para(?:\s+|>|/>)')

sizeDelta = 2       # amount to reduce font size by for super and sub script

subFraction = 0.5   # fraction of font size that a sub script should be lowered

superFraction = 0.5 # fraction of font size that a super script should be raised

DEFAULT_INDEX_NAME='_indexAdd'

def _convnum(s, unit=1, allowRelative=True):

    if s[0] in ('+','-') and allowRelative:

        try:

            return ('relative',int(s)*unit)

        except ValueError:

            return ('relative',float(s)*unit)

    else:

        try:

            return int(s)*unit

        except ValueError:

            return float(s)*unit

def _num(s, unit=1, allowRelative=True):

    """Convert a string like '10cm' to an int or float (in points).

       The default unit is point, but optionally you can use other

       default units like mm.

    """

    if s.endswith('cm'):

        unit=cm

        s = s[:-2]

    if s.endswith('in'):

        unit=inch

        s = s[:-2]

    if s.endswith('pt'):

        unit=1

        s = s[:-2]

    if s.endswith('i'):

        unit=inch

        s = s[:-1]

    if s.endswith('mm'):

        unit=mm

        s = s[:-2]

    if s.endswith('pica'):

        unit=pica

        s = s[:-4]

    return _convnum(s,unit,allowRelative)

def _numpct(s,unit=1,allowRelative=False):

    if s.endswith('%'):

        return _PCT(_convnum(s[:-1],allowRelative=allowRelative))

    else:

        return _num(s,unit,allowRelative)

class _PCT:

    def __init__(self,v):

        self._value = v*0.01

    def normalizedValue(self,normalizer):

        normalizer = normalizer or getattr(self,'_normalizer')

        return normalizer*self._value

def _valignpc(s):

    s = s.lower()

    if s in ('baseline','sub','super','top','text-top','middle','bottom','text-bottom'):

        return s

    if s.endswith('%'):

        n = _convnum(s[:-1])

        if isinstance(n,tuple):

            n = n[1]

        return _PCT(n)

    n = _num(s)

    if isinstance(n,tuple):

        n = n[1]

    return n

def _autoLeading(x):

    x = x.lower()

    if x in ('','min','max','off'):

        return x

    raise ValueError('Invalid autoLeading=%r' % x )

def _align(s):

    s = s.lower()

    if s=='left': return TA_LEFT

    elif s=='right': return TA_RIGHT

    elif s=='justify': return TA_JUSTIFY

    elif s in ('centre','center'): return TA_CENTER

    else: raise ValueError

_paraAttrMap = {'font': ('fontName', None),

                'face': ('fontName', None),

                'fontsize': ('fontSize', _num),

                'size': ('fontSize', _num),

                'leading': ('leading', _num),

                'autoleading': ('autoLeading', _autoLeading),

                'lindent': ('leftIndent', _num),

                'rindent': ('rightIndent', _num),

                'findent': ('firstLineIndent', _num),

                'align': ('alignment', _align),

                'spaceb': ('spaceBefore', _num),

                'spacea': ('spaceAfter', _num),

                'bfont': ('bulletFontName', None),

                'bfontsize': ('bulletFontSize',_num),

                'boffsety': ('bulletOffsetY',_num),

                'bindent': ('bulletIndent',_num),

                'bcolor': ('bulletColor',toColor),

                'color':('textColor',toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'bg':('backColor',toColor),

                'fg': ('textColor',toColor),

                }

_bulletAttrMap = {

                'font': ('bulletFontName', None),

                'face': ('bulletFontName', None),

                'size': ('bulletFontSize',_num),

                'fontsize': ('bulletFontSize',_num),

                'offsety': ('bulletOffsetY',_num),

                'indent': ('bulletIndent',_num),

                'color': ('bulletColor',toColor),

                'fg': ('bulletColor',toColor),

                }

#things which are valid font attributes

_fontAttrMap = {'size': ('fontSize', _num),

                'face': ('fontName', None),

                'name': ('fontName', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                }

#things which are valid span attributes

_spanAttrMap = {'size': ('fontSize', _num),

                'face': ('fontName', None),

                'name': ('fontName', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'style': ('style',None),

                }

#things which are valid font attributes

_linkAttrMap = {'size': ('fontSize', _num),

                'face': ('fontName', None),

                'name': ('fontName', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'dest': ('link', None),

                'destination': ('link', None),

                'target': ('link', None),

                'href': ('link', None),

                }

_anchorAttrMap = {'fontSize': ('fontSize', _num),

                'fontName': ('fontName', None),

                'name': ('name', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'href': ('href', None),

                }

_imgAttrMap = {

                'src': ('src', None),

                'width': ('width',_numpct),

                'height':('height',_numpct),

                'valign':('valign',_valignpc),

                }

_indexAttrMap = {

                'name': ('name',None),

                'item': ('item',None),

                'offset': ('offset',None),

                'format': ('format',None),

                }

def _addAttributeNames(m):

    K = list(m.keys())

    for k in K:

        n = m[k][0]

        if n not in m: m[n] = m[k]

        n = n.lower()

        if n not in m: m[n] = m[k]

_addAttributeNames(_paraAttrMap)

_addAttributeNames(_fontAttrMap)

_addAttributeNames(_spanAttrMap)

_addAttributeNames(_bulletAttrMap)

_addAttributeNames(_anchorAttrMap)

_addAttributeNames(_linkAttrMap)

def _applyAttributes(obj, attr):

    for k, v in attr.items():

        if isinstance(v,(list,tuple)) and v[0]=='relative':

            if hasattr(obj, k):

                v = v[1]+getattr(obj,k)

            else:

                v = v[1]

        setattr(obj,k,v)

#Named character entities intended to be supported from the special font

#with additions suggested by Christoph Zwerschke who also suggested the

#numeric entity names that follow.

greeks = {

    'Aacute': b'\xc3\x81',

    'aacute': b'\xc3\xa1',

    'Acirc': b'\xc3\x82',

    'acirc': b'\xc3\xa2',

    'acute': b'\xc2\xb4',

    'AElig': b'\xc3\x86',

    'aelig': b'\xc3\xa6',

    'Agrave': b'\xc3\x80',

    'agrave': b'\xc3\xa0',

    'alefsym': b'\xe2\x84\xb5',

    'Alpha': b'\xce\x91',

    'alpha': b'\xce\xb1',

    'and': b'\xe2\x88\xa7',

    'ang': b'\xe2\x88\xa0',

    'Aring': b'\xc3\x85',

    'aring': b'\xc3\xa5',

    'asymp': b'\xe2\x89\x88',

    'Atilde': b'\xc3\x83',

    'atilde': b'\xc3\xa3',

    'Auml': b'\xc3\x84',

    'auml': b'\xc3\xa4',

    'bdquo': b'\xe2\x80\x9e',

    'Beta': b'\xce\x92',

    'beta': b'\xce\xb2',

    'brvbar': b'\xc2\xa6',

    'bull': b'\xe2\x80\xa2',

    'cap': b'\xe2\x88\xa9',

    'Ccedil': b'\xc3\x87',

    'ccedil': b'\xc3\xa7',

    'cedil': b'\xc2\xb8',

    'cent': b'\xc2\xa2',

    'Chi': b'\xce\xa7',

    'chi': b'\xcf\x87',

    'circ': b'\xcb\x86',

    'clubs': b'\xe2\x99\xa3',

    'cong': b'\xe2\x89\x85',

    'copy': b'\xc2\xa9',

    'crarr': b'\xe2\x86\xb5',

    'cup': b'\xe2\x88\xaa',

    'curren': b'\xc2\xa4',

    'dagger': b'\xe2\x80\xa0',

    'Dagger': b'\xe2\x80\xa1',

    'darr': b'\xe2\x86\x93',

    'dArr': b'\xe2\x87\x93',

    'deg': b'\xc2\xb0',

    'delta': b'\xce\xb4',

    'Delta': b'\xe2\x88\x86',

    'diams': b'\xe2\x99\xa6',

    'divide': b'\xc3\xb7',

    'Eacute': b'\xc3\x89',

    'eacute': b'\xc3\xa9',

    'Ecirc': b'\xc3\x8a',

    'ecirc': b'\xc3\xaa',

    'Egrave': b'\xc3\x88',

    'egrave': b'\xc3\xa8',

    'empty': b'\xe2\x88\x85',

    'emsp': b'\xe2\x80\x83',

    'ensp': b'\xe2\x80\x82',

    'Epsilon': b'\xce\x95',

    'epsilon': b'\xce\xb5',

    'epsiv': b'\xce\xb5',

    'equiv': b'\xe2\x89\xa1',

    'Eta': b'\xce\x97',

    'eta': b'\xce\xb7',

    'ETH': b'\xc3\x90',

    'eth': b'\xc3\xb0',

    'Euml': b'\xc3\x8b',

    'euml': b'\xc3\xab',

    'euro': b'\xe2\x82\xac',

    'exist': b'\xe2\x88\x83',

    'fnof': b'\xc6\x92',

    'forall': b'\xe2\x88\x80',

    'frac12': b'\xc2\xbd',

    'frac14': b'\xc2\xbc',

    'frac34': b'\xc2\xbe',

    'frasl': b'\xe2\x81\x84',

    'Gamma': b'\xce\x93',

    'gamma': b'\xce\xb3',

    'ge': b'\xe2\x89\xa5',

    'harr': b'\xe2\x86\x94',

    'hArr': b'\xe2\x87\x94',

    'hearts': b'\xe2\x99\xa5',

    'hellip': b'\xe2\x80\xa6',

    'Iacute': b'\xc3\x8d',

    'iacute': b'\xc3\xad',

    'Icirc': b'\xc3\x8e',

    'icirc': b'\xc3\xae',

    'iexcl': b'\xc2\xa1',

    'Igrave': b'\xc3\x8c',

    'igrave': b'\xc3\xac',

    'image': b'\xe2\x84\x91',

    'infin': b'\xe2\x88\x9e',

    'int': b'\xe2\x88\xab',

    'Iota': b'\xce\x99',

    'iota': b'\xce\xb9',

    'iquest': b'\xc2\xbf',

    'isin': b'\xe2\x88\x88',

    'Iuml': b'\xc3\x8f',

    'iuml': b'\xc3\xaf',

    'Kappa': b'\xce\x9a',

    'kappa': b'\xce\xba',

    'Lambda': b'\xce\x9b',

    'lambda': b'\xce\xbb',

    'lang': b'\xe2\x8c\xa9',

    'laquo': b'\xc2\xab',

    'larr': b'\xe2\x86\x90',

    'lArr': b'\xe2\x87\x90',

    'lceil': b'\xef\xa3\xae',

    'ldquo': b'\xe2\x80\x9c',

    'le': b'\xe2\x89\xa4',

    'lfloor': b'\xef\xa3\xb0',

    'lowast': b'\xe2\x88\x97',

    'loz': b'\xe2\x97\x8a',

    'lrm': b'\xe2\x80\x8e',

    'lsaquo': b'\xe2\x80\xb9',

    'lsquo': b'\xe2\x80\x98',

    'macr': b'\xc2\xaf',

    'mdash': b'\xe2\x80\x94',

    'micro': b'\xc2\xb5',

    'middot': b'\xc2\xb7',

    'minus': b'\xe2\x88\x92',

    'mu': b'\xc2\xb5',

    'Mu': b'\xce\x9c',

    'nabla': b'\xe2\x88\x87',

    'nbsp': b'\xc2\xa0',

    'ndash': b'\xe2\x80\x93',

    'ne': b'\xe2\x89\xa0',

    'ni': b'\xe2\x88\x8b',

    'notin': b'\xe2\x88\x89',

    'not': b'\xc2\xac',

    'nsub': b'\xe2\x8a\x84',

    'Ntilde': b'\xc3\x91',

    'ntilde': b'\xc3\xb1',

    'Nu': b'\xce\x9d',

    'nu': b'\xce\xbd',

    'Oacute': b'\xc3\x93',

    'oacute': b'\xc3\xb3',

    'Ocirc': b'\xc3\x94',

    'ocirc': b'\xc3\xb4',

    'OElig': b'\xc5\x92',

    'oelig': b'\xc5\x93',

    'Ograve': b'\xc3\x92',

    'ograve': b'\xc3\xb2',

    'oline': b'\xef\xa3\xa5',

    'omega': b'\xcf\x89',

    'Omega': b'\xe2\x84\xa6',

    'Omicron': b'\xce\x9f',

    'omicron': b'\xce\xbf',

    'oplus': b'\xe2\x8a\x95',

    'ordf': b'\xc2\xaa',

    'ordm': b'\xc2\xba',

    'or': b'\xe2\x88\xa8',

    'Oslash': b'\xc3\x98',

    'oslash': b'\xc3\xb8',

    'Otilde': b'\xc3\x95',

    'otilde': b'\xc3\xb5',

    'otimes': b'\xe2\x8a\x97',

    'Ouml': b'\xc3\x96',

    'ouml': b'\xc3\xb6',

    'para': b'\xc2\xb6',

    'part': b'\xe2\x88\x82',

    'permil': b'\xe2\x80\xb0',

    'perp': b'\xe2\x8a\xa5',

    'phis': b'\xcf\x86',

    'Phi': b'\xce\xa6',

    'phi': b'\xcf\x95',

    'piv': b'\xcf\x96',

    'Pi': b'\xce\xa0',

    'pi': b'\xcf\x80',

    'plusmn': b'\xc2\xb1',

    'pound': b'\xc2\xa3',

    'prime': b'\xe2\x80\xb2',

    'Prime': b'\xe2\x80\xb3',

    'prod': b'\xe2\x88\x8f',

    'prop': b'\xe2\x88\x9d',

    'Psi': b'\xce\xa8',

    'psi': b'\xcf\x88',

    'radic': b'\xe2\x88\x9a',

    'rang': b'\xe2\x8c\xaa',

    'raquo': b'\xc2\xbb',

    'rarr': b'\xe2\x86\x92',

    'rArr': b'\xe2\x87\x92',

    'rceil': b'\xef\xa3\xb9',

    'rdquo': b'\xe2\x80\x9d',

    'real': b'\xe2\x84\x9c',

    'reg': b'\xc2\xae',

    'rfloor': b'\xef\xa3\xbb',

    'Rho': b'\xce\xa1',

    'rho': b'\xcf\x81',

    'rlm': b'\xe2\x80\x8f',

    'rsaquo': b'\xe2\x80\xba',

    'rsquo': b'\xe2\x80\x99',

    'sbquo': b'\xe2\x80\x9a',

    'Scaron': b'\xc5\xa0',

    'scaron': b'\xc5\xa1',

    'sdot': b'\xe2\x8b\x85',

    'sect': b'\xc2\xa7',

    'shy': b'\xc2\xad',

    'sigmaf': b'\xcf\x82',

    'sigmav': b'\xcf\x82',

    'Sigma': b'\xce\xa3',

    'sigma': b'\xcf\x83',

    'sim': b'\xe2\x88\xbc',

    'spades': b'\xe2\x99\xa0',

    'sube': b'\xe2\x8a\x86',

    'sub': b'\xe2\x8a\x82',

    'sum': b'\xe2\x88\x91',

    'sup1': b'\xc2\xb9',

    'sup2': b'\xc2\xb2',

    'sup3': b'\xc2\xb3',

    'supe': b'\xe2\x8a\x87',

    'sup': b'\xe2\x8a\x83',

    'szlig': b'\xc3\x9f',

    'Tau': b'\xce\xa4',

    'tau': b'\xcf\x84',

    'there4': b'\xe2\x88\xb4',

    'thetasym': b'\xcf\x91',

    'thetav': b'\xcf\x91',

    'Theta': b'\xce\x98',

    'theta': b'\xce\xb8',

    'thinsp': b'\xe2\x80\x89',

    'THORN': b'\xc3\x9e',

    'thorn': b'\xc3\xbe',

    'tilde': b'\xcb\x9c',

    'times': b'\xc3\x97',

    'trade': b'\xef\xa3\xaa',

    'Uacute': b'\xc3\x9a',

    'uacute': b'\xc3\xba',

    'uarr': b'\xe2\x86\x91',

    'uArr': b'\xe2\x87\x91',

    'Ucirc': b'\xc3\x9b',

    'ucirc': b'\xc3\xbb',

    'Ugrave': b'\xc3\x99',

    'ugrave': b'\xc3\xb9',

    'uml': b'\xc2\xa8',

    'upsih': b'\xcf\x92',

    'Upsilon': b'\xce\xa5',

    'upsilon': b'\xcf\x85',

    'Uuml': b'\xc3\x9c',

    'uuml': b'\xc3\xbc',

    'weierp': b'\xe2\x84\x98',

    'Xi': b'\xce\x9e',

    'xi': b'\xce\xbe',

    'Yacute': b'\xc3\x9d',

    'yacute': b'\xc3\xbd',

    'yen': b'\xc2\xa5',

    'yuml': b'\xc3\xbf',

    'Yuml': b'\xc5\xb8',

    'Zeta': b'\xce\x96',

    'zeta': b'\xce\xb6',

    'zwj': b'\xe2\x80\x8d',

    'zwnj': b'\xe2\x80\x8c',

    }

#------------------------------------------------------------------------

class ParaFrag(ABag):

    """class ParaFrag contains the intermediate representation of string

    segments as they are being parsed by the XMLParser.

    fontname, fontSize, rise, textColor, cbDefn

    """