#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

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

                }

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

    }

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

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)

    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:

            else:

            self.unknown_charref(name)

            return

    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)

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

    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 = int(attr['base'])

        except:

            base=0

        self._seq.reset(id, base)