#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 reportlab.lib.sequencer

from reportlab.lib.abag import ABag

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 _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]

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

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

                }

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)

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

#       < 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">

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

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

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

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

    #### super script

    def start_super( self, attributes ):

        self._push(super=1)

    def end_super( self ):

        self._pop(super=1)

    start_sup = start_super

    end_sup = end_super

    #### sub script

    def start_sub( self, attributes ):

        self._push(sub=1)

    def end_sub( self ):

        self._pop(sub=1)

    #### greek script

    #### add symbol encoding

    def handle_charref(self, name):

        try:

            if name[0]=='x':

                n = int(name[1:],16)

            else:

                n = int(name)

        except ValueError:

            self.unknown_charref(name)

            return

        self.handle_data(unichr(n).encode('utf8'))

    def handle_entityref(self,name):

        if greeks.has_key(name):

            self.handle_data(greeks[name])

        else:

            xmllib.XMLParser.handle_entityref(self,name)

    def syntax_error(self,lineno,message):

        self._syntax_error(message)

    def _syntax_error(self,message):

        if message[:10]=="attribute " and message[-17:]==" value not quoted": return

        self.errors.append(message)

    def start_greek(self, attr):

        self._push(greek=1)

    def end_greek(self):

        self._pop(greek=1)

    def start_unichar(self, attr):

        if attr.has_key('name'):

            if attr.has_key('code'):

                self._syntax_error('<unichar/> invalid with both name and code attributes')

            try:

                v = unicodedata.lookup(attr['name']).encode('utf8')

            except KeyError:

                self._syntax_error('<unichar/> invalid name attribute\n"%s"' % name)

                v = '\0'

        elif attr.has_key('code'):

            try:

                v = unichr(int(eval(attr['code']))).encode('utf8')

            except:

                self._syntax_error('<unichar/> invalid code attribute %s' % attr['code'])

                v = '\0'

        else:

            v = None

            if attr: 

                self._syntax_error('<unichar/> invalid attribute %s' % attr.keys()[0])

        if v is not None:

            self.handle_data(v)

        self._push(_selfClosingTag='unichar')

    def end_unichar(self):

        self._pop()

    def start_font(self,attr):

        self._push(**self.getAttributes(attr,_fontAttrMap))

    def end_font(self):

        self._pop()

    def _initial_frag(self,attr,attrMap,bullet=0):

        style = self._style

        if attr!={}:

            style = copy.deepcopy(style)

            _applyAttributes(style,self.getAttributes(attr,attrMap))

            self._style = style

        # initialize semantic values

        frag = ParaFrag()

        frag.sub = 0

        frag.super = 0

        frag.rise = 0

        frag.underline = 0

        frag.greek = 0