#Copyright ReportLab Europe Ltd. 2000-2004

#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$ '''

import string

import re

from types import TupleType, UnicodeType, StringType

import sys

import os

import copy

import unicodedata

import reportlab.lib.sequencer

from reportlab.lib.abag import ABag

from reportlab.lib.utils import ImageReader

from reportlab.lib import xmllib

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

def _convnum(s, unit=1):

    if s[0] in ['+','-']:

        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):

    """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[-2:]=='cm':

        unit=cm

        s = s[:-2]

    if s[-2:]=='in':

        unit=inch

        s = s[:-2]

    if s[-2:]=='pt':

        unit=1

        s = s[:-2]

    if s[-1:]=='i':

        unit=inch

        s = s[:-1]

    if s[-2:]=='mm':

        unit=mm

        s = s[:-2]

    if s[-4:]=='pica':

        unit=pica

        s = s[:-4]

    return _convnum(s,unit)

class _PCT:

    def __init__(self,v):

        self._value = v*0.01

    def normalizedValue(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 = string.lower(s)

    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),

                '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),

                '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 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',_num),

                'height':('height',_num),

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

                }

def _addAttributeNames(m):

    K = m.keys()

    for k in K:

        n = m[k][0]

        if not m.has_key(n): m[n] = m[k]

        n = string.lower(n)

        if not m.has_key(n): m[n] = m[k]

_addAttributeNames(_paraAttrMap)

_addAttributeNames(_fontAttrMap)

_addAttributeNames(_bulletAttrMap)

_addAttributeNames(_anchorAttrMap)

_addAttributeNames(_linkAttrMap)

def _applyAttributes(obj, attr):

    for k, v in attr.items():

        if type(v) is TupleType and v[0]=='relative':

            #AR 20/5/2000 - remove 1.5.2-ism

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

            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 = {

    'pound': '\xc2\xa3',

    'nbsp': '\xc2\xa0',

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

    'Alpha': '\xce\x91',

    'alpha': '\xce\xb1',

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

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

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

    'Beta': '\xce\x92',

    'beta': '\xce\xb2',

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

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

    'Chi': '\xce\xa7',

    'chi': '\xcf\x87',

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

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

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

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

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

    'delta': '\xce\xb4',

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

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

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

    'Epsilon': '\xce\x95',

    'epsilon': '\xce\xb5',

    'epsiv': '\xce\xb5',

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

    'Eta': '\xce\x97',

    'eta': '\xce\xb7',

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

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

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

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

    'Gamma': '\xce\x93',

    'gamma': '\xce\xb3',

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

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

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

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

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

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

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

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

    'Iota': '\xce\x99',

    'iota': '\xce\xb9',

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

    'Kappa': '\xce\x9a',

    'kappa': '\xce\xba',

    'Lambda': '\xce\x9b',

    'lambda': '\xce\xbb',

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

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

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

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

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

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

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

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

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

    'mu': '\xc2\xb5',

    'Mu': '\xce\x9c',

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

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

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

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

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

    'Nu': '\xce\x9d',

    'nu': '\xce\xbd',

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

    'omega': '\xcf\x89',

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

    'Omicron': '\xce\x9f',

    'omicron': '\xce\xbf',

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

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

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

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

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

    'Phi': '\xce\xa6',

    'phi': '\xcf\x95',

    'phis': '\xcf\x86',

    'Pi': '\xce\xa0',

    'pi': '\xcf\x80',

    'piv': '\xcf\x96',

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

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

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

    'Psi': '\xce\xa8',

    'psi': '\xcf\x88',

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

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

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

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

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

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

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

    'Rho': '\xce\xa1',

    'rho': '\xcf\x81',

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

    'Sigma': '\xce\xa3',

    'sigma': '\xcf\x83',

    'sigmaf': '\xcf\x82',

    'sigmav': '\xcf\x82',

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

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

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

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

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

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

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

    'Tau': '\xce\xa4',

    'tau': '\xcf\x84',

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

    'Theta': '\xce\x98',

    'theta': '\xce\xb8',

    'thetasym': '\xcf\x91',

    'thetav': '\xcf\x91',

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

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

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

    'upsih': '\xcf\x92',

    'Upsilon': '\xce\xa5',

    'upsilon': '\xcf\x85',

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

    'Xi': '\xce\x9e',

    'xi': '\xce\xbe',

    'Zeta': '\xce\x96',

    'zeta': '\xce\xb6',

    }

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

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

    """

_greek2Utf8=None

