#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

import sys

import os

import copy

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

#with additions suggested by Christoph Zwerschke who also suggested the

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

    #### super script

    def start_super( self, attributes ):

        self._push(super=1)

    def end_super( self ):

        self._pop(super=1)

    #### sub script

    def start_sub( self, attributes ):

        self._push(sub=1)