#copyright ReportLab Inc. 2000

#see license.txt for license details

#history http://cvs.sourceforge.net/cgi-bin/cvsweb.cgi/reportlab/platypus/paraparser.py?cvsroot=reportlab

import string

import re

from types import TupleType

import sys

import os

import copy

import reportlab.lib.sequencer

from reportlab.lib.abag import ABag

try:

    from reportlab.lib import xmllib

    _xmllib_newStyle = 1

except ImportError:

    import xmllib

    _xmllib_newStyle = 0

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('^\\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),

                }

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

#numeric entity names that follow.

greeks = {

    'Alpha': 'A',

    'Beta': 'B',

    'Chi': 'C',

    'Delta': 'D',

    'Epsilon': 'E',

    'Eta': 'H',

    'Gamma': 'G',

    'Iota': 'I',

    'Kappa': 'K',

    'Lambda': 'L',

    'Mu': 'M',

    'Nu': 'N',

    'Omega': 'W',

    'Omicron': 'O',

    'Phi': 'F',

    'Pi': 'P',

    'Psi': 'Y',

    'Rho': 'R',

    'Sigma': 'S',

    'Tau': 'T',

    'Theta': 'Q',

    'Upsilon': 'U',

    'Xi': 'X',

    'Zeta': 'Z',

    'alefsym': '\xc0',

    'alpha': 'a',

    'and': '\xd9',

    'ang': '\xd0',

    'asymp': '\xbb',

    'beta': 'b',

    'bull': '\xb7',

    'cap': '\xc7',

    'chi': 'c',

    'clubs': '\xa7',

    'cong': '@',

    'cup': '\xc8',

    'dArr': '\xdf',

    'darr': '\xaf',

    'delta': 'd',

    'diams': '\xa8',

    'empty': '\xc6',

    'epsilon': 'e',

    'epsiv': 'e',

    'equiv': '\xba',

    'eta': 'h',

    'euro': '\xa0',

    'exist': '$',

    'forall': '"',

    'frasl': '\xa4',

    'gamma': 'g',

    'ge': '\xb3',

    'hArr': '\xdb',

    'harr': '\xab',

    'hearts': '\xa9',

    'hellip': '\xbc',

    'image': '\xc1',

    'infin': '\xa5',

    'int': '\xf2',

    'iota': 'i',

    'isin': '\xce',

    'kappa': 'k',

    'lArr': '\xdc',

    'lambda': 'l',

    'lang': '\xe1',

    'larr': '\xac',

    'lceil': '\xe9',

    'le': '\xa3',

    'lfloor': '\xeb',

    'lowast': '*',

    'loz': '\xe0',

    'minus': '-',

    'mu': 'm',

    'nabla': '\xd1',

    'ne': '\xb9',

    'ni': "'",

    'notin': '\xcf',

    'nsub': '\xcb',

    'nu': 'n',

    'oline': '`',

    'omega': 'w',

    'omicron': 'o',

    'oplus': '\xc5',

    'or': '\xda',

    'otimes': '\xc4',

    'part': '\xb6',

    'perp': '^',

    'phi': 'j',

    'phis': 'f',

    'pi': 'p',

    'piv': 'v',

    'prime': '\xa2',

    'prod': '\xd5',

    'prop': '\xb5',

    'psi': 'y',

    'rArr': '\xde',

    'radic': '\xd6',

    'rang': '\xf1',

    'rarr': '\xae',

    'rceil': '\xf9',

    'real': '\xc2',

    'rfloor': '\xfb',

    'rho': 'r',

    'sdot': '\xd7',

    'sigma': 's',

    'sigmaf': 'V',

    'sigmav': 'V',

    'sim': '~',

    'spades': '\xaa',

    'sub': '\xcc',

    'sube': '\xcd',

    'sum': '\xe5',

    'sup': '\xc9',

    'supe': '\xca',

    'tau': 't',

    'there4': '\\',

    'theta': 'q',

    'thetasym': 'J',

    'thetav': 'J',

    'trade': '\xe4',

    'uArr': '\xdd',

    'uarr': '\xad',

    'upsih': '\xa1',

    'upsilon': 'u',

    'weierp': '\xc3',

    'xi': 'x',

    'zeta': 'z',

    }