def _greekConvert(data):

    global _greek2Utf8

    if not _greek2Utf8:

        from reportlab.pdfbase.rl_codecs import RL_Codecs

        import codecs

        dm = decoding_map = codecs.make_identity_dict(xrange(32,256))

        for k in xrange(0,32):

            dm[k] = None

        dm.update(RL_Codecs._RL_Codecs__rl_codecs_data['symbol'][0])

        _greek2Utf8 = {}

        for k,v in dm.iteritems():

            if not v:

                u = '\0'

            else:

                u = unichr(v).encode('utf8')

            _greek2Utf8[chr(k)] = u

    return ''.join(map(_greek2Utf8.__getitem__,data))

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

# !!! NOTE !!! THIS TEXT IS NOW REPLICATED IN PARAGRAPH.PY !!!

# The ParaFormatter will be able to format the following

# tags:

#       < /b > - bold

#       < /i > - italics

#       < u > < /u > - underline

#       < strike > < /strike > - strike through

#       < super > < /super > - superscript

#       < sup > < /sup > - superscript

#       < sub > < /sub > - subscript

#       <font name=fontfamily/fontname color=colorname size=float>

#       < bullet > </bullet> - bullet text (at head of para only)

#       <onDraw name=callable label="a label">

#       <link>link text</link>

#           attributes of links 

#               size/fontSize=num

#               name/face/fontName=name

#               fg/textColor/color=color

#               backcolor/backColor/bgcolor=color

#               dest/destination/target/href/link=target

#       <a>anchor text</a>

#           attributes of anchors 

#               fontSize=num

#               fontName=name

#               fg/textColor/color=color

#               backcolor/backColor/bgcolor=color

#               href=href

#       <a name="anchorpoint"/>

#       <unichar name="unicode character name"/>

#       <unichar value="unicode code point"/>

#       <img src="path" width="1in" height="1in" valign="bottom"/>

#       <greek> - </greek>

#

#       The whole may be surrounded by <para> </para> tags

#

# It will also be able to handle any MathML specified Greek characters.

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

class ParaParser(xmllib.XMLParser):

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

    # First we will define all of the xml tag handler functions.

    #

    # start_<tag>(attributes)

    # end_<tag>()

    #

    # While parsing the xml ParaFormatter will call these

    # functions to handle the string formatting tags.

    # At the start of each tag the corresponding field will

    # be set to 1 and at the end tag the corresponding field will

    # be set to 0.  Then when handle_data is called the options

    # for that data will be aparent by the current settings.

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

    def __getattr__( self, attrName ):

        """This way we can handle <TAG> the same way as <tag> (ignoring case)."""

        if attrName!=attrName.lower() and attrName!="caseSensitive" and not self.caseSensitive and \

            (attrName.startswith("start_") or attrName.startswith("end_")):

                return getattr(self,attrName.lower())

        raise AttributeError, attrName

    #### bold

    def start_b( self, attributes ):

        self._push(bold=1)

    def end_b( self ):

        self._pop(bold=1)

    def start_strong( self, attributes ):

        self._push(bold=1)

    def end_strong( self ):

        self._pop(bold=1)

    #### italics

    def start_i( self, attributes ):

        self._push(italic=1)

    def end_i( self ):

        self._pop(italic=1)

    def start_em( self, attributes ):

        self._push(italic=1)

    def end_em( self ):

        self._pop(italic=1)

    #### underline

    def start_u( self, attributes ):

        self._push(underline=1)

    def end_u( self ):

        self._pop(underline=1)

    #### strike

    def start_strike( self, attributes ):

        self._push(strike=1)

    def end_strike( self ):

        self._pop(strike=1)

    #### link

    def start_link(self, attributes):

        self._push(**self.getAttributes(attributes,_linkAttrMap))

    def end_link(self):

        frag = self._stack[-1]

        del self._stack[-1]

        assert frag.link!=None

    #### anchor

    def start_a(self, attributes):

        A = self.getAttributes(attributes,_anchorAttrMap)

        if A.get('name',None):

            if len(A)>1:

                self._syntax_error('<a name="..."/> anchor variant only allows name attribute')

                A = dict(name=A['name'])

            A['_selfClosingTag'] = 'anchor'

        elif not A.get('href',None):

            self._syntax_error('<a> tag must have name or href attribute')

        else:

            A['link'] = A.pop('href')   #convert to our link form

        self._push(**A)

    def end_a(self):

        frag = self._stack[-1]

        sct = getattr(frag,'_selfClosingTag','')

        if sct:

            assert sct=='anchor' and frag.name,'Parser failure in <a/>'

            defn = frag.cbDefn = ABag()

            defn.label = defn.kind = 'anchor'