#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

from reportlab.lib.utils import _checkImportError

try:

    from reportlab.lib import xmllib

    _xmllib_newStyle = 1

except ImportError, errMsg:

    _checkImportError(errMsg)

    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

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

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

        try:

            return ('relative',int(s))

        except ValueError:

            return ('relative',float(s))

    else:

        try:

            return int(s)

        except ValueError:

            return float(s)

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 = string.lower(m[k][0])

        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)

#characters not supported: epsi, Gammad, gammad, kappav, rhov, Upsi, upsi

greeks = {

    'alpha':'a',

    'beta':'b',

    'chi':'c',

    'Delta':'D',

    'delta':'d',

    'epsiv':'e',

    'eta':'h',

    'Gamma':'G',

    'gamma':'g',

    'iota':'i',

    'kappa':'k',

    'Lambda':'L',

    'lambda':'l',

    'mu':'m',

    'nu':'n',

    'Omega':'W',

    'omega':'w',

    'omicron':'x',

    'Phi':'F',

    'phi':'f',

    'phiv':'j',

    'Pi':'P',

    'pi':'p',

    'piv':'v',

    'Psi':'Y',

    'psi':'y',

    'rho':'r',

    'Sigma':'S',

    'sigma':'s',

    'sigmav':'V',

    'tau':'t',

    'Theta':'Q',

    'theta':'q',

    'thetav':'j',

    'Xi':'X',

    'xi':'x',

    'zeta':'z'

}

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

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

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

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

    #### bold

    def start_b( self, attributes ):

        self._push(bold=1)

    def end_b( self ):

        self._pop(bold=1)

    #### italics

    def start_i( self, attributes ):

        self._push(italic=1)

    def end_i( 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)

    def end_sub( self ):

        self._pop(sub=1)

    #### greek script

    if _xmllib_newStyle:

        def handle_entityref(self,name):

            if greeks.has_key(name):

                self._push(greek=1)

                self.handle_data(greeks[name])

                self._pop(greek=1)

            else:

                xmllib.XMLParser.handle_entityref(self,name)

        def syntax_error(self,lineno,message):

            self._syntax_error(message)

    else:

        def start_greekLetter(self, attributes,letter):

            self._push(greek=1)

            self.handle_data(letter)

        def syntax_error(self,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, attributes):

        self._push(greek=1)

    def end_greek(self):

        self._pop(greek=1)

    def start_font(self,attr):

        apply(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

        if bullet:

            frag.fontName, frag.bold, frag.italic = ps2tt(style.bulletFontName)

            frag.fontSize = style.bulletFontSize

            frag.textColor = hasattr(style,'bulletColor') and style.bulletColor or style.textColor

        else:

            frag.fontName, frag.bold, frag.italic = ps2tt(style.fontName)

            frag.fontSize = style.fontSize

            frag.textColor = style.textColor

        return frag

    def start_para(self,attr):

        self._stack = [self._initial_frag(attr,_paraAttrMap)]

    def end_para(self):

        self._pop()

    def start_bullet(self,attr):

        if hasattr(self,'bFragList'):

            self._syntax_error('only one <bullet> tag allowed')

        self.bFragList = []

        frag = self._initial_frag(attr,_bulletAttrMap,1)

        frag.isBullet = 1

        self._stack.append(frag)

    def end_bullet(self):

        self._pop()

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

    def start_seqdefault(self, attr):

        try:

            default = attr['id']

        except KeyError:

            default = None

        self._seq.setDefaultCounter(default)

    def end_seqdefault(self):

        pass

    def start_seqreset(self, attr):

        try:

            id = attr['id']

        except KeyError:

            id = None

        try:

            base = math.atoi(attr['base'])

        except:

            base=0

        self._seq.reset(id, base)

    def end_seqreset(self):

        pass

    # AR hacking in aliases to allow the proper casing for RML.

    # the above ones should be deprecated over time. 2001-03-22

    def start_seqDefault(self, attr):

        self.start_seqdefault(attr)

    def end_seqDefault(self):

        self.end_seqdefault()

    def start_seqReset(self, attr):

        self.start_seqreset(attr)

    def end_seqReset(self):

        self.end_seqreset()

    def start_seq(self, attr):

        #if it has a template, use that; otherwise try for id;

        #otherwise take default sequence

        if attr.has_key('template'):

            templ = attr['template']

            self.handle_data(templ % self._seq)

            return

        elif attr.has_key('id'):

            id = attr['id']

            id = None

        output = self._seq.nextf(id)

        self.handle_data(output)

    def end_seq(self):

        pass

    def start_onDraw(self,attr):

        defn = ABag()

        if attr.has_key('name'): defn.name = attr['name']

        else: self._syntax_error('<onDraw> needs at least a name attribute')

        if attr.has_key('label'): defn.label = attr['label']

        defn.kind='onDraw'

        self._push(cbDefn=defn)

        self.handle_data('')

        self._pop()

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

    def _push(self,**attr):

        frag = copy.copy(self._stack[-1])

        _applyAttributes(frag,attr)

        self._stack.append(frag)

    def _pop(self,**kw):

        frag = self._stack[-1]

        del self._stack[-1]

        for k, v in kw.items():

            assert getattr(frag,k)==v

        return frag

    def getAttributes(self,attr,attrMap):

        A = {}

        for k, v in attr.items():

            k = string.lower(k)

            if k in attrMap.keys():

                j = attrMap[k]

                func = j[1]

                try:

                    A[j[0]] = (func is None) and v or apply(func,(v,))

                except:

                    self._syntax_error('%s: invalid value %s'%(k,v))

            else:

                self._syntax_error('invalid attribute name %s'%k)

        return A

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

    def __init__(self,verbose=0):

        if _xmllib_newStyle:

            xmllib.XMLParser.__init__(self,verbose=verbose)

        else:

            xmllib.XMLParser.__init__(self)

            # set up handlers for various tags

            self.elements = {   'b': (self.start_b, self.end_b),

                            'u': (self.start_u, self.end_u),

                            'i': (self.start_i, self.end_i),

                            'super': (self.start_super, self.end_super),

                            'sub': (self.start_sub, self.end_sub),

                            'font': (self.start_font, self.end_font),

                            'greek': (self.start_greek, self.end_greek),

                            'para': (self.start_para, self.end_para)

                            }

            # automatically add handlers for all of the greek characters

            for item in greeks.keys():

                self.elements[item] = (lambda attr,self=self,letter=greeks[item]:

                    self.start_greekLetter(attr,letter), self.end_greek)

            # set up dictionary for greek characters, this is a class variable

            self.entitydefs = self.entitydefs.copy()

            for item in greeks.keys():

                self.entitydefs[item] = '<%s/>' % item

    def _iReset(self):

        self.fragList = []

        if hasattr(self, 'bFragList'): delattr(self,'bFragList')

    def _reset(self, style):

        '''reset the parser'''

        xmllib.XMLParser.reset(self)

        # initialize list of string segments to empty

        self.errors = []

        self._style = style

        self._iReset()

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

    def handle_data(self,data):

        "Creates an intermediate representation of string segments."

        frag = copy.copy(self._stack[-1])

        if hasattr(frag,'cbDefn'):

            if data!='': syntax_error('Only <onDraw> tag allowed')

        else:

            # if sub and super are both one they will cancel each other out

            if frag.sub == 1 and frag.super == 1:

                frag.sub = 0

                frag.super = 0

            if frag.sub:

                frag.rise = -frag.fontSize*subFraction

                frag.fontSize = max(frag.fontSize-sizeDelta,3)

            elif frag.super:

                frag.rise = frag.fontSize*superFraction

                frag.fontSize = max(frag.fontSize-sizeDelta,3)

            if frag.greek: frag.fontName = 'symbol'

        # bold, italic, and underline

        x = frag.fontName = tt2ps(frag.fontName,frag.bold,frag.italic)

        #save our data

        frag.text = data

        if hasattr(frag,'isBullet'):

            delattr(frag,'isBullet')

            self.bFragList.append(frag)

        else:

            self.fragList.append(frag)

    def handle_cdata(self,data):

        self.handle_data(data)

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