# mapping of xml character entities to symbol encoding

symenc = {

    # greek letters

    913:'A', # Alpha

    914:'B', # Beta

    915:'G', # Gamma

    916:'D', # Delta

    917:'E', # Epsilon

    918:'Z', # Zeta

    919:'H', # Eta

    920:'Q', # Theta

    921:'I', # Iota

    922:'K', # Kappa

    923:'L', # Lambda

    924:'M', # Mu

    925:'N', # Nu

    926:'X', # Xi

    927:'O', # Omicron

    928:'P', # Pi

    929:'R', # Rho

    931:'S', # Sigma

    932:'T', # Tau

    933:'U', # Upsilon

    934:'F', # Phi

    935:'C', # Chi

    936:'Y', # Psi

    937:'W', # Omega

    945:'a', # alpha

    946:'b', # beta

    947:'g', # gamma

    948:'d', # delta

    949:'e', # epsilon

    950:'z', # zeta

    951:'h', # eta

    952:'q', # theta

    953:'i', # iota

    954:'k', # kappa

    955:'l', # lambda

    956:'m', # mu

    957:'n', # nu

    958:'x', # xi

    959:'o', # omicron

    960:'p', # pi

    961:'r', # rho

    962:'V', # sigmaf

    963:'s', # sigma

    964:'t', # tau

    965:'u', # upsilon

    966:'j', # phi

    967:'c', # chi

    968:'y', # psi

    969:'w', # omega

    977:'J', # thetasym

    978:'\241', # upsih

    981:'f', # phis

    982:'v', # piv

    # mathematical symbols

    8704:'"', # forall

    8706:'\266', # part

    8707:'$', # exist

    8709:'\306', # empty

    8711:'\321', # nabla

    8712:'\316', # isin

    8713:'\317', # notin

    8715:'\'', # ni

    8719:'\325', # prod

    8721:'\345', # sum

    8722:'-', # minus

    8727:'*', # lowast

    8730:'\326', # radic

    8733:'\265', # prop

    8734:'\245', # infin

    8736:'\320', # ang

    8869:'\331', # and

    8870:'\332', # or

    8745:'\307', # cap

    8746:'\310', # cup

    8747:'\362', # int

    8756:'\\', # there4

    8764:'~', # sim

    8773:'@', # cong

    8776:'\273', #asymp

    8800:'\271', # ne

    8801:'\272', # equiv

    8804:'\243', # le

    8805:'\263', # ge

    8834:'\314', # sub

    8835:'\311', # sup

    8836:'\313', # nsub

    8838:'\315', # sube

    8839:'\312', # supe

    8853:'\305', # oplus

    8855:'\304', # otimes

    8869:'^', # perp

    8901:'\327', # sdot

    9674:'\340', # loz

    # technical symbols

    8968:'\351', # lceil

    8969:'\371', # rceil

    8970:'\353', # lfloor

    8971:'\373', # rfloor

    9001:'\341', # lang

    9002:'\361', # rang

    # arrow symbols

    8592:'\254', # larr

    8593:'\255', # uarr

    8594:'\256', # rarr

    8595:'\257', # darr

    8596:'\253', # harr

    8656:'\334', # lArr

    8657:'\335', # uArr

    8658:'\336', # rArr

    8659:'\337', # dArr

    8660:'\333', # hArr

    # divers symbols

    8226:'\267', # bull

    8230:'\274', # hellip

    8242:'\242', # prime

    8254:'`', # oline

    8260:'\244', # frasl

    8472:'\303', # weierp

    8465:'\301', # image

    8476:'\302', # real

    8482:'\344', # trade

    8364:'\240', # euro

    8501:'\300', # alefsym

    9824:'\252', # spades

    9827:'\247', # clubs

    9829:'\251', # hearts

    9830:'\250' # diams

    }

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

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

    """

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

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

# The ParaFormatter will be able to format the following xml

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

#

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

            if attrName[:6]=="start_":

                return eval ("self."+attrName.lower())

            if attrName[:4]=="end_":

                return eval ("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)

    #### super script

    def start_super( self, attributes ):

        self._push(super=1)

    def end_super( self ):

        self._pop(super=1)